ddql 0.1.0 → 1.0.0

data/lib/ddql/list_operator.rb

@@ -0,0 +1,7 @@
+module DDQL
+  class ListOperator < Operator
+    def initialize(symbol, name, type, ordinal)
+      super(symbol, name, type, 4, false, :boolean, ordinal)
+    end
+  end
+end

data/lib/ddql/lookup_operator.rb

@@ -0,0 +1,22 @@
+require_relative 'agg_operator'
+
+module DDQL
+  class LookupOperator < AggOperator
+    def initialize
+      super("LOOKUP BY", "Lookup", type: :infix, return_type: :string)
+    end
+
+    def parse(parser, token, expression: nil)
+      precedence      = self.precedence
+      precedence     -= 1 if right?
+      next_expression = parser.parse(precedence: precedence)
+      op_expression   = token.as_hash
+      
+      {
+        left: expression,
+        op: op_expression[:op],
+        right: next_expression.delete(:left) || next_expression,
+      }
+    end
+  end
+end

data/lib/ddql/operator.rb

@@ -0,0 +1,173 @@
+module DDQL
+  class Operator
+    attr_reader :associativity, :symbol, :name, :type, :precedence, :return_type, :ordinal
+
+    def initialize(symbol, name, type, precedence, right, return_type, ordinal=0)
+      @symbol        = symbol
+      @name          = name
+      @type          = type
+      @precedence    = precedence
+      @associativity = right ? :right : :left
+      @return_type   = return_type
+      @ordinal       = ordinal
+    end
+
+    def boolean?
+      return_type == :boolean
+    end
+
+    def comparison?
+      (infix? || postfix?) && boolean?
+    end
+
+    def complex_comparison?
+      comparison? && !simple_comparison?
+    end
+
+    def infix?
+      @name == :infixoperator || @type == :infix
+    end
+
+    def left?
+      !right?
+    end
+
+    def math?
+      math_op?(symbol)
+    end
+
+    def parse(parser, token, expression: nil)
+      case type
+      when :infix; parse_infix(parser, token, expression)
+      when :prefix; parse_prefix(parser, token, expression)
+      when :postfix; parse_postfix(parser, token, expression)
+      else
+        raise "unsupported operator type[#{type}]"
+      end
+    end
+
+    def pattern
+      symbol
+    end
+
+    def postfix?
+      @name == :postfixoperator || @type == :postfix
+    end
+
+    def prefix?
+      @name == :prefixoperator || @type == :prefix
+    end
+
+    def register(hash)
+      hash[symbol] = self
+      hash
+    end
+
+    def right?
+      @associativity == :right
+    end
+
+    def simple_comparison?
+      case symbol
+      when "==", "=", "!=", "<=", "<", ">=", ">"
+        true
+      else
+        false
+      end
+    end
+
+    def type?(incoming)
+      type == incoming
+    end
+
+    private
+
+    def boolean_stmt(left, op, right)
+      # the following avoids unnecessarily deeply nested statements
+      while left.key?(:lstatement) && !left.key?(:rstatement)
+        left = left[:lstatement]
+      end
+      while right.key?(:lstatement) && !right.key?(:rstatement)
+        right = right[:lstatement]
+      end
+      {
+        lstatement: left,
+        boolean_operator: op[:op],
+        rstatement: right,
+      }
+    end
+
+    def math_op?(str)
+      case str
+      when '+', '-', '*', '/', '%', '^'
+        true
+      else
+        false
+      end
+    end
+
+    def merged_negation(left, right, op)
+      needs_statement_wrapper = lambda do |expr|
+        (expr.key?(:lstatement) && expr.key?(:op_not)) || !expr.key?(:lstatement)
+      end
+
+      left = {lstatement: left} if needs_statement_wrapper[left]
+      right = {rstatement: right} if needs_statement_wrapper[right]
+      left.merge(boolean_operator: op[:op]).merge(right)
+    end
+
+    def parse_infix(parser, token, expression)
+      precedence      = self.precedence
+      precedence     -= 1 if right?
+      next_expression = parser.parse(precedence: precedence)
+      op_expression   = token.as_hash
+
+      if token.and? || token.or?
+        return boolean_stmt(expression, op_expression, next_expression)
+      end
+
+      if expression.key?(:op_not) || next_expression.key?(:op_not)
+        return merged_negation(expression, next_expression, op_expression)
+      end
+
+      if next_expression&.key?(:lstatement) && expression&.key?(:lstatement)
+        left = expression.merge(boolean_operator: op_expression[:op], rstatement: next_expression[:lstatement])
+        return next_expression.key?(:rstatement) ?
+          left.merge(
+            boolean_operator: next_expression[:boolean_operator][:op],
+            rstatement: next_expression[:rstatement]
+          ) :
+          left
+      end
+
+      expression = {left: expression} unless redundant?(expression, :left)
+      next_expression = {right: next_expression} unless redundant?(next_expression, :right)
+      expression.merge(op_expression).merge(next_expression)
+    end
+
+    def parse_postfix(parser, token, expression)
+      op_expression = token.as_hash
+      if expression && !expression.empty?
+        expression = {left: expression} unless expression.key?(:left)
+        expression.merge(op_expression)
+      else
+        op_expression
+      end
+    end
+
+    def parse_prefix(parser, token, _expression)
+      op_expression   = token.type.as_hash(token.data)
+      next_expression = parser.parse(precedence: precedence)
+      if next_expression.key?(:lstatement) && !next_expression.key?(:rstatement)
+        next_expression = next_expression[:lstatement]
+      elsif next_expression.key?(:rstatement) && !next_expression.key?(:lstatement)
+        next_expression = next_expression[:rstatement]
+      end
+      op_expression[:op].merge(next_expression)
+    end
+
+    def redundant?(expression, *keys)
+      expression.keys == keys
+    end
+  end
+end

