ddql 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82f78b8b46dd03069598a3945141114c781eef9da44a0f409d8a8ab3c6bae4b0
-  data.tar.gz: ec23e584baad9e0359c9471cf3002371863f888cf5cf718ef7cdeb6eb8291686
+  metadata.gz: '038be470281a3216e90884f9b14e2f30c087494906a79089d7dff5ea32bdd29a'
+  data.tar.gz: 812b0f99b1b1f2c84bddf6ebbe0abfeecdbdbfc47d036c3d65d5a0234b961f8d
 SHA512:
-  metadata.gz: 14f90543034d8fdd8813aad9db740efb95f11b9feb9ba17b0f23fd64b603cc7b804cde2fee516c95d11d593b0d57f219edee1d736246d5670e41afbd15c5ae1d
-  data.tar.gz: 62e76c1c990a1168a4510b56636a6ca9105d1720794e4535a07bd53c5742cd5f5710fcd21ace66ff3e39623d800a07bcf8ee6ac71a87a38650ecf9ce4ac57441
+  metadata.gz: c313fd79cb88f08c98af30190e24d52a66e05365c02e29a6c1900d77bef056443f3db18bf3e204b81bdcaa0cefb4e00b778cad159c53c3cee6b9d4ddc775d76b
+  data.tar.gz: ced003fd8bcd3fa2b7a9e828fa76d01e101109b9eca210778b9283e226004cc4803a17f15b763ab8659a3d07506add93d28be0078fd11c15e5c04f290dc10345

data/.gitignore

@@ -9,3 +9,5 @@
 
 # rspec failure tracking
 .rspec_status
+vendor
+spec/examples.txt

data/.travis.yml

@@ -2,6 +2,8 @@
 sudo: false
 language: ruby
 cache: bundler
+env:
+  - JRUBY_OPTS="-J-Xss8m"
 rvm:
   - 2.5
   - 2.6

data/Gemfile

@@ -2,3 +2,17 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in ddql.gemspec
 gemspec
+
+group :development do
+  platform :mri do
+    gem 'pry-byebug', '= 3.8.0'
+    # gem 'pry', '~> 0.11'
+  end
+
+  platform :jruby do
+    gem 'pry-debugger-jruby', '~> 1.2'
+    # gem 'pry', '0.11.3-java'
+  end
+
+  gem 'pry', '~> 0.10'
+end

data/Gemfile.lock

@@ -1,45 +1,57 @@
 PATH
   remote: .
   specs:
-    ddql (0.1.0)
-      parslet (~> 2.0)
+    ddql (1.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     byebug (11.1.3)
     coderay (1.1.3)
-    diff-lcs (1.3)
-    method_source (1.0.0)
-    parslet (2.0.0)
-    pry (0.13.1)
-      coderay (~> 1.1)
-      method_source (~> 1.0)
-    pry-byebug (3.9.0)
+    diff-lcs (1.4.4)
+    ffi (1.13.1-java)
+    method_source (0.9.2)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry (0.11.3-java)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+      spoon (~> 0.0)
+    pry-byebug (3.8.0)
       byebug (~> 11.0)
-      pry (~> 0.13.0)
+      pry (~> 0.10)
+    pry-debugger-jruby (1.2.1-java)
+      pry (>= 0.10, < 0.12)
+      ruby-debug-base (~> 0.10.4)
     rake (13.0.1)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.0)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.3)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    ruby-debug-base (0.10.6-java)
+    spoon (0.0.6)
+      ffi
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES
   bundler (~> 2.0)
   ddql!
-  pry-byebug (~> 3.9)
+  pry (~> 0.10)
+  pry-byebug (= 3.8.0)
+  pry-debugger-jruby (~> 1.2)
   rake (~> 13.0)
   rspec (~> 3.0)
 

data/README.md

@@ -1,5 +1,7 @@
 # DDQL
 
