ddql 1.0.0 → 1.0.1

data/lib/ddql/list_operator.rb

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

data/lib/ddql/lookup_operator.rb

@@ -6,16 +6,18 @@ module DDQL
       super("LOOKUP BY", "Lookup", type: :infix, return_type: :string)
     end
 
-    def parse(parser, token, expression: nil)
+    def parse(parser, _token, expression: nil)
       precedence      = self.precedence
       precedence     -= 1 if right?
       next_expression = parser.parse(precedence: precedence)
-      op_expression   = token.as_hash
-      
+
+      foreign_value_factor = expression[:factor]
+      foreign_key_factor = (next_expression.delete(:left) || next_expression)[:factor]
       {
-        left: expression,
-        op: op_expression[:op],
-        right: next_expression.delete(:left) || next_expression,
+        op_lookup_by: {
+          foreign_key: {factor: foreign_key_factor},
+          foreign_value: {factor: foreign_value_factor},
+        },
       }
     end
   end

data/lib/ddql/operator.rb

@@ -1,15 +1,18 @@
 module DDQL
   class Operator
-    attr_reader :associativity, :symbol, :name, :type, :precedence, :return_type, :ordinal
+    attr_reader :associativity, :symbol, :name, :type, :precedence, :return_type
 
-    def initialize(symbol, name, type, precedence, right, return_type, ordinal=0)
+    def initialize(symbol, name, type, precedence, right, return_type)
       @symbol        = symbol
       @name          = name
       @type          = type
       @precedence    = precedence
       @associativity = right ? :right : :left
       @return_type   = return_type
-      @ordinal       = ordinal
+    end
+
+    def any_type?
+      return_type == :any
     end
 
     def boolean?
@@ -118,10 +121,14 @@ module DDQL
 
     def parse_infix(parser, token, expression)
       precedence      = self.precedence
-      precedence     -= 1 if right?
+      precedence     -= 0.05 if right?
       next_expression = parser.parse(precedence: precedence)
       op_expression   = token.as_hash
 
+      if math? && next_expression&.dig(:left, :factor) && next_expression.size == 1
+        return op_expression.merge(left: expression, right: next_expression[:left])
+      end
+
       if token.and? || token.or?
         return boolean_stmt(expression, op_expression, next_expression)
       end
@@ -162,6 +169,9 @@ module DDQL
         next_expression = next_expression[:lstatement]
       elsif next_expression.key?(:rstatement) && !next_expression.key?(:lstatement)
         next_expression = next_expression[:rstatement]
+      elsif op_expression[:op].key?(:op_not) && next_expression.key?(:op_not)
+        next_expression.delete(:op_not)
+        return next_expression
       end
       op_expression[:op].merge(next_expression)
     end

data/lib/ddql/operators.rb

@@ -1,5 +1,4 @@
 require 'singleton'
-
 require_relative 'operator'
 require_relative 'agg_operator'
 require_relative 'coalesce_operator'
@@ -38,33 +37,36 @@ module DDQL
     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(TokenType::NESTED_OPEN_PATTERN, "Nested Query Opener", :prefix, 3, false, :none).register(cache)
+      Operator.new(TokenType::NESTED_CLOSE_PATTERN, "Nested Query Closer", :postfix, 3, false, :none).register(cache)
+      Operator.new("==", "Double Equals", :infix, 3, false, :boolean).register(cache)
+      Operator.new("=", "Single Equals", :infix, 3, false, :boolean).register(cache)
+      Operator.new("!=", "Not Equals", :infix, 3, false, :boolean).register(cache)
+      Operator.new("<=", "Less Than or Equals", :infix, 4, false, :boolean).register(cache)
+      Operator.new("<", "Less Than", :infix, 4, false, :boolean).register(cache)
+      Operator.new(">=", "Greater Than or Equals", :infix, 4, false, :boolean).register(cache)
+      Operator.new(">", "Greater Than", :infix, 4, false, :boolean).register(cache)
+      Operator.new("CTN", "Contains", :infix, 4, false, :boolean).register(cache)
+      Operator.new("STW", "Starts With", :infix, 4, false, :boolean).register(cache)
+      Operator.new("IN", "In Any", :infix, 4, false, :boolean).register(cache)
+      Operator.new("LCTN", "Contains", :infix, 4, false, :boolean).register(cache)
+      Operator.new("ON", "On Date", :infix, 4, false, :boolean).register(cache)
+      Operator.new("EPST", "On Or After Date", :infix, 4, false, :boolean).register(cache)
+      Operator.new("PST", "After Date", :infix, 4, false, :boolean).register(cache)
+      Operator.new("EPRE", "On Or Before Date", :infix, 4, false, :boolean).register(cache)
+      Operator.new("PRE", "Before Date", :infix, 4, false, :boolean).register(cache)
+      Operator.new("OR", "Or", :infix, 0.1, false, :boolean).register(cache)
+      Operator.new("AND", "And", :infix, 0.2, false, :boolean).register(cache)
+      Operator.new("NOT", "Not", :prefix, 0.3, false, :boolean).register(cache)
+      Operator.new("IS NULL", "Is Null", :postfix, 9, false, :boolean).register(cache)
+      Operator.new("IS NOT NULL", "Is Not Null", :postfix, 9, false, :boolean).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("ALIAS", "Alias", return_type: :any).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)
@@ -78,36 +80,35 @@ module DDQL
       # 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)
