bigdata-commit Mailing List for Blazegraph (powered by bigdata) (Page 5)

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 8635
          http://sourceforge.net/p/bigdata/code/8635
Author:   mrpersonick
Date:     2014-09-02 15:01:44 +0000 (Tue, 02 Sep 2014)
Log Message:
-----------
Ticket #714: Sesame 2.7.  Committing Bryan's changes for inline VALUES.

Modified Paths:
--------------
    branches/SESAME_2_7/bigdata/src/java/com/bigdata/bop/join/HashIndexOp.java
    branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/BindingsClause.java
    branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/CompiledSolutionSetStats.java
    branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/StaticAnalysis.java
    branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/eval/AST2BOpUtility.java
    branches/SESAME_2_7/bigdata-sails/src/test/com/bigdata/rdf/sail/tck/BigdataComplexSparqlQueryTest.java

Modified: branches/SESAME_2_7/bigdata/src/java/com/bigdata/bop/join/HashIndexOp.java
===================================================================

--- branches/SESAME_2_7/bigdata/src/java/com/bigdata/bop/join/HashIndexOp.java	2014-09-02 14:36:42 UTC (rev 8634)
+++ branches/SESAME_2_7/bigdata/src/java/com/bigdata/bop/join/HashIndexOp.java	2014-09-02 15:01:44 UTC (rev 8635)
@@ -49,6 +49,7 @@
 import com.bigdata.relation.accesspath.UnsyncLocalOutputBuffer;
 
 import cutthecrap.utils.striterators.ICloseableIterator;
+import cutthecrap.utils.striterators.SingleValueIterator;
 
 /**
  * Operator builds a hash index from the source solutions. Once all source
@@ -100,6 +101,17 @@
          */
         final String NAMED_SET_SOURCE_REF = "namedSetSourceRef";
 
+        /**
+         * An optional attribute specifying the <em>source</em> IBindingSet[]
+         * for the index build operation. Normally, the hash index is built from
+         * the solutions flowing through the pipeline. When this attribute is
+         * specified, the hash index is instead built from the solutions in the
+         * specified IBindingSet[]. Regardless, the solutions flowing through
+         * the pipeline are copied to the sink once the hash index has been
+         * built.
+         */
+        final String BINDING_SETS_SOURCE = "bindingSets";
+        
     }
 
     /**
@@ -138,20 +150,10 @@
                     BOp.Annotations.EVALUATION_CONTEXT + "="
                             + getEvaluationContext());
         }
-//        if (getEvaluationContext() != BOpEvaluationContext.CONTROLLER) {
-//            throw new IllegalArgumentException(
-//                    BOp.Annotations.EVALUATION_CONTEXT + "="
-//                            + getEvaluationContext());
-//        }
-
-        if (getMaxParallel() != 1) {
-            /*
-             * Parallel evaluation is not allowed. This operator writes on an
-             * object that is not thread-safe for mutation.
-             */
+        if (getEvaluationContext() != BOpEvaluationContext.CONTROLLER) {
             throw new IllegalArgumentException(
-                    PipelineOp.Annotations.MAX_PARALLEL + "="
-                            + getMaxParallel());
+                    BOp.Annotations.EVALUATION_CONTEXT + "="
+                            + getEvaluationContext());
         }
 
         if (!isLastPassRequested()) {
@@ -224,11 +226,11 @@
         
     }
     
-	/**
-	 * Evaluates the subquery for each source binding set. If the controller
-	 * operator is interrupted, then the subqueries are cancelled. If a subquery
-	 * fails, then all subqueries are cancelled.
-	 */
+    /**
+     * Evaluates the subquery for each source binding set. If the controller
+     * operator is interrupted, then the subqueries are cancelled. If a subquery
+     * fails, then all subqueries are cancelled.
+     */
     private static class ChunkTask implements Callable<Void> {
 
         private final BOpContext<IBindingSet> context;
@@ -268,7 +270,7 @@
             
             this.stats = ((NamedSolutionSetStats) context.getStats());
 
-            // Metadata to identify the named solution set.
+            // Metadata to identify the target named solution set.
             final INamedSolutionSetRef namedSetRef = (INamedSolutionSetRef) op
                     .getRequiredProperty(Annotations.NAMED_SET_REF);
 
@@ -312,8 +314,10 @@
             }
             
             // true iff we will build the index from the pipeline.
