sparkql 1.3.2 → 1.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4f82b65f3fa050b24c53c7c5cb1e4a113d99e5e4ada4510695179c100aac711
-  data.tar.gz: 6fb9758b1883beadbbf9f864a9b1b782bfbc6f29b1a0061f9f66f33e1a0ed0b3
+  metadata.gz: 995514ae40305cedb2116dafc6c98b8efb534ae3d2f31c9d48e86421e3f5c10c
+  data.tar.gz: 6162d29fb4520941edb2b53742d966fdf373418b2745f6fd1d8c1fa79432b896
 SHA512:
-  metadata.gz: 9752471d2b83c520c9ac52fa6fbc0219ffd914648bd8801f7953f41799a31ecd3de242e9a62e89cf5a7752c29337e85b14cba254779583ad914ac3cc4c06dc5b
-  data.tar.gz: 3ccd9092e28b7fd3064768deb46eb4d7d5205be213adad251bb568958d4975e109080a74759613fb6c0e425a0ddda0ca7af37253b71bbe2ce18fd57891e0f6e3
+  metadata.gz: c39c06894d6a7b298d4fafb3c578e6d203543c77c68ad0cf8acb9ec943c00c656e38529a7e6b2afe4cc3177b5a59b078c7ce4c193a08dea0f575bd62ee0495d7
+  data.tar.gz: fbbba23b099146c85f3c15fb82ea3bbc93fe989b156752a80137a2212b2ed64f4cf50ecb99bf06b59914f1e1f8996a65155c9cde11c025702e6b8504b083cc93

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+v1.3.4, 20265-01-20
+  * [BUGFIX] Validate limit for days and weekdays
+
+v1.3.3, 2025-08-12
+-------------------
+  * [BUGFIX] Evaluator fix for Not regression
+
 v1.3.2, 2025-08-06
 -------------------
   * [BUGFIX] More Evaluator fixes

data/VERSION

@@ -1 +1 @@
-1.3.2
+1.3.4

data/lib/sparkql/evaluator.rb

@@ -1,9 +1,12 @@
+
 # Using an instance of ExpressionResolver to resolve the individual expressions,
 # this class will evaluate the rest of a parsed sparkql string to true or false.
 # Namely, this class will handle all the nesting, boolean algebra, and dropped
 # fields. Plus, it has some optimizations built in to skip the processing for
 # any expressions that don't contribute to the net result of the filter.
 class Sparkql::Evaluator
+  include Sparkql::Token
+
   attr_reader :processed_count
 
   def initialize(expression_resolver)
@@ -40,6 +43,11 @@ class Sparkql::Evaluator
       block = expression[:block_group]
       block_group = block_groups[block]
 
+      if expression[:conjunction] == NOT && expression[:conjunction_level] == level
+        expression[:conjunction] = AND
+        expression[:unary] = NOT
+      end
+
       unless block_group
         block_groups[block] ||= block_builder(expression, level)
         block_group = block_groups[block]
@@ -48,9 +56,9 @@ class Sparkql::Evaluator
 
         # When dealing with Not expression conjunctions at the block level,
         # it's far simpler to convert it into the equivalent "And Not"
-        if block_group[:conjunction] == "Not"
-          block_group[:unary] = "Not"
-          block_group[:conjunction] = "And"
+        if block_group[:conjunction] == NOT
+          block_group[:unary] = NOT
+          block_group[:conjunction] = AND
         end
 
         # Every block group _must_ be seen as an expression in another block
@@ -100,7 +108,7 @@ class Sparkql::Evaluator
         block_group[:expressions].each do |expression|
           # If we encounter any or's in the same block group, we can cheat at
           # resolving the rest, if we are at a true
-          if block_result && expression[:conjunction] == 'Or'
+          if block_result && expression[:conjunction] == OR
             break
           end
 
@@ -114,7 +122,7 @@ class Sparkql::Evaluator
                               end
           next if expression_result == :drop
 
-          if expression[:unary] == "Not"
+          if expression[:unary] == NOT
             expression_result = !expression_result
           end
 
@@ -124,11 +132,11 @@ class Sparkql::Evaluator
           end
 
           case expression[:conjunction]
-          when 'Not'
+          when NOT
             block_result &= !expression_result
-          when 'And'
+          when AND
             block_result &= expression_result
-          when 'Or'
+          when OR
             block_result |= expression_result
           else
             # Not a supported conjunction. We skip over this for backwards
@@ -136,7 +144,7 @@ class Sparkql::Evaluator
           end
         end
 
