sparkql 1.1.17 → 1.2.0

data/test/unit/function_resolver_test.rb

@@ -31,7 +31,7 @@ class FunctionResolverTest < Test::Unit::TestCase
 
     assert_equal :function, value[:type]
     assert_equal 'round', value[:value]
-    assert_equal "ListPrice", value[:args].first
+    assert_equal "ListPrice", value[:args].first[:value]
   end
 
   test "substring character one index" do
@@ -89,8 +89,8 @@ class FunctionResolverTest < Test::Unit::TestCase
 
     assert_equal :function, value[:type]
     assert_equal 'substring', value[:value]
-    assert_equal "ListPrice", value[:args].first
-    assert_nil value[:args].last
+    assert_equal "ListPrice", value[:args].first[:value]
+    assert_equal 2, value[:args].size
   end
 
   test "substring field two indexes" do
@@ -106,8 +106,8 @@ class FunctionResolverTest < Test::Unit::TestCase
 
     assert_equal :function, value[:type]
     assert_equal 'substring', value[:value]
-    assert_equal "ListPrice", value[:args].first
-    assert_equal 2, value[:args].last
+    assert_equal "ListPrice", value[:args].first[:value]
+    assert_equal 2, value[:args].last[:value]
   end
 
   test "substring with negative M is a parse error" do
@@ -145,7 +145,7 @@ class FunctionResolverTest < Test::Unit::TestCase
 
     assert_equal :function, value[:type]
     assert_equal 'trim', value[:value]
-    assert_equal "Name", value[:args].first
+    assert_equal "Name", value[:args].first[:value]
   end
 
   test 'trim with character' do
@@ -177,7 +177,7 @@ class FunctionResolverTest < Test::Unit::TestCase
     value = f.call
     assert_equal :function, value[:type]
     assert_equal 'toupper', value[:value]
-    assert_equal "City", value[:args].first
+    assert_equal "City", value[:args].first[:value]
   end
 
   test "toupper('string')" do
@@ -196,7 +196,7 @@ class FunctionResolverTest < Test::Unit::TestCase
     value = f.call
     assert_equal :function, value[:type]
     assert_equal 'length', value[:value]
-    assert_equal "City", value[:args].first
+    assert_equal "City", value[:args].first[:value]
   end
 
   test "length('string')" do
@@ -256,7 +256,7 @@ class FunctionResolverTest < Test::Unit::TestCase
 
     assert_equal :function, value[:type]
     assert_equal 'floor', value[:value]
-    assert_equal "ListPrice", value[:args].first
+    assert_equal "ListPrice", value[:args].first[:value]
   end
 
   test "ceiling(float)" do
@@ -276,7 +276,7 @@ class FunctionResolverTest < Test::Unit::TestCase
 
     assert_equal :function, value[:type]
     assert_equal 'ceiling', value[:value]
-    assert_equal "ListPrice", value[:args].first
+    assert_equal "ListPrice", value[:args].first[:value]
   end
 
   test "days()" do
@@ -325,7 +325,7 @@ class FunctionResolverTest < Test::Unit::TestCase
       value = f.call
       assert_equal :function, value[:type]
       assert_equal function, value[:value]
-      assert_equal "OriginalEntryTimestamp", value[:args].first
+      assert_equal "OriginalEntryTimestamp", value[:args].first[:value]
     end
   end
 
@@ -337,7 +337,7 @@ class FunctionResolverTest < Test::Unit::TestCase
       value = f.call
       assert_equal :function, value[:type]
       assert_equal function, value[:value]
-      assert_equal "OriginalEntryTimestamp", value[:args].first
+      assert_equal "OriginalEntryTimestamp", value[:args].first[:value]
     end
   end
 
@@ -348,7 +348,7 @@ class FunctionResolverTest < Test::Unit::TestCase
     value = f.call
     assert_equal :function, value[:type]
     assert_equal 'fractionalseconds', value[:value]
-    assert_equal "OriginalEntryTimestamp", value[:args].first
+    assert_equal "OriginalEntryTimestamp", value[:args].first[:value]
   end
 
   # Polygon searches
@@ -544,7 +544,7 @@ class FunctionResolverTest < Test::Unit::TestCase
 
     assert_equal :function, value[:type]
     assert_equal 'cast', value[:value]
-    assert_equal ['Bedrooms', 'character'], value[:args]
+    assert_equal ['Bedrooms', 'character'], value[:args].map { |v| v[:value]}
   end
 
   test "invalid cast returns null" do
@@ -593,7 +593,7 @@ class FunctionResolverTest < Test::Unit::TestCase
     value = f.call
     assert_equal :function, value[:type]
     assert_equal 'time', value[:value]
