skydb 0.2.1 → 0.2.2

data/test/message/add_event_message_test.rb

@@ -12,7 +12,7 @@ class TestMessageAddEvent < MiniTest::Unit::TestCase
   
   def test_encode
     buffer = StringIO.new
-    @message.table = "users"
+    @message.table_name = "users"
     @message.event = SkyDB::Event.new(
       object_id: 12,
       timestamp:DateTime.parse('2010-01-02T10:30:20Z'),

data/test/message/add_property_message_test.rb

@@ -27,14 +27,14 @@ class TestMessageAddProperty < MiniTest::Unit::TestCase
 
   def test_encode_object_property
     buffer = StringIO.new
-    @message.property = SkyDB::Property.new(0, :object, 'Int', 'foo')
+    @message.property = SkyDB::Property.new(:type => :object, :data_type => 'Int', :name => 'foo')
     @message.encode(buffer)
     assert_bytes "\x93\x01\xacadd_property\xa0\x84\xa2id\x00\xa4type\x01\xa8dataType\xa3Int\xa4name\xa3foo", buffer
   end
 
   def test_encode_action_property
     buffer = StringIO.new
-    @message.property = SkyDB::Property.new(0, :action, 'Boolean', 'foo')
+    @message.property = SkyDB::Property.new(:type => :action, :data_type => 'Boolean', :name => 'foo')
     @message.encode(buffer)
     assert_bytes "\x93\x01\xacadd_property\xa0\x84\xa2id\x00\xa4type\x02\xa8dataType\xa7Boolean\xa4name\xa3foo", buffer
   end

data/test/message/create_table_message_test.rb

@@ -0,0 +1,34 @@
+# encoding: binary
+require 'test_helper'
+
+class TestMessageCreateTable < MiniTest::Unit::TestCase
+  def setup
+    @message = SkyDB::Message::CreateTable.new()
+  end
+  
+  ######################################
+  # Action
+  ######################################
+
+  def test_table
+    @message.table = SkyDB::Table.new('foo')
+    refute_nil @message.table
+  end
+  
+  def test_invalid_table
+    @message.table = "foo"
+    assert_nil @message.table
+  end
+  
+
+  ######################################
+  # Encoding
+  ######################################
+
+  def test_encode
+    buffer = StringIO.new
+    @message.table = SkyDB::Table.new("foo", :tablet_count => 8)
+    @message.encode(buffer)
+    assert_bytes "\x93\x01\xaccreate_table\xa0\x82\xa4name\xa3foo\xactablet_count\x08", buffer
+  end
+end

data/test/message/delete_table_message_test.rb

@@ -0,0 +1,34 @@
+# encoding: binary
+require 'test_helper'
+
+class TestMessageDeleteTable < MiniTest::Unit::TestCase
+  def setup
+    @message = SkyDB::Message::DeleteTable.new()
+  end
+  
+  ######################################
+  # Action
+  ######################################
+
+  def test_table
+    @message.table = SkyDB::Table.new('foo')
+    refute_nil @message.table
+  end
+  
+  def test_invalid_table
+    @message.table = "foo"
+    assert_nil @message.table
+  end
+  
+
+  ######################################
+  # Encoding
+  ######################################
+
+  def test_encode
+    buffer = StringIO.new
+    @message.table = SkyDB::Table.new("foo")
+    @message.encode(buffer)
+    assert_bytes "\x93\x01\xacdelete_table\xa0\x81\xa4name\xa3foo", buffer
+  end
+end

data/test/message/get_table_message_test.rb

@@ -0,0 +1,19 @@
+# encoding: binary
+require 'test_helper'
+
+class TestMessageGetTable < MiniTest::Unit::TestCase
+  def setup
+    @message = SkyDB::Message::GetTable.new()
+  end
+  
+  ######################################
+  # Encoding
+  ######################################
+
+  def test_encode
+    buffer = StringIO.new
+    @message.name = "foo"
+    @message.encode(buffer)
+    assert_bytes "\x93\x01\xa9get_table\xa0\x81\xa4name\xa3foo", buffer
+  end
+end

data/test/message/lookup_message_test.rb

@@ -0,0 +1,27 @@
+# encoding: binary
+require 'test_helper'
+
+class TestMessageLookup < MiniTest::Unit::TestCase
+  def setup
+    @message = SkyDB::Message::Lookup.new()
+  end
+  
+  ######################################
+  # Encoding
+  ######################################
+
+  def test_encode
+    buffer = StringIO.new
+    @message.actions = [
+      SkyDB::Action.new(:name => 'foo'),
+      SkyDB::Action.new(:name => 'bar'),
+    ]
+    @message.properties = [
+      SkyDB::Property.new(:name => 'xxx'),
+      SkyDB::Property.new(:name => 'yyy'),
+      SkyDB::Property.new(:name => 'zzz'),
+    ]
+    @message.encode(buffer)
+    assert_bytes "\x93\x01\xa6lookup\xa0\x82\xabactionNames\x92\xa3foo\xa3bar\xadpropertyNames\x93\xa3xxx\xa3yyy\xa3zzz", buffer
+  end
+end

data/test/message_test.rb

@@ -8,7 +8,7 @@ class TestMessage < MiniTest::Unit::TestCase
   
   def test_encode
     buffer = StringIO.new
-    @message.table = "users"
+    @message.table_name = "users"
     @message.encode(buffer)
     assert_bytes "\x93\x01\xa3xyz\xa5users", buffer
   end

data/test/query/after_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class TestQueryAfter < MiniTest::Unit::TestCase
+  ##############################################################################
+  #
+  # Setup / Teardown
+  #
+  ##############################################################################
+
+  def setup
+    @after = SkyDB::Query::After.new()
+  end
+
+
+  ##############################################################################
+  #
+  # Tests
+  #
+  ##############################################################################
+
+  ######################################
+  # Validation
+  ######################################
+
+  def test_validate_action
+    e = assert_raises(SkyDB::Query::ValidationError) do
+      SkyDB::Query::After.new(:function_name => "foo").validate!
+    end
+    assert_match /^Action with non-zero identifier required/, e.message
+  end
+  
+  def test_validate_function_name
+    e = assert_raises(SkyDB::Query::ValidationError) do
+      SkyDB::Query::After.new(:action => 10).validate!
+    end
+    assert_match /^Invalid function name ''/, e.message
+  end
+  
+  
+  ######################################
+  # Code Generation
+  ######################################
+
+  def test_codegen
+    @after = SkyDB::Query::After.new(:action => 10, :function_name => "foo")
+    expected =
+      <<-BLOCK.unindent
+        function foo(cursor, data)
+          repeat
+            if cursor.event.action_id == 10 then
+              cursor:next()
+              return true
+            end
+          until not cursor:next()
+          return false
+        end
+      BLOCK
+    assert_equal expected, @after.codegen()
+  end
+
+  def test_codegen_enter
+    @after = SkyDB::Query::After.new(:action => :enter, :function_name => "foo")
+    expected =
+      <<-BLOCK.unindent
+        function foo(cursor, data)
+          return (cursor.session_event_index == 0)
+        end
+      BLOCK
+    assert_equal expected, @after.codegen()
+  end
+end

data/test/query/selection_test.rb

@@ -0,0 +1,273 @@
+require 'test_helper'
+
+class TestQuerySelection < MiniTest::Unit::TestCase
+  ##############################################################################
+  #
+  # Setup / Teardown
+  #
+  ##############################################################################
+
+  def setup
+    @selection = SkyDB::Query::Selection.new()
+  end
+
+
+  ##############################################################################
+  #
+  # Tests
+  #
+  ##############################################################################
+
+  ######################################
+  # Field parsing
+  ######################################
+
+  def test_parse_single_field
+    fields = SkyDB::Query::Selection.parse_fields("foo")
+    assert_equal 1, fields.length
+    assert_equal "foo", fields[0].expression
+  end
+
+  def test_parse_multiple_fields
+    fields = SkyDB::Query::Selection.parse_fields("  foo  , bar, baz_12  ")
+    assert_equal 3, fields.length
+    assert_equal "foo", fields[0].expression
+    assert_equal "bar", fields[1].expression
+    assert_equal "baz_12", fields[2].expression
+  end
+
+  def test_parse_aliased_fields
+    fields = SkyDB::Query::Selection.parse_fields("foo bar, baz bat")
+    assert_equal 2, fields.length
+    assert_equal "foo", fields[0].expression
+    assert_equal "bar", fields[0].alias_name
+    assert_equal "baz", fields[1].expression
+    assert_equal "bat", fields[1].alias_name
+  end
+
+  def test_parse_aggregated_fields
+    fields = SkyDB::Query::Selection.parse_fields("sum(foo), MIN(bar)")
+    assert_equal 2, fields.length
+    assert_equal "foo", fields[0].expression
+    assert_equal :sum, fields[0].aggregation_type
+    assert_equal "bar", fields[1].expression
+    assert_equal :min, fields[1].aggregation_type
+  end
+
+  def test_parse_aliased_aggregated_fields
+    fields = SkyDB::Query::Selection.parse_fields("sum(foo) baz, MIN(bar) bat")
+    assert_equal 2, fields.length
+    assert_equal "foo", fields[0].expression
+    assert_equal "baz", fields[0].alias_name
+    assert_equal :sum, fields[0].aggregation_type
+    assert_equal "bar", fields[1].expression
+    assert_equal "bat", fields[1].alias_name
+    assert_equal :min, fields[1].aggregation_type
+  end
+
+
+  ######################################
+  # Group parsing
+  ######################################
+
+  def test_parse_single_group
+    groups = SkyDB::Query::Selection.parse_groups("foo")
+    assert_equal 1, groups.length
+    assert_equal "foo", groups[0].expression
+  end
+
+  def test_parse_multiple_groups
+    groups = SkyDB::Query::Selection.parse_groups("foo, bar")
+    assert_equal 2, groups.length
+    assert_equal "foo", groups[0].expression
+    assert_equal "bar", groups[1].expression
+  end
+
+
+
+  ######################################
+  # Aggregation Generation
+  ######################################
+
+  def test_simple_codegen
+    @selection.fields = SkyDB::Query::Selection.parse_fields("foo, bar my_alias")
+    expected =
+      <<-BLOCK.unindent
+        function select(cursor, data)
+          target = data
+          target.foo = cursor.event.foo()
+          target.my_alias = cursor.event.bar()
+        end
+      BLOCK
+    assert_equal expected, @selection.codegen_select()
+  end
+
+  def test_count_codegen
+    @selection.fields = SkyDB::Query::Selection.parse_fields("count() bar")
+    expected =
+      <<-BLOCK.unindent
+        function select(cursor, data)
+          target = data
+          target.bar = (target.bar or 0) + 1
+        end
+      BLOCK
+    assert_equal expected, @selection.codegen_select()
+  end
+
+  def test_sum_codegen
+    @selection.fields = SkyDB::Query::Selection.parse_fields("SUM(foo) bar")
+    expected =
+      <<-BLOCK.unindent
+        function select(cursor, data)
+          target = data
+          target.bar = (target.bar or 0) + cursor.event.foo()
+        end
+      BLOCK
+    assert_equal expected, @selection.codegen_select()
+  end
+
+  def test_min_codegen
+    @selection.fields = SkyDB::Query::Selection.parse_fields("min(foo) bar")
+    expected =
+      <<-BLOCK.unindent
+        function select(cursor, data)
+          target = data
+          if(target.bar == nil or target.bar > cursor.event.foo()) then
+            target.bar = cursor.event.foo()
+          end
+        end
+      BLOCK
+    assert_equal expected, @selection.codegen_select()
+  end
+
+  def test_max_codegen
+    @selection.fields = SkyDB::Query::Selection.parse_fields("min(foo) bar")
+    expected =
+      <<-BLOCK.unindent
+        function select(cursor, data)
+          target = data
+          if(target.bar == nil or target.bar > cursor.event.foo()) then
+            target.bar = cursor.event.foo()
+          end
+        end
+      BLOCK
+    assert_equal expected, @selection.codegen_select()
+  end
+
+  def test_grouped_codegen
+    @selection.fields = SkyDB::Query::Selection.parse_fields("foo, bar my_alias")
+    @selection.groups = SkyDB::Query::Selection.parse_groups("baz")
+    expected =
+      <<-BLOCK.unindent
+        function select(cursor, data)
+          target = data
+          
+          group_value = cursor.event.baz()
+          if target[group_value] == nil then
+            target[group_value] = {}
+          end
+          target = target[group_value]
+          
+          target.foo = cursor.event.foo()
+          target.my_alias = cursor.event.bar()
+        end
+      BLOCK
+    assert_equal expected, @selection.codegen_select()
+  end
+
+  def test_multiple_group_codegen
+    @selection.fields = SkyDB::Query::Selection.parse_fields("foo, bar my_alias")
+    @selection.groups = SkyDB::Query::Selection.parse_groups("aaa, bbb, ccc")
+    expected =
+      <<-BLOCK.unindent
+        function select(cursor, data)
+          target = data
+          
+          group_value = cursor.event.aaa()
+          if target[group_value] == nil then
+            target[group_value] = {}
+          end
+          target = target[group_value]
+          
+          group_value = cursor.event.bbb()
+          if target[group_value] == nil then
+            target[group_value] = {}
+          end
+          target = target[group_value]
+          
+          group_value = cursor.event.ccc()
+          if target[group_value] == nil then
+            target[group_value] = {}
+          end
+          target = target[group_value]
+          
+          target.foo = cursor.event.foo()
+          target.my_alias = cursor.event.bar()
+        end
+      BLOCK
+    assert_equal expected, @selection.codegen_select()
+  end
+
+
+  ######################################
+  # Merge Codegen
+  ######################################
+
+  def test_simple_merge_codegen
+    @selection.fields = SkyDB::Query::Selection.parse_fields("foo, sum(bar) my_alias, count(), min(x), max(y)")
+    expected =
+      <<-BLOCK.unindent
+        function merge(results, data)
+          a = results
+          b = data
+          a.foo = b.foo
+          a.my_alias = (a.my_alias or 0) + (b.my_alias or 0)
+          a.count = (a.count or 0) + (b.count or 0)
+          if(a.x == nil or a.x > b.x) then
+            a.x = b.x
+          end
+          if(a.y == nil or a.y < b.y) then
+            a.y = b.y
+          end
+        end
+      BLOCK
+    assert_equal expected, @selection.codegen_merge()
+  end
+
+  def test_grouped_merge_codegen
+    @selection = SkyDB::Query::Selection.new.select("sum(foo), count()").group_by(:bar)
+    expected =
+      <<-BLOCK.unindent
+        function merge(results, data)
+          for k0,v0 in pairs(data) do
+            if results[k0] == nil then results[k0] = {} end
+            a = results[k0]
+            b = data[k0]
+            a.foo = (a.foo or 0) + (b.foo or 0)
+            a.count = (a.count or 0) + (b.count or 0)
+          end
+        end
+      BLOCK
+    assert_equal expected, @selection.codegen_merge()
+  end
+  
+  def test_multigroup_merge_codegen
+    @selection = SkyDB::Query::Selection.new.select("sum(foo), count()").group_by(:bar, :baz)
+    expected =
+      <<-BLOCK.unindent
+        function merge(results, data)
+          for k0,v0 in pairs(data) do
+            if results[k0] == nil then results[k0] = {} end
+            for k1,v1 in pairs(data[k0]) do
+              if results[k0][k1] == nil then results[k0][k1] = {} end
+              a = results[k0][k1]
+              b = data[k0][k1]
+              a.foo = (a.foo or 0) + (b.foo or 0)
+              a.count = (a.count or 0) + (b.count or 0)
+            end
+          end
+        end
+      BLOCK
+    assert_equal expected, @selection.codegen_merge()
+  end
+end