+      InfixStringMapOperator.new("ANY_MAP", "Has Any").register(cache)
+      InfixStringMapOperator.new("ALL_MAP", "Has All").register(cache)
+      InfixStringMapOperator.new("NONE_MAP", "Has None").register(cache)
+      InfixFloatMapOperator.new("ANY_GREATER_THAN_FLOAT_MAP", "Has Any Greater Than", :any, :gt).register(cache)
+      InfixFloatMapOperator.new("ALL_GREATER_THAN_FLOAT_MAP", "Has All Greater Than", :all, :gt).register(cache)
+      InfixFloatMapOperator.new("NONE_GREATER_THAN_FLOAT_MAP", "Has None Greater Than", :none, :gt).register(cache)
+      InfixFloatMapOperator.new("ANY_GREATER_THAN_OR_EQUAL_FLOAT_MAP", "Has Any Greater Than Or Equal To", :any, :ge).register(cache)
+      InfixFloatMapOperator.new("ALL_GREATER_THAN_OR_EQUAL_FLOAT_MAP", "Has All Greater Than Or Equal To", :all, :ge).register(cache)
+      InfixFloatMapOperator.new("NONE_GREATER_THAN_OR_EQUAL_FLOAT_MAP", "Has None Greater Than Or Equal To", :none, :ge).register(cache)
+      InfixFloatMapOperator.new("ANY_LESS_THAN_FLOAT_MAP", "Has Any Less Than", :any, :lt).register(cache)
+      InfixFloatMapOperator.new("ALL_LESS_THAN_FLOAT_MAP", "Has All Less Than", :all, :lt).register(cache)
+      InfixFloatMapOperator.new("NONE_LESS_THAN_FLOAT_MAP", "Has None Less Than", :none, :lt).register(cache)
+      InfixFloatMapOperator.new("ANY_LESS_THAN_OR_EQUAL_FLOAT_MAP", "Has Any Less Than Or Equal To", :any, :le).register(cache)
+      InfixFloatMapOperator.new("ALL_LESS_THAN_OR_EQUAL_FLOAT_MAP", "Has All Less Than Or Equal To", :all, :le).register(cache)
+      InfixFloatMapOperator.new("NONE_LESS_THAN_OR_EQUAL_FLOAT_MAP", "Has None Less Than Or Equal To", :none, :le).register(cache)
+      InfixFloatMapOperator.new("ANY_EQUAL_FLOAT_MAP", "Has Any Equal To", :any, :eq).register(cache)
+      InfixFloatMapOperator.new("ALL_EQUAL_FLOAT_MAP", "Has All Equal To", :all, :eq).register(cache)
+      InfixFloatMapOperator.new("NONE_EQUAL_FLOAT_MAP", "Has None Equal To", :none, :eq).register(cache)
+      ListOperator.new("ANY", "Has Any", :infix).register(cache)
+      ListOperator.new("ALL", "Has All", :infix).register(cache)
+      ListOperator.new("NONE", "Has None", :infix).register(cache)
+      ListOperator.new("EMPTY", "Is Empty", :postfix).register(cache)
+      PostfixNullTypeOperator.new("NO_INFORMATION", :NoInformation).register(cache)
+      PostfixNullTypeOperator.new("NOT_APPLICABLE", :NotApplicable).register(cache)
+      PostfixNullTypeOperator.new("NOT_COLLECTED", :NotCollected).register(cache)
+      PostfixNullTypeOperator.new("NOT_DISCLOSED", :NotDisclosed).register(cache)
+      PostfixNullTypeOperator.new("NOT_MEANINGFUL", :NotMeaningful).register(cache)
+      Operator.new("YES", "Is True", :postfix, 9, false, :boolean).register(cache)
+      Operator.new("NO", "Is False", :postfix, 9, false, :boolean).register(cache)
     end
   end
 end