data/lib/ddql/operators.rb

@@ -0,0 +1,113 @@
+require 'singleton'
+
+require_relative 'operator'
+require_relative 'agg_operator'
+require_relative 'coalesce_operator'
+require_relative 'infix_float_map_operator'
+require_relative 'infix_string_map_operator'
+require_relative 'list_operator'
+require_relative 'lookup_operator'
+require_relative 'postfix_null_type_operator'
+
+module DDQL
+  class Operators
+    include Singleton
+
+    attr_reader :cache
+
+    def self.float_map_ops
+      instance.cache.select { |_, v| v.is_a? InfixFloatMapOperator }
+    end
+
+    def self.operator_regex(operator_type)
+      ops = instance.cache.select { |k, v| v.type?(operator_type) }
+      
+      if ops.empty?
+        # if there are no registered operators of the given type use negative
+        # lookahead to generate a regex pattern that can never be matched
+        return /(?!x)x/
+      else
+        ops.keys[1..-1].inject(ops.keys.first) { |a, e| Regexp.union(a, ops[e].pattern) }
+      end
+    end
+
+    def initialize
+      @cache = build_cache
+    end
+
+    private
+    def build_cache
+      cache = {}
+      Operator.new("==", "Double Equals", :infix, 3, false, :boolean, 0).register(cache)
+      Operator.new("=", "Single Equals", :infix, 3, false, :boolean, 0).register(cache)
+      Operator.new("!=", "Not Equals", :infix, 3, false, :boolean, 1).register(cache)
+      Operator.new("<=", "Less Than or Equals", :infix, 4, false, :boolean, 4).register(cache)
+      Operator.new("<", "Less Than", :infix, 4, false, :boolean, 2).register(cache)
+      Operator.new(">=", "Greater Than or Equals", :infix, 4, false, :boolean, 5).register(cache)
+      Operator.new(">", "Greater Than", :infix, 4, false, :boolean, 3).register(cache)
+      # Operator.new("GROUP BY", "Group By", :infix, 7, false, :double).register(cache)
+      Operator.new("CTN", "Contains", :infix, 4, false, :boolean, 6).register(cache)
+      Operator.new("STW", "Starts With", :infix, 4, false, :boolean, 7).register(cache)
+      Operator.new("IN", "In Any", :infix, 4, false, :boolean, 8).register(cache)
+      Operator.new("LCTN", "Contains", :infix, 4, false, :boolean, 6).register(cache)
+      Operator.new("ON", "On Date", :infix, 4, false, :boolean, 0).register(cache)
+      Operator.new("EPST", "On Or After Date", :infix, 4, false, :boolean, 1).register(cache)
+      Operator.new("PST", "After Date", :infix, 4, false, :boolean, 1).register(cache)
+      Operator.new("EPRE", "On Or Before Date", :infix, 4, false, :boolean, 1).register(cache)
+      Operator.new("PRE", "Before Date", :infix, 4, false, :boolean, 0).register(cache)
+      Operator.new("OR", "Or", :infix, 1, false, :boolean).register(cache)
+      Operator.new("AND", "And", :infix, 2, false, :boolean).register(cache)
+      Operator.new("IS NULL", "Is Null", :postfix, 9, false, :boolean, 0).register(cache)
+      Operator.new("IS NOT NULL", "Is Not Null", :postfix, 9, false, :boolean, 1).register(cache)
+      Operator.new("+", "Plus", :infix, 5, false, :double).register(cache)
+      Operator.new("-", "Minus", :infix, 5, false, :double).register(cache)
+      Operator.new("*", "Multiplied By", :infix, 6, false, :double).register(cache)
+      Operator.new("/", "Divided By", :infix, 6, false, :double).register(cache)
+      Operator.new("%", "Modulus", :infix, 6, false, :integer).register(cache)
+      Operator.new("^", "To the Power of", :infix, 7, true, :double).register(cache)
+      AggOperator.new("EXISTS", "Exists", return_type: :boolean).register(cache)
+      AggOperator.new("CNT", "Count", return_type: :integer).register(cache)
+      AggOperator.new("AVG", "Mean", return_type: :double).register(cache)
+      AggOperator.new("MED", "Median", return_type: :double).register(cache)
+      AggOperator.new("MAX", "Max", return_type: :double).register(cache)
+      AggOperator.new("MIN", "Min", return_type: :double).register(cache)
+      AggOperator.new("SUM", "Sum", return_type: :double).register(cache)
+      AggOperator.new("MERGE", "Merge", return_type: :string_list).register(cache)
+      LookupOperator.new.register(cache)
+      CoalesceOperator.new.register(cache)
+      # PNT & RATIO don't work and aren't used in DD PROD as of 2020-07-24
+      # AggOperator.new("PNT", "Percent", return_type: :double).register(cache)
+      # AggOperator.new("RATIO", "Ratio", return_type: :double).register(cache)
+      InfixStringMapOperator.new("ANY_MAP", "Has Any", 0).register(cache)
+      InfixStringMapOperator.new("ALL_MAP", "Has All", 1).register(cache)
+      InfixStringMapOperator.new("NONE_MAP", "Has None", 2).register(cache)
+      InfixFloatMapOperator.new("ANY_GREATER_THAN_FLOAT_MAP", "Has Any Greater Than", 1, :any, :gt).register(cache)
+      InfixFloatMapOperator.new("ALL_GREATER_THAN_FLOAT_MAP", "Has All Greater Than", 2, :all, :gt).register(cache)
+      InfixFloatMapOperator.new("NONE_GREATER_THAN_FLOAT_MAP", "Has None Greater Than", 3, :none, :gt).register(cache)
+      InfixFloatMapOperator.new("ANY_GREATER_THAN_OR_EQUAL_FLOAT_MAP", "Has Any Greater Than Or Equal To", 4, :any, :ge).register(cache)
+      InfixFloatMapOperator.new("ALL_GREATER_THAN_OR_EQUAL_FLOAT_MAP", "Has All Greater Than Or Equal To", 5, :all, :ge).register(cache)
+      InfixFloatMapOperator.new("NONE_GREATER_THAN_OR_EQUAL_FLOAT_MAP", "Has None Greater Than Or Equal To", 6, :none, :ge).register(cache)
+      InfixFloatMapOperator.new("ANY_LESS_THAN_FLOAT_MAP", "Has Any Less Than", 7, :any, :lt).register(cache)
+      InfixFloatMapOperator.new("ALL_LESS_THAN_FLOAT_MAP", "Has All Less Than", 8, :all, :lt).register(cache)
+      InfixFloatMapOperator.new("NONE_LESS_THAN_FLOAT_MAP", "Has None Less Than", 9, :none, :lt).register(cache)
+      InfixFloatMapOperator.new("ANY_LESS_THAN_OR_EQUAL_FLOAT_MAP", "Has Any Less Than Or Equal To", 10, :any, :le).register(cache)
+      InfixFloatMapOperator.new("ALL_LESS_THAN_OR_EQUAL_FLOAT_MAP", "Has All Less Than Or Equal To", 11, :all, :le).register(cache)
+      InfixFloatMapOperator.new("NONE_LESS_THAN_OR_EQUAL_FLOAT_MAP", "Has None Less Than Or Equal To", 12, :none, :le).register(cache)
+      InfixFloatMapOperator.new("ANY_EQUAL_FLOAT_MAP", "Has Any Equal To", 13, :any, :eq).register(cache)
+      InfixFloatMapOperator.new("ALL_EQUAL_FLOAT_MAP", "Has All Equal To", 14, :all, :eq).register(cache)
+      InfixFloatMapOperator.new("NONE_EQUAL_FLOAT_MAP", "Has None Equal To", 15, :none, :eq).register(cache)
+      ListOperator.new("ANY", "Has Any", :infix, 0).register(cache)
+      ListOperator.new("ALL", "Has All", :infix, 1).register(cache)
+      ListOperator.new("NONE", "Has None", :infix, 2).register(cache)
+      ListOperator.new("EMPTY", "Is Empty", :postfix, 3).register(cache)
+      PostfixNullTypeOperator.new("NO_INFORMATION", :NoInformation, 99).register(cache)
+      PostfixNullTypeOperator.new("NOT_APPLICABLE", :NotApplicable, 101).register(cache)
+      PostfixNullTypeOperator.new("NOT_COLLECTED", :NotCollected, 103).register(cache)
+      PostfixNullTypeOperator.new("NOT_DISCLOSED", :NotDisclosed, 100).register(cache)
+      PostfixNullTypeOperator.new("NOT_MEANINGFUL", :NotMeaningful, 102).register(cache)
+      Operator.new("NOT", "Not", :prefix, 9, false, :boolean).register(cache)
+      Operator.new("YES", "Is True", :postfix, 9, false, :boolean, 0).register(cache)
+      Operator.new("NO", "Is False", :postfix, 9, false, :boolean, 1).register(cache)
+    end
+  end
+end

