sparkql 1.1.15 → 1.1.16

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZWExMjRhNmFjYzM3NTdjYWNkMjdmOWRjYzBhYTJiNGVjMTRjOTViZg==
+    MDI5NzJhMzM4MGY2MWFlNGM0YjE3N2Y1OWI2NDBhYzhhYTA5ODU2NQ==
   data.tar.gz: !binary |-
-    YzhiYTlhMWM0OTRkNWE4ZTFjMTQzYzE4MmNjYzJiZWQ3MDdhMmFiYQ==
+    MmJlZTY5NzRlZGEwY2RkYTcyNzU1NDUyMzBiZGY1MDdjN2IwZjI1OA==
 SHA512:
   metadata.gz: !binary |-
-    Mzk5MGUxM2M0ZWQ2M2QxMTQ2ZDM3MTMxNTEwODVhZTc0NzJlZWJhYzkzODA4
-    NDIxZTUxNzE4OTYxYmI3MTJiNzkxMGU1MzVjMGQ3ZDdkMzIzZDQ5OGExMmI5
-    YmM1NDU2M2IzM2JhMWU2OTY3Y2NhYzM5MDNiMjllNmVkYjA2NDM=
+    NWY3MDFkNWIyYmM2ZjNmODMwMTA3MWQzZTZlN2NhMmEzNTA2YzE5M2Q4NzEw
+    MmE0YWJhM2ZlYTkxZWE5ZDAyYWU0NDNiZTVlZjZlM2FkMzgwZTA0ZTI0OTEy
+    ZDAxNzc5NzdmNTgzMWYxN2U4MjAzZDJkYmJjMTdlMGMyNDE2ZmY=
   data.tar.gz: !binary |-
-    MTRjZDEyN2U5N2IwZTA5NGEwZjZjMmEyMzM5ZTA4YWUwMDcxNWEwZTZjODli
-    OWNmZDBjNmU0YzNiNWZiNjc3MWRkYmRjNjc1ZTg4MjNlNWVlNzAzYTVhY2Uz
-    NzU2OTg2NzAzZTA4ZjdmMDFkZDdhMzY3NTU4ZTQxNTRhODkyNDQ=
+    YTI4YmQwYzFkNjllNDc0Yzg0YWFiYzVjMGZmNDJkNDNlODc5MTcyMzVhYzcy
+    MjhmMjUyMTQwYmUwMjY4N2U1MzIzNzI5MWVjMmFjNmI0MDg3ZDBmMmZiZDFl
+    YzZhNjkxYTAxZTJiZGI1MTZjY2NlMjlmNjYyZGExNmRkMDdjYTU=

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+v1.1.16, 2018-07-26
+-------------------
+  * [IMPROVEMENT] New Function: cast()
+
 v1.1.15, 2018-07-12
 -------------------
   * [IMPROVEMENT] New Functions: ceiling(), floor()

data/VERSION

@@ -1 +1 @@
-1.1.15
+1.1.16

data/lib/sparkql/function_resolver.rb

@@ -16,6 +16,8 @@ class Sparkql::FunctionResolver
   VALID_REGEX_FLAGS = ["", "i"]
   MIN_DATE_TIME = Time.new(1970, 1, 1, 0, 0, 0, "+00:00").iso8601
   MAX_DATE_TIME = Time.new(9999, 12, 31, 23, 59, 59, "+00:00").iso8601
