sqliterate 0.1.1 → 0.1.2

data/lib/sqliterate/grammar/expression.treetop

@@ -7,6 +7,61 @@ module SQLiterate
     include Operator
 
     rule scalar_expression
+      disjunction_expression
+    end
+
+    rule disjunction_expression
+      e:conjunction_expression r:( space or_kw space e:conjunction_expression )*
+      <Node::DisjunctionExpression>
+    end
+
+    rule conjunction_expression
+      e:negation_expression r:( space and_kw space e:negation_expression )*
+      <Node::ConjunctionExpression>
+    end
+
+    rule negation_expression
+      not_kw space e:equality_expression <Node::NegationExpression>
+      /
+      equality_expression
+    end
+
+    rule equality_expression
+      e:between_expression r:( space '=' space e:between_expression )*
+      <Node::EqualityExpression>
+    end
+
+    rule between_expression
+      e:set_predicate_expression r:( space
+        ( not_kw space )? between_kw space ( symmetric_kw space )?
+        l:set_predicate_expression space and_kw space
+        r:set_predicate_expression
+      )*
+      <Node::BetweenExpression>
+    end
+
+    rule set_predicate_expression
+      exists_expression
+      /
+      e:test_expression space set_predicate_operator space
+      '(' space query_expression space ')'
+      <Node::SetPredicateExpression>
+      /
+      test_expression
+    end
+
+    rule exists_expression
+      exists_kw space '(' space query_expression space ')'
+      <Node::ExistsExpression>
+    end
+
+    rule test_expression
+      l:gen_expression space binary_test_operator space r:gen_expression
+      <Node::TestExpression::Binary>
+      /
+      e:gen_expression space unary_test_operator
+      <Node::TestExpression::Unary>
+      /
       gen_expression
     end
 
@@ -21,13 +76,34 @@ module SQLiterate
     rule gen_value
       literal_value <Node::GenValue::Literal>
       /
-      function_call <Node::GenValue::Function>
+      function_call
       /
       field_selection r:( space '['
         space range_expression space
       ']' )+ <Node::GenValue::Subscript>
       /
-      field_selection <Node::GenValue::Field>
+      field_selection
+      /
+      case_expression
+    end
+
+    rule case_expression
+      case_kw required_space
+      case_when_section r:( space case_when_section )* space
+      case_else_section space
+      end_kw
+      <Node::CaseExpression>
+    end
+
+    rule case_when_section
+      when_kw required_space w:scalar_expression space
+      then_kw required_space t:scalar_expression
+      <Node::CaseWhenSection>
+    end
+
+    rule case_else_section
+      ( else_kw required_space scalar_expression / space )
+      <Node::CaseElseSection>
     end
 
     rule function_call
@@ -77,12 +153,19 @@ module SQLiterate
     end
 
     rule order_by_clause
-      ( order_by_kw space expressions_list space ordering_specifier / space )
-      <Node::OrderByClause>
+      ( order_by_kw required_space sort_expressions_list / space ) <Node::OrderByClause>
+    end
+
+    rule sort_expressions_list
+      sort_expression r:( space ',' space sort_expression)* <Node::SortExpressionsList>
+    end
+
+    rule sort_expression
+      scalar_expression space ordering_specifier <Node::SortExpression>
     end
 
     rule expressions_list
-      gen_expression r:( space ',' space gen_expression)* <Node::ExpressionsList>
+      scalar_expression r:( space ',' space scalar_expression)* <Node::ExpressionsList>
     end
 
     rule range_expression
@@ -102,9 +185,9 @@ module SQLiterate
     end
 
     rule row_value
-      '(' query_expression ')' <Node::RowValue::Query>
+      '(' space query_expression space ')' <Node::RowValue::Query>
       /
-      '(' space gen_expression space ')' <Node::RowValue::Expression>
+      '(' space scalar_expression space ')' <Node::RowValue::Expression>
       /
       positional_param <Node::RowValue::Positional>
       /
@@ -155,7 +238,7 @@ module SQLiterate
     end
 
     rule named_expression
-      gen_expression ( space (as_kw space)? column_name )? <Node::NamedExpression>
+      scalar_expression ( space (as_kw space)? column_name )? <Node::NamedExpression>
     end
 
     rule table_reference
@@ -173,19 +256,20 @@ module SQLiterate
     end
 
     rule from_clause