data/lib/ddql/parser.rb

@@ -1,282 +1,61 @@
 module DDQL
-  class Parser < Parslet::Parser
-    # comparison constants
-    rule(:eq)   { (str('==') | str('=')) }
-    rule(:ge)   { str('>=') }
-    rule(:gt)   { str('>') }
-    rule(:is)   { str('IS') }
-    rule(:isnt) { str('IS NOT') }
-    rule(:le)   { str('<=') }
-    rule(:lt)   { str('<') }
-    rule(:ne)   { str('!=') }
-    rule(:no)   { str('NO') }
-    rule(:null) { str('NULL') }
-    rule(:yes)  { str('YES') }
-
-    # constants
-    rule(:comma)    { str(',') }
-    rule(:digit)    { match('[0-9]') }
-    rule(:group_by) { str('GROUP BY') }
-    rule(:spaces)   { match('\s').repeat(1) }
-    rule(:spaces?)  { spaces.maybe }
-    rule(:tick)     { str("'") }
-    rule(:string)   { (tick >> (tick.absent? >> any).repeat.as(:string) >> tick) }
-
-    # brackets
-    rule(:lbracket)  { str('[') }
-    rule(:lparen)    { spaces? >> str('(') >> spaces? }
-    rule(:lsquiggly) { spaces? >> str('{') >> spaces? }
-    rule(:rbracket)  { str(']') }
-    rule(:rparen)    { spaces? >> str(')') >> spaces? }
-    rule(:rsquiggly) { spaces? >> str('}') >> spaces? }
-
-    # math ops
-    rule(:math_add)      { str('+').as(:op_add) }
-    rule(:math_subtract) { str('-').as(:op_subtract) }
-    rule(:math_multiply) { str('*').as(:op_multiply) }
-    rule(:math_divide)   { str('/').as(:op_divide) }
-    rule(:math_mod)      { str('%').as(:op_mod) }
-    rule(:math_power)    { str('^').as(:op_power) }
-    rule(:math_operation) do
-      math_add | math_subtract | math_multiply | math_divide | math_mod | math_power
-    end
-
-    # boolean operators
-    rule(:bool_not)     { spaces? >> str('NOT').as(:op_not) >> spaces? }
-    rule(:or_operator)  { spaces? >> str('OR').as(:op_or) >> spaces? }
-    rule(:and_operator) { spaces? >> str('AND').as(:op_and) >> spaces? }
-
-    # string operators
-    rule(:ctn_operator) { spaces? >> (str('CTN') | str('LCTN')).as(:op_ctn) >> spaces? }
-    rule(:stw_operator) { spaces? >> str('STW').as(:op_stw) >> spaces? }
-
-    # date operators
-    rule(:date_on_operator)           { spaces? >> str('ON').as(:op_date_on) >> spaces? }
-    rule(:date_after_operator)        { spaces? >> str('PST').as(:op_date_after) >> spaces? }
-    rule(:date_after_operator_or_on)  { spaces? >> str('EPST').as(:op_date_after_or_on) >> spaces? }
-    rule(:date_before_operator)       { spaces? >> str('PRE').as(:op_date_before) >> spaces? }
-    rule(:date_before_operator_or_on) { spaces? >> str('EPRE').as(:op_date_before_or_on) >> spaces? }
-
-    # currency support
-    rule(:currency_code) { match('[A-Z]').repeat(3) }
-    rule(:currency) do
-      tick.maybe >>
-        (
-          tick.absent? >>
-          currency_code.as(:currency_code) >>
-          str(':') >>
-          (float_numeric | int_numeric).as(:currency_value)
-        ) >>
-        tick.maybe
-    end
-
-    # numbers
-    rule(:float_numeric) do
-      (str('-').maybe >> (
-              str('0') | (match('[1-9]') >> digit.repeat)
-            ) >> (
-              str('.') >> digit.repeat(1)
-            ) >> (
-              match('[eE]') >> (str('+') | str('-')).maybe >> digit.repeat(1)
-            ).maybe
-      ).as(:float)
-    end
-    rule(:float) do
-      (tick.maybe >> (tick.absent? >> float_numeric >> tick)) | float_numeric
-    end
-    rule(:int_numeric) { (str('-').maybe >> digit.repeat(1)).as(:int) }
-    rule(:int) do
-      (tick.maybe >> (tick.absent? >> int_numeric >> tick)) | int_numeric
-    end
-
-    # special markers
-    rule(:current_date)           { str('$CURRENT_DATE').as(:current_date) }
-    rule(:current_quarter)        { str('$CURRENT_QUARTER').as(:current_quarter) }
-    rule(:current_year)           { str('$CURRENT_YEAR').as(:current_year) }
-    rule(:relative_end_date)      { str('$END_DATE').as(:relative_end_date) }
-    rule(:relative_end_quarter)   { str('$END_QUARTER').as(:relative_end_quarter) }
-    rule(:relative_end_year)      { str('$END_YEAR').as(:relative_end_year) }
-    rule(:relative_start_date)    { str('$START_DATE').as(:relative_start_date) }
-    rule(:relative_start_quarter) { str('$START_QUARTER').as(:relative_start_quarter) }
-    rule(:relative_start_year)    { str('$START_YEAR').as(:relative_start_year) }
-    rule(:special_marker)  do
-      (
-        current_year | current_date | current_quarter |
-        relative_end_date | relative_end_quarter | relative_end_year |
-        relative_start_date | relative_start_quarter | relative_start_year
-      ).as(:special_marker)
-    end
-
-    # nulls
-    rule(:null_no_information) { str('NO_INFORMATION') }
-    rule(:null_not_applicable) { str('NOT_APPLICABLE') }
-    rule(:null_not_collected)  { str('NOT_COLLECTED') }
-    rule(:null_not_disclosed)  { str('NOT_DISCLOSED') }
-    rule(:null_not_meaningful) { str('NOT_MEANINGFUL') }
-    rule(:null_value_type) do
-      (
-        null_no_information |
-        null_not_applicable |
-        null_not_collected  |
-        null_not_disclosed  |
-        null_not_meaningful
-      ).as(:null_value_type)
-    end
-
-    # array operators
-    rule(:arrays_all_operator)  { str('ALL').as(:op_all) }
-    rule(:arrays_any_operator)  { str('ANY').as(:op_any) }
-    rule(:arrays_in_operator)   { str('IN').as(:op_in) }
-    rule(:arrays_none_operator) { str('NONE').as(:op_none) }
-    rule(:arrays_operator) do
-      arrays_all_operator | arrays_any_operator | arrays_in_operator | arrays_none_operator
+  class Parser
+    class ParseException < StandardError
     end
 
