alf-sql 0.15.0

data/lib/alf/sql/grammar.sexp.yml

@@ -0,0 +1,92 @@
+rules:
+  query:
+    - with_exp
+    - nonjoin_exp
+  with_exp:
+    - [ with_spec, nonjoin_exp ]
+  with_spec:
+    - [ name_intro+ ]
+  name_intro:
+    - [ table_name, nonjoin_exp ]
+  nonjoin_exp:
+    - union
+    - except
+    - intersect
+    - select_exp
+  union:
+    - [ all, nonjoin_exp, nonjoin_exp ]
+  all:
+    - truth_value
+  except:
+    - [ set_quantifier, nonjoin_exp, nonjoin_exp ]
+  intersect:
+    - [ set_quantifier, nonjoin_exp, nonjoin_exp ]
+  join_exp:
+    - cross_join
+    - inner_join
+  cross_join:
+    - [ table_spec, table_spec ]
+  inner_join:
+    - [ table_spec, table_spec, predicate ]
+  using:
+    - [ column_name+ ]
+  select_exp:
+    - [ set_quantifier,
+        [ select_list, select_star ],
+        from_clause,
+        where_clause,
+        order_by_clause,
+        limit_clause,
+        offset_clause ]
+  set_quantifier:
+    - [ set_quantifier_name ]
+  select_star:
+    - []
+  set_quantifier_name:
+    !ruby/regexp /^all|distinct$/
+  select_list:
+    - [ select_item+ ]
+  from_clause:
+    - [ table_spec ]
+  where_clause:
+    - [ predicate ]
+  order_by_clause:
+    - [ order_by_term+ ]
+  order_by_term:
+    - [ qualified_name, direction ]
+  direction:
+    !ruby/regexp /^asc|desc$/
+  select_item:
+    - [ scalar_exp, column_name ]
+  table_spec:
+    - table_as
+    - subquery_as
+    - join_exp
+  table_as:
+    - [ table_name, range_var_name ]
+  subquery_as:
+    - [ nonjoin_exp, range_var_name ]
+  scalar_exp:
+    - qualified_name
+    - column_name
+    - literal
+  qualified_name:
+    - [ range_var_name, column_name ]
+  column_name:
+    - [ name_rgx ]
+  table_name:
+    - [ name_rgx ]
+  range_var_name:
+    - [ name_rgx ]
+  limit_clause:
+    - [ integer ]
+  offset_clause:
+    - [ integer ]
+  integer:
+    - "::Integer"
+  literal:
+    - "::Object"
+  name_rgx:
+    !ruby/regexp /^[a-zA-Z0-9_]+$/
+  truth_value:
+    "::Alf::Boolean"

data/lib/alf/sql/loader.rb

@@ -0,0 +1,2 @@
+require "alf-core"
+require "sexpr"

data/lib/alf/sql/nodes/column_name.rb

@@ -0,0 +1,25 @@
+module Alf
+  module Sql
+    module ColumnName
+      include Expr
+
+      def qualifier
+        nil
+      end
+
+      def as_name
+        last
+      end
+
+      def would_be_name
+        last
+      end
+
+      def to_sql(buffer = "")
+        buffer << last
+        buffer
+      end
+
+    end # module ColumnName
+  end # module Sql
+end # module Alf

data/lib/alf/sql/nodes/cross_join.rb

@@ -0,0 +1,28 @@
+module Alf
+  module Sql
+    module CrossJoin
+      include Expr
+
+      def join?
+        true
+      end
+
+      def left
+        self[1]
+      end
+
+      def right
+        self[2]
+      end
+
+      def to_sql(buffer = "")
+        each_child do |child, index|
+          buffer << COMMA << SPACE unless index == 0
+          child.to_sql(buffer)
+        end
+        buffer
+      end
+
+    end # module CrossJoin
+  end # module Sql
+end # module Alf

data/lib/alf/sql/nodes/except.rb

@@ -0,0 +1,14 @@
+module Alf
+  module Sql
+    module Except
+      include SetOperator
+
+      EXCEPT = "EXCEPT".freeze
+
+      def keyword
+        EXCEPT
+      end
+
+    end # module Except
+  end # module Sql
+end # module Alf

data/lib/alf/sql/nodes/expr.rb

@@ -0,0 +1,90 @@
+module Alf
+  module Sql
+    module Expr
+
+      LEFT_PARENTHESE  = "(".freeze
+      RIGHT_PARENTHESE = ")".freeze
+      SPACE            = " ".freeze
+      COMMA            = ",".freeze
+      DOT              = ".".freeze
+      QUOTE            = "'".freeze
+      AS               = "AS".freeze
+      AND              = "AND".freeze
+      OR               = "OR".freeze
+      NOT              = "NOT".freeze
+      TRUE             = "TRUE".freeze
+      FALSE            = "FALSE".freeze
+      EQUAL            = "=".freeze
+      NOT_EQUAL        = "<>".freeze
+      GREATER          = ">".freeze
+      LESS             = "<".freeze
+      GREATER_OR_EQUAL = ">=".freeze
+      LESS_OR_EQUAL    = "<=".freeze
+      IN               = "IN".freeze
+      EXISTS           = "EXISTS".freeze
+
+      def set_operator?
+        false
+      end
+
+      def limit_or_offset?
+        not(limit_clause.nil? and offset_clause.nil?)
+      end
+
+      def join?
+        false
+      end
+
+      def ordering
+        obc = order_by_clause
+        obc && order_by_clause.to_ordering
+      end
+
+      def with_update(index, what)
+        index = find_child_index(index) if index.is_a?(Symbol)
+        dup.tap{|x| x[index] = Grammar.sexpr(what) }
+      end
+
+      def with_insert(index, what)
+        dup.tap{|x| x.insert(index, Grammar.sexpr(what)) }
+      end
+
+      def with_push(*sexprs)
+        dup.push(*sexprs)
+      end
+
+      def each_child(skip = 0)
+        each_with_index do |c,i|
+          next if i <= skip
+          yield(c, i - 1)
+        end
+      end
+
+    private
+
+      def find_child(kind = nil, &search)
+        if search.nil? and kind
+          search = ->(x){ x.is_a?(Array) && x.first == kind }
+        end
+        each_child do |child|
+          return child if search.call(child)
+        end
+        nil
+      end
+
+      def find_child_index(kind)
+        each_with_index do |child,index|
+          return index if child.is_a?(Array) && child.first == kind
+        end
+        nil
+      end
+
+      def sql_parenthesized(buffer)
+        buffer << LEFT_PARENTHESE
+        yield(buffer)
+        buffer << RIGHT_PARENTHESE
+      end
+
+    end # module Expr
+  end # module Sql
+end # module Alf

