@@ -185,7 +185,7 @@ module Neo4j::Aggregate # check if it is the leaf node or not if (@child_dsl) # this is not the leaf aggregate dsl, let the child node add the node instead - @child_dsl.create_groups(group_node, node) # TODO + @child_dsl.create_groups(group_node, node) else # this IS a leaf aggregate dsl, add node to the group rel_type = node.kind_of?(AggregateGroupNode)? key : :aggregate lib/neo4j/extensions/aggregate/aggregator.rb @@ -6,7 +6,6 @@ module Neo4j::Aggregate Neo4j.event_handler.add(self) @filter = nodes_or_class end - puts "init aggregate_each root #{root_node.neo_node_id}" @root_node = root_node @nodes = nodes_or_class end @@ -34,8 +33,6 @@ module Neo4j::Aggregate return if node.class != @filter return unless @group_by.include?(prop_key.to_sym) - puts "on_property_changed node: #{node.neo_node_id} prop: #{prop_key} old: #{old_value} new: #{new_value}" - # for each aggregate the node belongs to delete it # we have to first create it and then deleted, otherwise cascade delete will kick in group = node.aggregate_groups(@root_node.aggregate_id) @@ -45,15 +42,6 @@ module Neo4j::Aggregate # delete this aggregate group if it exists group.delete if group - -# puts "EXIT NODE CHANGED ====" -# puts "OUTGOING NODE" -# node.print 3, :outgoing -# puts "INCOMING NODE" -# node.print 3, :incoming -# -# puts "ROOT NODE, OUTGOING" - @root_node.print 3, :outgoing end # Specifies which properties we should group on. @@ -65,6 +53,10 @@ module Neo4j::Aggregate self end + def with(prop_key, &proc) + @with_proc = proc + @prop_key = prop_key + end def execute(nodes = @nodes) return unless nodes @@ -72,13 +64,13 @@ module Neo4j::Aggregate group_node = GroupEachNode.new group_node.group_by = @group_by.join(',') group_node.aggregate = node - puts " create rel between #{node.neo_node_id} and group_node #{group_node.neo_node_id}" rel = group_node.relationships.outgoing(:aggregate)[node] - puts " found rel #{rel.neo_relationship_id} agg_id: #{@root_node.aggregate_id.to_s} start: #{rel.start_node.neo_node_id}, end: #{rel.end_node.neo_node_id}" rel[:aggregate_group] = @root_node.aggregate_id.to_s @root_node.groups << group_node - puts " created rel between root #{@root_node.neo_node_id} and #{group_node.neo_node_id}" -# group_node.print 3, :both + if @with_proc + val = group_node.inject(0) {|sum, val| next sum if val.nil?; @with_proc.call(sum, val, 0)} + group_node[@prop_key.to_s] = val + end end @nodes = nil # prevent it to run twice end lib/neo4j/extensions/aggregate/aggregator_each.rb @@ -8,14 +8,18 @@ require 'neo4j/spec_helper' AggregateEachNode = Neo4j::Aggregate::AggregateEachNode -describe "Aggregate Each" do +describe "Aggregate each node" do before(:all) do class Company include Neo4j::NodeMixin property :month, :revenue end end - + + after(:all) do + undefine_class :Company + end + before(:each) do start Neo4j::Transaction.new @@ -27,45 +31,65 @@ describe "Aggregate Each" do @registrations.each {|reg| reg.unregister} end - it "should create a new group for each node" do - #pending "work in progress" - nodes = [] - 4.times {nodes << Neo4j::Node.new} - nodes[0][:colour] = 'red'; nodes[0][:name] = "a"; nodes[0][:age] = 0 - nodes[1][:colour] = 'red'; nodes[1][:name] = "b"; nodes[1][:age] = 1 - nodes[2][:colour] = 'red'; nodes[2][:name] = "c"; nodes[2][:age] = 2 - nodes[3][:colour] = 'blue'; nodes[3][:name] = "d"; nodes[3][:age] = 3 + describe "Access aggregated node properties" do + before(:each) do +# Neo4j::Transaction.new + @nodes = [] + 4.times {@nodes << Neo4j::Node.new} + @nodes[0][:colour] = 'red'; @nodes[0][:name] = "a"; @nodes[0][:age] = 0 + @nodes[1][:colour] = 'red'; @nodes[1][:name] = "b"; @nodes[1][:age] = 1 + @nodes[2][:colour] = 'red'; @nodes[2][:name] = "c"; @nodes[2][:age] = 2 + @nodes[3][:colour] = 'blue'; @nodes[3][:name] = "d"; @nodes[3][:age] = 3 + + # when + @aggregate_node = AggregateEachNode.new + @aggregate_node.aggregate_each(@nodes).group_by(:colour, :name).execute + end + it "can be retrieved as a group Neo4j::NodeMixin#aggregate_groups" do + Neo4j::Transaction.new + # then we should have one group + @nodes[0].aggregate_groups.to_a.size.should == 1 + group = @nodes[0].aggregate_groups.to_a[0] - agg1 = AggregateEachNode.new + # and that group should contain the node property values + group.should include('red', 'a') + group.to_a.size.should == 2 + group[:age].should == 0 # group for @nodes[0] + end - # when - agg1.aggregate_each(nodes).group_by(:colour, :name).execute + it "can all be retrieved from the aggregate node" do + # there are total 8 property values + @aggregate_node.to_a.sort.should == ["blue", "d", "red", "c", "red", "b", "red", "a"].sort + end - # then - nodes[0].aggregate_groups.to_a.size.should == 1 - g1 = nodes[0].aggregate_groups.to_a[0] - g1.should include('red', 'a') - g1.to_a.size.should == 2 - g1[:age].should == 0 # group for @nodes[0] + it "can be retrieved from the aggregate node as an group" do + # there are total 4 groups + @aggregate_node.aggregate_size.should == 4 - agg1.to_a.sort.should == ["blue", "d", "red", "c", "red", "b", "red", "a"].sort - agg1.to_a.size.should == 8 - agg1.aggregate_size.should == 4 + # so that we know which group is which group we put it in a age_groups map + age_groups = {} + @aggregate_node.groups.each {|g| age_groups[g[:age]] = g} + + age_groups[3].should include('blue','d') + age_groups[0].should include('red','a') + end end it "should delete group if the node is deleted" do nodes = [] 4.times {nodes << Neo4j::Node.new} - nodes[0][:colour] = 'red'; nodes[0][:name] = "a"; nodes[0][:age] = 0 - nodes[1][:colour] = 'red'; nodes[1][:name] = "b"; nodes[1][:age] = 1 - nodes[2][:colour] = 'red'; nodes[2][:name] = "c"; nodes[2][:age] = 2 + nodes[0][:colour] = 'red'; nodes[0][:name] = "a"; nodes[0][:age] = 0 + nodes[1][:colour] = 'red'; nodes[1][:name] = "b"; nodes[1][:age] = 1 + nodes[2][:colour] = 'red'; nodes[2][:name] = "c"; nodes[2][:age] = 2 nodes[3][:colour] = 'blue'; nodes[3][:name] = "d"; nodes[3][:age] = 3 agg1 = AggregateEachNode.new agg1.aggregate_each(nodes).group_by(:colour, :name) agg1.to_a.size.should == 8 agg1.aggregate_size.should == 4 + agg1.groups.size.should == 4 + # when n = nodes[2].aggregate_groups.to_a[0] @@ -83,7 +107,7 @@ describe "Aggregate Each" do it "should create new groups for each node, group by quarter" do revenue1 = Neo4j::Node.new revenue2 = Neo4j::Node.new - revenue1[:jan] = 1; revenue1[:feb] = 2; revenue1[:mars] = 3; revenue1[:april] = 4; revenue1[:may] = 5; revenue1[:june] = 6 + revenue1[:jan] = 1; revenue1[:feb] = 2; revenue1[:mars] = 3; revenue1[:april] = 4; revenue1[:may] = 5; revenue1[:june] = 6 revenue2[:jan] = 11; revenue2[:feb] = 12; revenue2[:mars] = 13; revenue2[:april] = 14; revenue2[:may] = 15; revenue2[:june] = 16 # when @@ -96,8 +120,8 @@ describe "Aggregate Each" do # then there should be two groups, one for each revenue node q1.aggregate_size.should == 2 # with each 3 values, total 6 (2*3) - q1.to_a.sort.should == [1,2,3,11,12,13] - q2.to_a.sort.should == [4,5,6,14,15,16] + q1.to_a.sort.should == [1, 2, 3, 11, 12, 13] + q2.to_a.sort.should == [4, 5, 6, 14, 15, 16] end @@ -107,29 +131,29 @@ describe "Aggregate Each" do # when c1 = Company.new - c1[:jan] = 100 - c1[:feb] = 200 + c1[:jan] = 100 + c1[:feb] = 200 c1[:mars] = 300 - c1[:april] = 400 - c1[:may] = 500 + c1[:april] = 400 + c1[:may] = 500 c1[:june] = 600 c2 = Company.new - c2[:jan] = 1100 - c2[:feb] = 1200 + c2[:jan] = 1100 + c2[:feb] = 1200 c2[:mars] = 1300 - c2[:april] = 1400 - c2[:may] = 1500 + c2[:april] = 1400 + c2[:may] = 1500 c2[:june] = 1600 - q1.aggregate_each([c1,c2]).group_by(:jan, :feb, :mars).execute - q2.aggregate_each([c1,c2]).group_by(:april, :may, :june).execute + q1.aggregate_each([c1, c2]).group_by(:jan, :feb, :mars).execute + q2.aggregate_each([c1, c2]).group_by(:april, :may, :june).execute # then q1.groups.should include(c1.aggregate_groups(:q1)) q1.groups.should include(c2.aggregate_groups(:q1)) q2.groups.should include(c1.aggregate_groups(:q2)) - q2.groups.should include(c2.aggregate_groups(:q2)) + q2.groups.should include(c2.aggregate_groups(:q2)) end it "should allow to register nodes classes to be part of aggregates" do @@ -141,24 +165,24 @@ describe "Aggregate Each" do # when c1 = Company.new - c1[:jan] = 100 - c1[:feb] = 200 + c1[:jan] = 100 + c1[:feb] = 200 c1[:mars] = 300 - c1[:april] = 400 - c1[:may] = 500 + c1[:april] = 400 + c1[:may] = 500 c1[:june] = 600 c2 = Company.new - c2[:jan] = 1100 - c2[:feb] = 1200 + c2[:jan] = 1100 + c2[:feb] = 1200 c2[:mars] = 1300 - c2[:april] = 1400 - c2[:may] = 1500 + c2[:april] = 1400 + c2[:may] = 1500 c2[:june] = 1600 # then - q1.should include(100,200,300,1100,1200,1300) - q2.should include(400,500,600,1400,1500,1600) + q1.should include(100, 200, 300, 1100, 1200, 1300) + q2.should include(400, 500, 600, 1400, 1500, 1600) end it "should update the aggregate when a node changes" do @@ -167,9 +191,9 @@ describe "Aggregate Each" do # given c1 = Company.new - c1[:jan] = 100 - c1[:feb] = 200 - q1.should include(100,200) + c1[:jan] = 100 + c1[:feb] = 200 + q1.should include(100, 200) # when c1[:feb] = 42 @@ -179,65 +203,49 @@ describe "Aggregate Each" do q1.should include(42) end - it "should delete the aggregate when the node is deleted" do + it "should delete the group when the node is deleted" do pending q1 = AggregateEachNode.new(:q1) @registrations << q1.aggregate_each(Company).group_by(:jan, :feb, :mars) # given c1 = Company.new - c1[:jan] = 100 - c1[:feb] = 200 - q1.should include(100,200) + c1[:jan] = 100 + c1[:feb] = 200 + q1.should include(100, 200) q1.groups.size.should == 1 Neo4j.load(q1.neo_node_id).should_not be_nil - # then -# puts "C1, incoming" -# c1.print 3, :incoming -# -# puts "C1, outgoing" -# c1.print 3, :outgoing -# -# puts "Q1, incoming" -# q1.print 3, :incoming -# -# puts "Q1, outgoing" -# q1.print 3, :outgoing - puts "------------------------" - puts "D E L E T E" - puts "------------------------" - # when c1.delete # then - puts "Q1------------------" - q1.print 2,:both q1.groups.size.should == 0 - q1.should_not include(100) q1.should_not include(200) end - + it "should allow to register nodes classes to be part of aggregates" do - pending +# pending # given q1 = AggregateEachNode.new(:q1) - q1.aggregate_each(Company).group_by(:jan, :feb, :mars).with(:sum){|sum,val,prev_val| sum + val - prev_val} + q1.aggregate_each(Company).group_by(:jan, :feb, :mars).with(:sum){|sum, val, prev_val| sum + val - prev_val} q2 = AggregateEachNode.new(:q2) - q2.aggregate_each(Company).group_by(:april, :may, :june) + q2.aggregate_each(Company).group_by(:april, :may, :june).with(:sum){|sum, val, prev_val| sum + val - prev_val} # when c1 = Company.new - c1[:jan] = 100 - c1[:feb] = 200 + c1[:jan] = 100 + c1[:feb] = 200 c1[:mars] = 300 - c1[:april] = 400 - c1[:may] = 500 + c1[:april] = 400 + c1[:may] = 500 c1[:june] = 600 # then + puts "C1 GROUP Q1: #{c1.aggregate_groups(:q1).neo_node_id}" + puts "C1 GROUP Q2: #{c1.aggregate_groups(:q2).neo_node_id}" + c1.aggregate_groups(:q1)[:sum].should == 100+200+300 c1.aggregate_groups(:q2)[:sum].should == 400+500+600 end test/extensions/aggregate_each_spec.rb @@ -190,7 +190,7 @@ describe "Aggregates" do agg_root["bad"].aggregate_size.should == 1 agg_root["average"].aggregate_size.should == 2 - # there are two sub groups, one groop with same score 101 and another group with score 102 + # there are two sub groups, one group with same score 101 and another group with score 102 agg_root["good"].aggregate_size.should == 2 agg_root["good"][101].aggregate_size.should == 2 @@ -280,7 +280,7 @@ describe "Aggregates" do end - describe "grouped by one property (colour)" do + describe "grouped by one property" do # Called before each example. before(:each) do @red=[] @@ -336,7 +336,7 @@ describe "Aggregates" do names.should include('a', 'b', 'c', 'd') end - it "should not add nodes to the aggreation that does not have a group property" do + it "should not add nodes to the aggregation that does not have a group property" do # add a node that does not have the colour property @agg_node.to_a.size.should == 3 @@ -418,7 +418,7 @@ describe "Aggregates" do end - it "should have a counter for number of meber in each group" do + it "should have a counter for number of member in each group" do # Creates age group 0=0-4, 1=5-9, 2=10-14 @registrations << @aggregate_node.aggregate(@people).group_by(:age).map_value{|age| age / 5} @@ -562,23 +562,6 @@ describe "Aggregates" do # when agg_node.include_node?(new_node).should be_true end - - it "should not append a node to an aggregate if it already exist in the aggregate" do - pending "Not sure if we want that. Will get bad performance if we have to check it each time we add a node to a aggregate" - agg_node = AggregateNode.new - @registrations << agg_node.aggregate.group_by(:colour) - - new_node = Neo4j::Node.new - new_node[:colour] = 'black' - - # when - agg_node << new_node - agg_node << new_node - - # then - agg_node[:black].aggregate_size.should == 1 - agg_node[:black].should include(new_node) - end end test/extensions/aggregate_spec.rb 4de7d5fc2268320550b1d89499df3241f3753106 andreas andreas@andreas-xps16.(none) http://github.com/andreasronge/neo4j/commit/21f4009cee0058a142fe59053fb0a022a6571c01 21f4009cee0058a142fe59053fb0a022a6571c01 2009-10-26T15:07:35-07:00 2009-10-26T15:07:35-07:00 Impl aggregation function (not very effiecient yet). There is now a DSL for creating things like a sum of the revenue grouped by quarter [#72] Tidied up some RSpecs fdcf561e07efc5c2c33451d15fbba521da6452f8 andreas andreas@andreas-xps16.(none)