Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) 2009 Mysema Ltd.
   * All rights reserved.
   * 
   */
  package com.mysema.rdfbean.sesame.query;
  
  import java.util.Arrays;
  import java.util.HashSet;
 import java.util.Set;
 
 import  javax.annotation.Nullable;
 
 import  org.openrdf.model.Literal;
 import  org.openrdf.model.URI;
 import  org.openrdf.model.Value;
 import  org.openrdf.model.impl.URIImpl;
 import  org.openrdf.query.algebra.*;
 import  org.openrdf.query.algebra.helpers.QueryModelVisitorBase;
 import  org.openrdf.query.parser.GraphQueryModel;
 import  org.openrdf.query.parser.TupleQueryModel;
 
QuerySerializer seriales ParsedTupleQuery instances to a syntax combining SeRQL and SPARQL features for optimal readability

Author(s):
tiwe
Version:
$Id$
See also:
http://www.openrdf.org/doc/sesame2/2.2.4/users/ch09.html.d0e1398
 
 public class QuerySerializer extends QueryModelVisitorBase<RuntimeException>{
     
     private static final Set<StringknownNamespaces = new HashSet<String>(Arrays.asList(....));
     
     private final StringBuilder builder = new StringBuilder();
     
     private boolean fromPrinted;
     
     @Nullable
     private StatementPattern lastPattern;
     
     private final Set<Stringnamespaces = new HashSet<String>();
     
     private boolean usingNsPrinted;
     
     public QuerySerializer(GraphQueryModel queryboolean verbose){
         query.getTupleExpr().visit(this);        
         if (!.isEmpty() && verbose){           
             printNamespaces();
         }
     }
     
     public QuerySerializer(TupleQueryModel queryboolean verbose){
         query.getTupleExpr().visit(this);        
         if (!.isEmpty() && verbose){           
             printNamespaces();
         }
     }
 
     private void printNamespaces() {
         for (String ns : ){
             String prefix = Namespaces.getPrefix(ns);
             if (prefix != null && !.contains(ns)){
                 if (!){
                     append("\nPREFIXES");
                      = true;
                 }
                 append("\n  ").append(prefix).append(": <").append(ns).append(">");
             }
         }
     }
     
     private QuerySerializer append(String str){
         .append(str);
         return this;
     }
     
     @Override
     public void meet(And nodethrows RuntimeException{
         visit(node.getArg(0)).append( " AND\n  " ).visit(node.getArg(1));
     }
     
     @Override
     public void meet(Bound nodethrows RuntimeException{
         append"BOUND( " ).visit(node.getArg()).append( " )" );
     }
     
     @Override
     public void meet(Compare nodethrows RuntimeException{
         node.getLeftArg().visit(this);
         append" " ).append(node.getOperator().getSymbol()).append( " " );
         node.getRightArg().visit(this);
     }
    
    @Override
    public void meet(CompareAll nodethrows RuntimeException{
        node.getArg().visit(this);
        append" " ).append(node.getOperator().getSymbol()).append( " ALL " );
        node.getSubQuery().visit(this);
    }
    
    @Override
    public void meet(CompareAny nodethrows RuntimeException{
        node.getArg().visit(this);
        append" " ).append(node.getOperator().getSymbol()).append( " ANY " );
        node.getSubQuery().visit(this);
    }
    
    @Override
    public void meet(Count nodethrows RuntimeException{
        append"COUNT( " ).visit(node.getArg()).append( " )" );
    }
    
    @Override
    public void meet(Datatype nodethrows RuntimeException{
        append"DATATYPE( " ).visit(node.getArg()).append( " )" );
    }
    
    @Override
    public void meet(Difference nodethrows RuntimeException{
        node.getLeftArg().visit(this);
        append"\n\nMINUS\n\n" );
        node.getRightArg().visit(this);
    }
    
    @Override
    public void meet(Distinct nodethrows RuntimeException{
        if (node.getArg() instanceof Projection){
            meet((Projection)node.getArg(), true);
        }else{
            append"DISTINCT( " ).visit(node.getArg()).append( " )" );    
        }        
    }
    
    @Override
    public void meet(Exists nodethrows RuntimeException{
         = null;
        append"EXISTS( " );
        visit(node.getSubQuery());
        append" )" );
    }
    
    @Override
    public void meet(Extension nodethrows RuntimeException{
        append("\nEXTENSIONS ");
        boolean first = true;
        for (ExtensionElem elem : node.getElements()){
            if (!first){
                append"," );
            }
            append(elem.getName()).append(" = ");
            elem.getExpr().visit(this);
            first = false;
        }
        node.getArg().visit(this);
    }
    
    @Override
    public void meet(Filter nodethrows RuntimeException{
        append"\nFROM " );
         = true;
        node.getArg().visit(this);
        append"\nWHERE " );
        node.getCondition().visit(this);
    }
    
    @Override
    public void meet(FunctionCall nodethrows RuntimeException{        
        URI uri = new URIImpl(node.getURI());
        .add(uri.getNamespace());
        append(Namespaces.getReadableURI(uri.getNamespace(), uri.getLocalName()));
        append"( " );
        boolean first = true;
        for (ValueExpr v : node.getArgs()){
            if (!first){
                append"," );
            }
            first = false;
            v.visit(this);
        }
        append" )" );
    }
    
    @Override
    public void meet(Slice nodethrows RuntimeException{
        node.getArg().visit(this);
        if (node.getLimit() > -1){
            append("\nLIMIT " + node.getLimit());    
        }
        if (node.getOffset() > 0){
            append("\nOFFSET " + node.getOffset());    
        }        
    }
    
    @Override
    public void meet(In nodethrows RuntimeException{
        node.getArg().visit(this);
        append" IN " );
        node.getSubQuery().visit(this);
    }
    
    @Override
    public void meet(Intersection nodethrows RuntimeException{        
        node.getLeftArg().visit(this);
        append"\n\nINTERSECT\n\n" );
        node.getRightArg().visit(this);        
    }
    
    @Override
    public void meet(IsBNode nodethrows RuntimeException{
        append"isBNode( " ).visit(node.getArg()).append( " )" );
    }
    
    @Override
    public void meet(IsLiteral nodethrows RuntimeException{
        append"isLiteral( " ).visit(node.getArg()).append( " )" );
    }
    
    @Override
    public void meet(IsResource nodethrows RuntimeException{
        append"isResource( " ).visit(node.getArg()).append( " )" );
    }
    
    @Override
    public void meet(IsURI nodethrows RuntimeException{
        append"isURI( " ).visit(node.getArg()).append( " )" );
    }
    
    @Override
    public void meet(Join nodethrows RuntimeException{
        if (!){
            append"\nFROM " );
             = true;
        }
        node.getArg(0).visit(this);
        if (node.getArg(1) != null){
            node.getArg(1).visit(this);    
        }        
    }
    
    @Override
    public void meet(Label nodethrows RuntimeException{
        append"label( " ).visit(node.getArg()).append( " )" );
    }
    
    @Override
    public void meet(Lang nodethrows RuntimeException{
        append"lang( " ).visit(node.getArg()).append( " )" );
    }
    
    @Override
    public void meet(LangMatches nodethrows RuntimeException{
        visit(node.getLeftArg()).append(" match ").visit(node.getRightArg());
    }
    
//    @Override
//    public void meet(Like node) throws RuntimeException{
//        node.getArg().visit(this);
//        append( " LIKE '" ).append(node.getOpPattern()).append( "' " );
//    }
    
    @Override
    public void meet(LeftJoin nodethrows RuntimeException{
        if (!){
            append"\nFROM " );
             = true;
        }
        node.getArg(0).visit(this);        
        append".\n  OPTIONAL ( " );
         = null;
        node.getArg(1).visit(this);
        append" )" );
    }
    
    
    @Override
    public void meet(Max nodethrows RuntimeException{
        append"MAX( " ).visit(node.getArg()).append( " )" );
    }
    
    @Override
    public void meet(Min nodethrows RuntimeException{
        append"MIN( " ).visit(node.getArg()).append( " )" );
    }
    
    @Override
    public void meet(Not nodethrows RuntimeException{
        append"NOT " ).visit(node.getArg());
    }
    
    @Override
    public void meet(Or nodethrows RuntimeException{
        node.getArg(0).visit(this);
        append" OR\n  " );
        node.getArg(1).visit(this);
    }
    
    @Override
    public void meet(Order nodethrows RuntimeException{
        visit(node.getArg());
        append("\nORDER BY ");
        boolean first = true;
        for (OrderElem elem : node.getElements()){
            if (!first){
                append(", ");
            }
            visit(elem.getExpr());
            append(elem.isAscending() ? " ASC" : " DESC");
            first = false;
        }
    }
    
    @Override
    public void meet(Projection nodethrows RuntimeException{
        meet(nodefalse);
    }
    
    private void meet(Projection nodeboolean distinct){
        append"SELECT " );
        if (distinctappend("DISTINCT ");
        boolean first = true;
        for (ProjectionElem p : node.getProjectionElemList().getElements()){
            if (!first){
                append", " );
            }            
            if (!p.getSourceName().equals(p.getTargetName())){
                append(p.getSourceName()).append( " AS " );
            }
            append(p.getTargetName());
            
            first = false;
        }        
        node.getArg().visit(this);
    }
    
    @Override
    public void meet(Regex nodethrows RuntimeException{        
        append"regex( " );
        node.getArg().visit(this);
        append", " );
        node.getPatternArg().visit(this);
        if (node.getFlagsArg() != null){
            append", " );
            node.getFlagsArg().visit(this);
        }
        append" )" );
    }
    
    @Override
    public void meet(StatementPattern nodethrows RuntimeException{
        if (!){
            append"\nFROM " );
             = true;
        }
        if ( != null){
            if (.getSubjectVar().equals(node.getSubjectVar())){
                if (.getPredicateVar().equals(node.getPredicateVar())){
                    append(" , ").visit(node.getObjectVar());
                    return;
                }else{
                    append(" ; ").visit(node.getPredicateVar()).append(" ").visit(node.getObjectVar());
                    return;
                }
            }else{
                append(" .\n ");
            }            
        }        
        visit(node.getSubjectVar()).append( " " ).visit(node.getPredicateVar()).append( " " ).visit(node.getObjectVar());
         = node;
    }
    
    @Override
    public void meet(Str nodethrows RuntimeException{
        append"str( " ).visit(node.getArg()).append( " )" );
    }
    
    @Override
    public void meet(Union nodethrows RuntimeException{
        for (int i = 0; i < node.getNumberOfArguments(); i++){            
            if (i > 0){
                 = null;
                append(" UNION ");
            }
            visit(node.getArg(i));
        }        
//        lastPattern = null;
    }
        
    private void meet(Value value){
        if (value instanceof URI){    
            URI uri = (URI) value;
            .add(uri.getNamespace());
            append(Namespaces.getReadableURI(uri.getNamespace(), uri.getLocalName()));
        
        }else if (value instanceof Literal){
            Literal lit = (Literal) value;
            if (lit.getDatatype() != null){
                append("\"").append(lit.getLabel()).append("\"^^");
                .add(lit.getDatatype().getNamespace());
                append(Namespaces.getReadableURI(lit.getDatatype().getNamespace(), lit.getDatatype().getLocalName()));
            }else{
                append(lit.toString());
            }
            
        }else{
            append(value.toString());
        }
    }
    
    @Override
    public void meet(ValueConstant nodethrows RuntimeException{
        meet(node.getValue());
    }
    
    @Override
    public void meet(Var nodethrows RuntimeException{
        Value value = node.getValue();
        if (value == null){
            append("{").append(node.getName()).append("}");            
        }else{    
            meet(value);
        }
    }
    
    public String toString(){
        return .toString();
    }
    private QuerySerializer visit(QueryModelNode node){
        node.visit(this);
        return this;
    }
New to GrepCode? Check out our FAQ X