com.bigdata.rdf.sparql.ast.optimizers.TestASTBottomUpOptimizer Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of bigdata-rdf-test Show documentation
Show all versions of bigdata-rdf-test Show documentation
Blazegraph(TM) RDF Test Suites
/**
Copyright (C) SYSTAP, LLC DBA Blazegraph 2006-2016. All rights reserved.
Contact:
SYSTAP, LLC DBA Blazegraph
2501 Calvert ST NW #106
Washington, DC 20008
[email protected]
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
* Created on Sep 15, 2011
*/
package com.bigdata.rdf.sparql.ast.optimizers;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.junit.Assert.assertThat;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import org.openrdf.model.impl.URIImpl;
import org.openrdf.query.MalformedQueryException;
import org.openrdf.query.algebra.StatementPattern.Scope;
import com.bigdata.bop.BOpUtility;
import com.bigdata.bop.Constant;
import com.bigdata.bop.IBindingSet;
import com.bigdata.bop.IConstant;
import com.bigdata.bop.IVariable;
import com.bigdata.bop.Var;
import com.bigdata.bop.bindingSet.ListBindingSet;
import com.bigdata.rdf.internal.IV;
import com.bigdata.rdf.internal.XSD;
import com.bigdata.rdf.model.BigdataLiteral;
import com.bigdata.rdf.model.BigdataURI;
import com.bigdata.rdf.model.BigdataValue;
import com.bigdata.rdf.model.BigdataValueFactory;
import com.bigdata.rdf.sail.sparql.Bigdata2ASTSPARQLParser;
import com.bigdata.rdf.sparql.ast.ASTContainer;
import com.bigdata.rdf.sparql.ast.AbstractASTEvaluationTestCase;
import com.bigdata.rdf.sparql.ast.ConstantNode;
import com.bigdata.rdf.sparql.ast.FilterNode;
import com.bigdata.rdf.sparql.ast.FunctionNode;
import com.bigdata.rdf.sparql.ast.FunctionRegistry;
import com.bigdata.rdf.sparql.ast.GlobalAnnotations;
import com.bigdata.rdf.sparql.ast.IQueryNode;
import com.bigdata.rdf.sparql.ast.JoinGroupNode;
import com.bigdata.rdf.sparql.ast.NamedSubqueriesNode;
import com.bigdata.rdf.sparql.ast.NamedSubqueryInclude;
import com.bigdata.rdf.sparql.ast.NamedSubqueryRoot;
import com.bigdata.rdf.sparql.ast.ProjectionNode;
import com.bigdata.rdf.sparql.ast.QueryNodeWithBindingSet;
import com.bigdata.rdf.sparql.ast.QueryRoot;
import com.bigdata.rdf.sparql.ast.QueryType;
import com.bigdata.rdf.sparql.ast.SolutionSetStatserator;
import com.bigdata.rdf.sparql.ast.StatementPatternNode;
import com.bigdata.rdf.sparql.ast.TestStaticAnalysis;
import com.bigdata.rdf.sparql.ast.ValueExpressionNode;
import com.bigdata.rdf.sparql.ast.VarNode;
import com.bigdata.rdf.sparql.ast.eval.AST2BOpContext;
import com.bigdata.rdf.sparql.ast.eval.AST2BOpUtility;
import com.bigdata.rdf.sparql.ast.eval.ASTDeferredIVResolution;
import com.bigdata.rdf.sparql.ast.explainhints.ExplainHints;
/**
* Test suite for {@link ASTBottomUpOptimizer}.
*
* @author Bryan Thompson
* @version $Id: TestASTBottomUpOptimizer.java 5197 2011-09-15 19:10:44Z
* thompsonbry $
*
* @see TestStaticAnalysis
*/
public class TestASTBottomUpOptimizer extends
AbstractASTEvaluationTestCase {
// private static final Logger log = Logger
// .getLogger(TestASTBottomUpOptimizer.class);
public TestASTBottomUpOptimizer() {
super();
}
public TestASTBottomUpOptimizer(final String name) {
super(name);
}
/**
* Nested Optionals - 1 (Query is not well designed because there are no
* shared variables in the intermediate join group and there is an embedded
* OPTIONAL join group. Since ?v is not present in the intermediate join
* group the (:x3 :q ?w . OPTIONAL { :x2 :p ?v }) solutions must be computed
* first and then joined against the (:x1 :p ?v) solutions.)
*
*
* PREFIX :
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public void test_bottomUpOptimizer_nested_optionals_1()
throws MalformedQueryException {
final String queryStr = "" + //
"PREFIX : v in each exogenous solutions. This
* turns v into a "known" bound variable. At that point we no
* longer need to rewrite the query in order to have the correct evaluation
* semantics.
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public void test_bottomUpOptimizer_nested_optionals_1_correctRejection()
throws MalformedQueryException {
final String queryStr = "" + //
"PREFIX :
* PREFIX :
*
* ?v is bound in the outer join group.
*
* ?w is bound in the child join group regardless of whether
* the embedded optional succeeds.
*
* ?v is not bound in the FILTER because it is evaluated with
* bottom up semantics and therefore the bindings from the outer parent
* group are not visible.
*
* For reference, the AST for that SPARQL query is:
*
*
* PREFIX :
*
* This query includes both a badly designed left join pattern, which must
* be lifted out:
*
*
* { :x :q ?w OPTIONAL { :x :p ?v2 FILTER(?v = 1) } }
*
*
* and a FILTER on a variable which is not in scope:
*
*
* FILTER(?v = 1)
*
*
* @see ASTBottomUpOptimizer
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public void test_bottomUpOptimizer_filter_scope_1()
throws MalformedQueryException {
final String queryStr = "" + //
"PREFIX :
* PREFIX :
*
* Note: For this query, the bindings of ?X in the outer group
* are not visible when the inner groups are evaluated. Because of this,
* ?X in the optional clause binds for values which differ from
* the values bound on ?X in the outer group. This means that
* the solutions from the middle group with bindings for ?Y and
* ?X fail to join with the solutions in the outer group. Note
* that there is no email address for "paul" for the data set used to run
* this query. If there were, then the query would have a result.
*
* These group expressions need to be evaluated independently because they
* are not sharing a binding for ?X until we join them together
* on ?X.
*
* In order for us to run this query correctly we need to run
*
*
* {?Y :name "george" . OPTIONAL { ?X :email ?Z } }
*
*
* BEFORE
*
*
* ?X :name "paul"
*
*
* This can be most easily achieved by lifting the former out into a named
* subquery.
*
* @see ASTBottomUpOptimizer
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public void test_bottomUpOptimizer_join_scope_1()
throws MalformedQueryException {
final String queryStr = "" + //
"PREFIX : ?X
* in the intermediate join group. This test verifies that we DO NOT rewrite
* the query.
*/
public void test_wellDesigned01()
throws MalformedQueryException {
final String queryStr = "" + //
"PREFIX : ?o1 . " +
" { ?s ?o2 } " +
" UNION " +
" { " +
" ?s ?o3 . " +
" OPTIONAL { ?s ?o1 } " +
" }" +
"}";
/*
* Add the Values used in the query to the lexicon. This makes it
* possible for us to explicitly construct the expected AST and
* the verify it using equals().
*/
final BigdataValueFactory f = store.getValueFactory();
final BigdataURI p1 = f.createURI("http://example/p1");
final BigdataURI p2 = f.createURI("http://example/p2");
final BigdataURI p3 = f.createURI("http://example/p3");
final BigdataValue[] values = new BigdataValue[] { p1, p2, p3 };
store.getLexiconRelation().
addTerms(values, values.length, false/* readOnly */);
final ASTContainer astContainer =
new Bigdata2ASTSPARQLParser().parseQuery2(queryStr, baseURI);
final AST2BOpContext context = new AST2BOpContext(astContainer, store);
QueryRoot queryRoot = astContainer.getOriginalAST();
queryRoot = (QueryRoot) new ASTBottomUpOptimizer().
optimize(context, new QueryNodeWithBindingSet(queryRoot, null))
.getQueryNode();
final Iterator itr = BOpUtility.visitAll(
queryRoot.getWhereClause(), NamedSubqueryInclude.class);
assertTrue(itr.hasNext());
assertThat(null, is(not(itr.next())));
assertFalse(itr.hasNext());
}
/**
* This test is be based on Filter-nested - 2 (Filter on
* variable ?v which is not in scope).
*
*
* PREFIX :
*
* This is one of the DAWG "bottom-up" evaluation semantics tests.
* ?v is not bound in the FILTER because it is evaluated with
* bottom up semantics and therefore the bindings from the parent group are
* not visible.
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public void test_bottomUpOptimizer_filter_nested_2()
throws MalformedQueryException {
final String queryStr = "" + //
"PREFIX : ?v is bound in the input {@link IBindingSet}[]. In
* this case we can not rewrite the filter.
*
*
* PREFIX :
*
* @throws MalformedQueryException
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public void test_bottomUpOptimizer_filter_nested_2_withBindings()
throws MalformedQueryException {
final String queryStr = "" + //
"PREFIX : > globallyScopedVars = new HashSet>();
globallyScopedVars.add(Var.var("v"));
context.setSolutionSetStats(SolutionSetStatserator.get(bindingSets));
context.setGloballyScopedVariables(globallyScopedVars);
queryRoot =
(QueryRoot) new ASTBottomUpOptimizer().optimize(
context, new QueryNodeWithBindingSet(queryRoot, bindingSets))
.getQueryNode();
diff(expected, queryRoot);
}
/**
* Unit test for filter with a variable which is never bound (this has
* nothing to do with the variable scoping).
*
*
* SELECT ?v
* { :x :p ?v . FILTER(?w = 1) }
*
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public void test_bottomUpOptimizer_filter_unboundVar()
throws MalformedQueryException {
final String queryStr = "" + //
"PREFIX :
* PREFIX :
*
* Reading [1], it appears "SELECT *" is a special case:
*
*
* SELECT * { P } v is in-scope in P
*
*
* Thus, we need to handle v as if it were an exogenous variable for this
* query, which is to say that we would just execute it normally.
*
* This case is a bit puzzling. As other TCK examples show, you can have a
* badly designed left join pattern with SELECT * so this only
* appear to affect the visibility of ?v in the FILTER?
*
* [1] http://www.w3.org/TR/sparql11-query/#variableScope
*
* @see ASTBottomUpOptimizer
*/
public void test_opt_filter_1() throws Exception {
final String queryStr = "" + //
"PREFIX :
* PREFIX :
*
* This query does not need to be rewritten for bottom up semantics, so the
* expected AST is the same as the given AST.
*/
public void test_minus_sharedVariables() {
/*
* Note: DO NOT share structures in this test!!!!
*/
final IBindingSet[] bsets = new IBindingSet[] {};
final IV p = makeIV(new URIImpl("http://example/p"));
final IV q = makeIV(new URIImpl("http://example/q"));
// The source AST.
final QueryRoot given = new QueryRoot(QueryType.SELECT);
{
final ProjectionNode projection = new ProjectionNode();
given.setProjection(projection);
projection.addProjectionVar(new VarNode("a"));
projection.addProjectionVar(new VarNode("n"));
final JoinGroupNode whereClause = new JoinGroupNode();
given.setWhereClause(whereClause);
whereClause.addChild(new StatementPatternNode(new VarNode("a"),
new ConstantNode(p), new VarNode("n")));
final JoinGroupNode minusGroup = new JoinGroupNode();
whereClause.addChild(minusGroup);
minusGroup.setMinus(true);
minusGroup.addChild(new StatementPatternNode(new VarNode("a"),
new ConstantNode(q), new VarNode("n")));
}
// The expected AST after the rewrite.
final QueryRoot expected = new QueryRoot(QueryType.SELECT);
{
final ProjectionNode projection = new ProjectionNode();
expected.setProjection(projection);
projection.addProjectionVar(new VarNode("a"));
projection.addProjectionVar(new VarNode("n"));
final JoinGroupNode whereClause = new JoinGroupNode();
expected.setWhereClause(whereClause);
whereClause.addChild(new StatementPatternNode(new VarNode("a"),
new ConstantNode(p), new VarNode("n")));
final JoinGroupNode minusGroup = new JoinGroupNode();
whereClause.addChild(minusGroup);
minusGroup.setMinus(true);
minusGroup.addChild(new StatementPatternNode(new VarNode("a"),
new ConstantNode(q), new VarNode("n")));
}
final IASTOptimizer rewriter = new ASTBottomUpOptimizer();
final IQueryNode actual = rewriter.optimize(null/* AST2BOpContext */,
new QueryNodeWithBindingSet(given, bsets)).getQueryNode();
assertSameAST(expected, actual);
}
/**
* For this case, there are no shared variables so the MINUS group can just
* be eliminated (it can not produce any solutions which would be removed
* from the parent group).
*
* This example is from the SPARQL 1.1 LCWD.
*
*
* PREFIX :
*
* This expected result is:
*
*
* PREFIX :
*/
public void test_minus_noSharedVariables() {
/*
* Note: DO NOT share structures in this test!!!!
*/
final IBindingSet[] bsets = new IBindingSet[] {};
// The source AST.
final QueryRoot given = new QueryRoot(QueryType.SELECT);
{
final ProjectionNode projection = new ProjectionNode();
given.setProjection(projection);
projection.addProjectionVar(new VarNode("s"));
projection.addProjectionVar(new VarNode("p"));
projection.addProjectionVar(new VarNode("o"));
final JoinGroupNode whereClause = new JoinGroupNode();
given.setWhereClause(whereClause);
whereClause.addChild(new StatementPatternNode(new VarNode("s"),
new VarNode("p"), new VarNode("o")));
final JoinGroupNode minusGroup = new JoinGroupNode();
whereClause.addChild(minusGroup);
minusGroup.setMinus(true);
minusGroup.addChild(new StatementPatternNode(new VarNode("z"),
new VarNode("x"), new VarNode("y")));
}
// The expected AST after the rewrite.
final QueryRoot expected = new QueryRoot(QueryType.SELECT);
{
final ProjectionNode projection = new ProjectionNode();
expected.setProjection(projection);
projection.addProjectionVar(new VarNode("s"));
projection.addProjectionVar(new VarNode("p"));
projection.addProjectionVar(new VarNode("o"));
final JoinGroupNode whereClause = new JoinGroupNode();
expected.setWhereClause(whereClause);
whereClause.addChild(new StatementPatternNode(new VarNode("s"),
new VarNode("p"), new VarNode("o")));
}
final IASTOptimizer rewriter = new ASTBottomUpOptimizer();
final IQueryNode actual = rewriter.optimize(null/* AST2BOpContext */,
new QueryNodeWithBindingSet(given, bsets)).getQueryNode();
// remove explain hints in actual ast before comparing
ExplainHints.removeExplainHintAnnotationsFromBOp(actual);
assertSameAST(expected, actual);
}
// Note: This was not actually a bottom up evaluation problem at all.
//
// /**
// * This is a bottom up semantics test from the openrdf services test suite.
// * There are no shared variables for the two SERVICE clauses. This means
// * that we need to lift them out into named subqueries in order to have
// * bottom up evaluation semantics.
// *
// *
// * # Test for SES 899
// *
// * PREFIX :
// *
// * SELECT ?a ?b
// * {
// * SERVICE {
// * ?a a ?t1
// * filter(?t1 = owl:Class)
// * }
// * SERVICE {
// * ?b a ?t2
// * filter(?t2 = owl:Class)
// * }
// *
// * }
// *
// */
// @SuppressWarnings({ "rawtypes", "unchecked" })
// public void test_service13() {
//
// /*
// * Note: DO NOT share structures in this test!!!!
// */
// final IBindingSet[] bsets = new IBindingSet[] {};
//
// /*
// * Add the Values used in the query to the lexicon. This makes it
// * possible for us to explicitly construct the expected AST and
// * the verify it using equals().
// */
// final BigdataValueFactory f = store.getValueFactory();
// final BigdataURI rdfType = f.asValue(RDF.TYPE);
// final BigdataURI owlClass = f.asValue(OWL.CLASS);
// final BigdataURI endpoint1 = f.createURI("http://localhost:18080/openrdf/repositories/endpoint1");
// final BigdataValue[] values = new BigdataValue[] { rdfType, owlClass, endpoint1 };
// store.getLexiconRelation()
// .addTerms(values, values.length, false/* readOnly */);
//
// /**
// * The source AST.
// *
// *
// * PREFIX :
// * PREFIX owl:
// * QueryType: SELECT
// * SELECT VarNode(a) VarNode(b)
// * JoinGroupNode {
// * SERVICE {
// * JoinGroupNode {
// * StatementPatternNode(VarNode(a), ConstantNode(Vocab(14)), VarNode(t1), DEFAULT_CONTEXTS)
// * FILTER( com.bigdata.rdf.sparql.ast.FunctionNode(VarNode(t1),ConstantNode(Vocab(39)))[ com.bigdata.rdf.sparql.ast.FunctionNode.functionURI=http://www.w3.org/2005/xpath-functions#equal-to] )
// * }
// * }
// * SERVICE {
// * JoinGroupNode {
// * StatementPatternNode(VarNode(b), ConstantNode(Vocab(14)), VarNode(t2), DEFAULT_CONTEXTS)
// * FILTER( com.bigdata.rdf.sparql.ast.FunctionNode(VarNode(t2),ConstantNode(Vocab(39)))[ com.bigdata.rdf.sparql.ast.FunctionNode.functionURI=http://www.w3.org/2005/xpath-functions#equal-to] )
// * }
// * }
// * }
// *
// */
// final QueryRoot given = new QueryRoot(QueryType.SELECT);
// {
//
// final Map prefixDecls = new LinkedHashMap();
// prefixDecls.put("", "http://example.org");
// prefixDecls.put("owl", "http://www.w3.org/2002/07/owl#");
// given.setPrefixDecls(prefixDecls);
//
// final ProjectionNode projection = new ProjectionNode();
// given.setProjection(projection);
//
// projection.addProjectionVar(new VarNode("a"));
// projection.addProjectionVar(new VarNode("b"));
//
// final JoinGroupNode whereClause = new JoinGroupNode();
// given.setWhereClause(whereClause);
//
// {
// final JoinGroupNode serviceGroup = new JoinGroupNode();
// serviceGroup.addChild(new StatementPatternNode(new VarNode("a"),
// new ConstantNode(new Constant(rdfType.getIV())),
// new VarNode("t1")));
// serviceGroup.addChild(new FilterNode(FunctionNode.EQ(
// new VarNode("t1"), new ConstantNode(new Constant(
// owlClass.getIV())))));
// final TermNode serviceRef = new ConstantNode(new Constant(
// endpoint1.getIV()));
// final ServiceNode service = new ServiceNode(serviceRef,
// serviceGroup);
// whereClause.addChild(service);
// }
//
// {
// final JoinGroupNode serviceGroup = new JoinGroupNode();
// serviceGroup.addChild(new StatementPatternNode(new VarNode("b"),
// new ConstantNode(new Constant(rdfType.getIV())),
// new VarNode("t2")));
// serviceGroup.addChild(new FilterNode(FunctionNode.EQ(
// new VarNode("t2"), new ConstantNode(new Constant(
// owlClass.getIV())))));
// final TermNode serviceRef = new ConstantNode(new Constant(
// endpoint1.getIV()));
// final ServiceNode service = new ServiceNode(serviceRef,
// serviceGroup);
// whereClause.addChild(service);
// }
//
// }
//
// // The expected AST after the rewrite.
// final QueryRoot expected = new QueryRoot(QueryType.SELECT);
// {
//
// final Map prefixDecls = new LinkedHashMap();
// prefixDecls.put("", "http://example.org");
// prefixDecls.put("owl", "http://www.w3.org/2002/07/owl#");
// expected.setPrefixDecls(prefixDecls);
//
// final ProjectionNode projection = new ProjectionNode();
// expected.setProjection(projection);
//
// projection.addProjectionVar(new VarNode("a"));
// projection.addProjectionVar(new VarNode("b"));
//
// final NamedSubqueriesNode nsn = expected.getNamedSubqueriesNotNull();
// final String name1 = "name1";
// final String name2 = "name2";
//
// final JoinGroupNode whereClause = new JoinGroupNode();
// expected.setWhereClause(whereClause);
//
// {
// final JoinGroupNode serviceGroup = new JoinGroupNode();
// serviceGroup.addChild(new StatementPatternNode(new VarNode("a"),
// new ConstantNode(new Constant(rdfType.getIV())),
// new VarNode("t1")));
// serviceGroup.addChild(new FilterNode(FunctionNode.EQ(
// new VarNode("t1"), new ConstantNode(new Constant(
// owlClass.getIV())))));
// final TermNode serviceRef = new ConstantNode(new Constant(
// endpoint1.getIV()));
// final ServiceNode service = new ServiceNode(serviceRef,
// serviceGroup);
// final NamedSubqueryRoot nsr = new NamedSubqueryRoot(
// QueryType.SELECT, name1);
// nsr.setWhereClause(new JoinGroupNode(service));
// nsn.add(nsr);
// whereClause.addChild(new NamedSubqueryInclude(name1));
// }
//
// {
// final JoinGroupNode serviceGroup = new JoinGroupNode();
// serviceGroup.addChild(new StatementPatternNode(new VarNode("b"),
// new ConstantNode(new Constant(rdfType.getIV())),
// new VarNode("t2")));
// serviceGroup.addChild(new FilterNode(FunctionNode.EQ(
// new VarNode("t2"), new ConstantNode(new Constant(
// owlClass.getIV())))));
// final TermNode serviceRef = new ConstantNode(new Constant(
// endpoint1.getIV()));
// final ServiceNode service = new ServiceNode(serviceRef,
// serviceGroup);
// final NamedSubqueryRoot nsr = new NamedSubqueryRoot(
// QueryType.SELECT, name2);
// nsr.setWhereClause(new JoinGroupNode(service));
// nsn.add(nsr);
// whereClause.addChild(new NamedSubqueryInclude(name2));
// }
//
// }
//
// final IASTOptimizer rewriter = new ASTBottomUpOptimizer();
//
// final IQueryNode actual = rewriter.optimize(null/* AST2BOpContext */,
// given/* queryNode */, bsets);
//
// assertSameAST(expected, actual);
//
// }
// /**
// * The variable ?n in the FILTER is the same as the
// * variable ?n in the outer join group. It must not be
// * rewritten into an anonymous variable.
// *
// * PREFIX rdf:
// * PREFIX foaf:
// */
// public void test_exists_filter_variable_scope_01() {
//
// /*
// * Note: DO NOT share structures in this test!!!!
// */
// final IBindingSet[] bsets = new IBindingSet[] {};
//
// final IV rdfType = makeIV(RDF.TYPE);
// final IV foafPerson = makeIV(FOAFVocabularyDecl.Person);
//
// // The source AST.
// final QueryRoot given = new QueryRoot(QueryType.SELECT);
// {
//
// final ProjectionNode projection = new ProjectionNode();
// given.setProjection(projection);
//
// projection.setDistinct(true);
// projection.addProjectionVar(new VarNode("x"));
//
// final JoinGroupNode whereClause = new JoinGroupNode();
// given.setWhereClause(whereClause);
//
// whereClause.addChild(new StatementPatternNode(new VarNode("x"),
// new VarNode("p"), new VarNode("o")));
//
// {
//
// final JoinGroupNode existsGroup = new JoinGroupNode();
//
// existsGroup
// .addChild(new StatementPatternNode(new VarNode("x"),
// new ConstantNode(rdfType), new ConstantNode(
// foafPerson)));
//
// final FilterNode outerFilter = new FilterNode(
// new NotExistsNode(new VarNode("--anonVar"), existsGroup));
//
// whereClause.addChild(outerFilter);
//
// }
//
// }
//
// // The expected AST after the rewrite.
// final QueryRoot expected = new QueryRoot(QueryType.SELECT);
// {
//
// final ProjectionNode projection = new ProjectionNode();
// expected.setProjection(projection);
//
// projection.setDistinct(true);
// projection.addProjectionVar(new VarNode("x"));
//
// final JoinGroupNode whereClause = new JoinGroupNode();
// expected.setWhereClause(whereClause);
//
// whereClause.addChild(new StatementPatternNode(new VarNode("x"),
// new VarNode("p"), new VarNode("o")));
//
// {
//
// final JoinGroupNode existsGroup = new JoinGroupNode();
//
// existsGroup
// .addChild(new StatementPatternNode(new VarNode("x"),
// new ConstantNode(rdfType), new ConstantNode(
// foafPerson)));
//
// final FilterNode outerFilter = new FilterNode(
// new NotExistsNode(new VarNode("--anonVar"), existsGroup));
//
// whereClause.addChild(outerFilter);
//
// }
//
// }
//
// {
//
//// final IBindingSet[] bindingSets = new IBindingSet[] {};
//
// final ASTContainer astContainer = new ASTContainer(given);
//
// final AST2BOpContext context = new AST2BOpContext(astContainer,
// store);
//
// // TODO the ASK subquery needs to be setup correctly for this test
//
// IQueryNode actual;
//
// actual = new ASTExistsOptimizer().optimize(context,
// given/* queryNode */, bsets);
//
// actual = new ASTBottomUpOptimizer().optimize(context,
// given/* queryNode */, bsets);
//
// assertSameAST(expected, actual);
//
// }
//
// }
//
// /**
// * The variable ?n in the inner FILTER is the same as the
// * variable ?n in the outer join group. It must not be
// * rewritten into an anonymous variable.
// *
// * This example is from the SPARQL 1.1 LCWD.
// *
// *
// * PREFIX :
// */
// public void test_exists_filter_variable_scope_02() {
//
// /*
// * Note: DO NOT share structures in this test!!!!
// */
// final IBindingSet[] bsets = new IBindingSet[] {};
//
// final IV p = makeIV(new URIImpl("http://example.com/p"));
// final IV q = makeIV(new URIImpl("http://example.com/q"));
//
// // The source AST.
// final QueryRoot given = new QueryRoot(QueryType.SELECT);
// {
//
// final ProjectionNode projection = new ProjectionNode();
// given.setProjection(projection);
//
// projection.addProjectionVar(new VarNode("a"));
// projection.addProjectionVar(new VarNode("n"));
//
// final JoinGroupNode whereClause = new JoinGroupNode();
// given.setWhereClause(whereClause);
//
// whereClause.addChild(new StatementPatternNode(new VarNode("a"),
// new ConstantNode(p), new VarNode("n")));
//
// {
//
// final JoinGroupNode existsGroup = new JoinGroupNode();
//
// existsGroup.addChild(new StatementPatternNode(new VarNode("a"),
// new ConstantNode(q), new VarNode("m")));
//
// final FilterNode innerFilter = new FilterNode(
// FunctionNode.sameTerm(new VarNode("n"),
// new VarNode("m")));
//
// existsGroup.addChild(innerFilter);
//
// final FilterNode outerFilter = new FilterNode(
// new NotExistsNode(new VarNode("--anonVar"), existsGroup));
//
// whereClause.addChild(outerFilter);
//
// }
//
// }
//
// // The expected AST after the rewrite.
// final QueryRoot expected = new QueryRoot(QueryType.SELECT);
// {
//
// final ProjectionNode projection = new ProjectionNode();
// expected.setProjection(projection);
//
// projection.addProjectionVar(new VarNode("a"));
// projection.addProjectionVar(new VarNode("n"));
//
// final JoinGroupNode whereClause = new JoinGroupNode();
// expected.setWhereClause(whereClause);
//
// whereClause.addChild(new StatementPatternNode(new VarNode("a"),
// new ConstantNode(p), new VarNode("n")));
//
// {
//
// final JoinGroupNode existsGroup = new JoinGroupNode();
//
// existsGroup.addChild(new StatementPatternNode(new VarNode("a"),
// new ConstantNode(q), new VarNode("m")));
//
// final FilterNode innerFilter = new FilterNode(
// FunctionNode.sameTerm(new VarNode("n"),
// new VarNode("m")));
//
// existsGroup.addChild(innerFilter);
//
// final FilterNode outerFilter = new FilterNode(
// new NotExistsNode(new VarNode("--anonVar"), existsGroup));
//
// whereClause.addChild(outerFilter);
//
// }
//
// }
//
// {
//
//// final IBindingSet[] bindingSets = new IBindingSet[] {};
//
// final ASTContainer astContainer = new ASTContainer(given);
//
// final AST2BOpContext context = new AST2BOpContext(astContainer,
// store);
//
// // TODO the ASK subquery needs to be setup correctly for this test
//
// final IASTOptimizer rewriter = new ASTBottomUpOptimizer();
//
// final IQueryNode actual = rewriter.optimize(context,
// given/* queryNode */, bsets);
//
// assertSameAST(expected, actual);
//
// }
//
// }
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy