Example #1
0
        private SparqlQuery CreateSparqlQuery(IQuery sparqlQuery, out SparqlQueryVariables variables)
        {
            SparqlQueryParser parser = new SparqlQueryParser();
            bool isQueryOptimized    = false;

            return(parser.ParseFromString(ParseQuery(sparqlQuery, out variables, ref isQueryOptimized)));
        }
Example #2
0
        private string ParseQuery(IQuery sparqlQuery, out SparqlQueryVariables variables, ref bool isQueryOptimized)
        {
            var queryVisitor = new SparqlQueryVisitor(isQueryOptimized);

            queryVisitor.MetaGraphUri = MetaGraphUri;
            queryVisitor.VisitQuery(sparqlQuery);
            variables        = queryVisitor.Variables;
            isQueryOptimized = queryVisitor.IsQueryOptimized;
            return(queryVisitor.CommandText);
        }
        /// <inheritdoc />
        public virtual SparqlQuery GetSparqlQuery(IQuery sparqlQuery, out SparqlQueryVariables variables)
        {
            GenericSparqlQueryVisitor queryVisitor = new GenericSparqlQueryVisitor()
            {
                MetaGraphUri = MetaGraphUri
            };

            queryVisitor.VisitQuery(sparqlQuery);
            variables = queryVisitor.Variables;
            SparqlQueryParser parser = new SparqlQueryParser();

            return(parser.ParseFromString(queryVisitor.CommandText));
        }
Example #4
0
        /// <inheritdoc />
        public override SparqlResultSet ExecuteSelect(IQuery sparqlQuery, out SparqlQueryVariables variables)
        {
            bool   isQueryOptimized = Math.Pow(Store.Triples.Count(), 2) > QueryOptimizationTriplesCountThreshold;
            string commandText      = ParseQuery(sparqlQuery, out variables, ref isQueryOptimized);
            var    parser           = new SparqlQueryParser();

            if (!isQueryOptimized)
            {
                return((SparqlResultSet)_processor.ProcessQuery(parser.ParseFromString(commandText)));
            }

            return(ExecuteOptimizedSelect(commandText, variables, parser));
        }
Example #5
0
        private SparqlResultSet ExecuteOptimizedSelect(string commandText, SparqlQueryVariables variables, SparqlQueryParser parser)
        {
            var parametrizedCommandText = new SparqlParameterizedString(commandText);
            var metaGraphQuery          = new SparqlQueryParser().ParseFromString(
                String.Format(
                    "SELECT ?{0} WHERE {{ GRAPH <{2}> {{ ?{0} <http://xmlns.com/foaf/0.1/primaryTopic> ?{1} . }} }}",
                    variables.MetaGraph,
                    variables.Entity,
                    MetaGraphUri));
            IEnumerable <SparqlResult> result         = new List <SparqlResult>();
            SparqlQueryVariables       queryVariables = variables;

            Parallel.ForEach(
                ((SparqlResultSet)_processor.ProcessQuery(metaGraphQuery)).Results,
                (row, state) => ProcessPartialResult(parametrizedCommandText, queryVariables, parser, (List <SparqlResult>)result, row, state));
            return(new SparqlResultSet(result));
        }
Example #6
0
        private void ProcessPartialResult(
            SparqlParameterizedString parametrizedCommandText,
            SparqlQueryVariables queryVariables,
            SparqlQueryParser parser,
            List <SparqlResult> result,
            SparqlResult row,
            ParallelLoopState state)
        {
            if (state.IsStopped)
            {
                return;
            }

            SparqlQuery query;

            lock (parametrizedCommandText)
            {
                parametrizedCommandText.SetUri("graph", ((IUriNode)row[queryVariables.MetaGraph]).Uri);
                query = parser.ParseFromString(parametrizedCommandText);
            }

            query.Timeout = Timeout;
            try
            {
                var graphResult = ((SparqlResultSet)_processor.ProcessQuery(query)).Results;
                lock (result)
                {
                    result.AddRange(graphResult);
                }
            }
            catch (RdfQueryTimeoutException)
            {
                state.Stop();
                lock (result)
                {
                    result.Clear();
                }
            }
        }
 /// <inheritdoc />
 public virtual SparqlResultSet ExecuteSelect(IQuery sparqlQuery, out SparqlQueryVariables variables)
 {
     return((SparqlResultSet)((INativelyQueryableStore)Store).ExecuteQuery(GetSparqlQuery(sparqlQuery, out variables).ToString()));
 }