-            this.sourceIsPipeline = null == op
-                    .getProperty(Annotations.NAMED_SET_SOURCE_REF);
+            this.sourceIsPipeline //
+                = (op.getProperty(Annotations.NAMED_SET_SOURCE_REF) == null)
+                && (op.getProperty(Annotations.BINDING_SETS_SOURCE) == null)
+                ;
 
         }
         
@@ -390,7 +394,7 @@
             
                 src = context.getSource();
                 
-            } else {
+            } else if (op.getProperty(Annotations.NAMED_SET_SOURCE_REF) != null) {
                 
                 /*
                  * Metadata to identify the optional *source* solution set. When
@@ -403,6 +407,22 @@
 
                 src = context.getAlternateSource(namedSetSourceRef);
                 
+            } else if (op.getProperty(Annotations.BINDING_SETS_SOURCE) != null) {
+
+                /*
+                 * The IBindingSet[] is directly given. Just wrap it up as an
+                 * iterator. It will visit a single chunk of solutions.
+                 */
+                final IBindingSet[] bindingSets = (IBindingSet[]) op
+                        .getProperty(Annotations.BINDING_SETS_SOURCE);
+
+                src = new SingleValueIterator<IBindingSet[]>(bindingSets);
+                
+            } else {
+
+                throw new UnsupportedOperationException(
+                        "Source was not specified");
+                
             }
 
             try {

Modified: branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/BindingsClause.java
===================================================================
--- branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/BindingsClause.java	2014-09-02 14:36:42 UTC (rev 8634)
+++ branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/BindingsClause.java	2014-09-02 15:01:44 UTC (rev 8635)
@@ -166,6 +166,7 @@
 
     }
 
+    @Override
     public String toString(final int indent) {
 
         final LinkedHashSet<IVariable<?>> declaredVars = getDeclaredVariables();

Modified: branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/CompiledSolutionSetStats.java
===================================================================
--- branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/CompiledSolutionSetStats.java	2014-09-02 14:36:42 UTC (rev 8634)
+++ branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/CompiledSolutionSetStats.java	2014-09-02 15:01:44 UTC (rev 8635)
@@ -148,6 +148,7 @@
 
 	}
 
+	@Override
 	public String toString() {
 
 		final StringBuilder sb = new StringBuilder();

Modified: branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/StaticAnalysis.java
===================================================================
--- branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/StaticAnalysis.java	2014-09-02 14:36:42 UTC (rev 8634)
+++ branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/StaticAnalysis.java	2014-09-02 15:01:44 UTC (rev 8635)
@@ -2125,7 +2125,51 @@
 
     }
     