+[![Build Status](https://travis-ci.com/iss-lab/DDQL.svg?branch=master)](https://travis-ci.com/iss-lab/DDQL)
+
 A (Ruby) DataDesk query language parser written in Parslet.
 
 ## Installation

data/bin/console

@@ -7,10 +7,15 @@ require 'ddql'
 # with your gem easier. You can also use a different console, if you like.
 
 # (If you use this, don't forget to add pry to your Gemfile!)
-require 'pry'
+
 PARSER = DDQL::Parser.new
-puts 'Create a new instance of the parser or use the PARSER constant'
-Pry.start
 
-# require "irb"
-# IRB.start(__FILE__)
+begin
+  require 'pry'
+  puts 'Create a new instance of the parser or use the PARSER constant'
+  Pry.start
+rescue
+  require "irb"
+  puts 'Create a new instance of the parser or use the PARSER constant'
+  IRB.start(__FILE__)
+end

data/ddql.gemspec

@@ -27,10 +27,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "parslet", "~> 2.0"
-
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "pry-byebug", "~> 3.9"
 end

data/lib/ddql.rb

@@ -1,6 +1,13 @@
-require 'parslet'
-require 'ddql/parser'
 require 'ddql/version'
+require_relative 'ddql/linked_list'
+require_relative 'ddql/query_expression_error'
+require_relative 'ddql/lexer'
+require_relative 'ddql/operators'
+require_relative 'ddql/parser'
+require_relative 'ddql/string_refinements'
+require_relative 'ddql/token_type'
+require_relative 'ddql/token'
+
 
 module DDQL
   class ParseError < StandardError; end

data/lib/ddql/agg_operator.rb

@@ -0,0 +1,79 @@
+module DDQL
+  # +AggOperators+ return a Hash structure describing the type of aggregation, an optional
+  # expression (filter) to apply, an optional factor (field) against which the aggregation
+  # is applied, and the entity type for which the aggregation is applicable.
+  #
+  # ==== Examples
+  #    +SUM {type: IssuerPerson, fields: [SomeFactor], expression: [OtherFactor] == 'Value'}+
+  #
+  #      {
+  #        agg: {op_sum: 'SUM'},
+  #        sub_query_expression: "[OtherFactor] == 'Value'",
+  #        sub_query_fields: 'SomeFactor',
+  #        sub_query_type: 'IssuerPerson',
+  #      }
+  #
+  #    +CNT{type:Issuer, expression: [SomeFactor]} / CNT{type:Issuer, expression: [OtherFactor]}+
+  #
+  #      {
+  #        left: {
+  #           agg: {op_cnt: 'CNT'},
+  #           sub_query_fields: 'SomeFactor',
+  #           sub_query_type: 'Issuer',
+  #        },
+  #        op: {op_divide: '/'},
+  #        right: {
+  #           agg: {op_cnt: 'CNT'},
+  #           sub_query_fields: 'OtherFactor',
+  #           sub_query_type: 'Issuer',
+  #        },
+  #      }
+  #
+  #    +MAX{type:Case, expression: [SomeFactor]} > 5+
+  #
+  #      {
+  #        left: {
+  #           agg: {op_max: 'MAX'},
+  #           sub_query_fields: 'SomeFactor',
+  #           sub_query_type: 'Case',
+  #        },
+  #        op: {op_gt: '>'},
+  #        right: {int: 5},
+  #      }
+  class AggOperator < Operator
+    def initialize(symbol, name, return_type:, type: :prefix, precedence: 8, right: false)
+      super(symbol, name, type, precedence, right, return_type)
+    end
+
+    def parse(parser, token, expression: nil)
+      new_expression = parser.parse(precedence: precedence)
+      if expression
+        expression = expression.merge(new_expression)
+      else
+        expression = new_expression
+      end
+      expression.merge!(agg: {:"op_#{symbol.downcase}" => symbol})
+
+      if expression.key?(:op) && expression.key?(:right)
+        if expression[:left]&.empty?
+          expression.delete :left
+        end
+        op = expression.delete :op
+        right = expression.delete :right
+        {
+          left: expression,
+          op: op,
+          right: right,
+        }
+      elsif expression.key?(:yes_no_op)
+        yes_no = expression.delete :yes_no_op
+        {
+          left: expression,
+          yes_no_op: yes_no,
+        }
+      else
+        expression
+      end
+    end
+  end
+end

data/lib/ddql/coalesce_operator.rb

@@ -0,0 +1,26 @@
+module DDQL
+  class CoalesceOperator < AggOperator
+    def initialize
+      super("COALESCE", "Coalesce", return_type: :match)
+    end
+
+    def parse(parser, token, expression: nil)
+      new_expression = parser.parse(precedence: precedence)
+      if expression
+        expression = expression.merge(new_expression)
+      else
+        expression = new_expression
+      end
+
+      left_factor, right_factor = expression[:string].split('|', 2)
+      {
+        op_coalesce: {
+          factors: {
+            left_factor: {factor: left_factor},
+            right_factor: {factor: right_factor},
+          },
+        }
+      }
+    end
+  end
+end

data/lib/ddql/infix_float_map_operator.rb

@@ -0,0 +1,12 @@
+module DDQL
+  class InfixFloatMapOperator < Operator
+    attr_reader :comparison, :op_type, :op_symbol
+
+    def initialize(symbol, name, ordinal, op_type, comparison)
+      super(symbol, name, :infix, 4, false, :boolean, ordinal)
+      @op_type    = op_type
+      @comparison = comparison
+      @op_symbol  = :"op_float_map_#{op_type}_#{comparison}"
+    end
+  end
+end

data/lib/ddql/infix_string_map_operator.rb

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

data/lib/ddql/lexer.rb

@@ -0,0 +1,22 @@
+require_relative 'linked_list'
+
+module DDQL
+  class Lexer
+    def self.lex(expression, pattern: TokenType.all_types_pattern, available_types: TokenType::ALL)
+      tokens = LinkedList.new.doubly_linked!
+      md = pattern.match expression
+      while md
+        token_type = available_types.detect { |tt| tt.match?(match_data: md) }
+        if token_type
+          tokens << Token.new(
+            data: token_type.interpreted_data_from(match_data: md),
+            location: expression.length - md.string.length,
+            type: token_type,
+          )
+        end
+        md = pattern.match md.post_match
+      end
+      tokens
+    end
+  end
+end

data/lib/ddql/linked_list.rb

@@ -0,0 +1,171 @@
+module DDQL
+  class LinkedList
+    include Enumerable
+
+    class Node
+      attr_accessor :next, :previous
+      attr_reader   :value
+
+      def initialize(value)
+        @next     = nil
+        @previous = nil
+        @value    = value
+      end
+
+      def to_s
+        "Node[#{@value}]"
+      end
+    end
+
+    attr_reader :head, :size
+
+    def initialize(head=nil)
+      @doubly_linked = false
+      @head          = head
+      @size          = 0
+    end
+
+    def append(value)
+      if @head
+        tail = find_tail
+        tail.next = Node.new(value)
+        tail.next.previous = tail if @doubly_linked
+      else
+        @head = Node.new(value)
+      end
+      @size += 1
+    end
+    alias :<< :append
+
+    def append_after(target, value)
+      node           = find(target)
+      return unless node
+      old_next       = node.next
+      node.next      = Node.new(value)
+      node.next.next = old_next
+    end
+
+    def doubly_linked!
+      current = nil
+      each_node do |node|
+        node.previous = current
+        current = node
+      end
+      @doubly_linked = true
+      self
+    end
+
+    def doubly_linked?
+      @doubly_linked
+    end
+
+    def delete(value)
+      if value.is_a?(Node) && @head == value
+        @head = @head.next
+        value.next = value.previous = nil
+      elsif @head.value == value
+        node = @head.next
+        @head.next = @head.previous = nil
+        value = @head
+        @head = node
+      else
+        node = find_before(value)
+        node.next = node.next.next if node && node.next
+        node.next = node.previous = nil if node
+      end
+      @size -= 1
+      value
+    end
+
+    def each
+      return to_enum unless block_given?
+      node = @head
+      while node
+        yield node.value
+        node = node.next
+      end
+    end
+
+    def find(value)
+      node = @head
+      is_node = value.is_a?(Node)
+      return false if !node.next
+      return node  if (is_node && node == value) || node.value == value
+      while (node = node.next)
+        return node if (is_node && node == value) || node.value == value
+      end
+    end
+
+    def find_before(value)
+      node = @head
+      return false if !node.next
+
+      is_node = value.is_a?(Node)
+      if (is_node && node.next == value) || node.next.value == value
+        return node
+      end
+
+      while (node = node.next)
+        if (is_node && node.next == value) || node.next.value == value
+          return node
+        end
+      end
+    end
+
+    def find_tail
+      node = @head
+      return node if !node.next
+      return node if !node.next while (node = node.next)
+    end
+    alias :tail :find_tail
+
+    def peek
+      return nil unless @head
+      @head.value
+    end
+
+    def poll
+      return nil unless @head
+      previous_head = @head
+      @head = previous_head.next
+      @size -= 1
+      @head.previous = nil if @head
+      previous_head.next = nil
+      previous_head.value
+    end
+
+    def print(stream=STDOUT)
+      node = @head
+      prefix = ''
+      postfix = ''
+      stream.print "(size: #{size}) "
+      while node
+        postfix = "\n⨂" unless node.next
+        stream.print prefix
+        stream.print node
+        stream.print postfix
+        stream.print "\n"
+        node = node.next
+        prefix = '  ⤿  ' if node
+      end
+    end
+
+    def singly_linked!
+      each_node do |node|
+        node.previous = nil
+      end
+      @doubly_linked = false
+      self
+    end
+
+    private
+    def each_node
+      raise 'requires a block' unless block_given?
+      node = @head
+      while node
+        yield node
+        node = node.next
+      end
+    end
+  end
+end