-    assert_equal "OriginalEntryTimestamp", value[:args].first
+    assert_equal "OriginalEntryTimestamp", value[:args].first[:value]
   end
   
   test "date(field)" do
@@ -603,7 +603,7 @@ class FunctionResolverTest < Test::Unit::TestCase
     value = f.call
     assert_equal :function, value[:type]
     assert_equal 'date', value[:value]
-    assert_equal "OriginalEntryTimestamp", value[:args].first
+    assert_equal "OriginalEntryTimestamp", value[:args].first[:value]
   end
 
   test "startswith(), endswith() and contains()" do

data/test/unit/parser_compatability_test.rb

@@ -346,6 +346,23 @@ class ParserCompatabilityTest < Test::Unit::TestCase
     assert parser.errors?
   end
 
+  test "max out nested functions of 5" do
+    field = "tolower(City)"
+
+    4.times do
+      field = "tolower(#{field})"
+    end
+
+    parser = Parser.new
+    parser.parse("#{field} Eq 'Fargo'")
+    assert !parser.errors?
+
+    parser = Parser.new
+    field = "tolower(#{field})"
+    parser.parse("#{field} Eq 'Fargo'")
+    assert parser.errors?, 'should error on too many nested functions'
+  end
+
   test "max out function args" do
     parser = Parser.new
     to_the_max = []

data/test/unit/parser_test.rb

@@ -170,6 +170,11 @@ class ParserTest < Test::Unit::TestCase
     assert_equal 'City', expression[:field]
     assert_equal '13', expression[:value]
     assert_equal '4131800000000', expression[:args].last
+
+    assert_equal 'indexof', expression[:field_manipulations][:function_name]
+    assert_equal :function, expression[:field_manipulations][:type]
+    assert_equal :integer, expression[:field_manipulations][:return_type]
+    assert_equal ['City', '4131800000000'], expression[:field_manipulations][:args].map {|v| v[:value]}
   end
 
   test "function data preserved in expression" do
@@ -207,8 +212,6 @@ class ParserTest < Test::Unit::TestCase
   end
 
   test "mixed list" do
-    # TODO This is an unrealistic example. We need number functions or support 
-    # for dates in lists
     filter = "OriginalEntryTimestamp Eq 2014,days(-7)"
     @parser = Parser.new
     expressions = @parser.parse(filter)
@@ -217,14 +220,11 @@ class ParserTest < Test::Unit::TestCase
     assert_equal '2014,days(-7)', expressions.first[:condition]
   end
 
+  def test_errors_on_left_hand_field_function
+    parser_errors("Field Eq ceiling(Field)")
+  end
+
   def test_function_date
-    filter = "OnMarketDate Eq date(OriginalEntryTimestamp)"
-    @parser = Parser.new
-    expressions = @parser.parse(filter)
-    assert !@parser.errors?, "errors #{@parser.errors.inspect}"
-    assert_equal 'date(OriginalEntryTimestamp)', expressions.first[:condition]
-    assert_equal 'date', expressions.first[:value]
-    assert_equal :function, expressions.first[:type]
     # Run using a static value, we just resolve the type
     filter = "OnMarketDate Eq date(2013-07-26T10:22:15.111-0100)"
     @parser = Parser.new
@@ -685,14 +685,17 @@ class ParserTest < Test::Unit::TestCase
   end
 
   def test_round_with_field
-    filter = "ListPrice Eq round(FieldName)"
+    filter = "round(ListPrice) Eq 1"
     @parser = Parser.new
     expression = @parser.parse(filter).first
     assert !@parser.errors?, "Filter '#{filter}' failed: #{@parser.errors.first.inspect}"
 
-    assert_equal 'round', expression[:function_name]
-    assert_equal 'round(FieldName)', expression[:condition]
-    assert_equal(["FieldName"], expression[:function_parameters])
+    assert_equal 'round', expression[:field_function]
+    assert_equal(["ListPrice"], expression[:args])
+
+    assert_equal 'round', expression[:field_manipulations][:function_name]
+    assert_equal :function, expression[:field_manipulations][:type]
+    assert_equal ['ListPrice'], expression[:field_manipulations][:args].map {|v| v[:value]}
   end
 
   def test_ceiling_with_literal
@@ -714,14 +717,13 @@ class ParserTest < Test::Unit::TestCase
   end
 
   def test_ceiling_with_field
-    filter = "ListPrice Eq ceiling(FieldName)"
+    filter = "ceiling(ListPrice) Eq 4"
     @parser = Parser.new
     expression = @parser.parse(filter).first
     assert !@parser.errors?, "Filter '#{filter}' failed: #{@parser.errors.first.inspect}"
 
