Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) 2009 Mysema Ltd.
   * All rights reserved.
   * 
   */
  package com.mysema.query.jdoql;
  
  import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
 import  javax.annotation.Nullable;
 
 
JDOQLSerializer serializes Querydsl queries and expressions into JDOQL strings

Author(s):
tiwe
 
 public final class JDOQLSerializer extends SerializerBase<JDOQLSerializer> {
     
     private static final String COMMA = ", ";
 
     private static final String FROM = "\nFROM ";
 
     private static final String GROUP_BY = "\nGROUP BY ";
 
     private static final String HAVING = "\nHAVING ";
 
     private static final String ORDER_BY = "\nORDER BY ";
 
     private static final String PARAMETERS = "\nPARAMETERS ";
 
     private static final String RANGE = "\nRANGE ";
 
     private static final String SELECT = "SELECT ";
 
     private static final String SELECT_COUNT = "SELECT count(";
     
     private static final String SELECT_COUNT_THIS = "SELECT count(this)\n";
 
     private static final String SELECT_DISTINCT = "SELECT DISTINCT ";
 
     private static final String SELECT_UNIQUE = "SELECT UNIQUE ";
 
     private static final String THIS = "this";
 
     private static final String VARIABLES = "\nVARIABLES ";
 
     private static final String WHERE = "\nWHERE ";
    
     private static Comparator<Map.Entry<Object,String>> comparator = new Comparator<Map.Entry<Object,String>>(){
         @Override
         public int compare(Entry<ObjectStringo1Entry<ObjectStringo2) {
             return o1.getValue().compareTo(o2.getValue());
         }        
     };
 
     private Expr<?> candidatePath;
     
     private List<Objectconstants = new ArrayList<Object>();
     
     public JDOQLSerializer(JDOQLTemplates patternsExpr<?> candidate) {
         super(patterns);
         this. = candidate;
     }
         
     public Expr<?> getCandidatePath() {
         return ;
     }
 
     public List<ObjectgetConstants() {
         return ;
     }
 
     @SuppressWarnings("unchecked")
     private <T> Expr<?> regexToLike(Operation<T> operation) {
        List<Expr<?>> args = new ArrayList<Expr<?>>();
        for (Expr<?> arg : operation.getArgs()){
            if (!arg.getType().equals(String.class)){
                args.add(arg);
            }else if (arg instanceof Constant){
                args.add(regexToLike(arg.toString()));
            }else if (arg instanceof Operation){
                args.add(regexToLike((Operation)arg));
            }else{
                args.add(arg);
            }
        }
        return OSimple.create(
                operation.getType(),
                operation.getOperator(), 
                args.<Expr<?>>toArray(new Expr[args.size()]));
    }
    private Expr<?> regexToLike(String str){
        return EStringConst.create(str.replace(".*""%").replace(".""_"));
    }
    
    @SuppressWarnings("unchecked")
    public void serialize(QueryMetadata metadataboolean forCountRowboolean subquery) {
        List<? extends Expr<?>> select = metadata.getProjection();
        List<JoinExpressionjoins = metadata.getJoins();
        Expr<?> source = joins.get(0).getTarget();
        EBoolean where = metadata.getWhere();
        List<? extends Expr<?>> groupBy = metadata.getGroupBy();
        EBoolean having = metadata.getHaving();
        List<OrderSpecifier<?>> orderBy = metadata.getOrderBy();
        // select 
        if (forCountRow) {
            if (joins.size() == 1){
                append();    
            }else{
                append();
                boolean first = true;
                for (JoinExpression je : joins){
                    if (!first){
                        append();
                    }
                    handle(je.getTarget());
                    first = false;
                }
                append(")");
            }
            
            
        } else if (!select.isEmpty()) {
            if (metadata.isDistinct()){
                append();
            }else if (metadata.isUnique() && !subquery){
                append();
            }else{
                append();
            }
            handle(select);
        }
        
        // from        
        append();
        if (source instanceof Operation && subquery){
            handle(source);
        }else{
            append(source.getType().getName());
            if (!source.equals()){
                append(" ").handle(source);
            }    
        }        
        // where
        if (where != null) {
            append().handle(where);
        }
        
        // variables
        if (joins.size() > 1){
            serializeVariables(joins);
        }        
        
        // parameters
        if (!subquery && !getConstantToLabel().isEmpty()){
            serializeParameters();    
        }        
                
        // group by
        if (!groupBy.isEmpty()) {
            append().handle(groupBy);
        }
        
        // having
        if (having != null) {
            if (groupBy.isEmpty()) {
                throw new IllegalArgumentException(
                        "having, but not groupBy was given");
            }
            append().handle(having);
        }
        
        // order by
        if (!orderBy.isEmpty() && !forCountRow) {
            append();
            boolean first = true;
            for (OrderSpecifier<?> os : orderBy) {
                if (!first){
                    append();
                }                    
                handle(os.getTarget());
                append(" " + os.getOrder());
                first = false;
            }
        }
        
        // range
        if (!forCountRow && metadata.getModifiers().isRestricting()){
            Long limit = metadata.getModifiers().getLimit();
            Long offset = metadata.getModifiers().getOffset();
            serializeModifiers(limitoffset);
        }
        
    }
    private void serializeModifiers(@Nullable Long limit, @Nullable Long offset) {
        append();
        if (offset != null){
            append(String.valueOf(offset));
            if (limit != null){
                append();
                append(String.valueOf(offset + limit));    
            }                
        }else{
            append("0, ").append(String.valueOf(limit));
        }
    }
    
    private void serializeParameters() {
        append();
        boolean first = true;
        List<Map.Entry<ObjectString>> entries = new ArrayList<Map.Entry<ObjectString>>(getConstantToLabel().entrySet());
        Collections.sort(entries);            
        for (Map.Entry<ObjectStringentry : entries){
            if (!first){
                append();
            }
            .add(entry.getKey());
            append(entry.getKey().getClass().getName()).append(" ").append(entry.getValue());
            first = false;
        }
    }
    @SuppressWarnings("unchecked")
    private void serializeVariables(List<JoinExpressionjoins) {
        append();
        for (int i = 1; i < joins.size(); i++) {                
            JoinExpression je = joins.get(i);
            if (i > 1) {
                append("; ");
            }
            
            // type specifier
            if (je.getTarget() instanceof PEntity) {
                PEntity<?> pe = (PEntity<?>) je.getTarget();
                if (pe.getMetadata().getParent() == null) {
                    append(pe.getType().getName()).append(" ");
                }
            }
            handle(je.getTarget());
        }
    }
    @Override
    public void visit(Path<?> path) {
        if (path.equals()) {
            append();
        } else {
            super.visit(path);
        }
    }
    @Override
    public void visit(SubQuery<?> query) {
        append("(");
        serialize(query.getMetadata(), falsetrue);
        append(")");
    }
    @SuppressWarnings("unchecked")
    @Override
    protected void visitOperation(Class<?> typeOperator<?> operatorList<Expr<?>> args) {
        // TODO : these should be handled as serialization patterns
        if (operator.equals(.)) {
            handle(args.get(0)).append(" instanceof ");
            append(((Constant<Class<?>>) args.get(1)).getConstant().getName());
            
        } else if (operator.equals(.)){
            // switch from regex to like if the regex expression is an operation
            if (args.get(1) instanceof Operation){
                operator = .;
                args = Arrays.asList(args.get(0), regexToLike((Operation<?>) args.get(1)));                
            }
            super.visitOperation(typeoperatorargs);
            
        } else if (operator.equals(.)) {
            Class<?> clazz = ((Constant<Class<?>>)args.get(1)).getConstant();
            if (Number.class.isAssignableFrom(clazz) && ClassUtils.wrapperToPrimitive(clazz) != null){
                clazz = ClassUtils.wrapperToPrimitive(clazz);
            }
            append("(",clazz.getSimpleName(),")").handle(args.get(0));
            
        } else {
            super.visitOperation(typeoperatorargs);
        }
    }
    
    
New to GrepCode? Check out our FAQ X