-    # comparison operators
-    rule(:boolean_operator)     { or_operator | and_operator }
-    rule(:date_rel_operator)    { date_on_operator | date_after_operator | date_after_operator_or_on | date_before_operator | date_before_operator_or_on }
-    rule(:eq_operator)          { eq.as(:op_eq) }
-    rule(:ge_operator)          { ge.as(:op_ge) }
-    rule(:gt_operator)          { gt.as(:op_gt) }
-    rule(:is_not_null_operator) { (isnt >> spaces >> null).as(:op_is_not_null) }
-    rule(:is_null_operator)     { (is >> spaces >> null).as(:op_is_null) }
-    rule(:is_operator)          { is.as(:op_is) }
-    rule(:le_operator)          { le.as(:op_le) }
-    rule(:lt_operator)          { lt.as(:op_lt) }
-    rule(:ne_operator)          { ne.as(:op_ne) }
-    rule(:no_operator)          { no.as(:op_no) }
-    rule(:relational_operator)  { eq_operator | le_operator | ge_operator | lt_operator | gt_operator | ne_operator }
-    rule(:string_rel_operator)  { ctn_operator | stw_operator }
-    rule(:yes_operator)         { yes.as(:op_yes) }
-
-    # aggregations
-    rule(:avg_operator) { str('AVG').as(:op_avg) }
-    rule(:cnt_operator) { str('CNT').as(:op_cnt) }
-    rule(:ext_operator) { str('EXISTS').as(:op_exist) }
-    rule(:max_operator) { str('MAX').as(:op_max) }
-    rule(:med_operator) { str('MED').as(:op_med) }
-    rule(:min_operator) { str('MIN').as(:op_min) }
-    rule(:sum_operator) { str('SUM').as(:op_sum) }
-    rule(:grouping_operator) { (max_operator | min_operator).as(:agg) }
-    rule(:agg_operator) do
-      (avg_operator | cnt_operator | ext_operator | med_operator | sum_operator).as(:agg)
-    end
-    rule(:aggregation_operator) do
-      # Examples:
-      #   CNT {type: IssuerCase, fields: [], expression: ([CaseFlag] == 'Amber' AND [CaseFlag] == 'RED' AND [CaseFlag] == 'Green')} >= '0'
-      #   CNT {type: IssuerPerson, expression: [ipAssociationType] == 'Director'}
-      (agg_operator >>
-        lsquiggly >>
-        (rsquiggly.absent? >> any).repeat(1).as(:sub_query_info) >>
-        rsquiggly >>
-        relational_operator.as(:op) >>
-        value.as(:right)
-      ) | (agg_operator >>
-        lsquiggly >>
-        (rsquiggly.absent? >> any).repeat(1).as(:sub_query_info) >>
-        rsquiggly
-      ) | (grouping_operator >>
-        lsquiggly >>
-        (rsquiggly.absent? >> any).repeat(1).as(:sub_query_info) >>
-        rsquiggly >>
-        spaces? >>
-        group_by >>
-        spaces? >>
-        factor.as(:group_by)
-      )
+    class NoTokenException < ParseException
+      def initialize
+        super 'No token found - ensure literals are surrounded by single quotes'
+      end
     end
 