data/lib/ddql/parser.rb

@@ -1,5 +1,7 @@
 module DDQL
   class Parser
+    attr_reader :tokens
+
     class ParseException < StandardError
     end
 
@@ -9,10 +11,51 @@ module DDQL
       end
     end
 
-    def initialize(expression)
+    class ResolvedToken
+      attr_reader :value
+
+      def initialize(v)
+        @value = v
+      end
+
+      def parse(_)
+        value
+      end
+    end
+
+    def self.from_tokens(tokens)
+      opener = tokens.doubly_linked!.find { |node| node.value.type == TokenType::NESTED_OPENER }
+      if opener
+        closer = tokens.find_from_tail { |node| node.value.type == TokenType::NESTED_CLOSER }
+        new_tokens  = DDQL::LinkedList.new
+        current = opener
+        while (current = current.next) && !(current === closer)
+          new_tokens << current.dup
+        end
+        new_tokens.tail.next = nil
+        new(tokens: tokens.replace!(
+          from: opener,
+          to: closer,
+          with: ResolvedToken.new(sub_query: from_tokens(new_tokens).parse)),
+        )
+      else
+        new(tokens: tokens)
+      end
+    end
+
+    def self.parse(expr)
+      from_tokens(Lexer.lex(expr)).record_expression(expr).parse
+    end
+
+    def initialize(expression: nil, tokens: nil)
       @expression = expression
-      @tokens     = Lexer.lex(expression)
       @depth      = 0
+      if expression
+        @tokens = Lexer.lex(expression)
+      else
+        @tokens = tokens
+      end
+      raise "tokens cannot be determined" if @tokens.nil? || @tokens.empty?
     end
 
     def consume(token_type)
@@ -31,6 +74,7 @@ module DDQL
     def parse(precedence: 0)
       @depth += 1
       token   = @tokens.poll
+
       raise NoTokenException if token.nil?
 
       expression = token.parse(self)
@@ -51,6 +95,28 @@ module DDQL
       @tokens.peek
     end
 
+    def record_expression(expr)
+      @expression = expr
+      self
+    end
+
+    # supports reading until the next +token_type+, does not support
+    # nested reads of +token_type+
+    #
+    # @raise [RuntimeError] if +token_type+ is not found
+    # @return [LinkedList<Token>] tokens exclusive of the final token_type
+    def until(token_type)
+      new_list = LinkedList.new.doubly_linked!
+      while token = @tokens.poll
+        if token.type?(token_type)
+          return new_list
+        else
+          new_list << token
+        end
+      end
+      raise "expected to consume tokens up to type[#{token_type.name}]"
+    end
+
     private
     def next_precedence
       token = peek

data/lib/ddql/postfix_null_type_operator.rb

@@ -2,8 +2,8 @@ module DDQL
   class PostfixNullTypeOperator < Operator
     attr_reader :pattern
 
-    def initialize(symbol, null_type, ordinal)
-      super("IS #{symbol}", "Is #{symbol}", :postfix, 9, false, :boolean, ordinal)
+    def initialize(symbol, null_type)
+      super("IS #{symbol}", "Is #{symbol}", :postfix, 9, false, :boolean)
       @null_type = null_type
       @pattern   = /IS\s+#{symbol}/
     end

data/lib/ddql/string_refinements.rb

@@ -1,6 +1,10 @@
 module DDQL
   module StringRefinements
     refine String do
+      def blank?
+        empty? || strip.empty?
+      end
+
       def squish
         self.dup.squish!
       end

data/lib/ddql/token.rb

@@ -1,13 +1,12 @@
 require 'forwardable'
 
 module DDQL