+  VALID_CAST_TYPES = [:field, :character, :decimal, :integer]
+
   SUPPORTED_FUNCTIONS = {
     :polygon => {
       :args => [:character],
@@ -69,6 +71,10 @@ class Sparkql::FunctionResolver
       :args => [[:field, :character], :character],
       :return_type => :integer
     },
+    :cast => {
+      :args => [[:field, :character, :decimal, :integer, :null], :character],
+      :resolve_for_type => true,
+    },
     :round => {
       :args => [[:field, :decimal]],
       :resolve_for_type => true,
@@ -190,7 +196,7 @@ class Sparkql::FunctionResolver
   end
   
   # Validate the function instance prior to calling it. All validation failures will show up in the
-  # errors array. 
+  # errors array.
   def validate()
     name = @name.to_sym
     unless support.has_key?(name)
@@ -219,10 +225,26 @@ class Sparkql::FunctionResolver
       end
       count +=1
     end
+
+    if name == :cast
+      type = @args.last[:value]
+      if !VALID_CAST_TYPES.include?(type.to_sym)
+        @errors << Sparkql::ParserError.new(:token => @name,
+                                            :message => "Function call '#{@name}' requires a castable type.",
+                                            :status => :fatal )
+        return
+      end
+    end
   end
   
   def return_type
-    support[@name.to_sym][:return_type]
+    name = @name.to_sym
+
+    if name == :cast
+      @args.last[:value].to_sym
+    else
+      support[@name.to_sym][:return_type]
+    end
   end
   
   def errors
@@ -752,7 +774,76 @@ class Sparkql::FunctionResolver
       :value => [start_str.to_s, end_str.to_s]
     }
   end
-  
+
+  def cast_field(value, type)
+    {
+      :type => :function,
+      :value => "cast",
+      :args => [value, type]
+    }
+  end
+
+  def cast(value, type)
+    if value == 'NULL'
+      value = nil
+    end
+
+    new_type = type.to_sym
+    {
+      type: new_type,
+      value: cast_literal(value, new_type)
+    }
+  rescue
+    {
+      type: :null,
+      value: 'NULL'
+    }
+  end
+
+  def valid_cast_type?(type)
+    if VALID_CAST_TYPES.key?(type.to_sym)
+      true
+    else
+      @errors << Sparkql::ParserError.new(:token => coords,
+                                          :message => "Function call 'cast' requires a castable type.",
+                                          :status => :fatal )
+      false
+    end
+  end
+
+  def cast_null(value, type)
+    cast(value, type)
+  end
+
+  def cast_decimal(value, type)
+    cast(value, type)
+  end
+
+  def cast_character(value, type)
+    cast(value, type)
+  end
+
+  def cast_literal(value, type)
+    case type
+    when :character
+      "'#{value.to_s}'"
+    when :integer
+      if value.nil?
+        '0'
+      else
+        Integer(Float(value)).to_s
+      end
+    when :decimal
+      if value.nil?
+        '0.0'
+      else
+        Float(value).to_s
+      end
+    when :null
+      'NULL'
+    end
+  end
+
   private
 
   def is_coords?(coord_string)

data/lib/sparkql/parser_tools.rb

@@ -31,15 +31,20 @@ module Sparkql::ParserTools
       function = Sparkql::FunctionResolver::SUPPORTED_FUNCTIONS[field[:value].to_sym]
       if !function.nil?
         field_args[:field_function] = field[:value]
-        field_args[:field_function_type] = function[:return_type]
         field_args[:args] = field[:args]
+
+        if field_args[:field_function] == 'cast'
+          field_args[:field_function_type] = field[:args].last.to_sym
+        else
+          field_args[:field_function_type] = function[:return_type]
+        end
       else
         tokenizer_error(:token => field[:value], 
           :message => "Unsupported function type", :status => :fatal )
       end
       field = field[:args].first
     end
-    custom_field = field.start_with?('"')
+    custom_field = !field.nil? && field.start_with?('"')
     block_group = (@lexer.level == 0) ? 0 : @lexer.block_group_identifier
     expression = {:field => field, :operator => operator, :conjunction => 'And',
       :conjunction_level => 0, :level => @lexer.level,

data/test/unit/function_resolver_test.rb

@@ -451,7 +451,112 @@ class FunctionResolverTest < Test::Unit::TestCase
         :value => 1.0}])
     assert_equal :shape, f.return_type
   end
