@@ -6,10 +6,198 @@ @prefix asc: <http://aaronland.info/ns/changefile/> . <> - dc:identifier "$Id: Changes.ttl 298 2007-12-03 20:48:55Z samofool $" ; dc:description "Changes for RDF::Query" ; dcterms:references <http://kasei.us/code/rdf-query/#project> . +<http://kasei.us/code/files/RDF-Query-2.100.tar.gz> + dcterms:isVersionOf <http://kasei.us/code/rdf-query/#project> ; + dcterms:replaces <http://kasei.us/code/files/RDF-Query-2.002.tar.gz> ; + + doap:Version [ + doap:revision "2.100" ; + doap:created "2009-03-18" ; + ]; + asc:changes [ + asc:addition "Added ::Algebra::BasicGraphPattern::connected method." ; + asc:addition "Added ::Model::node_count method." ; + asc:addition "Added ::Model::RDFTrine::count_statements() and ::Model::RDFTrine::node_count() methods." ; + asc:addition "Added 'node_counts' as a recognized key to ::Model::RDFTrine::suports()." ; + asc:addition "Added 'store' field to the data returned by the meta() method in the ::Model::* classes." ; + asc:addition "Added a peek method to ::Iterator to support execution deferment like in ::Algebra::Service." ; + asc:addition "Added a RequestedInterruptError exception class." ; + asc:addition "Added ability to force SERVICE calls to abort using $ENV{RDFQUERY_THROW_ON_SERVICE} and RequestedInterruptError." ; + asc:addition "Added algebra classes for solution modifiers and query forms (construct, project)." ; + asc:addition "Added benchmark/costmodel.pl for testing the RDF::Query::CostModel." ; + asc:addition "Added benchmark/plans.pl to show the runtimes of the available QEPs for a query." ; + asc:addition "Added bf methods to ::Triple and ::BasicGraphPattern to describe the BGP in terms of bound/free." ; + asc:addition "Added bin/graph-bgp.pl to produce a png of a query's BGP variable connectivity graph." ; + asc:addition "Added bin/graph-qeps.pl to vizualize all QEPs of a query with GraphViz." ; + asc:addition "Added bin/graph-query.pl to graph the (one chosen) QEP tree." ; + asc:addition "Added bind_variables method to RDF::Query::Algebra." ; + asc:addition "Added caching to ::Algebra::Service::_names_for_node." ; + asc:addition "Added code and tests for Query Execution Plan classes RDF::Query::Plan::*." ; + asc:addition "Added code for RDF-Trine specific BGP query plans." ; + asc:addition "Added code to count (and warn) the rate of false positives from a bloomjoin." ; + asc:addition "Added cost model hooks in RDF::Query and ::Algebra::BasicGraphPattern." ; + asc:addition "Added debugging information when RDFQUERY_THROW_ON_SERVICE is in effect." ; + asc:addition "Added examples/create_query_api.pl for generating queries programatically (based on request from KjetilK)." ; + asc:addition "Added examples/query.pl to show a simple example of loading data and executing a query." ; + asc:addition "Added expected result count test in t/34-servicedescription.t." ; + asc:addition "Added FeDeRate BINDINGS to the list of supported extensions." ; + asc:addition "Added from_sse method to ::Statement, ::Node." ; + asc:addition "Added get_basic_graph_pattern to ::Model::RDFTrine (not used yet)." ; + asc:addition "Added initial code for ARQ-style property paths." ; + asc:addition "Added initial parser code for SPARQL Update (SPARUL) extension." ; + asc:addition "Added initial tests for algebra subsumes method." ; + asc:addition "Added is_solution_modifier() methods to ::Algebra classes." ; + asc:addition "Added labels and common patterns to service description template." ; + asc:addition "Added logging and costmodel tests." ; + asc:addition "Added logging for execution time (time to construct iterator) of Triples, BGPs, GGPs and sorting." ; + asc:addition "Added logging of cardinalities in ::Algebra::Triple, ::Algebra::BasicGraphPattern and ::Algebra::Service." ; + asc:addition "Added logging to plan classes ::NestedLoop, ::Service, ::Triple." ; + asc:addition "Added more example capabilities and patterns to the test service descriptions." ; + asc:addition "Added more logic and debugging to aggregating triples into BGPs for SERVICE calls." ; + asc:addition "Added new 'UNSAID' syntax for SPARQLP, implementing negation." ; + asc:addition "Added new bloom:filter function variant that doesn't use identity reasoning." ; + asc:addition "Added optional restriction argument to ::Algebra::subpatterns_of_type." ; + asc:addition "Added parse_expr method to RDF::Query::Parser::SPARQL." ; + asc:addition "Added RDF::Query::Algebra::Quad::bf() method." ; + asc:addition "Added RDF::Query::BGPOptimizer implementing a basic optimizer for basic selectivity-based join ordering." ; + asc:addition "Added RDF::Query::CostModel classes for computing/estimating the cost of executing a specific pattern." ; + asc:addition "Added RDF::Query::ExecutionContext to hold all necessary information for query execution (query, model, bound variables)." ; + asc:addition "Added RDF::Query::Federate::Plan for federation-specific code." ; + asc:addition "Added RDF::Query::Model::RDFTrine::BasicGraphPattner::graph() method." ; + asc:addition "Added RDF::Query::Node::compare for sorting (either Trine or Query) node objects." ; + asc:addition "Added RDF::Query::plan_class so that ::Federate can overload calls to ::Plan methods." ; + asc:addition "Added RDF::Query::ServiceDescription for parsing DARQ-style service descriptions." ; + asc:addition "Added RDF::Query::VariableBindings to wrap existing HASH-based variable binding structure." ; + asc:addition "Added RDF::Trine::Store::Hexastore to test model construction list in t/models.pl." ; + asc:addition "Added sparql:pattern data to test service descriptions." ; + asc:addition "Added sse re-serialization test to t/29-serialize.t." ; + asc:addition "Added stub ::Plan::ThresholdUnion class for running optimistic queries." ; + asc:addition "Added support for computed statement generators (like ARQ's computed property support [e.g. list:member])." ; + asc:addition "Added support for sparql:pattern in service description parsing." ; + asc:addition "Added t/plan-rdftrine.t to test QEP generation optimized for RDF::Trine BGPs." ; + asc:addition "Added test data for repeat patterns (e.g. { ?a ?a ?b})." ; + asc:addition "Added tests to t/plan.t for QEP sse serialization." ; + asc:addition "Added trial subsumes() methods to ::Algebra::BasicGraphPattern and ::Algebra::Triple." ; + asc:addition "Added workaround to RDFCore bridge so that RDF::Core doesn't die if getStmts is called with a Literal in the subj or pred position." ; + asc:update "Algebra classes now call RDF::Query::algebra_fixup for optimization before falling back on normal fixup code." ; + asc:update "Allow equality test and disjunction filters in patterns that can be compiled to SQL." ; + asc:update "Bloom filter use is now only attempted on SERVICE blocks that don't immediately contain a FILTER." ; + asc:update "Changed debugging in RDF::Query modules to use Log::Log4perl." ; + asc:update "Cleaned up federation tests." ; + asc:update "Code now materializes all node identities before creating the Bloom filter (so capacity arg is accurate)." ; + asc:update "Commented out in-progress service description tests." ; + asc:update "Converted RDF::Query::execute() to use ::Plan classes." ; + asc:update "Fixed ::Algebra::GroupGraphPattern to use join_bnode_streams in cases where the bloom filter wasn't automatically created but instead provided by the user." ; + asc:update "Fixed ::Model::RDFTrine::as_string use with Quads." ; + asc:update "Fixed argument list for RDF::Query::Algebra::Service::_names_for_node called from bloom function." ; + asc:update "Fixed bitrotted livejournal example script to work with new 2.000 API." ; + asc:update "Fixed bug in SQL compilation when restricting left-joins to specific node types (based on functions like isIRI)." ; + asc:update "Fixed bug in t/23-model_bridge.t to allow two models from the same model class to be used in testing." ; + asc:update "Fixed bug so ::Model::RDFTrine::meta may be called as a class method." ; + asc:update "Fixed bugs in RDF::Query and RDF::Query::Expression classes that insisted variables be RDF::Query objects (and not simply RDF::Trine objects)." ; + asc:update "Fixed error handling in t/plan.t." ; + asc:update "Fixed node identity computation based on owl:sameAs." ; + asc:update "Fixed propogation of iterator binding_names when pre-bound values are used in ::Algebra execution." ; + asc:update "Fixed RDF::Query::algebra_fixup to ignore service capabilities that would result in empty BGPs." ; + asc:update "Fixed RDF::Query::Algebra::Triple to correctly set binding_names when pre-binding is used." ; + asc:update "Fixed RDQL parser to qualify URIs before returning from parse()." ; + asc:update "Fixed SSE serialization bug in ::Algebra::Sort." ; + asc:update "Fixed SSE serialization of Aggregates using '*' instead of a variable as the column." ; + asc:update "Fixed t/costmodel-naive.t to provide a serialized query to ::Plan::Service constructor." ; + asc:update "Fixed test count in algebra-bgp.t." ; + asc:update "Fixed test in t/31-service.t that relied on identity-reasoning support in bloom filters (which is now off by default)." ; + asc:update "Fixed test plan for t/optimizer.t in cases where no appropriate model is available." ; + asc:update "Fixed use of pre-binding in execution of RDF::Trine optimized BasicGraphPatterns." ; + asc:update "Fixed use of RDFQUERY_NETWORK_TESTS in 31-service.t." ; + asc:update "Improved use of temporary RDF::Trine stores in RDF::Query tests." ; + asc:update "Logging code now uses sse serialization as log keys (because of expressions that can't be serialized as SPARQL)." ; + asc:update "Logging object can now be passed to RDF::Query constructor." ; + asc:update "Made SERVICE work again by rolling back streaming socket work (now commented out)." ; + asc:update "Marked tests TODO for federated query serialization." ; + asc:update "Modified code for aggregate queries (though they are currently broken)." ; + asc:update "Moved construction of bloom-filter-optimized patterns to RDF::Query::Algebra::GroupGraphPattern::_bloom_optimized_pattern()." ; + asc:update "Moved federation code to new RDF::Query::Federate class." ; + asc:update "Moved initial federated service code into RDF::Query::fixup and ::algebra_fixup." ; + asc:update "Moved QEP generation code to RDF::Query::query_plan so it can be overloaded." ; + asc:update "Moved RDF::Query::add_service() to RDF::Query::Federate::add_service()." ; + asc:update "Naive plan is used in ::Federate::Plan::generate_plans only if no optimistic plans are available." ; + asc:update "Parsing service descriptions now more forgiving in the face of missing values." ; + asc:update "Plan generation now includes any plans the model object can provide." ; + asc:update "RDF::Query now always uses a cost model (defaulting to ::Naive)." ; + asc:update "RDF::Query::Algebra::Triple::new now adds RDF::Query::Node::Variable objects for undefined nodes." ; + asc:update "RDF::Query::Federate now defaults to SPARQLP parser." ; + asc:update "RDF::Query::fixup() now only returns a construct pattern (the query pattern now being returned by RDF::Query::query_plan())." ; + asc:update "RDF::Query::Model::get_computed_statements now doesn't die if there's no query object present." ; + asc:update "RDF::Query::new() now accepts two-argument form with just $query and \\%options." ; + asc:update "RDF::Query::Node::Literal objects now can compare as equal when they're of numeric type but the lexical values aren't numeric." ; + asc:update "RDF::Query::prune_plans now takes ExecutionContext as an argument, and in turn calls ::Plan::prune_plans." ; + asc:update "RDF::Query::query_plan() now returns all possible query plans when called in list context." ; + asc:update "RDF::Query::query_plans now calls RDF::Query::prune_plans to select from the list of possible QEPs." ; + asc:update "RDF::Trine::Node::Resource now escapes unicode in base URIs (now just relative URI part) before calling URI->new_abs." ; + asc:update "Re-ordered conditionals so that the service-bloom-filter try block is called less frequently." ; + asc:update "Removed (now unused) parser generator script." ; + asc:update "Removed logging/warn calls from forked process in ::Service (was screwing up the parent-child IO pipe)." ; + asc:update "Removed now unused RDF::Query::construct() and RDF::Query::fixup()." ; + asc:update "Removed old execute() code from ::Algebra classes." ; + asc:update "Removed unused redland fallback code from RDF::Query::Model::RDFTrine." ; + asc:update "Removed use of \"DISTINCT\" queries in SERVICE calls (for pipelining)." ; + asc:update "Removed what looks like an accidentally pasted test in t/plan.t." ; + asc:update "SERVICE execution now uses non-identity reasoning Bloom filter function." ; + asc:update "SERVICE tests involving bloom filter handling marked as TODO." ; + asc:update "ServiceDescription now only runs sofilter if ?subject/?object are bound." ; + asc:update "ServiceDescription parsing now gets entire sparql:patterns and not just arcs to depth one." ; + asc:update "Silenced unfinished test debugging in t/logging.t." ; + asc:update "SPARQL parser now always adds a ::Algebra::Project (even when the query selects '*')." ; + asc:update "SPARQL parser now constructs ::Algebra::Project objects (had been in RDF::Query::execute)." ; + asc:update "SPARQL parser now creates ::Algebra::Construct objects for CONSTRUCT queries." ; + asc:update "SPARQL parser now puts ::Distinct above ::Sort algebras in the parse tree." ; + asc:update "SPARQLP parser now creates ::Project object as parent of any ::Aggregate." ; + asc:update "Split RDF::Query::execute into prepare() and execute_plan() methods." ; + asc:update "Started work on a more holistic approach to supporting service descriptions (instead of using add_computed_statement_generator())." ; + asc:update "Turtle parser now doesn't modify the lexical value of numeric typed literals." ; + asc:update "Turtle parser now makes universal IDs for all blank node (even those with given IDs like _:xyz)." ; + asc:update "Updated ::Algebra SSE serializations to conform to Jena's serialization syntax." ; + asc:update "Updated ::Algebra::Limit::sse to emit 'slice' serialization if its child is a ::Algebra::Offset." ; + asc:update "Updated ::Algebra::Service to fork and use LWP's callback mechanism for concurrency." ; + asc:update "Updated ::Compiler::SQL to recognize ::Algebra::Project objects." ; + asc:update "Updated args to roqet call in failing_earl_tests.sh." ; + asc:update "Updated as_sparql() methods to support the new ::Construct classes." ; + asc:update "Updated bin/parse.pl to emit the SSE serialization of the query algebra tree." ; + asc:update "Updated bin/rdf_parse_turtle.pl to warn on any parser error." ; + asc:update "Updated cost model code to work with ::Plan classes instead of ::Algebra classes." ; + asc:update "Updated costmodel and logging test expected results that changed due to changes to ::Plan::Join code." ; + asc:update "Updated dawg-eval.t regex to recognize RDFTrine blank nodes." ; + asc:update "Updated DBPedia test query in t/34-servicedescription.t to reflect new source data." ; + asc:update "Updated expected cardinalities in t/logging.t for current plan choice." ; + asc:update "Updated logging of algebra execution to use SPARQL serialization as logging key." ; + asc:update "Updated logging tests to use the new sparql serialization keys." ; + asc:update "Updated plan generation code to use ::BGPOptimizer when the model supports node_counts." ; + asc:update "Updated RDF::Query to require version 0.108 of RDF::Trine." ; + asc:update "Updated RDF::Query::sse to emit base and prefix serializations." ; + asc:update "Updated SERVICE test in t/plan.t (still broken, but only runs when dev env var RDFQUERY_NETWORK_TESTS in effect)." ; + asc:update "Updated SPARQL parser and serializer tests to always assume an ::Algebra::Project on SELECT queries." ; + asc:update "Updated SSE serialization of ::Join::PushDownNestedLoop to use 'bind-join' terminology." ; + asc:update "Updated t/plan.t to be less dependent on the specific state of the kasei.us service endpoint." ; + asc:update "Updated test service description RDF for new tests." ; + asc:update "Updates to improve logging and test coverage." ; + asc:update "Updates to RDF::Query::execute() to support explicit pre-binding lists (instead of just scalar values)." ; + asc:update "Updates to SPARQLP parser to support FeDeRate BINDINGS keyword." ; + asc:update "::Algebra::Distinct now does proper serialization in as_sparql()." ; + asc:update "::Algebra::GroupGraphPattern now throws an exception if passed unblessed values as patterns." ; + asc:update "::Algebra::Service now defers loading of content until the first result is requested." ; + asc:update "::Federate now labels nodes in the QEP tree with applicable services." ; + asc:update "::GroupGraphPattern::sse() updated to output the '(join ...)' only if the GGP has more than one pattern." ; + asc:update "::Model::debug() now shows data from the named graph model." ; + asc:update "::Model::RDFTrine now only produces BGP plans if there is no get_computed_statement_generators in the query object." ; + asc:update "::Model::RDFTrine::add_uri now decodes resulting content as utf8 before proceeding." ; + asc:update "::Model::RDFTrine::meta() probes the underlying store object to declare the proper 'store' class." ; + asc:update "::Service::_names_for_node updated to use ::Plan classes for query execution (fixes use of the k:bloom filter)." ; + ] . + + <http://kasei.us/code/files/RDF-Query-2.002.tar.gz> dcterms:isVersionOf <http://kasei.us/code/rdf-query/#project> ; dcterms:replaces <http://kasei.us/code/files/RDF-Query-2.001.tar.gz> ; @@ -19,11 +207,11 @@ doap:created "2008-04-25" ; ]; asc:changes [ - asc:update "Updated Bloom::Filter required version in RDF-Query's Makefile.PL. - asc:update "Fixed bug in get_function() when called as a class method. - asc:update "Updated sparql:logical-* functions to accept more than two operands. - asc:addition "Added code to make loading of Bloom::Filter optional. - asc:addition "Added Bloom::Filter to list of recommended modules. + asc:update "Updated Bloom::Filter required version in RDF-Query's Makefile.PL." ; + asc:update "Fixed bug in get_function() when called as a class method." ; + asc:update "Updated sparql:logical-* functions to accept more than two operands." ; + asc:addition "Added code to make loading of Bloom::Filter optional." ; + asc:addition "Added Bloom::Filter to list of recommended modules." ; ] . @@ -36,7 +224,7 @@ doap:created "2008-04-19" ; ]; asc:changes [ - asc:addition "Added test for using AS syntax for variable renaming: "(?var AS ?newvar)"." ; + asc:addition "Added test for using AS syntax for variable renaming: \"(?var AS ?newvar)\"." ; asc:addition "Added support for MIN, MAX, COUNT and COUNT-DISTINCT aggregate operators to the SPARQLP parser." ; asc:addition "Added COUNT DISTINCT variant aggregate operator." ; asc:addition "Added as_sparql submethod to RDF::Query::Node::Literal to serialize numeric types unquoted." ; @@ -47,7 +235,7 @@ asc:addition "Added ::Algebra::subpatterns_of_type method for retrieving all subpatterns of a particular type." ; asc:addition "Added tests for select expressions." ; asc:addition "Added initial support for selecting expression values." ; - asc:update "Fixed use of "DESCRIBE <resource>" (instead of "DESCRIBE ?var")." ; + asc:update "Fixed use of \"DESCRIBE <resource>\" (instead of \"DESCRIBE ?var\")." ; asc:update "Fixed SPARQL serialization of queries with DISTINCT." ; asc:update "Moved sort_rows() into new ::Algebra classes Sort, Limit, Offset and Distinct." ; asc:update "Updated SQL compiler to handle new ::Algebra classes." ; RDF-Query/Changes.ttl @@ -3,7 +3,7 @@ meta-spec: version: 1.3 url: http://module-build.sourceforge.net/META-spec-v1.3.html name: RDF-Query -version: 2.003_01 +version: 2.100 abstract: A pure-perl impelmentation of the RDF query languages SPARQL and RDQL. author: - Gregory Todd Williams <gwilliams@cpan.org> @@ -27,18 +27,19 @@ recommends: Geo::Distance: 0.09 Bloom::Filter: 1 requires: - Digest::SHA1: 0 - LWP::Simple: 0 DateTime::Format::W3CDTF: 0 + Digest::SHA1: 0 Error: 0 I18N::LangTags: 0 JSON: 2 + List::MoreUtils: 0 + LWP::Simple: 0 Parse::RecDescent: 0 + RDF::Trine: 0.109 Scalar::Util: 0 - URI: 0 - List::MoreUtils: 0 Set::Scalar: 0 - RDF::Trine: 0.109 + Storable: 0 + URI: 0 resources: homepage: http://kasei.us/code/rdf-query/ Repository: http://github.com/kasei/perlrdf/ RDF-Query/META.yml @@ -16,7 +16,6 @@ REQUIREMENTS * List::MoreUtils * LWP * Parse::RecDescent - * Parse::RecDescent * RDF::Trine * Scalar::Util * Set::Scalar @@ -41,6 +40,199 @@ INSTALLATION VERSION HISTORY + Version 2.100 (2009-03-18) + + *** API: + * Added ::Algebra::BasicGraphPattern::connected method. + * Added 'node_counts' as a recognized key to ::Model::RDFTrine::suports(). + * Added ::Model::node_count method. + * Added ::Model::RDFTrine::count_statements() and ::Model::RDFTrine::node_count() methods. + * Added 'store' field to the data returned by the meta() method in the ::Model::* classes. + * Added a peek method to ::Iterator to support execution deferment like in ::Algebra::Service. + * Added ability to force SERVICE calls to abort using $ENV{RDFQUERY_THROW_ON_SERVICE} and RequestedInterruptError. + * Added bf methods to ::Triple and ::BasicGraphPattern to describe the BGP in terms of bound/free. + * Added bind_variables method to RDF::Query::Algebra. + * Added caching to ::Algebra::Service::_names_for_node. + * Added code to count (and warn) the rate of false positives from a bloomjoin. + * Added cost model hooks in RDF::Query and ::Algebra::BasicGraphPattern. + * Added FeDeRate BINDINGS to the list of supported extensions. + * Added get_basic_graph_pattern to ::Model::RDFTrine (not used yet). + * Added is_solution_modifier() methods to ::Algebra classes. + * Added labels and common patterns to service description template. + * Added more logic and debugging to aggregating triples into BGPs for SERVICE calls. + * Added optional restriction argument to ::Algebra::subpatterns_of_type. + * Added RDF::Query::Model::RDFTrine::BasicGraphPattner::graph() method. + * Added RDF::Query::Node::compare for sorting (either Trine or Query) node objects. + * Added RDF::Query::plan_class so that ::Federate can overload calls to ::Plan methods. + * Added support for computed statement generators (like ARQ's computed property support [e.g. list:member]). + * Added trial subsumes() methods to ::Algebra::BasicGraphPattern and ::Algebra::Triple. + * Algebra classes now call RDF::Query::algebra_fixup for optimization before falling back on normal fixup code. + * Allow equality test and disjunction filters in patterns that can be compiled to SQL. + * Fixed ::Algebra::GroupGraphPattern to use join_bnode_streams in cases where the bloom filter wasn't automatically created but instead provided by the user. + * Fixed ::Model::RDFTrine::as_string use with Quads. + * Fixed argument list for RDF::Query::Algebra::Service::_names_for_node called from bloom function. + * Fixed bug so ::Model::RDFTrine::meta may be called as a class method. + * Fixed RDF::Query::algebra_fixup to ignore service capabilities that would result in empty BGPs. + * Modified code for aggregate queries (though they are currently broken). + * Moved construction of bloom-filter-optimized patterns to RDF::Query::Algebra::GroupGraphPattern::_bloom_optimized_pattern(). + * Moved initial federated service code into RDF::Query::fixup and ::algebra_fixup. + * Moved QEP generation code to RDF::Query::query_plan so it can be overloaded. + * Moved RDF::Query::add_service() to RDF::Query::Federate::add_service(). + * Parsing service descriptions now more forgiving in the face of missing values. + * RDF::Query::Algebra::Triple::new now adds RDF::Query::Node::Variable objects for undefined nodes. + * RDF::Query::fixup() now only returns a construct pattern (the query pattern now being returned by RDF::Query::query_plan()). + * RDF::Query::Model::get_computed_statements now doesn't die if there's no query object present. + * RDF::Query::new() now accepts two-argument form with just $query and \%options. + * RDF::Query::Node::Literal objects now can compare as equal when they're of numeric type but the lexical values aren't numeric. + * RDF::Query::prune_plans now takes ExecutionContext as an argument, and in turn calls ::Plan::prune_plans. + * RDF::Query::query_plan() now returns all possible query plans when called in list context. + * RDF::Query::query_plans now calls RDF::Query::prune_plans to select from the list of possible QEPs. + * RDF::Trine::Node::Resource now escapes unicode in base URIs (now just relative URI part) before calling URI->new_abs. + * Removed now unused RDF::Query::construct() and RDF::Query::fixup(). + * Removed old execute() code from ::Algebra classes. + * Removed unused redland fallback code from RDF::Query::Model::RDFTrine. + * Split RDF::Query::execute into prepare() and execute_plan() methods. + * Converted RDF::Query::execute() to use ::Plan classes. + * Updated ::Compiler::SQL to recognize ::Algebra::Project objects. + * Updates to RDF::Query::execute() to support explicit pre-binding lists (instead of just scalar values). + * ::Algebra::GroupGraphPattern now throws an exception if passed unblessed values as patterns. + * ::Federate now labels nodes in the QEP tree with applicable services. + * ::Model::debug() now shows data from the named graph model. + * ::Model::RDFTrine::add_uri now decodes resulting content as utf8 before proceeding. + * ::Model::RDFTrine::meta() probes the underlying store object to declare the proper 'store' class. + * ::Service::_names_for_node updated to use ::Plan classes for query execution (fixes use of the k:bloom filter). + + *** CLASSES: + * Added algebra classes for solution modifiers and query forms (construct, project). + * Added code and tests for Query Execution Plan classes RDF::Query::Plan::*. + * Added RDF::Query::Federate::Plan for federation-specific code. + * Added RDF::Query::BGPOptimizer implementing a basic optimizer for basic selectivity-based join ordering. + * Added RDF::Query::CostModel classes for computing/estimating the cost of executing a specific pattern. + * Added RDF::Query::ExecutionContext to hold all necessary information for query execution (query, model, bound variables). + * Added RDF::Query::ServiceDescription for parsing DARQ-style service descriptions. + * Added RDF::Query::VariableBindings to wrap existing HASH-based variable binding structure. + * Added stub ::Plan::ThresholdUnion class for running optimistic queries. + * Added workaround to RDFCore bridge so that RDF::Core doesn't die if getStmts is called with a Literal in the subj or pred position. + * Added a RequestedInterruptError exception class. + * Added code for RDF-Trine specific BGP query plans. + * Changed debugging in RDF::Query modules to use Log::Log4perl. + * Made SERVICE work again by rolling back streaming socket work (now commented out). + * Moved federation code to new RDF::Query::Federate class. + * Plan generation now includes any plans the model object can provide. + * RDF::Query now always uses a cost model (defaulting to ::Naive). + * RDF::Query::Federate now defaults to SPARQLP parser. + * Removed logging/warn calls from forked process in ::Service (was screwing up the parent-child IO pipe). + * Removed use of "DISTINCT" queries in SERVICE calls (for pipelining). + * ServiceDescription now only runs sofilter if ?subject/?object are bound. + * Started work on a more holistic approach to supporting service descriptions (instead of using add_computed_statement_generator()). + * Updated ::Algebra::Service to fork and use LWP's callback mechanism for concurrency. + * ::Algebra::Service now defers loading of content until the first result is requested. + * ::Model::RDFTrine now only produces BGP plans if there is no get_computed_statement_generators in the query object. + * Code now materializes all node identities before creating the Bloom filter (so capacity arg is accurate). + * Bloom filter use is now only attempted on SERVICE blocks that don't immediately contain a FILTER. + * Re-ordered conditionals so that the service-bloom-filter try block is called less frequently. + * SERVICE execution now uses non-identity reasoning Bloom filter function. + + *** SYNTAX and SERIALIZATION: + * Added from_sse method to ::Statement, ::Node. + * Added initial code for ARQ-style property paths. + * Added initial parser code for SPARQL Update (SPARUL) extension. + * Added new 'UNSAID' syntax for SPARQLP, implementing negation. + * Added parse_expr method to RDF::Query::Parser::SPARQL. + * Added RDF::Query::Algebra::Quad::bf() method. + * Fixed RDQL parser to qualify URIs before returning from parse(). + * Fixed SSE serialization of Aggregates using '*' instead of a variable as the column. + * Removed (now unused) parser generator script. + * SPARQL parser now always adds a ::Algebra::Project (even when the query selects '*'). + * SPARQL parser now creates ::Algebra::Construct objects for CONSTRUCT queries. + * SPARQL parser now puts ::Distinct above ::Sort algebras in the parse tree. + * SPARQLP parser now creates ::Project object as parent of any ::Aggregate. + * Turtle parser now doesn't modify the lexical value of numeric typed literals. + * Turtle parser now makes universal IDs for all blank node (even those with given IDs like _:xyz). + * Updated ::Algebra SSE serializations to conform to Jena's serialization syntax. + * Updated ::Algebra::Limit::sse to emit 'slice' serialization if its child is a ::Algebra::Offset. + * Updated as_sparql() methods to support the new ::Construct classes. + * Updated RDF::Query::sse to emit base and prefix serializations. + * Updated SPARQL parser and serializer tests to always assume an ::Algebra::Project on SELECT queries. + * Updated SSE serialization of ::Join::PushDownNestedLoop to use 'bind-join' terminology. + * Updates to SPARQLP parser to support FeDeRate BINDINGS keyword. + * ::Algebra::Distinct now does proper serialization in as_sparql(). + * ::GroupGraphPattern::sse() updated to output the '(join ...)' only if the GGP has more than one pattern. + + *** OPTIMIZER: + * Added benchmark/plans.pl to show the runtimes of the available QEPs for a query. + * Added benchmark/costmodel.pl for testing the RDF::Query::CostModel. + * Added logging for execution time (time to construct iterator) of Triples, BGPs, GGPs and sorting. + * Added logging of cardinalities in ::Algebra::Triple, ::Algebra::BasicGraphPattern and ::Algebra::Service. + * Added logging to plan classes ::NestedLoop, ::Service, ::Triple. + * Naive plan is used in ::Federate::Plan::generate_plans only if no optimistic plans are available. + * Updated cost model code to work with ::Plan classes instead of ::Algebra classes. + * Logging code now uses sse serialization as log keys (because of expressions that can't be serialized as SPARQL). + * Logging object can now be passed to RDF::Query constructor. + * Updated logging of algebra execution to use SPARQL serialization as logging key. + + *** MISC: + * SPARQL parser now constructs ::Algebra::Project objects (had been in RDF::Query::execute). + * Updated RDF::Query to require version 0.108 of RDF::Trine. + * Added new bloom:filter function variant that doesn't use identity reasoning. + * Added debugging information when RDFQUERY_THROW_ON_SERVICE is in effect. + * Fixed test plan for t/optimizer.t in cases where no appropriate model is available. + * Updated plan generation code to use ::BGPOptimizer when the model supports node_counts. + * Fixed SSE serialization bug in ::Algebra::Sort. + * Fixed bugs in RDF::Query and RDF::Query::Expression classes that insisted variables be RDF::Query objects (and not simply RDF::Trine objects). + * Fixed propogation of iterator binding_names when pre-bound values are used in ::Algebra execution. + * Fixed RDF::Query::Algebra::Triple to correctly set binding_names when pre-binding is used. + * Fixed use of pre-binding in execution of RDF::Trine optimized BasicGraphPatterns. + * Fixed bug in SQL compilation when restricting left-joins to specific node types (based on functions like isIRI). + * Fixed node identity computation based on owl:sameAs. + * Fixed bitrotted livejournal example script to work with new 2.000 API. + + *** TESTS: + * Added expected result count test in t/34-servicedescription.t. + * Added initial tests for algebra subsumes method. + * Added logging and costmodel tests. + * Added more example capabilities and patterns to the test service descriptions. + * Added RDF::Trine::Store::Hexastore to test model construction list in t/models.pl. + * Added sparql:pattern data to test service descriptions. + * Added sse re-serialization test to t/29-serialize.t. + * Added support for sparql:pattern in service description parsing. + * Added t/plan-rdftrine.t to test QEP generation optimized for RDF::Trine BGPs. + * Added test data for repeat patterns (e.g. { ?a ?a ?b}). + * Added tests to t/plan.t for QEP sse serialization. + * Cleaned up federation tests. + * Commented out in-progress service description tests. + * Fixed bug in t/23-model_bridge.t to allow two models from the same model class to be used in testing. + * Fixed error handling in t/plan.t. + * Fixed t/costmodel-naive.t to provide a serialized query to ::Plan::Service constructor. + * Fixed test count in algebra-bgp.t. + * Fixed test in t/31-service.t that relied on identity-reasoning support in bloom filters (which is now off by default). + * Fixed use of RDFQUERY_NETWORK_TESTS in 31-service.t. + * Improved use of temporary RDF::Trine stores in RDF::Query tests. + * Marked tests TODO for federated query serialization. + * Removed what looks like an accidentally pasted test in t/plan.t. + * SERVICE tests involving bloom filter handling marked as TODO. + * ServiceDescription parsing now gets entire sparql:patterns and not just arcs to depth one. + * Silenced unfinished test debugging in t/logging.t. + * Updated args to roqet call in failing_earl_tests.sh. + * Updated costmodel and logging test expected results that changed due to changes to ::Plan::Join code. + * Updated dawg-eval.t regex to recognize RDFTrine blank nodes. + * Updated DBPedia test query in t/34-servicedescription.t to reflect new source data. + * Updated expected cardinalities in t/logging.t for current plan choice. + * Updated logging tests to use the new sparql serialization keys. + * Updated SERVICE test in t/plan.t (still broken, but only runs when dev env var RDFQUERY_NETWORK_TESTS in effect). + * Updated t/plan.t to be less dependent on the specific state of the kasei.us service endpoint. + * Updated test service description RDF for new tests. + * Updates to improve logging and test coverage. + + *** EXAMPLES and DOCS: + * Added examples/query.pl to show a simple example of loading data and executing a query. + * Added examples/create_query_api.pl for generating queries programatically (based on request from KjetilK). + * Added bin/graph-bgp.pl to produce a png of a query's BGP variable connectivity graph. + * Added bin/graph-query.pl to graph the (one chosen) QEP tree. + * Added bin/graph-qeps.pl to vizualize all QEPs of a query with GraphViz. + * Updated bin/parse.pl to emit the SSE serialization of the query algebra tree. + * Updated bin/rdf_parse_turtle.pl to warn on any parser error. + Version 2.002 (2008-04-25) * Updated Bloom::Filter required version in RDF-Query's Makefile.PL. RDF-Query/README @@ -28,10 +28,10 @@ <li>List::MoreUtils</li> <li>LWP</li> <li>Parse::RecDescent</li> - <li>Parse::RecDescent</li> <li>RDF::Trine</li> <li>Scalar::Util</li> <li>Set::Scalar</li> + <li>Storable</li> <li>URI</li> </ul> <p>The following additional modules are recommended for some functionality:</p> @@ -40,6 +40,7 @@ <li>RDF::Redland</li> <li>JavaScript</li> <li>Geo::Distance</li> + <li>Bloom::Filter</li> </ul> <h2 id="installing">Installing RDF::Query</h2> <p>To install, run:</p> @@ -50,7 +51,215 @@ make install<br /> </div> <h2 id="changelog">Version History</h2> - <h3 id="v2_001">Version 2.002 (2008-04-25)</h3> + <h3 id="v2_100">Version 2.100 (2009-03-18)</h3> + <ul> + <li>API + <ul> + <li>Added ::Algebra::BasicGraphPattern::connected method.</li> + <li>Added 'node_counts' as a recognized key to ::Model::RDFTrine::suports().</li> + <li>Added ::Model::node_count method.</li> + <li>Added ::Model::RDFTrine::count_statements() and ::Model::RDFTrine::node_count() methods.</li> + <li>Added 'store' field to the data returned by the meta() method in the ::Model::* classes.</li> + <li>Added a peek method to ::Iterator to support execution deferment like in ::Algebra::Service.</li> + <li>Added ability to force SERVICE calls to abort using $ENV{RDFQUERY_THROW_ON_SERVICE} and RequestedInterruptError.</li> + <li>Added bf methods to ::Triple and ::BasicGraphPattern to describe the BGP in terms of bound/free.</li> + <li>Added bind_variables method to RDF::Query::Algebra.</li> + <li>Added caching to ::Algebra::Service::_names_for_node.</li> + <li>Added code to count (and warn) the rate of false positives from a bloomjoin.</li> + <li>Added cost model hooks in RDF::Query and ::Algebra::BasicGraphPattern.</li> + <li>Added FeDeRate BINDINGS to the list of supported extensions.</li> + <li>Added get_basic_graph_pattern to ::Model::RDFTrine (not used yet).</li> + <li>Added is_solution_modifier() methods to ::Algebra classes.</li> + <li>Added labels and common patterns to service description template.</li> + <li>Added more logic and debugging to aggregating triples into BGPs for SERVICE calls.</li> + <li>Added optional restriction argument to ::Algebra::subpatterns_of_type.</li> + <li>Added RDF::Query::Model::RDFTrine::BasicGraphPattner::graph() method.</li> + <li>Added RDF::Query::Node::compare for sorting (either Trine or Query) node objects.</li> + <li>Added RDF::Query::plan_class so that ::Federate can overload calls to ::Plan methods.</li> + <li>Added support for computed statement generators (like ARQ's computed property support [e.g. list:member]).</li> + <li>Added trial subsumes() methods to ::Algebra::BasicGraphPattern and ::Algebra::Triple.</li> + <li>Algebra classes now call RDF::Query::algebra_fixup for optimization before falling back on normal fixup code.</li> + <li>Allow equality test and disjunction filters in patterns that can be compiled to SQL.</li> + <li>Fixed ::Algebra::GroupGraphPattern to use join_bnode_streams in cases where the bloom filter wasn't automatically created but instead provided by the user.</li> + <li>Fixed ::Model::RDFTrine::as_string use with Quads.</li> + <li>Fixed argument list for RDF::Query::Algebra::Service::_names_for_node called from bloom function.</li> + <li>Fixed bug so ::Model::RDFTrine::meta may be called as a class method.</li> + <li>Fixed RDF::Query::algebra_fixup to ignore service capabilities that would result in empty BGPs.</li> + <li>Modified code for aggregate queries (though they are currently broken).</li> + <li>Moved construction of bloom-filter-optimized patterns to RDF::Query::Algebra::GroupGraphPattern::_bloom_optimized_pattern().</li> + <li>Moved initial federated service code into RDF::Query::fixup and ::algebra_fixup.</li> + <li>Moved QEP generation code to RDF::Query::query_plan so it can be overloaded.</li> + <li>Moved RDF::Query::add_service() to RDF::Query::Federate::add_service().</li> + <li>Parsing service descriptions now more forgiving in the face of missing values.</li> + <li>RDF::Query::Algebra::Triple::new now adds RDF::Query::Node::Variable objects for undefined nodes.</li> + <li>RDF::Query::fixup() now only returns a construct pattern (the query pattern now being returned by RDF::Query::query_plan()).</li> + <li>RDF::Query::Model::get_computed_statements now doesn't die if there's no query object present.</li> + <li>RDF::Query::new() now accepts two-argument form with just $query and \%options.</li> + <li>RDF::Query::Node::Literal objects now can compare as equal when they're of numeric type but the lexical values aren't numeric.</li> + <li>RDF::Query::prune_plans now takes ExecutionContext as an argument, and in turn calls ::Plan::prune_plans.</li> + <li>RDF::Query::query_plan() now returns all possible query plans when called in list context.</li> + <li>RDF::Query::query_plans now calls RDF::Query::prune_plans to select from the list of possible QEPs.</li> + <li>RDF::Trine::Node::Resource now escapes unicode in base URIs (now just relative URI part) before calling URI->new_abs.</li> + <li>Removed now unused RDF::Query::construct() and RDF::Query::fixup().</li> + <li>Removed old execute() code from ::Algebra classes.</li> + <li>Removed unused redland fallback code from RDF::Query::Model::RDFTrine.</li> + <li>Split RDF::Query::execute into prepare() and execute_plan() methods.</li> + <li>Converted RDF::Query::execute() to use ::Plan classes.</li> + <li>Updated ::Compiler::SQL to recognize ::Algebra::Project objects.</li> + <li>Updates to RDF::Query::execute() to support explicit pre-binding lists (instead of just scalar values).</li> + <li>::Algebra::GroupGraphPattern now throws an exception if passed unblessed values as patterns.</li> + <li>::Federate now labels nodes in the QEP tree with applicable services.</li> + <li>::Model::debug() now shows data from the named graph model.</li> + <li>::Model::RDFTrine::add_uri now decodes resulting content as utf8 before proceeding.</li> + <li>::Model::RDFTrine::meta() probes the underlying store object to declare the proper 'store' class.</li> + <li>::Service::_names_for_node updated to use ::Plan classes for query execution (fixes use of the k:bloom filter).</li> + </ul> + </li> + <li>Classes + <ul> + <li>Added algebra classes for solution modifiers and query forms (construct, project).</li> + <li>Added code and tests for Query Execution Plan classes RDF::Query::Plan::*.</li> + <li>Added RDF::Query::Federate::Plan for federation-specific code.</li> + <li>Added RDF::Query::BGPOptimizer implementing a basic optimizer for basic selectivity-based join ordering.</li> + <li>Added RDF::Query::CostModel classes for computing/estimating the cost of executing a specific pattern.</li> + <li>Added RDF::Query::ExecutionContext to hold all necessary information for query execution (query, model, bound variables).</li> + <li>Added RDF::Query::ServiceDescription for parsing DARQ-style service descriptions.</li> + <li>Added RDF::Query::VariableBindings to wrap existing HASH-based variable binding structure.</li> + <li>Added stub ::Plan::ThresholdUnion class for running optimistic queries.</li> + <li>Added workaround to RDFCore bridge so that RDF::Core doesn't die if getStmts is called with a Literal in the subj or pred position.</li> + <li>Added a RequestedInterruptError exception class.</li> + <li>Added code for RDF-Trine specific BGP query plans.</li> + <li>Changed debugging in RDF::Query modules to use Log::Log4perl.</li> + <li>Made SERVICE work again by rolling back streaming socket work (now commented out).</li> + <li>Moved federation code to new RDF::Query::Federate class.</li> + <li>Plan generation now includes any plans the model object can provide.</li> + <li>RDF::Query now always uses a cost model (defaulting to ::Naive).</li> + <li>RDF::Query::Federate now defaults to SPARQLP parser.</li> + <li>Removed logging/warn calls from forked process in ::Service (was screwing up the parent-child IO pipe).</li> + <li>Removed use of "DISTINCT" queries in SERVICE calls (for pipelining).</li> + <li>ServiceDescription now only runs sofilter if ?subject/?object are bound.</li> + <li>Started work on a more holistic approach to supporting service descriptions (instead of using add_computed_statement_generator()).</li> + <li>Updated ::Algebra::Service to fork and use LWP's callback mechanism for concurrency.</li> + <li>::Algebra::Service now defers loading of content until the first result is requested.</li> + <li>::Model::RDFTrine now only produces BGP plans if there is no get_computed_statement_generators in the query object.</li> + <li>Code now materializes all node identities before creating the Bloom filter (so capacity arg is accurate).</li> + <li>Bloom filter use is now only attempted on SERVICE blocks that don't immediately contain a FILTER.</li> + <li>Re-ordered conditionals so that the service-bloom-filter try block is called less frequently.</li> + <li>SERVICE execution now uses non-identity reasoning Bloom filter function.</li> + </ul> + </li> + <li>Syntax and Serialization + <ul> + <li>Added from_sse method to ::Statement, ::Node.</li> + <li>Added initial code for ARQ-style property paths.</li> + <li>Added initial parser code for SPARQL Update (SPARUL) extension.</li> + <li>Added new 'UNSAID' syntax for SPARQLP, implementing negation.</li> + <li>Added parse_expr method to RDF::Query::Parser::SPARQL.</li> + <li>Added RDF::Query::Algebra::Quad::bf() method.</li> + <li>Fixed RDQL parser to qualify URIs before returning from parse().</li> + <li>Fixed SSE serialization of Aggregates using '*' instead of a variable as the column.</li> + <li>Removed (now unused) parser generator script.</li> + <li>SPARQL parser now always adds a ::Algebra::Project (even when the query selects '*').</li> + <li>SPARQL parser now creates ::Algebra::Construct objects for CONSTRUCT queries.</li> + <li>SPARQL parser now puts ::Distinct above ::Sort algebras in the parse tree.</li> + <li>SPARQLP parser now creates ::Project object as parent of any ::Aggregate.</li> + <li>Turtle parser now doesn't modify the lexical value of numeric typed literals.</li> + <li>Turtle parser now makes universal IDs for all blank node (even those with given IDs like _:xyz).</li> + <li>Updated ::Algebra SSE serializations to conform to Jena's serialization syntax.</li> + <li>Updated ::Algebra::Limit::sse to emit 'slice' serialization if its child is a ::Algebra::Offset.</li> + <li>Updated as_sparql() methods to support the new ::Construct classes.</li> + <li>Updated RDF::Query::sse to emit base and prefix serializations.</li> + <li>Updated SPARQL parser and serializer tests to always assume an ::Algebra::Project on SELECT queries.</li> + <li>Updated SSE serialization of ::Join::PushDownNestedLoop to use 'bind-join' terminology.</li> + <li>Updates to SPARQLP parser to support FeDeRate BINDINGS keyword.</li> + <li>::Algebra::Distinct now does proper serialization in as_sparql().</li> + <li>::GroupGraphPattern::sse() updated to output the '(join ...)' only if the GGP has more than one pattern.</li> + </ul> + </li> + <li>Optimizer + <ul> + <li>Added benchmark/plans.pl to show the runtimes of the available QEPs for a query.</li> + <li>Added benchmark/costmodel.pl for testing the RDF::Query::CostModel.</li> + <li>Added logging for execution time (time to construct iterator) of Triples, BGPs, GGPs and sorting.</li> + <li>Added logging of cardinalities in ::Algebra::Triple, ::Algebra::BasicGraphPattern and ::Algebra::Service.</li> + <li>Added logging to plan classes ::NestedLoop, ::Service, ::Triple.</li> + <li>Naive plan is used in ::Federate::Plan::generate_plans only if no optimistic plans are available.</li> + <li>Updated cost model code to work with ::Plan classes instead of ::Algebra classes.</li> + <li>Logging code now uses sse serialization as log keys (because of expressions that can't be serialized as SPARQL).</li> + <li>Logging object can now be passed to RDF::Query constructor.</li> + <li>Updated logging of algebra execution to use SPARQL serialization as logging key.</li> + </ul> + </li> + <li>Miscellaneous + <ul> + <li>SPARQL parser now constructs ::Algebra::Project objects (had been in RDF::Query::execute).</li> + <li>Updated RDF::Query to require version 0.108 of RDF::Trine.</li> + <li>Added new bloom:filter function variant that doesn't use identity reasoning.</li> + <li>Added debugging information when RDFQUERY_THROW_ON_SERVICE is in effect.</li> + <li>Fixed test plan for t/optimizer.t in cases where no appropriate model is available.</li> + <li>Updated plan generation code to use ::BGPOptimizer when the model supports node_counts.</li> + <li>Fixed SSE serialization bug in ::Algebra::Sort.</li> + <li>Fixed bugs in RDF::Query and RDF::Query::Expression classes that insisted variables be RDF::Query objects (and not simply RDF::Trine objects).</li> + <li>Fixed propogation of iterator binding_names when pre-bound values are used in ::Algebra execution.</li> + <li>Fixed RDF::Query::Algebra::Triple to correctly set binding_names when pre-binding is used.</li> + <li>Fixed use of pre-binding in execution of RDF::Trine optimized BasicGraphPatterns.</li> + <li>Fixed bug in SQL compilation when restricting left-joins to specific node types (based on functions like isIRI).</li> + <li>Fixed node identity computation based on owl:sameAs.</li> + <li>Fixed bitrotted livejournal example script to work with new 2.000 API.</li> + </ul> + </li> + <li>Tests + <ul> + <li>Added expected result count test in t/34-servicedescription.t.</li> + <li>Added initial tests for algebra subsumes method.</li> + <li>Added logging and costmodel tests.</li> + <li>Added more example capabilities and patterns to the test service descriptions.</li> + <li>Added RDF::Trine::Store::Hexastore to test model construction list in t/models.pl.</li> + <li>Added sparql:pattern data to test service descriptions.</li> + <li>Added sse re-serialization test to t/29-serialize.t.</li> + <li>Added support for sparql:pattern in service description parsing.</li> + <li>Added t/plan-rdftrine.t to test QEP generation optimized for RDF::Trine BGPs.</li> + <li>Added test data for repeat patterns (e.g. { ?a ?a ?b}).</li> + <li>Added tests to t/plan.t for QEP sse serialization.</li> + <li>Cleaned up federation tests.</li> + <li>Commented out in-progress service description tests.</li> + <li>Fixed bug in t/23-model_bridge.t to allow two models from the same model class to be used in testing.</li> + <li>Fixed error handling in t/plan.t.</li> + <li>Fixed t/costmodel-naive.t to provide a serialized query to ::Plan::Service constructor.</li> + <li>Fixed test count in algebra-bgp.t.</li> + <li>Fixed test in t/31-service.t that relied on identity-reasoning support in bloom filters (which is now off by default).</li> + <li>Fixed use of RDFQUERY_NETWORK_TESTS in 31-service.t.</li> + <li>Improved use of temporary RDF::Trine stores in RDF::Query tests.</li> + <li>Marked tests TODO for federated query serialization.</li> + <li>Removed what looks like an accidentally pasted test in t/plan.t.</li> + <li>SERVICE tests involving bloom filter handling marked as TODO.</li> + <li>ServiceDescription parsing now gets entire sparql:patterns and not just arcs to depth one.</li> + <li>Silenced unfinished test debugging in t/logging.t.</li> + <li>Updated args to roqet call in failing_earl_tests.sh.</li> + <li>Updated costmodel and logging test expected results that changed due to changes to ::Plan::Join code.</li> + <li>Updated dawg-eval.t regex to recognize RDFTrine blank nodes.</li> + <li>Updated DBPedia test query in t/34-servicedescription.t to reflect new source data.</li> + <li>Updated expected cardinalities in t/logging.t for current plan choice.</li> + <li>Updated logging tests to use the new sparql serialization keys.</li> + <li>Updated SERVICE test in t/plan.t (still broken, but only runs when dev env var RDFQUERY_NETWORK_TESTS in effect).</li> + <li>Updated t/plan.t to be less dependent on the specific state of the kasei.us service endpoint.</li> + <li>Updated test service description RDF for new tests.</li> + <li>Updates to improve logging and test coverage.</li> + </ul> + </li> + <li>Examples and Documentation + <ul> + <li>Added examples/query.pl to show a simple example of loading data and executing a query.</li> + <li>Added examples/create_query_api.pl for generating queries programatically (based on request from KjetilK).</li> + <li>Added bin/graph-bgp.pl to produce a png of a query's BGP variable connectivity graph.</li> + <li>Added bin/graph-query.pl to graph the (one chosen) QEP tree.</li> + <li>Added bin/graph-qeps.pl to vizualize all QEPs of a query with GraphViz.</li> + <li>Updated bin/parse.pl to emit the SSE serialization of the query algebra tree.</li> + <li>Updated bin/rdf_parse_turtle.pl to warn on any parser error.</li> + </ul> + </li> + </ul> + <h3 id="v2_002">Version 2.002 (2008-04-25)</h3> <ul> <li>Updated Bloom::Filter required version in RDF-Query's Makefile.PL.</li> <li>Fixed bug in get_function() when called as a class method.</li> RDF-Query/README.html @@ -14,12 +14,12 @@ not run its Makefile.PL or Build.PL. -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 -SHA1 8d212c70baaefa9aa73c73f5fde8225660e2db3c Changes.ttl +SHA1 1a486eafd9029c8356f54b93b45e148b8fb8e8f5 Changes.ttl SHA1 274828b85997c0ddfe99de9ce144029066364d92 MANIFEST -SHA1 4c0e6d0fcee6a794230616106fc88569081e1e85 META.yml -SHA1 9ee4170148e20a60c3aeff503654b4dad67c1647 Makefile.PL -SHA1 fde3a55a05f702d2c7b91a7555294928ac68a9fd README -SHA1 7b870b9db9e90a4dd6215242574a7afe836f325a README.html +SHA1 5697d6d7fe1442199a5bbd766992fa39436fad8a META.yml +SHA1 687c62b642674896983d659187b04e3cda5d72e1 Makefile.PL +SHA1 19445db3f7adf92a0bd76c32b370f4c3a81d124e README +SHA1 978565085962c420f68017f27197cdc7cb00e442 README.html SHA1 8b4281014f577d343218f6cfe84c6963f9dec3fd bin/deparse.pl SHA1 83262469cfc6b8b1719b57adca7eb9a46c616ba4 bin/failing_earl_tests.sh SHA1 00c163f75e94852dc7a0b27db22b6e442b9dcd47 bin/graph-bgp.pl @@ -47,7 +47,7 @@ SHA1 8216059aa8dc09d808bab127c16d41008fc69d92 data/named_graphs/repeats2.rdf SHA1 02797e9814c7d00ff60397ee41a57e83a2344380 data/service-kasei.ttl SHA1 cebf882dd1823e09d5e513d1608174f654684022 data/service.ttl SHA1 8141df2762aba4205d2735e6bb7e7b247b3002c9 data/temporal.rdf -SHA1 e18c807b7a7721de9e9d526bb50ce86af0f68684 doap.rdf +SHA1 c8f24dedaf6746f39270883c4c8ef54c070d66ac doap.rdf SHA1 37df7c10adcc5341db64c1f70838e76776a16e95 examples/create_query_api.pl SHA1 683386fe0ba1cbe732e2e8b504addfca70e4643d examples/livejournal.pl SHA1 51dd2c90d7cea5a7d32bdce149c145ae2cc4b918 examples/query.pl @@ -56,61 +56,61 @@ SHA1 b1a70869c098ba602151631386fc510b5bfd3511 inc/Module/Install/Base.pm SHA1 d864f4a0dd148e4651cbe29c54c2ffc94d0f05f7 inc/Module/Install/MakeMaker.pm SHA1 176d68fe7c07b6ab7cfe09093078b8127bbde786 inc/Module/Install/Makefile.pm SHA1 8b37b38215d14f922b3d5132ce33d11d21d531ba inc/Module/Install/Metadata.pm -SHA1 44775fbd3e35db67927c14f25dcace2ab7c479d6 lib/RDF/Query.pm -SHA1 9a1ac6e3b4a25b8c0a1835583e5881db240e95cc lib/RDF/Query/Algebra.pm -SHA1 0fe373765587f81e254d743641f7a7e4cba45fa5 lib/RDF/Query/Algebra/Aggregate.pm -SHA1 70753da78f9c0a9def4472288266cc79e64ce6e3 lib/RDF/Query/Algebra/BasicGraphPattern.pm -SHA1 bee0bf83bc9eee27432c61e24daa63c75bf92874 lib/RDF/Query/Algebra/Construct.pm -SHA1 fcc83d2ec4e37b486e473baff74a5c1319d33096 lib/RDF/Query/Algebra/Distinct.pm -SHA1 f2e82c0ee818c22462dffbd652cfa8c037d04648 lib/RDF/Query/Algebra/Filter.pm -SHA1 0f4cc40696688941065c8e2fd24a306c3087751f lib/RDF/Query/Algebra/GroupGraphPattern.pm -SHA1 8475aa7a06df08373b7d9962993bb8f957f1bb4f lib/RDF/Query/Algebra/Limit.pm -SHA1 95237322934014f83c6cc5b55dcac6afd0f1c45f lib/RDF/Query/Algebra/NamedGraph.pm -SHA1 a23748a1dc167becc67b81f9570b5d7364687314 lib/RDF/Query/Algebra/Not.pm -SHA1 0576d8015cf266bfa18c44c70c1bf66530e00065 lib/RDF/Query/Algebra/Offset.pm -SHA1 0708e55f4d2f8142531f7296ac4d36d121299b49 lib/RDF/Query/Algebra/Optional.pm -SHA1 c517687848b1abed6a88cbd7c3769d3e99723307 lib/RDF/Query/Algebra/Path.pm -SHA1 77a1add6fc0101675a56d68c3ee0d25eab92c546 lib/RDF/Query/Algebra/Project.pm -SHA1 ba8f365433c0094f02c67e7b82a415b777785242 lib/RDF/Query/Algebra/Quad.pm -SHA1 af1b2efc2df0be12f07e6d05addd35de9e699c4c lib/RDF/Query/Algebra/Service.pm -SHA1 f82281414cf3df2a532b68b1f78983cd96cf9f5c lib/RDF/Query/Algebra/Sort.pm -SHA1 4f3dd0ccb09e76fd322ae8970e4a557ec6ce5bfa lib/RDF/Query/Algebra/TimeGraph.pm -SHA1 55f82dafc93523fa079c911543b24ffc80f07406 lib/RDF/Query/Algebra/Triple.pm -SHA1 0c0fd3121012d103fb22535b00fd85869f698d31 lib/RDF/Query/Algebra/Union.pm +SHA1 6e3610742f1489950d1b7971c84231b6c8474de3 lib/RDF/Query.pm +SHA1 afe9f7d8bba38e102852a65044dc9365dfd8677e lib/RDF/Query/Algebra.pm +SHA1 8bc3e1e5e32e4fb57adfcd1f4cf3b779d6d3a545 lib/RDF/Query/Algebra/Aggregate.pm +SHA1 313a4686388b9d363c8c46433d1bf3b99745d925 lib/RDF/Query/Algebra/BasicGraphPattern.pm +SHA1 dc9399f42b4823414ddcf4ffadd3fd5b13de5c2e lib/RDF/Query/Algebra/Construct.pm +SHA1 5744e0e40f74cca82ae3616814cc19a8e560c459 lib/RDF/Query/Algebra/Distinct.pm +SHA1 37a1c3937afd2605835c1d7e0a76fad888ed1707 lib/RDF/Query/Algebra/Filter.pm +SHA1 8250a7c8eedad6388eeb87b3bbae241d2b7deb1e lib/RDF/Query/Algebra/GroupGraphPattern.pm +SHA1 0bd3528cca4d9a5c2461689cd675d65a65d0efa6 lib/RDF/Query/Algebra/Limit.pm +SHA1 a0fb65e3034debe878a051221aaf7bcffe0cece0 lib/RDF/Query/Algebra/NamedGraph.pm +SHA1 2a6ae2fc8c557d695124726f74619794b8f0061c lib/RDF/Query/Algebra/Not.pm +SHA1 c008e689830fb73f0b4fe25a6f82cda90599f2c3 lib/RDF/Query/Algebra/Offset.pm +SHA1 cd098f0f96f008d071a7ae1b2c00c6522e96d3bc lib/RDF/Query/Algebra/Optional.pm +SHA1 56b8da944b833c5cc71ccc4f445e26fbbcee5d2d lib/RDF/Query/Algebra/Path.pm +SHA1 97273696ad730d8f3350fed3d9d11ca612d85d14 lib/RDF/Query/Algebra/Project.pm +SHA1 9f3a1b4d001fd4c300a93e7e21110dd494e465be lib/RDF/Query/Algebra/Quad.pm +SHA1 006bc1dd0a8501aa2429aadd5d9572f82943b31a lib/RDF/Query/Algebra/Service.pm +SHA1 0ad1e9ded7ebb1b4e61a2c476e9c0d41e9d00987 lib/RDF/Query/Algebra/Sort.pm +SHA1 d6e89be4d3617ed1515f9796dbcda7ab27f77963 lib/RDF/Query/Algebra/TimeGraph.pm +SHA1 042b2c1c5e7c44108b4a0c009db9929226d78665 lib/RDF/Query/Algebra/Triple.pm +SHA1 936cbb3b3b90b15b0fb8f83aa2551e2b4f9af93f lib/RDF/Query/Algebra/Union.pm SHA1 8d9d784da786ce21dab0e535cd3a616e9644cb44 lib/RDF/Query/BGPOptimizer.pm -SHA1 235221d969d5064a156342cdfda9765417d67094 lib/RDF/Query/Compiler/SQL.pm -SHA1 00df64055fb545c69f814229fbd5713718c3f56e lib/RDF/Query/CostModel.pm -SHA1 022e6bde996acf6e6d947614ad226e3fb424f2e3 lib/RDF/Query/CostModel/Counted.pm -SHA1 fa7768de9be9255163d0e421e3cb6e7430f4d1b0 lib/RDF/Query/CostModel/Logged.pm -SHA1 b5d9bd28c64e3982f1546ead3259d03ba0bae585 lib/RDF/Query/CostModel/Naive.pm -SHA1 0213e1d886231cd7a3cdeb1b983e8ff22296f816 lib/RDF/Query/Error.pm +SHA1 4306d88c0293006f7bbdc620b0cc58fa679ece36 lib/RDF/Query/Compiler/SQL.pm +SHA1 b426bfb853f3d375551438afc395c7c306193ba5 lib/RDF/Query/CostModel.pm +SHA1 8deb87515dd32284fd53f3b24e7b36ca72248bf4 lib/RDF/Query/CostModel/Counted.pm +SHA1 aa080aa18da0462b1b138ff8ee776d357564e6aa lib/RDF/Query/CostModel/Logged.pm +SHA1 417e5c677b6e2b793bee5df810c0e4f8fac3500b lib/RDF/Query/CostModel/Naive.pm +SHA1 77fbf4dacf63b289845369797496e95a66023ca5 lib/RDF/Query/Error.pm SHA1 c19453c21d34e665e479649df7609c7456ac1f33 lib/RDF/Query/ExecutionContext.pm -SHA1 678c5d7b7fecbec007392ee2c94edd3918aa678e lib/RDF/Query/Expression.pm -SHA1 30641201c2cb1f32fd6d6d048fcbfc4fb278e322 lib/RDF/Query/Expression/Alias.pm -SHA1 a19df83d8f470685877a78b3e23132b90bbae8af lib/RDF/Query/Expression/Binary.pm -SHA1 29e9830115bdae861df7498ecc43834105af6d17 lib/RDF/Query/Expression/Function.pm -SHA1 07dc17f87f9de4a7bcfdbe0bddfd98b2d039467a lib/RDF/Query/Expression/Nary.pm -SHA1 df8fcb3ef14bf3f0b7a5c0067548b68012739b46 lib/RDF/Query/Expression/Unary.pm -SHA1 03c9b754efc5432224d5f69f9fc935838a18ff64 lib/RDF/Query/Federate.pm +SHA1 969dbbc4d9b2582a9ecc89907a0d2b74471cfed8 lib/RDF/Query/Expression.pm +SHA1 53cf4619b3ff16964ced06a0dad4227c35456226 lib/RDF/Query/Expression/Alias.pm +SHA1 a6a67467ab70773ddb04d2b0c0786bbdd47815f2 lib/RDF/Query/Expression/Binary.pm +SHA1 00f1e76e5a197f8af0d9e150e308c1f0f2ee39d0 lib/RDF/Query/Expression/Function.pm +SHA1 023514474bbfed84bfbb3273dc490190cc693724 lib/RDF/Query/Expression/Nary.pm +SHA1 ae38de3638919a26cdb0b41afb4d20107cf4936e lib/RDF/Query/Expression/Unary.pm +SHA1 67f6ee7199cfed706342c5db6fe91096ce79dee3 lib/RDF/Query/Federate.pm SHA1 6e8a40046b8bc3225db27c2365fa3e4b6282045f lib/RDF/Query/Federate/Plan.pm -SHA1 71c5ee1da45623446e7b1aaecf1e799c701dfa26 lib/RDF/Query/Functions.pm -SHA1 579c325b8ebd1de799f192721d6e116eacbd4eb8 lib/RDF/Query/Logger.pm -SHA1 a189df6fbeacccaa1f9d1497d48ff78c805dd685 lib/RDF/Query/Model.pm -SHA1 773b7c615481fd51c4f0777bcd28dc65b049d62a lib/RDF/Query/Model/RDFCore.pm -SHA1 ff4e2a13b63f04d493ce63d4ee53b1f40ec3083d lib/RDF/Query/Model/RDFTrine.pm -SHA1 6cac21e6d3b3f7fb82114e1319947d7d8b8dfbf8 lib/RDF/Query/Model/RDFTrine/BasicGraphPattern.pm -SHA1 7450124d9a450a464fbb9c4f2ee8725749e7ba0f lib/RDF/Query/Model/RDFTrine/Filter.pm -SHA1 94ab86e9201beca69005d8d1999f6a55842a677f lib/RDF/Query/Model/Redland.pm -SHA1 1ec7c13a1846fa1a6453b54fab304a3167369cd2 lib/RDF/Query/Node.pm -SHA1 fd1512c3b2c5fdc6e0302da78da4b916f706d81a lib/RDF/Query/Node/Blank.pm -SHA1 35d916d81ba5652e28eb3dbf53b681e2ed1ed8d0 lib/RDF/Query/Node/Literal.pm -SHA1 f22504d8ddf4b7d3ed7706cdbbde54006d729978 lib/RDF/Query/Node/Resource.pm -SHA1 92993cdd2b5c6448bac0e02c10a1339cc457738b lib/RDF/Query/Node/Variable.pm -SHA1 b2eedf6ca6c2ec723742ff584ad2cb0b145ffd5f lib/RDF/Query/Parser.pm -SHA1 07efb66e1c831132101d6ff083c2c4ca6c16b038 lib/RDF/Query/Parser/RDQL.pm -SHA1 32ae4e9988a2ca538ef0a962116b0554d655ff30 lib/RDF/Query/Parser/SPARQL.pm -SHA1 2c3ed44d88db415156f39417db94f48b466a3e21 lib/RDF/Query/Parser/SPARQLP.pm -SHA1 20bf36f93a36ac920a1a66e8ea78d5a0ace5ac2b lib/RDF/Query/Parser/SPARUL.pm +SHA1 ffe73bdd2c1857131d08d72c4c2a888e86413ad9 lib/RDF/Query/Functions.pm +SHA1 0a1130671d3a2cd3619567f0ef1df09a94cb1fbe lib/RDF/Query/Logger.pm +SHA1 5107b394666c7b6d15016d8424d92c1fff4cbfec lib/RDF/Query/Model.pm +SHA1 39d17008aef28d7863a6ddb15c65003d850bf834 lib/RDF/Query/Model/RDFCore.pm +SHA1 b69661dc855c63a37db3eaf15c0ecf21c24aa613 lib/RDF/Query/Model/RDFTrine.pm +SHA1 8832bb673fec6cd51bc54885ceca65fb0188015f lib/RDF/Query/Model/RDFTrine/BasicGraphPattern.pm +SHA1 5a67eaaf87ae9261a04fe99097531cb5839e7311 lib/RDF/Query/Model/RDFTrine/Filter.pm +SHA1 ea3c526d50871bd5173bdeff734b68fbc5d993e3 lib/RDF/Query/Model/Redland.pm +SHA1 7c57417bc2e97716d5bed662b9f33a8274196875 lib/RDF/Query/Node.pm +SHA1 55f0bb1da473206ad1add4d8082b97313d9f5478 lib/RDF/Query/Node/Blank.pm +SHA1 97542dcaf85a5c87a92446d491e2096317eb2226 lib/RDF/Query/Node/Literal.pm +SHA1 44825a3942a13f0424062b65b285dca8f90582b1 lib/RDF/Query/Node/Resource.pm +SHA1 bb69d1c253362b60c31ed812069caaac3083162f lib/RDF/Query/Node/Variable.pm +SHA1 03bc739d056212b0e70c3166fbf7165d317e399a lib/RDF/Query/Parser.pm +SHA1 4a3e2d97e53ef4c7b349eb1e5ae1d1a57888c4ac lib/RDF/Query/Parser/RDQL.pm +SHA1 5d19619020801742bf6e28970dae3d242e63a53b lib/RDF/Query/Parser/SPARQL.pm +SHA1 a3cf8246656b314e4f6b396b50b1a4b1bf21f725 lib/RDF/Query/Parser/SPARQLP.pm +SHA1 5914171f0ad2bb6dc3cfb2752fc872c14f9b45e6 lib/RDF/Query/Parser/SPARUL.pm SHA1 af95dac2a8b4ad2818537e4b9096cdc7fd6b8475 lib/RDF/Query/Plan.pm SHA1 1a6b81245a0f381775c4b1ed02f9b360c53feab3 lib/RDF/Query/Plan/Aggregate.pm SHA1 9dc67a1400ac7053a2f574470a1634d1a68e6dc4 lib/RDF/Query/Plan/BasicGraphPattern.pm @@ -131,7 +131,7 @@ SHA1 c9c519e6335b9f8d7e792310d4bbab6d13d68a84 lib/RDF/Query/Plan/Sort.pm SHA1 d96f4c24bd0450b1857a2c5567e1ac83da30b3da lib/RDF/Query/Plan/ThresholdUnion.pm SHA1 7699d303303332b28b2789a8973953a959a2be63 lib/RDF/Query/Plan/Triple.pm SHA1 d2e969cb2453adf0ba91c0fc2d084ed8a760c364 lib/RDF/Query/Plan/Union.pm -SHA1 289488aaff213320abd12b69bfbbf7d76d78338d lib/RDF/Query/ServiceDescription.pm +SHA1 275b1e95b6995c778b3b8362d74f67c79f4abf94 lib/RDF/Query/ServiceDescription.pm SHA1 b997d7f6b5ccc65373e2526d883f05879a915ab3 lib/RDF/Query/Temporal.pm SHA1 9f3565f7a5f574d5629035b30e059edd9babfdee lib/RDF/Query/VariableBindings.pm SHA1 3fd735b3d152dba476f08c7a45e18afc18c97c8d t/00-simple.t @@ -173,7 +173,7 @@ SHA1 d825f12e985fe2d64a2079c2ad5e29c4aea99770 t/34-servicedescription.t SHA1 a773bcafcb069a9961ee660d940ea4d7b8946b94 t/35-bindings.t SHA1 9f1f7fd06de7111bc5cf2d65ec804a6a350cbc2b t/algebra-bgp.t SHA1 a29cfa1435d7e67a62aefe40b7123b1b8e28ed66 t/algebra-expr.t -SHA1 f48dc05b80aca6297bf64a4c6972acf56b4f04d4 t/algebra-func.t +SHA1 093e033541436749759a33b8d2305e613f198456 t/algebra-func.t SHA1 a3735e045ed9860ef7584b40c5f64381a1853165 t/algebra-subsumption.t SHA1 e9c165ba452532a4b7e52eda45c149202d0a5400 t/algebra.t SHA1 d0cb66c4d358e583f2258878f0222444eea3d8dc t/costmodel-logged.t @@ -181,7 +181,7 @@ SHA1 81d0ebfce1eab793e8b31e35cad393245eee2bd0 t/costmodel-naive.t SHA1 bcca0b7492c687cc4876b098abf810d9f03cfc86 t/distance.js SHA1 e1fccc14061a0f6dfca9e6ac833abaf1d2fe03b6 t/functions.rdf SHA1 7a331e95ce7e84817198facd382347d802c46f3e t/logging.t -SHA1 41f6d2e1128c26f9946db7f997c3ed5409a14467 t/models.pl +SHA1 c2f0fe1efa98211a272d2f37f6dea78a1f4e5b85 t/models.pl SHA1 74e777cc9c736509378815a161f7c556d631fdd1 t/optimizer.t SHA1 182369b36d168054474fd0b98be62ece33419382 t/plan-rdftrine.t SHA1 653b7a5dffb38dcdcc5a044d720b9eb8acc5d34a t/plan.t @@ -191,7 +191,7 @@ SHA1 49b00fec62d3340cf77f10f09d3bd70261658ea4 t/unsaid.t -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.3 (Darwin) -iD8DBQFJuDythPK6VMqoyC0RAvyWAJ0Xcu2zAuxfVzKa5rMZbtO272OAxwCfZ3in -GtX3WF6UgzLcsXUAwFkkXdo= -=SmVd +iD8DBQFJwRqbhPK6VMqoyC0RAlW7AJ94Heq6yrbvYh/iNJXHynjppdey+QCgngIQ +labxCtX0L8jw6OlVhJ9Y6oY= +=emw4 -----END PGP SIGNATURE----- RDF-Query/SIGNATURE @@ -34,8 +34,8 @@ <release> <Version> <name>stable</name> - <created>2009-03-XX</created> - <revision>2.003_01</revision> + <created>2009-03-19</created> + <revision>2.100</revision> </Version> </release> RDF-Query/doap.rdf @@ -7,7 +7,7 @@ RDF::Query - An RDF query implementation of SPARQL/RDQL in Perl for use with RDF =head1 VERSION -This document describes RDF::Query version 2.003_01, released XX March 2009. +This document describes RDF::Query version 2.100, released XX March 2009. =head1 SYNOPSIS @@ -101,6 +101,7 @@ use DateTime::Format::W3CDTF; use Log::Log4perl qw(:easy); Log::Log4perl->easy_init($ERROR); +no warnings 'numeric'; use RDF::Trine 0.108; use RDF::Trine::Iterator qw(sgrep smap swatch); @@ -128,7 +129,7 @@ use RDF::Query::CostModel::Counted; our ($VERSION, $DEFAULT_PARSER); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; $DEFAULT_PARSER = 'sparql'; } RDF-Query/lib/RDF/Query.pm @@ -14,7 +14,7 @@ RDF::Query::Algebra - Base class for Algebra expressions package RDF::Query::Algebra; BEGIN { - our $VERSION = '2.003_01'; + our $VERSION = '2.100'; } use strict; @@ -241,95 +241,6 @@ sub subpatterns_of_type { return @patterns; } -=item C<< nested_loop_local_join ( $outer_iterator, $inner_algebra, $query, $bridge, $bound, $context ) >> - -Performs a natural, nested loop join, returning a new stream of joined results. - -Items from C<< $outer_iterator >> are used as bound values to successive calls -to C<< $inner_algebra->execute >>. - -=cut - -sub nested_loop_local_join { - my $self = shift; - my $outer = shift; - my $inner = shift; - my $query = shift; - my $bridge = shift; - my $bound = shift || {}; - my $context = shift; - my %args = @_; - - Carp::confess unless ($outer->isa('RDF::Trine::Iterator::Bindings')); - Carp::confess unless ($inner->isa('RDF::Query::Algebra')); - my $l = Log::Log4perl->get_logger("rdf.query.algebra"); - - my $a = $outer; - - no warnings 'uninitialized'; - - my $rowa; - my $inner_iter; - my $need_new_a = 1; - my $sub = sub { - OUTER: while (1) { - if ($need_new_a) { - $rowa = $a->next or return undef; - $l->debug("*** new outer tuple"); - $l->debug("OUTER: " . Dumper($rowa)); - my %tmpbound; - foreach my $h ($bound, $rowa) { - foreach my $k (keys %$h) { - if (defined($h->{ $k })) { - $tmpbound{ $k } = $h->{ $k }; - } - } - } - $l->debug("executing inner pattern " . $inner->as_sparql . " with bound values: " . '{' . join(', ', map { join('=', $_, ($tmpbound{$_}) ? $tmpbound{$_}->as_string : '(undef)') } (keys %tmpbound)) . '}' ); - $inner_iter = $inner->execute( $query, $bridge, \%tmpbound, $context, %args ); #->project( @names ); - $need_new_a = 0; - } - $l->debug("OUTER: " . Dumper($rowa)); - return undef unless ($rowa); - LOOP: while (my $rowb = $inner_iter->next) { - $l->debug("- INNER: " . Dumper($rowb)); - $l->debug("[--JOIN--] " . join(' ', map { my $row = $_; '{' . join(', ', map { join('=', $_, ($row->{$_}) ? $row->{$_}->as_string : '(undef)') } (keys %$row)) . '}' } ($rowa, $rowb))); - my %keysa = map {$_=>1} (keys %$rowa); - my @shared = grep { $keysa{ $_ } } (keys %$rowb); - foreach my $key (@shared) { - my $val_a = $rowa->{ $key }; - my $val_b = $rowb->{ $key }; - my $defined = 0; - foreach my $n ($val_a, $val_b) { - $defined++ if (defined($n)); - } - if ($defined == 2) { - my $equal = $val_a->equal( $val_b ); - unless ($equal) { - $l->debug("can't join because mismatch of $key (" . join(' <==> ', map {$_->as_string} ($val_a, $val_b)) . ")"); - next LOOP; - } - } - } - - my $row = { (map { $_ => $rowa->{$_} } grep { defined($rowa->{$_}) } keys %$rowa), (map { $_ => $rowb->{$_} } grep { defined($rowb->{$_}) } keys %$rowb) }; - if ($l->is_debug) { - $l->debug("JOINED:"); - foreach my $key (keys %$row) { - $l->debug("$key\t=> " . $row->{ $key }->as_string); - } - } - return $row; - } - $need_new_a = 1; - } - }; - - my @names = uniq( $outer->binding_names, $inner->referenced_variables ); - my $args = $outer->_args; - return $outer->_new( $sub, 'bindings', \@names, %$args ); -} - =item C<< from_sse ( $sse, \%context ) >> Given an SSE serialization, returns the corresponding algebra expression. RDF-Query/lib/RDF/Query/Algebra.pm @@ -24,7 +24,7 @@ use RDF::Trine::Iterator qw(smap); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Aggregate.pm @@ -25,7 +25,7 @@ use RDF::Trine::Iterator qw(smap swatch); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/BasicGraphPattern.pm @@ -25,7 +25,7 @@ use RDF::Trine::Iterator qw(sgrep); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Construct.pm @@ -25,7 +25,7 @@ use RDF::Trine::Iterator qw(sgrep); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Distinct.pm @@ -26,7 +26,7 @@ use RDF::Trine::Iterator qw(sgrep smap swatch); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Filter.pm @@ -29,7 +29,7 @@ use RDF::Trine::Iterator qw(sgrep smap swatch); our ($VERSION, $debug); BEGIN { $debug = 0; - $VERSION = '2.003_01'; + $VERSION = '2.100'; our %SERVICE_BLOOM_IGNORE = ('http://dbpedia.org/sparql' => 1); # by default, assume dbpedia doesn't implement k:bloom(). } RDF-Query/lib/RDF/Query/Algebra/GroupGraphPattern.pm @@ -25,7 +25,7 @@ use RDF::Trine::Iterator qw(sgrep); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Limit.pm @@ -26,7 +26,7 @@ use RDF::Trine::Iterator qw(sgrep smap swatch); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/NamedGraph.pm @@ -23,7 +23,7 @@ use RDF::Trine::Iterator qw(smap sgrep swatch); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Not.pm @@ -25,7 +25,7 @@ use RDF::Trine::Iterator qw(sgrep); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Offset.pm @@ -23,7 +23,7 @@ use RDF::Trine::Iterator qw(smap sgrep swatch); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Optional.pm @@ -25,7 +25,7 @@ use Carp qw(carp croak confess); our ($VERSION, $debug, $lang, $languri); BEGIN { $debug = 0; - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Path.pm @@ -25,7 +25,7 @@ use RDF::Trine::Iterator qw(sgrep); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Project.pm @@ -24,7 +24,7 @@ use RDF::Trine::Iterator qw(smap sgrep swatch); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Quad.pm @@ -29,7 +29,7 @@ use RDF::Trine::Iterator qw(sgrep smap swatch); our ($VERSION, $BLOOM_FILTER_ERROR_RATE); BEGIN { $BLOOM_FILTER_ERROR_RATE = 0.1; - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Service.pm @@ -26,7 +26,7 @@ use Time::HiRes qw(gettimeofday tv_interval); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Sort.pm @@ -22,7 +22,7 @@ use Carp qw(carp croak confess); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/TimeGraph.pm @@ -27,7 +27,7 @@ use RDF::Trine::Iterator qw(smap sgrep swatch); our ($VERSION); my @node_methods = qw(subject predicate object); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Triple.pm @@ -25,7 +25,7 @@ use Carp qw(carp croak confess); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Algebra/Union.pm @@ -31,7 +31,7 @@ use RDF::Query::Error qw(:try); my (@NODE_TYPE_TABLES, %NODE_TYPE_TABLES); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; @NODE_TYPE_TABLES = ( ['Resources', 'ljr', 'URI'], ['Literals', 'ljl', qw(Value Language Datatype)], RDF-Query/lib/RDF/Query/Compiler/SQL.pm @@ -15,7 +15,7 @@ package RDF::Query::CostModel; our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } use strict; RDF-Query/lib/RDF/Query/CostModel.pm @@ -15,7 +15,7 @@ package RDF::Query::CostModel::Counted; our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } use strict; RDF-Query/lib/RDF/Query/CostModel/Counted.pm @@ -15,7 +15,7 @@ package RDF::Query::CostModel::Logged; our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } use strict; RDF-Query/lib/RDF/Query/CostModel/Logged.pm @@ -15,7 +15,7 @@ package RDF::Query::CostModel::Naive; our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } use strict; RDF-Query/lib/RDF/Query/CostModel/Naive.pm @@ -37,7 +37,7 @@ use base qw(Error); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Error.pm @@ -23,7 +23,7 @@ use Carp qw(carp croak confess); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Expression.pm @@ -23,7 +23,7 @@ use Carp qw(carp croak confess); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Expression/Alias.pm @@ -24,7 +24,7 @@ use Carp qw(carp croak confess); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Expression/Binary.pm @@ -23,7 +23,7 @@ use Carp qw(carp croak confess); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Expression/Function.pm @@ -23,7 +23,7 @@ use Carp qw(carp croak confess); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Expression/Nary.pm @@ -23,7 +23,7 @@ use Carp qw(carp croak confess); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Expression/Unary.pm @@ -38,7 +38,7 @@ use RDF::Trine::Iterator qw(sgrep smap swatch); our ($VERSION); BEGIN { - $VERSION = '2.000'; + $VERSION = '2.100'; } RDF-Query/lib/RDF/Query/Federate.pm @@ -31,7 +31,7 @@ use Carp qw(carp croak confess); our ($VERSION, $l); BEGIN { $l = Log::Log4perl->get_logger("rdf.query.functions"); - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Functions.pm @@ -15,7 +15,7 @@ package RDF::Query::Logger; our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } use strict; RDF-Query/lib/RDF/Query/Logger.pm @@ -23,7 +23,7 @@ use Carp qw(carp croak confess); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Model.pm @@ -27,7 +27,7 @@ use RDF::Trine::Statement::Quad; our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Model/RDFCore.pm @@ -31,7 +31,7 @@ use RDF::Trine::Iterator qw(smap); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Model/RDFTrine.pm @@ -22,7 +22,7 @@ use RDF::Trine::Statement; our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Model/RDFTrine/BasicGraphPattern.pm @@ -26,7 +26,7 @@ use RDF::Trine::Iterator qw(smap); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Model/RDFTrine/Filter.pm @@ -22,7 +22,7 @@ use RDF::Trine::Statement::Quad; our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Model/Redland.pm @@ -25,7 +25,7 @@ use RDF::Query::Node::Variable; our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } =item C<< is_variable >> RDF-Query/lib/RDF/Query/Node.pm @@ -26,7 +26,7 @@ use Carp qw(carp croak confess); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Node/Blank.pm @@ -26,7 +26,7 @@ use Carp qw(carp croak confess); our ($VERSION, $LAZY_COMPARISONS); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Node/Literal.pm @@ -23,7 +23,7 @@ use Carp qw(carp croak confess); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Node/Resource.pm @@ -22,7 +22,7 @@ use Carp qw(carp croak confess); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Node/Variable.pm @@ -28,7 +28,7 @@ use Carp qw(carp croak confess); our ($VERSION); BEGIN { - $VERSION = '2.003_01'; + $VERSION = '2.100'; } ###################################################################### RDF-Query/lib/RDF/Query/Parser.pm @@ -26,7 +26,7 @@ our ($VERSION, $lang, $languri); BEGIN { $::RD_TRACE = undef; $::RD_HINT = undef; - $VERSION = '2.003_01'; + $VERSION = '2.100'; $lang = 'rdql'; $languri = 'http://jena.hpl.hp.com/2003/07/query/RDQL'; } RDF-Query/lib/RDF/Query/Parser/RDQL.pm @@ -31,7 +31,7 @@ use strict; use warnings; no warnings 'redefine'; use base qw(RDF::Query::Parser); -our $VERSION = '2.003_01'; +our $VERSION = '2.100'; use URI; use Data::Dumper; RDF-Query/lib/RDF/Query/Parser/SPARQL.pm @@ -26,7 +26,7 @@ package RDF::Query::Parser::SPARQLP; use strict; use warnings; use base qw(RDF::Query::Parser::SPARQL); -our $VERSION = '2.003_01'; +our $VERSION = '2.100'; use URI; use Data::Dumper; RDF-Query/lib/RDF/Query/Parser/SPARQLP.pm @@ -26,7 +26,7 @@ package RDF::Query::Parser::SPARUL; use strict; use warnings; use base qw(RDF::Query::Parser::SPARQL); -our $VERSION = '2.003_01'; +our $VERSION = '2.100'; use URI; use Data::Dumper; RDF-Query/lib/RDF/Query/Parser/SPARUL.pm @@ -15,7 +15,7 @@ package RDF::Query::ServiceDescription; our ($VERSION); BEGIN { - $VERSION = '2.000'; + $VERSION = '2.100'; } use strict; RDF-Query/lib/RDF/Query/ServiceDescription.pm d71948d293d6469c6480d365a7e4e0c46e1b8e0a Gregory Todd Williams greg@evilfunhouse.com http://github.com/kasei/perlrdf/commit/d62ac2c165354c5c7707f5ab188c64985528d29a d62ac2c165354c5c7707f5ab188c64985528d29a 2009-03-18T09:02:12-07:00 2009-03-18T09:02:12-07:00 - Updated docs, versions, and SIGNATURE for 2.100 release. 5195e04f94c730f895e100bd72cb1f1d8ff386b3 Gregory Todd Williams greg@evilfunhouse.com