-        # block_group.delete(:expressions)
+        block_group.delete(:expressions)
         block_group[:result] = block_result
         final_result = block_result
       end

data/lib/sparkql/function_resolver.rb

@@ -21,6 +21,7 @@ module Sparkql
     VALID_REGEX_FLAGS = ['', 'i'].freeze
     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
+    MAX_DAYS = (365 * 1000).freeze # 1000 years ought to cover most cases
     VALID_CAST_TYPES = %i[field character decimal integer].freeze
 
     SUPPORTED_FUNCTIONS = {
@@ -43,16 +44,16 @@ module Sparkql
       regex: {
         args: [:character],
         opt_args: [{
-          type: :character,
-          default: ''
-        }],
+                     type: :character,
+                     default: ''
+                   }],
         return_type: :character
       },
       substring: {
         args: [%i[field character], :integer],
         opt_args: [{
-          type: :integer
-        }],
+                     type: :integer
+                   }],
         resolve_for_type: true,
         return_type: :character
       },
@@ -526,6 +527,15 @@ module Sparkql
 
     # Offset the current timestamp by a number of days
     def days(number_of_days)
+      if number_of_days.abs > MAX_DAYS
+        @errors << Sparkql::ParserError.new(token: number_of_days,
+                                            message: "Function call 'days' max offset #{MAX_DAYS} days",
+                                            status: :fatal,
+                                            syntax: false,
+                                            constraint: true)
+        return
+      end
+
       # date calculated as the offset from midnight tommorrow. Zero will provide values for all times
       # today.
       d = current_date + number_of_days
@@ -536,6 +546,15 @@ module Sparkql
     end
 
     def weekdays(number_of_days)
+      if number_of_days.abs > MAX_DAYS
+        @errors << Sparkql::ParserError.new(token: number_of_days,
+                                            message: "Function call 'weekdays' max offset #{MAX_DAYS} days",
+                                            status: :fatal,
+                                            syntax: false,
+                                            constraint: true)
+        return
+      end
+
       today = current_date
       weekend_start = today.saturday? || today.sunday?
       direction = number_of_days.positive? ? 1 : -1

data/lib/sparkql/token.rb

@@ -24,8 +24,15 @@ module Sparkql::Token
   NULL = /NULL|null|Null/.freeze
   # Reserved words
   RANGE_OPERATOR = 'Bt'.freeze
-  EQUALITY_OPERATORS = %w[Eq Ne].freeze
+  EQUAL = 'Eq'.freeze
+  NOT_EQUAL = 'Ne'.freeze
+  EQUALITY_OPERATORS = [EQUAL, NOT_EQUAL].freeze
+
   OPERATORS = %w[Gt Ge Lt Le] + EQUALITY_OPERATORS
-  UNARY_CONJUNCTIONS = ['Not'].freeze
-  CONJUNCTIONS = %w[And Or].freeze
+
+  NOT = 'Not'.freeze
+  AND = 'And'.freeze
+  OR = 'Or'.freeze
+  UNARY_CONJUNCTIONS = [NOT].freeze
+  CONJUNCTIONS = [AND, OR].freeze
 end

data/test/unit/evaluator_test.rb

@@ -64,39 +64,93 @@ class EvaluatorTest < Test::Unit::TestCase
   def test_dropped_field_handling
     assert sample("Test Eq 'Drop' And Test Eq true")
     assert !sample("Test Eq 'Drop' And Test Eq false")
-    assert !sample("Test Eq 'Drop' Or Test Eq false")
+
     assert sample("Test Eq 'Drop' Or Test Eq true")
+    assert !sample("Test Eq 'Drop' Or Test Eq false")
+
     assert sample("Test Eq false And Test Eq 'Drop' Or Test Eq true")
+    assert !sample("Test Eq false And Test Eq 'Drop' Or Test Eq false")
+
     assert sample("Test Eq false Or (Test Eq 'Drop' And Test Eq true)")