-    # sub-queries
-    rule(:sub_query_type) do
-      spaces? >> str('type:') >> spaces? >> (str('IssuerCase') | str('IssuerPerson') | str('Issuer')).as(:type) >> spaces?
-    end
-    rule(:sub_query_fields) do
-      spaces? >> str('fields:') >> spaces? >> (factor | (lbracket >> spaces?.as(:factor) >> rbracket)).as(:fields) >> spaces?
-    end
-    rule(:sub_query_qualifier) do
-      spaces? >> str('qualifier:') >> spaces? >> string.as(:assoc_qualifier)
-    end
-    rule(:sub_query_expression) do
-      spaces? >> str('expression:') >> spaces? >> top.as(:expression)
-    end
-    rule(:sub_query_info_parsing) do
-      (sub_query_type >> (comma >> sub_query_qualifier).maybe >> comma >> sub_query_expression >> comma >> sub_query_fields) |
-        (sub_query_type >> (comma >> sub_query_qualifier).maybe >> comma >> sub_query_expression >> comma.absent?) |
-        (sub_query_type >> (comma >> sub_query_qualifier).maybe >> comma >> (sub_query_fields >> comma).maybe >> sub_query_expression) |
-        (sub_query_fields >> comma >> sub_query_type >> (comma >> sub_query_qualifier).maybe >> comma >> sub_query_expression) |
-        (sub_query_fields >> comma >> sub_query_expression >> comma >> sub_query_type >> (comma >> sub_query_qualifier).maybe) |
-        (sub_query_expression >> comma >> sub_query_type >> (comma >> sub_query_qualifier).maybe >> (comma >> sub_query_fields).maybe) |
-        (sub_query_expression >> comma >> (sub_query_fields >> comma).maybe >> sub_query_type >> (comma >> sub_query_qualifier).maybe) |
-        (sub_query_type >> comma >> sub_query_fields) | # for MIN/MAX {...} GROUP BY [...]
-        (sub_query_fields >> comma >> sub_query_type)   # for MIN/MAX {...} GROUP BY [...]
+    def initialize(expression)
+      @expression = expression
+      @tokens     = Lexer.lex(expression)
+      @depth      = 0
     end
 