-      (from_kw required_space table_references / space) <Node::FromClause>
+      ( from_kw required_space table_references / space ) <Node::FromClause>
     end
 
     rule where_clause
-      where_kw required_space scalar_expression / space
+      ( where_kw required_space scalar_expression / space ) <Node::WhereClause>
     end
 
     rule group_by_clause
-      group_by_kw required_space expressions_list space having_clause / space
+      ( group_by_kw required_space expressions_list space having_clause / space )
+      <Node::GroupByClause>
     end
 
     rule having_clause
-      having_kw required_space scalar_expression / space
+      ( having_kw required_space scalar_expression / space ) <Node::HavingClause>
     end
 
     rule table_references

data/lib/sqliterate/grammar/keywords.treetop

@@ -10,7 +10,9 @@ module SQLiterate
       bigint_kw / boolean_kw / double_kw / float_kw / int_kw / real_kw /
       smallint_kw / string_kw / timestamp_kw / tinyint_kw / integer_kw /
       group_kw / having_kw / nulls_kw / first_kw / last_kw / union_kw /
-      intersect_kw / except_kw / limit_kw / offset_kw
+      intersect_kw / except_kw / limit_kw / offset_kw /
+      case_kw / when_kw / then_kw / else_kw / end_kw / symmetric_kw /
+      unknown_kw / exists_kw / any_kw / some_kw
     end
 
     rule type_name
@@ -259,5 +261,45 @@ module SQLiterate
     rule offset_kw
       [oO] [fF] [fF] [sS] [eE] [tT] kw_sep
     end
+
+    rule case_kw
+      [cC] [aA] [sS] [eE] kw_sep
+    end
+
+    rule when_kw
+      [wW] [hH] [eE] [nN] kw_sep
+    end
+
+    rule then_kw
+      [tT] [hH] [eE] [nN] kw_sep
+    end
+
+    rule else_kw
+      [eE] [lL] [sS] [eE] kw_sep
+    end
+
+    rule end_kw
+      [eE] [nN] [dD] kw_sep
+    end
+
+    rule symmetric_kw
+      [sS] [yY] [mM] [mM] [eE] [tT] [rR] [iI] [cC] kw_sep
+    end
+
+    rule unknown_kw
+      [uU] [nN] [kK] [nN] [oO] [wW] [nN] kw_sep
+    end
+
+    rule exists_kw
+      [eE] [xX] [iI] [sS] [tT] [sS] kw_sep
+    end
+
+    rule any_kw
+      [aA] [nN] [yY] kw_sep
+    end
+
+    rule some_kw
+      [sS] [oO] [mM] [eE] kw_sep
+    end
   end
 end

data/lib/sqliterate/grammar/operator.treetop

@@ -5,16 +5,14 @@ module SQLiterate
     include Keywords
 
     rule gen_operator
-      symbol_operator / keyword_operator
-    end
-
-    rule keyword_operator
-      ( and_kw / or_kw / not_kw ) <Node::KeywordOperator>
+      symbol_operator
     end
 
     rule symbol_operator
       sign_ending_operator
       /
+      comparison_operator
+      /
       nonsign_ending_operator
       /
       ambiguous_operator
@@ -22,10 +20,6 @@ module SQLiterate
       single_char_operator
     end
 
-    rule single_char_operator
-      c:op_char <Node::SingleCharOperator>
-    end
-
     rule sign_ending_operator
       b:( r:( basic_op_char !special_op_char )* basic_op_char )? special_op_char
       o:( r:( op_char !(sign_op_char !op_char) )* op_char )? sign_op_char !op_char
@@ -33,15 +27,22 @@ module SQLiterate
     end
 
     rule nonsign_ending_operator
+      !comparison_operator
       r:( op_char !(nonsign_op_char !op_char) )* op_char nonsign_op_char !op_char
       <Node::NonsignEndingOperator>
     end
 
     rule ambiguous_operator
+      !comparison_operator
       r:( op_char !(sign_op_char !op_char) )* op_char
       <Node::AmbiguousOperator>
     end
 
+    rule single_char_operator
+      !comparison_operator
+      c:op_char <Node::SingleCharOperator>
+    end
+
     rule sign_op_char
       c:[+\-] comment* <Node::OperatorChar>
     end
