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.List;
 import java.util.Map;
 
 

Author(s):
tiwe
 
 public class JDOQLSerializer extends BaseSerializer<JDOQLSerializer> {
     
     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(JDOQLPatterns patternsExpr<?> candidate) {
         super(patterns);
         this. = candidate;
     }
     
     @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) {
             append("SELECT count(this)\n");
         } else if (!select.isEmpty()) {
             if (metadata.isDistinct()){
                 append("SELECT DISTINCT ");
             }else if (metadata.isUnique() && !subquery){
                 append("SELECT UNIQUE ");
             }else{
                 append("SELECT ");
             }
             handle(", "select);
         }
         
         // FROM        
         append("\nFROM ");
         if (source instanceof Operation && subquery){
             handle(source);
         }else{
             append(source.getType().getName());
             if (!source.equals()){
                 append(" ").handle(source);
             }    
         }        
 
         // WHERE
         if (where != null) {
             append("\nWHERE ").handle(where);
         }
         
         // VARIABLES
        if (joins.size() > 1){
            append("\nVARIABLES ");
            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());
            }
        }        
        
        // PARAMETERS
        if (!subquery && !getConstantToLabel().isEmpty()){
            append("\nPARAMETERS ");
            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;
            }    
        }        
                
        // GROUP BY
        if (!groupBy.isEmpty()) {
            append("\nGROUP BY ").handle(", "groupBy);
        }
        // HAVING
        if (having != null) {
            if (groupBy.isEmpty()) {
                throw new IllegalArgumentException(
                        "having, but not groupBy was given");
            }
            append("\nHAVING ").handle(having);
        }
        // ORDER BY
        if (!orderBy.isEmpty() && !forCountRow) {
            append("\nORDER BY ");
            boolean first = true;
            for (OrderSpecifier<?> os : orderBy) {
                if (!first){
                    .append(", ");
                }                    
                handle(os.getTarget());
                append(os.getOrder() == . ? " ASC" : " DESC");
                first = false;
            }
        }
        // RANGE
        if (!forCountRow && metadata.getModifiers().isRestricting()){
            QueryModifiers modifiers = metadata.getModifiers();
            append("\nRANGE ");
            if (modifiers.getOffset() != null){
                append(String.valueOf(modifiers.getOffset()));
                if (modifiers.getLimit() != null){
                    append(", ");
                    append(String.valueOf(modifiers.getOffset() + modifiers.getLimit()));    
                }                
            }else{
                append("0, ").append(String.valueOf(modifiers.getLimit()));
            }
        }
        
    }
    
    protected void visit(ObjectSubQuery<?> query) {
        visit((SubQuery)query);
    }
    
    protected void visit(ListSubQuery<?> query) {
        visit((SubQuery)query);
    }
    
    protected void visit(SubQuery query) {
        append("(");
        serialize(query.getMetadata(), falsetrue);
        append(")");
    }
    @SuppressWarnings("unchecked")
    @Override
    protected void visitOperation(Class<?> typeOperator<?> operator,
            List<Expr<?>> args) {
        // TODO : these should be handled as serialization patterns
        if (operator.equals(.)) {
            handle(args.get(0)).append(" instanceof ");
            append(((EConstant<Class<?>>) args.get(1)).getConstant().getName());
            
        } else if (operator.equals(.)) {
            append("(String)").handle(args.get(0));
            
        } else if (operator.equals(.)) {
            Class<?> clazz = ((EConstant<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);
        }
    }
    @Override
    protected void visit(Path<?> path) {
        if (path.equals()) {
            append("this");
        } else {
            super.visit(path);
        }
    }
    public Expr<?> getCandidatePath() {
        return ;
    }
    public List<ObjectgetConstants() {
        return ;
    }
    
    
New to GrepCode? Check out our FAQ X