-    # higher-level definitions
-    rule(:operator) do
-      (relational_operator | arrays_operator).as(:op)
+    def consume(token_type)
+      token = @tokens.poll
+      if token.nil? || token_type != token.type
+        message  = "Expected token[#{token_type.name}], got #{token.nil? ? 'nil' : "[#{token.type.name}]"}\n"
+        if token
+          message += "    #{@expression}\n"
+          message += "    #{' ' * token.location}^"
+        end
+        raise ParseException, message
+      end
+      token
     end
 
-    rule(:factor) do
-      lbracket >> (
-        match('[_0-9a-zA-Z&]').repeat(1).as(:factor)
-      ) >> rbracket
-    end
+    def parse(precedence: 0)
+      @depth += 1
+      token   = @tokens.poll
+      raise NoTokenException if token.nil?
 
-    rule(:val) do
-      (currency | float | int | special_marker | string)
-    end
+      expression = token.parse(self)
+      while precedence < next_precedence
+        token = @tokens.poll
+        expression = token.parse(self, expression: expression)
+      end
+      @depth -= 1
 
-    rule(:value) do
-      spaces? >> (val | factor) >> spaces?
-    end
-
-    rule(:math_operand) do
-      spaces? >> (special_marker | float | int | factor | aggregation_operator) >> spaces?
-    end
-
-    rule(:equation) do
-      (math_operand.as(:left) >> spaces? >> math_operation >> spaces? >> math_operand.as(:right)) |
-        (math_operand.as(:left) >> spaces? >> math_operation >> spaces? >> equation.as(:right)) #|
-    end
-
-    rule(:factor_comparison) do
-      (factor.as(:left) >> spaces >> is_not_null_operator.as(:op)) |
-        (factor.as(:left) >> spaces >> is_null_operator.as(:op)) |
-        (factor.as(:left) >> spaces >> is_operator.as(:op) >> spaces >> null_value_type.as(:right)) |
-        (value.as(:left) >> operator >> value.as(:right)) |
-        (factor.as(:left) >> (string_rel_operator | date_rel_operator).as(:op) >> string.as(:right)) |
-        (factor.as(:left) >> spaces? >> (no_operator | yes_operator).as(:yes_no_op))
-    end
+      if @depth == 0 && !peek.nil?
+        raise ParseException, "Unable to fully parse expression; token[#{peek}], possible cause: invalid operator"
+      end
 
-    rule(:entity) do
-      equation |
-      sub_query_info_parsing |
-      (
-        bool_not.maybe >> (
-          (lparen >> entity >> rparen) |
-            aggregation_operator |
-            (factor_comparison) |
-            factor.as(:value_of) |
-            special_marker |
-            top
-        )
-      )
+      expression
     end
 
-    rule(:statement) do
-      spaces? >> (
-        (lparen >> spaces? >> (top | entity | factor) >> spaces? >> rparen) |
-          entity
-      ) >> spaces?
+    def peek
+      @tokens.peek
     end
 
-    rule(:top) do
-      (statement.as(:lstatement) >> (boolean_operator.as(:boolean_operator) >> top.as(:rstatement))) |
-        (statement.as(:lstatement) >> (math_operation.as(:math_operation) >> top.as(:rstatement))) |
-        (statement.as(:lstatement) >> (operator.as(:operator) >> top.as(:rstatement))) |
-        statement
+    private
+    def next_precedence
+      token = peek
+      return 0 if token.nil?
+      Operators.instance.cache[token.op_data]&.precedence || 0
     end
-
-    root(:top)
   end
-end
+end