-  
   class Token
-    using StringRefinements
-
     attr_reader :data, :type
     attr_accessor :location
 
+    using ::DDQL::StringRefinements
+
     def initialize(data:, location: nil, type:)
       @data     = data
       @location = location
@@ -50,6 +49,11 @@ module DDQL
       type.parse(parser, self, expression: expression)
     end
 
+    def post_process(parser:, expression:)
+      raise "#{type} doesn't support post-processing" unless supports_post_processing?
+      type.post_process(parser: parser, expression: expression)
+    end
+
     def postfix?
       type.postfix?
     end
@@ -62,6 +66,10 @@ module DDQL
       type.simple_comparison?(data)
     end
 
+    def supports_post_processing?
+      type.supports_post_processing?
+    end
+
     def to_h
       type.as_hash(data)
     end
@@ -69,5 +77,9 @@ module DDQL
     def to_s
       "#{type.name} : #{data}"
     end
+
+    def type?(token_type)
+      token_type == type
+    end
   end
 end

data/lib/ddql/token_type.rb

@@ -1,13 +1,15 @@
 module DDQL
   class TokenType
-    using StringRefinements
-
     attr_reader :label, :name, :pattern
 
+    using ::DDQL::StringRefinements
+
     FACTOR_PATTERN = /\[[^\]]+\]/
+    NESTED_OPEN_PATTERN = '‹'
+    NESTED_CLOSE_PATTERN = '›'
 
     def self.all_types_pattern
-      Regexp.compile(ALL.map { |tt| "(?<#{tt.name}>#{tt.pattern})" }.join('|'))
+      @pattern ||= Regexp.compile(ALL.map { |tt| "(?<#{tt.name}>#{tt.pattern})" }.join('|'))
     end
 
     def initialize(name:, pattern:, &block)
@@ -19,16 +21,12 @@ module DDQL
       @value_transformer = block
     end
 
+    def ==(other)
+      name == other.name
+    end
+
     def as_hash(data)
-      # case name
-      # when :string_literal; {right: {string: data}}
-      # when :integer_literal; {right: {int: data}}
-      # when :numeric_literal, :sci_num_literal; {right: {float: data}}
-      # # when :lparen; {lstatement: data}
-      # when :rparen; Hash.new
-      # else
-        raise "subclass responsibility name[#{name}] data[#{data}]"
-      # end
+      raise "subclass responsibility name[#{name}] data[#{data}]"
     end
 
     def comparison?(data)
@@ -96,6 +94,10 @@ module DDQL
       self
     end
 
+    def supports_post_processing?
+      false
+    end
+
     def trimming!(range=(1..-2))
       @data_range = range
       self
@@ -110,7 +112,6 @@ module DDQL
       end
 
       def as_hash(data)
-        # {right: {data_type => data}}
         {data_type => data}
       end
 
@@ -125,7 +126,7 @@ module DDQL
 
     class Currency < Literal
       def initialize
-        super(name: :currency, pattern: /'(?!')(?<code>[A-Z]{3}):(\d+\.?\d+)'/)
+        super(name: :currency, pattern: /'(?!')(?<code>[A-Z]{3}):(\d+\.?\d*)'/)
         @value_transformer = lambda do |s|
           s = s.split(':', 2)
           {currency_code: s.first, currency_value: {float: s.last.to_f}}
@@ -133,14 +134,13 @@ module DDQL
       end
 
       def as_hash(data)
-        # {right: data}
         data
       end
     end
 
     class Integer < Literal
       def initialize
-        super(name: :integer, pattern: /'(?!')(?>[+-]?)(\d+)'/)
+        super(name: :integer, pattern: /'(?!['0])(?>[+-]?)(\d+)'/)
         @value_transformer = -> (s) { s.to_i }
       end
 
@@ -151,7 +151,7 @@ module DDQL
 
     class Numeric < Literal
       def initialize
-        super(name: :numeric, pattern: /'(?!')((?>[+-]?)(?>(?>\d+)(?>\.?)(?>\d*)|(?>\d*)(?>\.?)(?>\d+)))'/)
+        super(name: :numeric, pattern: /'((?!('|0\d)))((?>[+-]?)(?>(?>\d*)(?>\.?)(?>\d+)))'/)
         @value_transformer = -> (s) { s.to_f }
       end
 