-  
+
+  test 'return_type for cast()' do
+    f = FunctionResolver.new('cast', [{:type => :character, 
+        :value => "1"},{:type => :character, 
+        :value => 'decimal'}])
+
+    assert_equal :decimal, f.return_type
+
+    f = FunctionResolver.new('cast', [{:type => :character, 
+        :value => "1"},{:type => :character, 
+        :value => 'integer'}])
+
+    assert_equal :integer, f.return_type
+  end
+
+  test "cast() decimal to integer" do
+    f = FunctionResolver.new('cast', [{:type => :decimal, :value => '1.2'}, {type: :character, :value => 'integer'}])
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :integer, value[:type]
+    assert_equal '1', value[:value]
+  end
+
+  test "cast() integer to decimal" do
+    f = FunctionResolver.new('cast', [{:type => :decimal, :value => '1'}, {type: :character, :value => 'decimal'}])
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :decimal, value[:type]
+    assert_equal '1.0', value[:value]
+  end
+
+  test "cast() nil to integer" do
+    f = FunctionResolver.new('cast', [{:type => :null, :value => 'NULL'}, {type: :character, :value => 'integer'}])
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :integer, value[:type]
+    assert_equal '0', value[:value]
+  end
+
+  test "cast() nil to decimal" do
+    f = FunctionResolver.new('cast', [{:type => :null, :value => 'NULL'}, {type: :character, :value => 'decimal'}])
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :decimal, value[:type]
+    assert_equal '0.0', value[:value]
+  end
+
+  test "cast() nil to character" do
+    f = FunctionResolver.new('cast', [{:type => :null, :value => 'NULL'}, {type: :character, :value => 'character'}])
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :character, value[:type]
+    assert_equal "''", value[:value]
+  end
+
+  test "cast() character to decimal" do
+    f = FunctionResolver.new('cast', [{:type => :character, :value => "1.1"}, {type: :character, :value => 'decimal'}])
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :decimal, value[:type]
+    assert_equal "1.1", value[:value]
+  end
+
+  test "cast() character to integer" do
+    f = FunctionResolver.new('cast', [{:type => :character, :value => "1"}, {type: :character, :value => 'integer'}])
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :integer, value[:type]
+    assert_equal "1", value[:value]
+  end
+
+  test "cast() Field" do
+    f = FunctionResolver.new('cast', [{:type => :field, :value => 'Bedrooms'}, {type: :character, :value => 'character'}])
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :function, value[:type]
+    assert_equal 'cast', value[:value]
+    assert_equal ['Bedrooms', 'character'], value[:args]
+  end
+
+  test "invalid cast returns null" do
+    f = FunctionResolver.new('cast', [{:type => :character, :value => '1.1.1'}, {type: :character, :value => 'integer'}])
+    f.validate
+    assert !f.errors?, "Errors #{f.errors.inspect}"
+    value = f.call
+
+    assert_equal :null, value[:type]
+    assert_equal 'NULL', value[:value]
+  end
+
   test "invalid function" do
     f = FunctionResolver.new('then', [])
     f.validate

data/test/unit/parser_test.rb

@@ -753,6 +753,22 @@ class ParserTest < Test::Unit::TestCase
     assert_equal(["FieldName"], expression[:function_parameters])
   end
 
+  def test_cast_with_field
+    filter = "cast(ListPrice, 'character') Eq '100000'"
+    @parser = Parser.new
+    expression = @parser.parse(filter).first
+    assert !@parser.errors?, "Filter '#{filter}' failed: #{@parser.errors.first.inspect}"
+
+    assert_equal 'cast', expression[:field_function]
+    assert_equal "'100000'", expression[:condition]
+    assert_equal(:character, expression[:field_function_type])
+  end
+
+  def test_cast_with_invalid_type
+    parser_errors("cast(ListPrice, 'bogus') Eq '10'")
+    parser_errors("ListPrice Eq cast('10', 'bogus')")
+  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.15
+  version: 1.1.16
 platform: ruby
 authors:
 - Wade McEwen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-19 00:00:00.000000000 Z
+date: 2018-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: georuby