+    /**
+     * Return the join variables for a VALUES clause (embedded only - not
+     * top-level).
+     * 
+     * @param bc The VALUES clause (a bunch of solutions)
+     * @param stats A static analysis of those solutions.
+     * @param vars
+     * @return 
+     */
+    public Set<IVariable<?>> getJoinVars(final BindingsClause bc,
+            final ISolutionSetStats stats,
+            final Set<IVariable<?>> vars) {
 
+        /*
+         * The variables which will be definitely bound based on the solutions
+         * in the VALUES clause.
+         * 
+         * Note: Collection is not modifyable, so we copy it.
+         */
+        final Set<IVariable<?>> boundByBindingsClause = new LinkedHashSet<IVariable<?>>(
+                stats.getAlwaysBound());
+
+        /*
+         * The variables which are definitely bound on entry to the join group
+         * in which the VALUES clause appears.
+         */
+        final Set<IVariable<?>> incomingBindings = getDefinitelyIncomingBindings(
+                bc, new LinkedHashSet<IVariable<?>>());
+        
+        /*
+         * This is only those variables which are bound on entry into the group
+         * in which the VALUES join appears *and* which are "must" bound
+         * variables projected by the VALUES.
+         * 
+         * FIXME Is this the correct semantics? I followed the pattern for SERVICE.
+         */
+        boundByBindingsClause.retainAll(incomingBindings);
+            
+        vars.addAll(boundByBindingsClause);
+
+        return vars;
+
+    }
+    
+
     /**
 	 * Return the join variables for an INCLUDE of a pre-existing named solution
 	 * set.

Modified: branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/eval/AST2BOpUtility.java
===================================================================
--- branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/eval/AST2BOpUtility.java	2014-09-02 14:36:42 UTC (rev 8634)
+++ branches/SESAME_2_7/bigdata-rdf/src/java/com/bigdata/rdf/sparql/ast/eval/AST2BOpUtility.java	2014-09-02 15:01:44 UTC (rev 8635)
@@ -61,6 +61,7 @@
 import com.bigdata.bop.join.JoinAnnotations;
 import com.bigdata.bop.join.JoinTypeEnum;
 import com.bigdata.bop.join.NestedLoopJoinOp;
+import com.bigdata.bop.join.SolutionSetHashJoinOp;
 import com.bigdata.bop.paths.ArbitraryLengthPathOp;
 import com.bigdata.bop.paths.ZeroLengthPathOp;
 import com.bigdata.bop.rdf.join.ChunkedMaterializationOp;
@@ -90,7 +91,6 @@
 import com.bigdata.rdf.internal.constraints.INeedsMaterialization.Requirement;
 import com.bigdata.rdf.internal.constraints.InBOp;
 import com.bigdata.rdf.internal.constraints.IsBoundBOp;
-import com.bigdata.rdf.internal.constraints.NowBOp;
 import com.bigdata.rdf.internal.constraints.ProjectedConstraint;
 import com.bigdata.rdf.internal.constraints.SPARQLConstraint;
 import com.bigdata.rdf.internal.constraints.TryBeforeMaterializationConstraint;
@@ -154,6 +154,7 @@
 import com.bigdata.rdf.spo.SPOPredicate;
 import com.bigdata.rdf.store.AbstractTripleStore;
 import com.bigdata.relation.accesspath.ElementFilter;
+import com.bigdata.striterator.Chunkerator;
 
 import cutthecrap.utils.striterators.FilterBase;
 import cutthecrap.utils.striterators.IFilter;
@@ -1469,14 +1470,184 @@
     }
 
     /**
-     * TODO Grab the binding sets from the BindingsClause, attach them to
-     * the query as a named subquery with a hash index, and then add a 
-     * named subquery include to the pipeline right here.
+     * This handles a VALUES clause. It grabs the binding sets from the
+     * BindingsClause, attach them to the query as a named subquery with a hash
+     * index, and then add a named subquery include to the pipeline right here.
+     * <p>
+     * The VALUES are interpreted using a solution set hash join. The "plan" for
+     * the hash join of the VALUES with the solutions flowing through the
+     * pipeline is: (a) we take the IBindingSet[] and use a {@link HashIndexOp}
+     * to generate the hash index; and (b) we use a
+     * {@link SolutionSetHashJoinOp} to join the solutions from the pipeline
+     * with those in the hash index. Both JVM and HTree versions of this plan
+     * are supported.
+     * <p>
+     * 1. {@link HashIndexOp} (JVM or HTree): Specify the IBindingSet[] as the
+     * source. When the HashIndexOp runs, it will build a hash index from the
+     * IBindingSet[].
+     * <p>
+     * Note: The join variables need to be set based on the known bound
+     * variables in the context where we will evaluate the solution set hash
+     * join (head of the sub-SELECT, OPTIONAL) and those that are bound by the
+     * solution set hash join.
+     * <p>
+     * Note: The static analysis code needs to examine the definitely, and maybe
+     * produced bindings for the {@link BindingsClause}. See the
+     * {@link ISolutionSetStats} interface and
+     * {@link SolutionSetStatserator#get(IBindingSet[])} for a convenience
+     * method.
+     * <p>
+     * 2. {@link SolutionSetHashJoinOp} (JVM or HTree): Joins the solutions
+     * flowing into the sub-query or update with the solutions from the
+     * HashIndexOp. This will take each solution from the pipeline, probe the
+     * hash index for solutions specified by the VALUES clause, and then do a
+     * JOIN for each such solution that is discovered.
      */
     private static PipelineOp addValues(PipelineOp left,
-            final BindingsClause bc,
+            final BindingsClause bindingsClause,
             final Set<IVariable<?>> doneSet, final AST2BOpContext ctx) {
 
+        // Convert solutions from VALUES clause to an IBindingSet[].
+        final IBindingSet[] bindingSets = BOpUtility.toArray(
+                new Chunkerator<IBindingSet>(bindingsClause.getBindingSets().iterator()),//
+                null/*stats*/
+                );
+        
+        // Static analysis of the VALUES solutions.
+        final ISolutionSetStats bindingsClauseStats = SolutionSetStatserator
+                .get(bindingSets);
+        
+        @SuppressWarnings("rawtypes")
+        final Map<IConstraint, Set<IVariable<IV>>> needsMaterialization = new LinkedHashMap<IConstraint, Set<IVariable<IV>>>();
+
+        /*
+         * BindingsClause is an IBindingsProducer, but it should also be
+         * an IJoinNode. That will let us attach constraints
+         * (getJoinConstraints()) and identify the join variables for the VALUES
+         * sub-plan (getJoinVars()).
+         */
+        final IConstraint[] joinConstraints = getJoinConstraints(
+                getJoinConstraints(bindingsClause), needsMaterialization);
+
+        /*
+         * Model the VALUES JOIN by building a hash index over the IBindingSet[]
+         * from the VALUES clause. Then use a solution set hash join to join the
+         * solutions flowing through the pipeline with those in the hash index.
+         */
+        final String solutionSetName = "--values-" + ctx.nextId(); // Unique name.
+
+        final Set<IVariable<?>> joinVarSet = ctx.sa.getJoinVars(bindingsClause,
+                bindingsClauseStats, new LinkedHashSet<IVariable<?>>());
+
+        @SuppressWarnings("rawtypes")
+        final IVariable[] joinVars = joinVarSet.toArray(new IVariable[0]);
+
+//            if (joinVars.length == 0) {
+//
+//                /*
+//                 * Note: If there are no join variables then the join will
+//                 * examine the full N x M cross product of solutions. That is
+//                 * very inefficient, so we are logging a warning.
+//                 */
+//
+//                log.warn("No join variables: " + subqueryRoot);
+//                
+//            }
+        
+        final INamedSolutionSetRef namedSolutionSet = NamedSolutionSetRefUtility.newInstance(
+                ctx.queryId, solutionSetName, joinVars);
+
+        // VALUES is not optional.
+        final JoinTypeEnum joinType = JoinTypeEnum.Normal;
+
+        // lastPass is required except for normal joins.
+        final boolean lastPass = false; 
+
+        // true if we will release the HTree as soon as the join is done.
+        // Note: also requires lastPass.
+        final boolean release = lastPass;
+
+        // join can be pipelined unless last pass evaluation is required
+        final int maxParallel = lastPass ? 1
+                : ctx.maxParallelForSolutionSetHashJoin;
+
+        // Generate the hash index operator.
+        if(ctx.nativeHashJoins) {
+            left = applyQueryHints(new HTreeHashIndexOp(leftOrEmpty(left),//
+                new NV(BOp.Annotations.BOP_ID, ctx.nextId()),//
+                new NV(BOp.Annotations.EVALUATION_CONTEXT,
+                        BOpEvaluationContext.CONTROLLER),//
+                new NV(PipelineOp.Annotations.MAX_PARALLEL, 1),// required for lastPass
+                new NV(PipelineOp.Annotations.LAST_PASS, true),// required
+                new NV(PipelineOp.Annotations.SHARED_STATE, true),// live stats.
+                new NV(HTreeHashIndexOp.Annotations.RELATION_NAME, new String[]{ctx.getLexiconNamespace()}),//                    new NV(HTreeHashIndexOp.Annotations.JOIN_VARS, joinVars),//
+                new NV(HTreeHashIndexOp.Annotations.JOIN_TYPE, joinType),//
+                new NV(HTreeHashIndexOp.Annotations.JOIN_VARS, joinVars),//
+                new NV(HTreeHashIndexOp.Annotations.CONSTRAINTS, joinConstraints),// Note: will be applied by the solution set hash join.
+//                    new NV(HTreeHashIndexOp.Annotations.SELECT, projectedVars),//
+                new NV(HTreeHashIndexOp.Annotations.BINDING_SETS_SOURCE, bindingSets),// source solutions from VALUES.
+                new NV(HTreeHashIndexOp.Annotations.NAMED_SET_REF, namedSolutionSet)// output named solution set.
+            ), bindingsClause, ctx);
+        } else {
+            left = applyQueryHints(new JVMHashIndexOp(leftOrEmpty(left),//
+                new NV(BOp.Annotations.BOP_ID, ctx.nextId()),//
+                new NV(BOp.Annotations.EVALUATION_CONTEXT,
+                        BOpEvaluationContext.CONTROLLER),//
+                new NV(PipelineOp.Annotations.MAX_PARALLEL, 1),// required for lastPass
+                new NV(PipelineOp.Annotations.LAST_PASS, true),// required
+                new NV(PipelineOp.Annotations.SHARED_STATE, true),// live stats.
+                new NV(JVMHashIndexOp.Annotations.JOIN_TYPE, joinType),//
+                new NV(JVMHashIndexOp.Annotations.JOIN_VARS, joinVars),//
+                new NV(JVMHashIndexOp.Annotations.CONSTRAINTS, joinConstraints),// Note: will be applied by the solution set hash join.
+//                    new NV(HTreeHashIndexOp.Annotations.SELECT, projectedVars),//
+                new NV(HTreeHashIndexOp.Annotations.BINDING_SETS_SOURCE, bindingSets),// source solutions from VALUES.
+                new NV(JVMHashIndexOp.Annotations.NAMED_SET_REF, namedSolutionSet)// output named solution set.
+            ), bindingsClause, ctx);
+        }
+
+        // Generate the solution set hash join operator.
+        if(ctx.nativeHashJoins) {
+            left = applyQueryHints(new HTreeSolutionSetHashJoinOp(
+                leftOrEmpty(left),//
+                new NV(BOp.Annotations.BOP_ID, ctx.nextId()),//
+                new NV(BOp.Annotations.EVALUATION_CONTEXT,
+                        BOpEvaluationContext.CONTROLLER),//
+                new NV(PipelineOp.Annotations.MAX_PARALLEL, maxParallel),//
+                new NV(PipelineOp.Annotations.SHARED_STATE, true),// live stats.
+//                    new NV(HTreeSolutionSetHashJoinOp.Annotations.OPTIONAL, optional),//
+//                    new NV(HTreeSolutionSetHashJoinOp.Annotations.JOIN_VARS, joinVars),//
+//                    new NV(HTreeSolutionSetHashJoinOp.Annotations.SELECT, null/*all*/),// 
+//                    new NV(HTreeSolutionSetHashJoinOp.Annotations.CONSTRAINTS, joinConstraints),//
+                new NV(HTreeSolutionSetHashJoinOp.Annotations.RELEASE, release),//
+                new NV(HTreeSolutionSetHashJoinOp.Annotations.LAST_PASS, lastPass),//
+                new NV(HTreeSolutionSetHashJoinOp.Annotations.NAMED_SET_REF, namedSolutionSet)//
+            ), bindingsClause, ctx);
+        } else {
+            left = applyQueryHints(new JVMSolutionSetHashJoinOp(
+                leftOrEmpty(left),//
+                new NV(BOp.Annotations.BOP_ID, ctx.nextId()),//
+                new NV(BOp.Annotations.EVALUATION_CONTEXT,
+                        BOpEvaluationContext.CONTROLLER),//
+                new NV(PipelineOp.Annotations.MAX_PARALLEL, maxParallel),//
+                new NV(PipelineOp.Annotations.SHARED_STATE, true),// live stats.
+//                    new NV(JVMSolutionSetHashJoinOp.Annotations.OPTIONAL, optional),//
+//                    new NV(JVMSolutionSetHashJoinOp.Annotations.JOIN_VARS, joinVars),//
+//                    new NV(JVMSolutionSetHashJoinOp.Annotations.SELECT, null/*all*/),//
+//                    new NV(JVMSolutionSetHashJoinOp.Annotations.CONSTRAINTS, joinConstraints),//
+                new NV(JVMSolutionSetHashJoinOp.Annotations.RELEASE, release),//
+                new NV(JVMSolutionSetHashJoinOp.Annotations.LAST_PASS, lastPass),//
+                new NV(JVMSolutionSetHashJoinOp.Annotations.NAMED_SET_REF, namedSolutionSet)//
+            ), bindingsClause, ctx);
+        }
+
+        /*
+         * For each filter which requires materialization steps, add the
+         * materializations steps to the pipeline and then add the filter to the
+         * pipeline.
+         */
+        left = addMaterializationSteps3(left, doneSet, needsMaterialization,
+                bindingsClause.getQueryHints(), ctx);
+
         return left;
         
     }