@@ -162,7 +162,7 @@ module DDQL
 
     class ScientificNumeric < Literal
       def initialize
-        super(name: :sci_num, pattern: /'(?!')([+-]?\d(\.\d+)?[Ee][+-]?[^0]\d+)'/)
+        super(name: :sci_num, pattern: /'(?!('|0\d))([+-]?\d(\.\d+)?[Ee][+-]?\d+)'/)
         @value_transformer = -> (s) { s.to_f }
       end
 
@@ -192,6 +192,14 @@ module DDQL
         @value_transformer = -> (s) { s.gsub('\\', '') }
       end
 
+      def as_hash(data)
+        if data&.strip.each_byte.all? { |e| e == 0x30 }
+          Integer.new.as_hash(data.to_i)
+        else
+          super
+        end
+      end
+
       def data_type
         name
       end
@@ -206,7 +214,6 @@ module DDQL
       end
 
       def as_hash(data)
-        # {left: {name => data}}
         {name => data}
       end
 
@@ -229,9 +236,9 @@ module DDQL
         true
       end
 
-      def parse(parser, token, expression: nil)
+      def parse(parser, _token, expression: nil)
         new_expression = parser.parse
-        parser.consume TokenType::RPAREN #if parser.peek&.data == ')'
+        parser.consume TokenType::RPAREN
 
         if expression.nil?
           next_token = parser.peek
@@ -280,7 +287,7 @@ module DDQL
 
       def parse(parser, token, expression: nil)
         operator = Operators.instance.cache[token.op_data]
-        if expression.nil? && !operator.prefix?
+        if expression.nil? && !operator&.prefix?
           raise "expected op[#{operator&.name}] to be part of an expression"
         end
         operator.parse(parser, token, expression: expression)
@@ -291,6 +298,7 @@ module DDQL
       end
 
       protected
+
       def op_symbol(data)
         float_map_ops = Operators.float_map_ops
 
@@ -405,6 +413,28 @@ module DDQL
       end
     end
 
