This is an automated email from the git hooks/post-receive script.

js pushed a change to annotated tag upstream/0.001_alpha2
in repository libatteanx-query-cache-perl.

        at  4a6875c   (tag)
   tagging  557071e86512e73bc8cd1ee7fb1999d3df331bdb (commit)
 tagged by  Jonas Smedegaard
        on  Sat Feb 20 11:45:30 2016 +0100

- Log -----------------------------------------------------------------
Upstream version 0.001~alpha2
Version: GnuPG v1


Gregory Todd Williams (8):
      Updated to align with changes in committed version of 
AtteanX::API::JoinRotatingPlanner role.
      Allow falling through to planner-supplied cost method in 
      Remove use of IDP query planning.
      Avoid cartesian products and fix bug in coalescing of SPARQLBGP plans.
      Call done_testing().
      Fix call to is_trace.
      Improve query plan cost estimation.
      Simplify generation of SPARQL BGP plans.

Jonas Smedegaard (1):
      Imported Upstream version 0.001~alpha2

Kjetil Kjernsmo (274):
      Autogenerated start of distro
      Just a start of some code
      First stab at cache lookup
      Failing tests for hash cache
      Partial support for two-variable triple patterns
      use method for getting vars
      Ensure stable tests (and passing)
      Failing tests for arbitrary terms
      Use NTriples parser for the cached results
      Use new is_variable method
      test for literals
      CUtnpaste from Quad and change to TPF
      remove 'a', insert 1;
      The Cache UA surely belongs here
      a bit of scrambling around
      a bit of scrambling around
      Non-working code
      fix the call to ::Triple
      add empty BGP special case to access_plan
      AaAAaarggh! Forgot that I override
      AaAAaarggh! Forgot that I override
      wrap the access_plans again
      Leave the cache to the model; Clean up tests
      A test that includes non-cached
      update makefile
      More tests for more other plans
      do a 2-triple test all with cache
      remove the rest of what we don't do
      Add a model for the SPARQL cache
      Commit with comments in the planning code, to understand
      plan with 2 triples, nothing in cache
      more testing on both
      make sure the model handles get_sparql
      Remove warns
      remove old use ::::Triple
      Make it a subclass of the upstream Model
      a first attempt at join_plans: Will either return BGP plan or orig
      5-triple test
      an attempt at more advanced join plans
      Just remove the add_triples stuff
      Add some comments
      Don't wrap quads calls in plan objects
      Deref quads as arrayref
      set a low cost on tables too
      set the in_scope_variables to the union
      fix some messy parentheses
      add a cost to the SPARQL BGP too
      fix some syntax errors
      rudimentary cost planning
      Go through tests to align them with real world
      Check for HashJoin
      make logic explicit for problem situation
      improve message
      Perhaps it isn't a bug...
      Add preliminary costs for joins
      Improve tests
      treat the case of table on one side and quad on the other
      should be just two plans, right?
      don't use Carp::Always always
      Change BGP plan to use children attribute
      fix comments
      update tests
      new plans seem ok for one cached
      new cartesian breakup test
      chain test
      predicate variable test
      Use NestedLoopJoin if there is no common variable
      don't do cartesian for predicate variable test
      comment out warns, no evidence of bugs there
      Fix bare quads issue #3
      refactor join_vars
      Comment out join_plans in cache planner and cost_for_plan in model
      Provide costs for some plans
      Merge pull request #12 from kasei/test-just-rotate
      Set a huge cost of locally joined quads
      allow join types in cost too
      Lower the cost of Join(Table,SPARQLBGP) by dividing with a factor
      Test for one cached should be OK
      return the join_plans to do work
      let the test stop where we're currently working
      Add Log::Any logging
      Enable logging in test script
      add some documentation
      mention Log::Any::Adapter::Screen
      make debug mode a little less verbose
      make debug statement a little more useful
      remove some logging; got out of hand
      fix array bug
      A newline in the trace
      Merge pull request #13 from kasei/master
      Merge pull request #14 from kasei/master
      Debugging stuff
      Add debugging to access_plans
      Now getting just one plan
      Fix schrodingertest
      Improve tests for case with one cached
      now passing 5-triple test
      A few weird 3-triple tests
      bump the quad cost
      Rename test files
      test for simpler BGP with 3 triple patterns in the SPARQL BGP
      clean some debugging statements
      Bump attean version dep
      Update dist.ini and add travis config
      remove 5.18.2
      Update deps
      remove scalar::util
      Add a Model to store the things the analyzer will compute plans for
      Cargo cult code to add a analyzer model and code to analyze
      Try canonicalizing on BGP
      add is_cached method to Model
      test for is_cached method
      a little progress on analysis code
      some very crude code in the analyzer
      Add a try attribute for the key to possibly cache
      a non-working query planner extension
      Switch to new canonicalization
      just serialize once
      use the string as cache key
      extend the query planner with dummy table
      make sure the cache key is a string
      add carp::always
      return some worthy candidates
      update is_cached tests
      remove some prelim stuff
      fix bug in the sort
      first real test
      Add a trace
      Make failing tests for 3-triple case
      remove warns
      bump log level
      use splice function
      if tracing estimate all plans
      tests are ok
      Make cache lookup info level log
      Merge pull request #19 from kasei/master
      port the predicate count analysis from the trine based code
      Merge branch 'master' of
      Add the redis store for the counts
      use Redis rather than Redis::Fast
      Add redis to deps
      Use Redis rather than Redis::Fast
      failing tests for counts
      add count_threshold attribute
      most passing counts tests
      more tests for just the analyzer without cache
      improve debugging
      Merge pull request #20 from kasei/master
      reintroduce BGP as the winning plan for broken chain
      move the BGP cost to their own model
      extend copyright
      extend copyright
      cost_for_plan wrapper that doesn't work
      another attempt
      an implementation of cost that fixes the chain, breaks other things
      remove the factor 2
      tweaked the costs until some tests pass :-P
      remove debugging comments
      fix bug in the planner that missed some quads when transforming to 
      another test
      use subtests
      check the predicate
      check the predicates
      Rename analysis test
      The start of code for prefetcher #18
      Remove comments and make actual test for #18
      For #18:
      For #18: Make the variables explicit
      tests for the hash case of #18
      don't need to handle cache #18
      Improve prefetcher code #18 and setting cache #6.
      change title
      improve diagnostics
      Basic test for analysis and cache, relevant to #6 , #9 and #18
      Remove other tests
      Add minor test
      add test requirements for analysis
      bump Attean version dep
      misc deps
      Remove unneeded digest package
      Refactor the access_plan into a role
      Create simple queryplanner with LDF
      no modifiers
      remove todo
      remove todo
      the beginning of some tests
      Create a Model for SPARQL+Cache+LDF
      remove some types
      remove some types
      add dep on List::MoreUtils
      Try to wrap SPARQLCache's model
      just deal with the case of a single quad BGP
      some simple tests that pass
      cost_for_plan test
      one more test looks good
      another good test
      another test fine
      test that fail should fail
      comment out slow test for now
      Failing tests for LDFs inside SPARQLBGP
      small error message fix
      LDF triples now named LDFTriple
      triple tests ok
      do not set $bgp->cost but sum up and return instead
      explicitly use AccessPlan::LDF in addition to say with
      remove the has_costs check here, will be dealt with elsewhere
      improve logging
      Uncomment 4-triple test
      try to make some tests
      move 4-triple test
      Use full absolute URIs
      Fix misuse of triple constructor
      a comment
      the final triplepattern
      add some real triples to test
      first four plans should be table and ldf joined
      terribly failing test...
      skip the tests that work for now
      Add dep on AtteanX::Store::LDF
      version dep on SPARQL store
      Just try something
      more logging
      make RDF::LinkedData a test dep
      Add RDF::Generator::Void to test deps
      Return early if theres no BGPs for now
      first attempt at calling planner on the plan
      more elaborate planning for children
      guard against cost overruns
      penalize the SPARQL BGPs a little heavier
      run all tests
      Make the single bare Quads SPARQLBGPs
      replace the Quad plan with a SPARQLBGP plan
      fix meaningless test
      another test error
      rebalance BGP cost
      log a little less
      try to lower the cost of single-quad SPARQL BGPs a bit
      improve tests
      some diagnostics in tests
      add a comment
      reindent and return cost to optimize
      Penalize plans that have an LDFTriple and SPARQLBGP with a shared variable
      first attempt at penalizing many lDFs
      implement penalizing joins with LDFs
      actually implement penalizing joins with many ldfs
      rewrite another test
      test should be OK
      use the name of variable for shared to improve diagnostics
      test for variable
      write simple README
      Set version
      update changelog
      escape curly brackets in regexps
      Drop some author tests for now
      escape more curly brackets
      log if count is 2
      version dep on Types::Standard
      remove warns
      First attempt at fixing #24
      remove DB::Single statements
      comment out skips2
      non-working attempt at using before for the allow_join_rotation
      Add the LDF rotation code to the LDF planner for #24
      analysis tests should be OK
      remove unused variable
      penalize all LDF plans with cartesians
      Make sure LDF plans are called by the analyzer
      Add LDF stores to other analysis tests
      divide the final pattern tests
      update changelog
      bump version


No new revisions were added by this update.

Alioth's /usr/local/bin/git-commit-notice on 

Pkg-perl-cvs-commits mailing list

Reply via email to