protected Transformer transformer(){ Transformer transformer = Transformer.create(); transformer.setSPARQLEngine(this); if (sort != null) { transformer.set(sort); } if (getVisitorList()!=null){ transformer.add(getVisitorList()); } return transformer; }
/** * ext is loaded function definitions define them as public * * @param ext * @param q */ void definePublic(Extension ext, Query q) { definePublic(ext, q, true); }
void setParameter(Transformer transformer){ transformer.setLinkedFunction(isLinkedFunction()); transformer.setGenerateMain(isGenerateMain()); transformer.setNamespaces(NAMESPACES); transformer.setPragma(getPragma()); transformer.setMetadata(getActualMetadata()); transformer.setPlanProfile(getPlanProfile()); transformer.setUseBind(isUseBind()); transformer.setBGP(isBGP()); transformer.setAlgebra(isAlgebra()); transformer.setServiceList(getServiceList()); }
/** * Subquery is a construct where */ Query constructQuery(ASTQuery ast) { Transformer t = Transformer.create(); t.setAlgebra(isAlgebra()); return t.transform(ast); }
Transformer getTransformer() { if (transformer == null) { transformer = Transformer.create(); transformer.setSPARQLEngine(this); transformer.setLinkedFunction(isLinkedFunction()); } return transformer; }
annotate(ast); Pragma p = new Pragma(this, ast); if (ast.getPragma() != null) { generateMain(); federate(ast); visit(ast); preprocess(ast); template(ast); Query q = compile(ast); q.setRule(ast.isRule()); q.setAlgebra(isAlgebra()); if (ast.getContext() != null) { q.setContext(ast.getContext()); template(q, ast); q = transform(q, ast); compileLambda(q, ast); error(q, ast); toJava(ast); metadata(ast, q);
Node node = getNode(qCurrent, var); Exp exp = Exp.create(NODE, node); Filter f = compileSelect(ee, ast); checkFilterVariables(qCurrent, f, select, lNodes); function(qCurrent, exp, var); aggregate(qCurrent, exp, ee, select); add(select, exp);
public Query transform(String squery) throws EngineException { return transform(squery, false); }
public Query compile(String squery, Dataset ds) throws EngineException { Transformer transformer = createTransformer(ds); transformer.setSPARQLCompliant(isSPARQLCompliant); Query query = transformer.transform(squery); return query; }
Exp bindings(Values values) { List<Node> lNode = bind(values); Node[] nodes = getNodes(lNode); Mappings lMap = new Mappings(); for (List<Constant> lVal : values.getValues()) { if (values.getVariables().size() != lVal.size()) { // error: not right number of values return null; } else { List<Node> list = bind(lVal); Mapping map = create(nodes, list); lMap.add(map); } } Exp bind = Exp.create(VALUES); bind.setNodeList(lNode); bind.setMappings(lMap); return bind; }
/** * Compile Graph into a BGP Generate a Query */ public Query getQuery() { Transformer t = Transformer.create(); ASTQuery ast = ASTQuery.create(); ast.setSelectAll(true); ast.setBody(BasicGraphPattern.create()); ast = visitor.visit(ast); graph = visitor.visit(graph); Exp exp = getExp(graph); Query q = Query.create(exp); q.setAST(ast); q = t.transform(q, ast); q.setDebug(isDebug); q = visitor.visit(q); if (isConstruct()) { // TODO: blanks in construct should be renamed q.setConstruct(q.getBody()); q.setConstruct(true); } return q; }
/** * templates share profile function definitions * function st:optimize(){} : run TransformerVisitor to optimize template */ public void profile() { Query profile = getTemplate(STL_PROFILE); if (profile != null) { if (profile.getExtension() != null) { // share profile function definitions in templates fr.inria.corese.compiler.parser.Transformer tr = fr.inria.corese.compiler.parser.Transformer.create(); tr.definePublic(profile.getExtension(), profile, false); TransformerVisitor tv = new TransformerVisitor(profile.getExtension().get(Transformer.STL_OPTIMIZE) != null); for (Query t : getTemplates()) { t.addExtension(profile.getExtension()); tv.visit(t); } for (Query t : getNamedTemplates()) { t.addExtension(profile.getExtension()); tv.visit(t); } } } }
public Query transform(String squery, boolean isRule) throws EngineException { ast = ASTQuery.create(squery); ast.setRule(isRule); ast.setDefaultNamespaces(namespaces); ast.setDefaultBase(getDefaultBase()); ast.setSPARQLCompliant(isSPARQLCompliant); if (dataset != null) { ast.setDefaultDataset(dataset); } ParserSparql1.create(ast).parse(); Query q = transform(ast); return q; }
public boolean getLinkedFunction(String label) { if (! isLinkedFunction()){ return false; } String path = NSManager.namespace(label); if (loaded.containsKey(path)) { return true; } logger.info("Load Linked Function: " + label); loaded.put(path, path); Query imp = sparql.parseQuery(path); if (imp != null && imp.hasDefinition()) { // loaded functions are exported in Interpreter definePublic(imp.getExtension(), imp); return true; } return false; }
/** * use case: * @federate <s1> * @federate <s2> * select * where { } * Rewrite every triple t as: service <s1> <s2> { t } */ void federate(ASTQuery ast) { if (ast.hasMetadata(Metadata.FEDERATION) && !ast.hasMetadata(Metadata.FEDERATE)) { add(new FederateVisitor(getSPARQLEngine())); } else if (ast.getServiceList() == null && getServiceList() != null) { // default service list ast.setServiceList(getServiceList()); if (ast.getServiceList().size() == 1) { ast.defService(ast.getServiceList().get(0).getLabel()); } } if (ast.getServiceList() != null && ast.getServiceList().size() > 1) { ast.defService((String) null); add(new FederateVisitor(getSPARQLEngine())); } }
@Override public void getLinkedFunction(String label) { getTransformer().getLinkedFunction(label); }
Constant cst = t.getObject().getConstant(); if (odt.isNumber()){ transform.add(ExpandPath.create(odt.intValue())); transform.add(ExpandPath.create()); transform.add(ExpandList.create()); transform.setPlanProfile(Query.QP_DEFAULT); transform.setPlanProfile(Query.QP_HEURISTICS_BASED);
public static Transformer create(CompilerFactory f) { return new Transformer(f); }
/** * Metadata => Visitor */ void visitor(ASTQuery ast) { if (ast.hasMetadata(Metadata.METADATA)){ add(new MetadataVisitor()); } if (ast.hasMetadata(Metadata.VISITOR)) { for (String name : ast.getMetadata().getValues(Metadata.VISITOR)) { try { Class visClass = Class.forName(name); Object obj = visClass.newInstance(); if (obj instanceof QueryVisitor) { add((QueryVisitor) obj); } else { logger.error("Undefined QueryVisitor: " + name); } } catch (ClassNotFoundException ex) { logger.error("Undefined QueryVisitor: " + name); } catch (InstantiationException ex) { logger.error("Undefined QueryVisitor: " + name); } catch (IllegalAccessException ex) { logger.error("Undefined QueryVisitor: " + name); } } } }