@@ -2672,7 +2843,7 @@
                 continue;
             } else if (child instanceof BindingsClause) {
                 /*
-                 * VALUES clause
+                 * FIXME Support VALUES clause
                  */
                 left = addValues(left,
                         (BindingsClause) child, doneSet, ctx);

Modified: branches/SESAME_2_7/bigdata-sails/src/test/com/bigdata/rdf/sail/tck/BigdataComplexSparqlQueryTest.java
===================================================================
--- branches/SESAME_2_7/bigdata-sails/src/test/com/bigdata/rdf/sail/tck/BigdataComplexSparqlQueryTest.java	2014-09-02 14:36:42 UTC (rev 8634)
+++ branches/SESAME_2_7/bigdata-sails/src/test/com/bigdata/rdf/sail/tck/BigdataComplexSparqlQueryTest.java	2014-09-02 15:01:44 UTC (rev 8635)
@@ -29,12 +29,17 @@
 
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.InputStreamReader;
 import java.util.Properties;
 
 import org.apache.log4j.Logger;
 import org.junit.Test;
+import org.openrdf.model.Literal;
 import org.openrdf.model.Resource;
+import org.openrdf.model.URI;
+import org.openrdf.model.Value;
+import org.openrdf.query.BindingSet;
+import org.openrdf.query.QueryLanguage;
+import org.openrdf.query.TupleQueryResult;
 import org.openrdf.query.parser.sparql.ComplexSPARQLQueryTest;
 import org.openrdf.repository.Repository;
 import org.openrdf.repository.RepositoryException;
@@ -42,11 +47,14 @@
 import org.openrdf.rio.RDFParseException;
 
 import com.bigdata.BigdataStatics;
+import com.bigdata.bop.BOpUtility;
 import com.bigdata.journal.BufferMode;
 import com.bigdata.journal.IIndexManager;
 import com.bigdata.rdf.sail.BigdataSail;
 import com.bigdata.rdf.sail.BigdataSail.Options;
 import com.bigdata.rdf.sail.BigdataSailRepository;
+import com.bigdata.rdf.sail.BigdataSailTupleQuery;
+import com.bigdata.rdf.sparql.ast.eval.AST2BOpUtility;
 
 /**
  * Bigdata integration for the {@link ComplexSPARQLQueryTest}.
@@ -301,11 +309,55 @@
         super.testSES1991RANDEvaluation();
     }
 
+    /**
+     * The one is fixed now.
+     */
     @Override
     @Test
     public void testValuesInOptional() throws Exception {
-        if (runKnownBadTests)
         super.testValuesInOptional();
     }
+    
+    /**
+     * TODO Write optimizer to pull this BindingsClause out of the join
+     * group and make it global.
+     */
+    public void testRequiredValues() throws Exception {
+        loadTestData("/testdata-query/dataset-ses1692.trig");
+        StringBuilder query = new StringBuilder();
+        query.append(" PREFIX : <http://example.org/>\n");
+        query.append(" SELECT DISTINCT ?a ?name ?isX WHERE { ?b :p1 ?a . ?a :name ?name. ?a a :X . VALUES(?isX) { (:X) } } ");
 
+        BigdataSailTupleQuery tq = (BigdataSailTupleQuery)
+                conn.prepareTupleQuery(QueryLanguage.SPARQL, query.toString());
+        
+        if (logger.isInfoEnabled()) {
+            logger.info("optimized ast:\n"+tq.optimize());
+            logger.info("query plan:\n"+BOpUtility.toString(tq.getASTContainer().getQueryPlan()));
+        }
+
+        TupleQueryResult result = tq.evaluate();
+        assertNotNull(result);
+        assertTrue(result.hasNext());
+
+        int count = 0;
+        while (result.hasNext()) {
+            count++;
+            BindingSet bs = result.next();
+            System.out.println(bs);
+            URI a = (URI)bs.getValue("a");
+            assertNotNull(a);
+            Value isX = bs.getValue("isX");
+            Literal name = (Literal)bs.getValue("name");
+            assertNotNull(name);
+            if (a.stringValue().endsWith("a1")) {
+                assertNotNull(isX);
+            }
+            else if (a.stringValue().endsWith(("a2"))) {
+                assertNull(isX);
+            }
+        }
+        assertEquals(1, count);
+    }
+
 }

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.