+    assert !sample("Test Eq false Or (Test Eq 'Drop' And Test Eq false)")
+
+    assert sample("Test Eq false Or (Not Test Eq 'Drop' And Test Eq true)")
+    assert !sample("Test Eq false Or (Not Test Eq 'Drop' And Test Eq false)")
+
+    assert sample("Test Eq true Not Test Eq 'Drop' And Test Eq true")
+    assert !sample("Test Eq true Not Test Eq 'Drop' And Test Eq false")
+    assert !sample("Test Eq false Not Test Eq 'Drop' And Test Eq false")
+
+    assert sample("Test Eq true And Test Eq 'Drop' Not Test Eq false")
+    assert !sample("Test Eq true And Test Eq 'Drop' Not Test Eq true")
+    assert !sample("Test Eq true And Test Eq 'Drop' Not Test Eq true")
+
+    assert sample("Test Eq true Not (Test Eq 'Drop' And Test Eq false)")
+    assert !sample("Test Eq true Not (Test Eq 'Drop' And Test Eq true)")
+    assert !sample("Test Eq true Not (Test Eq 'Drop' And Test Eq true)")
   end
 
   def test_nesting
     assert sample("Test Eq true Or (Test Eq true) And Test Eq false And (Test Eq true)")
+    assert sample("Test Eq true Or (Test Eq false) And Test Eq false And (Test Eq false)")
+    assert sample("Test Eq false Or (Test Eq true) And Test Eq true And (Test Eq true)")
+    assert !sample("Test Eq false Or (Test Eq false) And Test Eq false And (Test Eq false)")
+    assert !sample("Test Eq false Or (Test Eq true) And Test Eq false And (Test Eq false)")
+    assert !sample("Test Eq false Or (Test Eq false) And Test Eq true And (Test Eq false)")
+    assert !sample("Test Eq false Or (Test Eq false) And Test Eq false And (Test Eq true)")
+
     assert sample("Test Eq true Or ((Test Eq false) And Test Eq false) And (Test Eq false)")
     assert sample("(Test Eq false Or Test Eq true) Or (Test Eq false Or Test Eq false)")
     assert sample("(Test Eq true And Test Eq true) Or (Test Eq false)")
     assert sample("(Test Eq true And Test Eq true) Or (Test Eq false And Test Eq true)")
     assert !sample("(Test Eq false And Test Eq true) Or (Test Eq false)")
+
     assert sample("Test Eq true And ((Test Eq true And Test Eq false) Or Test Eq true)")
     assert !sample("Test Eq true And ((Test Eq true And Test Eq false) Or Test Eq false) And Test Eq true")
     assert !sample("Test Eq true And ((Test Eq true And Test Eq false) Or Test Eq false) Or Test Eq false")
     assert sample("Test Eq true And ((Test Eq true And Test Eq false) Or Test Eq false) Or Test Eq true")
     assert !sample("(Test Eq true Or Test Eq true) And Test Eq false")
     assert !sample("(Test Eq true Or Test Eq true) And (Test Eq false)")
+
     assert sample("(Test Eq true Or Test Eq true) And (Test Eq false Or Test Eq true)")
     assert !sample("(Test Eq true Or Test Eq true) And (Test Eq false Or Test Eq false)")
+
+    assert sample("(Test Eq true) Not Test Eq false And (Test Eq true)")
+    assert !sample("(Test Eq true) Not Test Eq true And (Test Eq true)")
+    assert !sample("(Test Eq false) Not Test Eq false And (Test Eq true)")
+    assert !sample("(Test1 Eq true) Not Test2 Eq false And (Test3 Eq false)")
   end
 
   def test_nots
     assert sample("Test Eq true Not Test Eq false")
     assert !sample("Test Eq true Not Test Eq true")
+    assert !sample("Test Eq false Not Test Eq true")
+    assert !sample("Test Eq false Not Test Eq false")
+
+    assert sample("Test Eq true And Test Eq true Not Test Eq false")
+    assert !sample("Test Eq false And Test Eq true Not Test Eq false")
+    assert !sample("Test Eq true And Test Eq true Not Test Eq true")
+    assert !sample("Test Eq true And Test Eq false Not Test Eq false")
+
     assert sample("Test Eq true Not (Test Eq false Or Test Eq false)")
-    assert sample("Test Eq true Not (Test Eq false And Test Eq false)")
     assert !sample("Test Eq true Not (Test Eq false Or Test Eq true)")
     assert !sample("Test Eq true Not (Test Eq true Or Test Eq false)")