-    assert_equal 'ceiling', expression[:function_name]
-    assert_equal 'ceiling(FieldName)', expression[:condition]
-    assert_equal(["FieldName"], expression[:function_parameters])
+    assert_equal 'ceiling', expression[:field_function]
+    assert_equal(["ListPrice"], expression[:args])
   end
 
   def test_floor_with_literal
@@ -743,26 +745,33 @@ class ParserTest < Test::Unit::TestCase
   end
 
   def test_floor_with_field
-    filter = "ListPrice Eq floor(FieldName)"
+    filter = "floor(ListPrice) Eq 1"
     @parser = Parser.new
     expression = @parser.parse(filter).first
     assert !@parser.errors?, "Filter '#{filter}' failed: #{@parser.errors.first.inspect}"
 
-    assert_equal 'floor', expression[:function_name]
-    assert_equal 'floor(FieldName)', expression[:condition]
-    assert_equal(["FieldName"], expression[:function_parameters])
+    assert_equal 'floor', expression[:field_function]
+    assert_equal(["ListPrice"], expression[:args])
+
+    assert_equal 'floor', expression[:field_manipulations][:function_name]
+    assert_equal :function, expression[:field_manipulations][:type]
+    assert_equal ['ListPrice'], expression[:field_manipulations][:args].map {|v| v[:value]}
   end
 
   def test_concat_with_field
-    filter = "City Eq concat(City, 'b')"
+    filter = "concat(City, 'b') Eq 'Fargob'"
     @parser = Parser.new
     expression = @parser.parse(filter).first
     assert !@parser.errors?, "Filter '#{filter}' failed: #{@parser.errors.first.inspect}"
 
-    assert_equal :function, expression[:type]
-    assert_equal 'concat', expression[:function_name]
-    assert_equal(["City", 'b'], expression[:function_parameters])
+    assert_equal :character, expression[:type]
+    assert_equal 'concat', expression[:field_function]
+    assert_equal(["City", 'b'], expression[:args])
     assert_equal("City", expression[:field])
+
+    assert_equal 'concat', expression[:field_manipulations][:function_name]
+    assert_equal :function, expression[:field_manipulations][:type]
+    assert_equal ['City', 'b'], expression[:field_manipulations][:args].map {|v| v[:value]}
   end
 
   def test_concat_with_literal
@@ -786,6 +795,10 @@ class ParserTest < Test::Unit::TestCase
     assert_equal 'cast', expression[:field_function]
     assert_equal "'100000'", expression[:condition]
     assert_equal(:character, expression[:field_function_type])
+
+    assert_equal 'cast', expression[:field_manipulations][:function_name]
+    assert_equal :function, expression[:field_manipulations][:type]
+    assert_equal ['ListPrice', 'character'], expression[:field_manipulations][:args].map {|v| v[:value]}
   end
 
   def test_cast_with_invalid_type
@@ -793,6 +806,39 @@ class ParserTest < Test::Unit::TestCase
     parser_errors("ListPrice Eq cast('10', 'bogus')")
   end
 
+  test 'nested functions on field side' do
+    @parser = Parser.new
+    filter = "tolower(toupper(City)) Eq 'Fargo'"
+    expression = @parser.parse(filter).first
+    assert_equal 'City', expression[:field]
+    assert expression.key?(:field_manipulations)
+    function1 = expression[:field_manipulations]
+    assert_equal :function, function1[:type]
+    assert_equal 'tolower', function1[:function_name]
+    assert_equal 'tolower', expression[:field_function]
+
+    function2 = function1[:args].first
+    assert_equal :function, function2[:type]
+    assert_equal 'toupper', function2[:function_name]
+    assert_equal({:type=>:field, :value=>"City"}, function2[:args].first)
+  end
+
+  test 'nested functions with multiple params' do
+    filter = "concat(tolower(City), 'b') Eq 'fargob'"
+    @parser = Parser.new
+    expression = @parser.parse(filter).first
+    assert expression.key?(:field_manipulations)
+    function1 = expression[:field_manipulations]
+    assert_equal :function, function1[:type]
+    assert_equal 'concat', function1[:function_name]
+    assert_equal({type: :character, value: 'b'}, function1[:args].last)
+
+    function2 = function1[:args].first
+    assert_equal :function, function2[:type]
+    assert_equal 'tolower', function2[:function_name]
+    assert_equal({:type=>:field, :value=>"City"}, function2[:args].first)
+  end
+
   private
 
   def parser_errors(filter)  

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sparkql
 version: !ruby/object:Gem::Version
-  version: 1.1.17
+  version: 1.2.0
 platform: ruby
 authors:
 - Wade McEwen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-02 00:00:00.000000000 Z
+date: 2018-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: georuby