+    class NestedQuery < TokenType
+      def initialize
+        super(name: :nested_opener, pattern: Regexp.compile(Regexp.escape TokenType::NESTED_OPEN_PATTERN))
+        trimming!
+      end
+
+      def as_hash(data)
+        require 'pry'; binding.pry
+        {screen: data.split('#').last.to_i}
+      end
+
+      def expression?
+        true
+      end
+
+      def parse(parser, token, expression: nil)
+        require 'pry'; binding.pry
+        nested_parser = parser.class.from_tokens(parser.until(TokenType::NESTED_CLOSER))
+        nested_parser.parse
+      end
+    end
+
     class SubQuery < TokenType
       def initialize
         super(name: :lbrace, pattern: /\{/)
@@ -414,15 +444,12 @@ module DDQL
         true
       end
 
-      def parse(parser, token, expression: nil)
+      def parse(parser, _token, expression: nil)
         new_expression = parser.parse
-        if parser.peek&.type == TokenType::SUB_Q_GROUP
-          token = parser.consume TokenType::SUB_Q_GROUP
-          new_expression.merge!(token.parse(parser, expression: new_expression))
+        if parser.peek&.supports_post_processing?
+          _token, new_expression = parser.peek.post_process(parser: parser, expression: new_expression)
         end
 
-        parser.consume TokenType::RBRACE if parser.peek&.type == TokenType::RBRACE
-
         if expression.nil?
           next_token = parser.peek
           if next_token && (next_token.and? || next_token.or?)
@@ -438,9 +465,43 @@ module DDQL
       end
     end
 
+    class SubQueryAlias < TokenType
+      def initialize
+        super(name: :sub_query_alias, pattern: /AS\s+(?<sub_query_alias>#{FACTOR_PATTERN})/)
+        trimming!
+      end
+
+      def as_hash(data)
+        factor, desc = data.split(':', 2)
+        desc = factor unless desc
+        {name => {factor: factor, desc: desc}}
+      end
+
+      def parse(parser, token, expression: nil)
+        if expression.nil?
+          raise 'expected AS to be part of an ALIAS expression'
+        end
+        if expression && expression.key?(:sub_query_expression)
+          expression[:sub_query] = parser.class.parse(expression[:sub_query_expression])
+          expression.delete :sub_query_expression
+        end
+        expression.merge(as_hash(token.data))
+      end
+
+      def post_process(parser:, expression:)
+        token = parser.consume TokenType::SUB_Q_ALIAS
+        new_expression = expression.merge!(token.parse(parser, expression: expression))
+        [token, new_expression]
+      end
+
+      def supports_post_processing?
+        true
+      end
+    end
+
     class SubQueryExpression < TokenType
       def initialize
-        super(name: :sub_query_expression, pattern: /expression:\s*(?<sub_query_expression>[^\{\}]{5,})\s*,?\s*/)
+        super(name: :sub_query_expression, pattern: /expression:\s*(?<sub_query_expression>[^\{\}#{Regexp.escape(TokenType::NESTED_OPEN_PATTERN)}#{Regexp.escape(TokenType::NESTED_CLOSE_PATTERN)}]{5,})\s*,?\s*/)
       end
 
       def as_hash(data)
@@ -448,10 +509,16 @@ module DDQL
       end
 
       def parse(parser, token, expression: nil)
+        data = token.data.strip
+        if data.start_with? TokenType::NESTED_OPEN_PATTERN
+          sub_data = data[1..(data.index(TokenType::NESTED_CLOSE_PATTERN))]
+          data = parser.class.parse sub_data
+        end
+
         if expression.nil? || expression.keys != %i[agg sub_query_fields sub_query_type]
-          as_hash(token.data.strip).merge parser.parse
+          as_hash(data).merge parser.parse
         else
-          expression.merge(as_hash(token.data.strip))
+          expression.merge(as_hash(data))
         end
       end
     end
@@ -491,6 +558,16 @@ module DDQL
         end
         expression.merge(as_hash(token.data))
       end
+
+      def post_process(parser:, expression:)
+        token = parser.consume TokenType::SUB_Q_GROUP
+        new_expression = expression.merge!(token.parse(parser, expression: expression))
+        [token, new_expression]
+      end
+
+      def supports_post_processing?
+        true
+      end
     end
 
     class SubQueryType < TokenType
@@ -519,8 +596,19 @@ module DDQL
       def as_hash(_data)
         Hash.new
       end
+
+      def post_process(parser:, expression:)
+        token = parser.consume TokenType::RBRACE
+        [token, expression]
+      end
+
+      def supports_post_processing?
+        true
+      end
     end
 
+    NESTED_OPENER    = NestedQuery.new
+    NESTED_CLOSER    = new(name: :nested_closer, pattern: Regexp.compile(Regexp.escape TokenType::NESTED_CLOSE_PATTERN))
     LPAREN           = Group.new
     RPAREN           = new(name: :rparen, pattern: /(?=[^%])\)/)
     LBRACE           = SubQuery.new #new(name: :lbrace, pattern: /\{/)
@@ -539,7 +627,7 @@ module DDQL
     PREFIXOPERATOR   = PrefixOperator.new
     INFIXOPERATOR    = InfixOperator.new
     POSTFIXOPERATOR  = PostfixOperator.new
-    # QUERY            = Query.new
+    SUB_Q_ALIAS      = SubQueryAlias.new
     SUB_Q_EXPR       = SubQueryExpression.new
     SUB_Q_FIELDS     = SubQueryFields.new
     SUB_Q_GROUP      = SubQueryGrouping.new
@@ -547,15 +635,20 @@ module DDQL
     WHITESPACE       = new(name: :whitespace, pattern: /[\s]/).skipping!
 
     ALL = [
+      NESTED_OPENER,
+      NESTED_CLOSER,
       LPAREN,
       RPAREN,
       # LCAPTURE,
       # RCAPTURE,
+      # NESTED_OPENER,
+      # NESTED_CLOSER,
       LBRACE,
       RBRACE,
       SUB_Q_EXPR,
       SUB_Q_FIELDS,
       SUB_Q_TYPE,
+      SUB_Q_ALIAS,
       SUB_Q_GROUP,
       CURRENCY_LITERAL,
       SCI_NUM_LITERAL,
@@ -568,7 +661,6 @@ module DDQL
       PREFIXOPERATOR,
       INFIXOPERATOR,
       POSTFIXOPERATOR,
-      # QUERY, # TODO: do we need this?
       WHITESPACE,
     ]
   end