2010	Jan	Feb	Mar	Apr	May	Jun	Jul (139)	Aug (94)	Sep (232)	Oct (143)	Nov (138)	Dec (55)
2011	Jan (127)	Feb (90)	Mar (101)	Apr (74)	May (148)	Jun (241)	Jul (169)	Aug (121)	Sep (157)	Oct (199)	Nov (281)	Dec (75)
2012	Jan (107)	Feb (122)	Mar (184)	Apr (73)	May (14)	Jun (49)	Jul (26)	Aug (103)	Sep (133)	Oct (61)	Nov (51)	Dec (55)
2013	Jan (59)	Feb (72)	Mar (99)	Apr (62)	May (92)	Jun (19)	Jul (31)	Aug (138)	Sep (47)	Oct (83)	Nov (95)	Dec (111)
2014	Jan (125)	Feb (60)	Mar (119)	Apr (136)	May (270)	Jun (83)	Jul (88)	Aug (30)	Sep (47)	Oct (27)	Nov (23)	Dec
2015	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep (3)	Oct	Nov	Dec
2016	Jan	Feb	Mar (4)	Apr (1)	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec

bigdata-commit Mailing List for Blazegraph (powered by bigdata) (Page 5)

Fast, scalable, robust graph database platform

bigdata-commit — Commit traffic.