@@ -61,5 +62,34 @@ module SQLiterate
     rule op_char
       c:[+\-*/<>=~!@#%^&|`?] comment* <Node::OperatorChar>
     end
+
+    rule comparison_operator
+      o:( '>=' / '<=' / '<>' / '!=' / '=' / '>' / '<' ) comment* !nonsign_op_char
+      <Node::ComparisonOperator>
+    end
+
+    rule binary_test_operator
+      is_kw space ( not_kw space )? distinct_kw space from_kw
+    end
+
+    rule unary_test_operator
+      is_kw space ( not_kw space )? null_kw
+      /
+      isnull_kw
+      /
+      notnull_kw
+      /
+      is_kw space ( not_kw space )? true_kw
+      /
+      is_kw space ( not_kw space )? false_kw
+      /
+      is_kw space ( not_kw space )? unknown_kw
+    end
+
+    rule set_predicate_operator
+      ( not_kw space )? in_kw
+      /
+      comparison_operator space ( any_kw / some_kw / all_kw )
+    end
   end
 end

data/lib/sqliterate/node/control/expression.rb

@@ -1,5 +1,62 @@
 module SQLiterate
   module Node
+    module DisjunctionExpression
+      def tables
+        e.tables + r.elements.flat_map { |e| e.e.tables }
+      end
+    end
+
+    module ConjunctionExpression
+      def tables
+        e.tables + r.elements.flat_map { |e| e.e.tables }
+      end
+    end
+
+    module NegationExpression
+      def tables
+        e.tables
+      end
+    end
+
+    module EqualityExpression
+      def tables
+        e.tables + r.elements.flat_map { |e| e.e.tables }
+      end
+    end
+
+    module BetweenExpression
+      def tables
+        e.tables + r.elements.flat_map do |e|
+          e.l.tables + e.r.tables
+        end
+      end
+    end
+
+    module SetPredicateExpression
+      def tables
+        e.tables + query_expression.tables
+      end
+    end
+
+    module ExistsExpression
+      def tables
+        query_expression.tables
+      end
+    end
+
+    module TestExpression
+      module Binary
+        def tables
+          l.tables + r.tables
+        end
+      end
+      module Unary
+        def tables
+          e.tables
+        end
+      end
+    end
+
     module GenExpression
       def tables
         gen_value.tables + r.elements.flat_map { |e| e.gen_value.tables }
@@ -21,6 +78,27 @@ module SQLiterate
       end
     end
 
+    module CaseExpression
+      def tables
+        case_else_section.tables + \
+        case_when_section.tables + r.elements.flat_map do |e|
+          e.case_when_section.tables
+        end
+      end
+    end
+
+    module CaseWhenSection
+      def tables
+        w.tables + t.tables
+      end
+    end
+
+    module CaseElseSection
+      def tables
+        respond_to?(:scalar_expression) ? scalar_expression.tables : []
+      end
+    end
+
     module FunctionCall
       def tables
         function_params.tables
@@ -47,14 +125,28 @@ module SQLiterate
 
     module OrderByClause
       def tables
-        respond_to?(:expressions_list) ? expressions_list.tables : []
+        respond_to?(:sort_expressions_list) ? sort_expressions_list.tables : []
+      end
+    end
+
+    module SortExpressionsList
+      def tables
+        sort_expression.tables + r.elements.flat_map do |e|
+          e.sort_expression.tables
+        end
+      end
+    end
+
+    module SortExpression
+      def tables
+        scalar_expression.tables
       end
     end
 
     module ExpressionsList
       def tables
-        gen_expression.tables + r.elements.flat_map do |e|
-          e.gen_expression.tables
+        scalar_expression.tables + r.elements.flat_map do |e|
+          e.scalar_expression.tables
         end
       end
     end
@@ -69,7 +161,7 @@ module SQLiterate
 
     module NamedExpression
       def tables
-        gen_expression.tables
+        scalar_expression.tables
       end
     end
 
@@ -99,7 +191,7 @@ module SQLiterate
       end
       module Expression
         def tables
-          gen_expression.tables
+          scalar_expression.tables
         end
       end
       module Identifier
@@ -127,13 +219,13 @@ module SQLiterate
 
     module SelectQuery
       def tables
-        select_list.tables + table_expression.tables
+        select_list.tables + table_expression.tables + order_by_clause.tables
       end
     end
 
     module TableExpression
       def tables
-        from_clause.tables
+        from_clause.tables + where_clause.tables + group_by_clause.tables
       end
     end
 
@@ -143,6 +235,28 @@ module SQLiterate
       end
     end
 
+    module WhereClause
+      def tables
+        respond_to?(:scalar_expression) ? scalar_expression.tables : []
+      end
+    end
+
+    module GroupByClause
+      def tables
+        if respond_to?(:expressions_list)
+          expressions_list.tables + having_clause.tables
+        else
+          []
+        end
+      end
+    end
+
+    module HavingClause
+      def tables
+        respond_to?(:scalar_expression) ? scalar_expression.tables : []
+      end
+    end
+
     module TableReferences
       def tables
         table_joins.tables + r.elements.flat_map { |e| e.table_joins.tables }

data/lib/sqliterate/node/evaluate/expression.rb

@@ -1,5 +1,78 @@
 module SQLiterate
   module Node
+    module DisjunctionExpression
+      def value
+        if r.empty?
+          e.value
+        else
+          [:or, e.value ] + r.elements.flat_map { |e| e.e.value }
+        end
+      end
+    end
+
+    module ConjunctionExpression
+      def value
+        if r.empty?
+          e.value
+        else
+          [:and, e.value ] + r.elements.flat_map { |e| e.e.value }
+        end
+      end
+    end
+
+    module NegationExpression
+      def value
+        [:not, e.value]
+      end
+    end
+
+    module EqualityExpression
+      def value
+        if r.empty?
+          e.value
+        else
+          [:eq, e.value ] + r.elements.flat_map { |e| e.e.value }
+        end
+      end
+    end
+
+    module BetweenExpression
+      def value
+        if r.empty?
+          e.value
+        else
+          [:b, gen_expression.value] + r.elements.flat_map do |e|
+            [e.l.value, e.r.value]
+          end
+        end
+      end
+    end
+
+    module SetPredicateExpression
+      def value
+        [:set, e.value, query_expression.value]
+      end
+    end
+
+    module ExistsExpression
+      def value
+        [:exists, query_expression.value]
+      end
+    end
+
+    module TestExpression
+      module Binary
+        def value
+          [:test, l.value, r.value]
+        end
+      end
+      module Unary
+        def value
+          [:test, e.value]
+        end
+      end
+    end
+
     module GenExpression
       def value
         h.elements.map { |e| e.gen_operator.operator } +
@@ -12,10 +85,6 @@ module SQLiterate
     end
 
     module GenValue
-      module Literal
-      end
-      module Function
-      end
       module Subscript
         def value
           [:s, field_selection.value] + r.elements.map do |e|
@@ -23,8 +92,6 @@ module SQLiterate
           end
         end
       end
-      module Field
-      end
     end
 
     module FunctionCall
@@ -59,8 +126,8 @@ module SQLiterate
 
     module ExpressionsList
       def value
-        [gen_expression.value] + r.elements.map do |e|
-          e.gen_expression.value
+        [scalar_expression.value] + r.elements.map do |e|
+          e.scalar_expression.value
         end
       end
     end
@@ -76,9 +143,9 @@ module SQLiterate
     module NamedExpression
       def value
         if respond_to?(:column_name)
-          [column_name.name, gen_expression.value]
+          [column_name.name, scalar_expression.value]
         else
-          gen_expression.value
+          scalar_expression.value
         end
       end
     end
@@ -109,7 +176,7 @@ module SQLiterate
       end
       module Expression
         def value
-          gen_expression.value
+          scalar_expression.value
         end
       end
       module Positional

data/lib/sqliterate/node/evaluate/operator.rb

@@ -1,11 +1,5 @@
 module SQLiterate
   module Node
-    module KeywordOperator
-      def operator
-        text_value.to_sym
-      end
-    end
-
     module OperatorChar
       def char
         c.text_value
@@ -47,5 +41,11 @@ module SQLiterate
         ( r.elements.map { |e| e.op_char.char } + [op_char.char] ).join.to_sym
       end
     end
+
+    module ComparisonOperator
+      def operator
+        o.text_value.to_sym
+      end
+    end
   end
 end

data/lib/sqliterate/version.rb

@@ -1,3 +1,3 @@
 module SQLiterate
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sqliterate
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -121,7 +121,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 382804920443655143
+      hash: 2802900881270778442
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -130,7 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 382804920443655143
+      hash: 2802900881270778442
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23