data/lib/alf/sql/nodes/from_clause.rb

@@ -0,0 +1,24 @@
+module Alf
+  module Sql
+    module FromClause
+      include Expr
+
+      FROM = "FROM".freeze
+
+      def table_spec
+        last
+      end
+
+      def join?
+        table_spec.join?
+      end
+
+      def to_sql(buffer = "")
+        buffer << FROM << SPACE
+        last.to_sql(buffer)
+        buffer
+      end
+
+    end # module FromClause
+  end # module Sql
+end # module Alf

data/lib/alf/sql/nodes/inner_join.rb

@@ -0,0 +1,37 @@
+module Alf
+  module Sql
+    module InnerJoin
+      include Expr
+
+      INNER = "INNER".freeze
+      JOIN  = "JOIN".freeze
+      ON    = "ON".freeze
+
+      def join?
+        true
+      end
+
+      def left
+        self[1]
+      end
+
+      def right
+        self[2]
+      end
+
+      def predicate
+        last
+      end
+
+      def to_sql(buffer = "")
+        left.to_sql(buffer)
+        buffer << SPACE << JOIN << SPACE
+        right.to_sql(buffer)
+        buffer << SPACE << ON << SPACE
+        predicate.to_sql(buffer)
+        buffer
+      end
+
+    end # module InnerJoin
+  end # module Sql
+end # module Alf

data/lib/alf/sql/nodes/intersect.rb

@@ -0,0 +1,14 @@
+module Alf
+  module Sql
+    module Intersect
+      include SetOperator
+
+      INTERSECT = "INTERSECT".freeze
+
+      def keyword
+        INTERSECT
+      end
+
+    end # module Intersect
+  end # module Sql
+end # module Alf

data/lib/alf/sql/nodes/limit_clause.rb

@@ -0,0 +1,19 @@
+module Alf
+  module Sql
+    module LimitClause
+      include Expr
+
+      LIMIT = "LIMIT"
+
+      def limit
+        last.to_i
+      end
+
+      def to_sql(buffer = "")
+        buffer << LIMIT << SPACE << limit.to_s
+        buffer
+      end
+
+    end # module LimitClause
+  end # module Sql
+end # module Alf

data/lib/alf/sql/nodes/literal.rb

@@ -0,0 +1,18 @@
+module Alf
+  module Sql
+    module Literal
+      include Expr
+      include Alf::Predicate::Expr
+
+      def would_be_name
+        nil
+      end
+
+      def to_sql(buffer = "")
+        to_sql_literal(buffer, last)
+        buffer
+      end
+
+    end # module Literal
+  end # module Sql
+end # module Alf

data/lib/alf/sql/nodes/name_intro.rb

@@ -0,0 +1,23 @@
+module Alf
+  module Sql
+    module NameIntro
+      include Expr
+
+      def table_name
+        self[1]
+      end
+
+      def subquery
+        self[2]
+      end
+
+      def to_sql(buffer = "")
+        table_name.to_sql(buffer)
+        buffer << SPACE << AS << SPACE
+        subquery.to_sql(buffer, true)
+        buffer
+      end
+
+    end # module WithSpec
+  end # module Sql
+end # module Alf

data/lib/alf/sql/nodes/offset_clause.rb

@@ -0,0 +1,19 @@
+module Alf
+  module Sql
+    module OffsetClause
+      include Expr
+
+      OFFSET = "OFFSET"
+
+      def offset
+        last.to_i
+      end
+
+      def to_sql(buffer = "")
+        buffer << OFFSET << SPACE << offset.to_s
+        buffer
+      end
+
+    end # module OffsetClause
+  end # module Sql
+end # module Alf

data/lib/alf/sql/nodes/order_by_clause.rb

@@ -0,0 +1,25 @@
+module Alf
+  module Sql
+    module OrderByClause
+      include Expr
+
+      ORDER_BY = "ORDER BY".freeze
+
+      def to_ordering
+        @ordering ||= Ordering.new(sexpr_body.map{|x|
+          [x.as_name, x.direction]
+        })
+      end
+
+      def to_sql(buffer = "")
+        buffer << ORDER_BY << SPACE
+        each_child do |item,index|
+          buffer << COMMA << SPACE unless index == 0
+          item.to_sql(buffer)
+        end
+        buffer
+      end
+
+    end # module OrderByClause
+  end # module Sql
+end # module Alf