-    assert !sample("Test Eq true Not (Not Test Eq false)")
-    assert !sample("Test Eq false And Test Eq true Not Test Eq false")
+    assert !sample("Test Eq true Not (Test Eq true Or Test Eq true)")
+    assert !sample("Test Eq false Not (Test Eq false Or Test Eq false)")
+
+    assert sample("Test Eq true Not (Test Eq false And Test Eq false)")
+    assert sample("Test Eq true Not (Test Eq true And Test Eq false)")
+    assert sample("Test Eq true Not (Test Eq false And Test Eq true)")
+    assert !sample("Test Eq true Not (Test Eq true And Test Eq true)")
+    assert !sample("Test Eq false Not (Test Eq false And Test Eq false)")
+
+    assert sample("Test Eq true Not (Test Eq false Or Test Eq false) And (Test Eq true Or Test Eq false)")
+    assert sample("Test Eq true Not (Test Eq false Or Test Eq false) And (Test Eq false Or Test Eq true)")
+    assert sample("Test Eq true Not (Test Eq false Or Test Eq false) And (Test Eq true Or Test Eq true)")
     assert !sample("Test Eq true Not (Test Eq false Or Test Eq false) And (Test Eq false Or Test Eq false)")
+    assert !sample("Test Eq true Not (Test Eq false Or Test Eq true) And (Test Eq true Or Test Eq false)")
+    assert !sample("Test Eq true Not (Test Eq true Or Test Eq false) And (Test Eq true Or Test Eq false)")
+    assert !sample("Test Eq false Not (Test Eq false Or Test Eq false) And (Test Eq true Or Test Eq false)")
   end
 
   def test_unary_nots
@@ -109,17 +163,14 @@ class EvaluatorTest < Test::Unit::TestCase
 
   def test_unary_double_nots
     assert sample("Not (Not(Not Test Eq true))")
+    assert !sample("Not (Not(Not Test Eq false))")
+
+    assert sample("Test Eq true Not (Not Test Eq true)")
+    assert !sample("Test Eq true Not (Not Test Eq false)")
+    assert !sample("Test Eq false Not (Not Test Eq true)")
   end
 
   def test_examples
-    # This one is based on a real life example that had problems.
-    #
-    # CurrentPrice Bt 130000.00,180000.00 And PropertySubType Eq 'Single Family Residence' And
-    # SchoolDistrict Eq 'Byron Center','Grandville','Jenison' And MlsStatus Eq 'Active' And
-    # BathsTotal Bt 1.50,9999.00 And BedsTotal Bt 3,99 And PropertyType Eq 'A'
-    # Not "Garage"."Garage2" Eq 'No' And "Pool"."OutdoorAbove" Eq true
-    # And "Pool"."OutdoorInground" Eq true Not "Substructure"."Michigan Basement" Eq true
-
     assert !sample("Test Eq false And Test Eq true And " \
       "Test Eq false And Test Eq true And " \
       "Test Eq true And Test Eq true And Test Eq true " \

data/test/unit/function_resolver_test.rb

@@ -445,6 +445,24 @@ class FunctionResolverTest < Test::Unit::TestCase
     end
   end
 
+  test 'days - exceed max' do
+    f = FunctionResolver.new('days',
+                             [{ type: :integer, value: 365_001 }],
+                             current_timestamp: EXAMPLE_DATE)
+    f.validate
+    assert !f.errors?
+    assert_nil f.call
+    assert f.errors?, "function 'days' limit 365000"
+
+    f = FunctionResolver.new('days',
+                             [{ type: :integer, value: -365_001 }],
+                             current_timestamp: EXAMPLE_DATE)
+    f.validate
+    assert !f.errors?
+    assert_nil f.call
+    assert f.errors?, "function 'days' limit 365000"
+  end
+
   test 'weekdays()' do
     friday = Date.new(2012, 10, 19)
     saturday = Date.new(2012, 10, 20)
@@ -514,6 +532,24 @@ class FunctionResolverTest < Test::Unit::TestCase
     end
   end
 
+  test 'weekdays - exceed max' do
+    f = FunctionResolver.new('weekdays',
+                             [{ type: :integer, value: 365_001 }],
+                             current_timestamp: EXAMPLE_DATE)
+    f.validate
+    assert !f.errors?
+    assert_nil f.call
+    assert f.errors?, "function 'weekdays' limit 365000"
+
+    f = FunctionResolver.new('weekdays',
+                             [{ type: :integer, value: -365_001 }],
+                             current_timestamp: EXAMPLE_DATE)
+    f.validate
+    assert !f.errors?
+    assert_nil f.call
+    assert f.errors?, "function 'weekdays' limit 365000"
+  end
+
   test 'months()' do
     f = FunctionResolver.new('months',
                              [{ type: :integer, value: 3 }],

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sparkql
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.3.4
 platform: ruby
 authors:
 - Wade McEwen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-08-07 00:00:00.000000000 Z
+date: 2026-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: georuby