alf-sql 0.15.0

data/lib/alf/predicate/nodes/neq.rb

@@ -0,0 +1,11 @@
+module Alf
+  class Predicate
+    module Neq
+
+      def to_sql_operator
+        Sql::Expr::NOT_EQUAL
+      end
+
+    end
+  end
+end

data/lib/alf/predicate/nodes/not.rb

@@ -0,0 +1,14 @@
+module Alf
+  class Predicate
+    module Not
+
+      def to_sql(buffer)
+        buffer << Sql::Expr::NOT << Sql::Expr::LEFT_PARENTHESE
+        last.to_sql(buffer)
+        buffer << Sql::Expr::RIGHT_PARENTHESE
+        buffer
+      end
+
+    end
+  end
+end

data/lib/alf/predicate/nodes/or.rb

@@ -0,0 +1,11 @@
+module Alf
+  class Predicate
+    module Or
+
+      def to_sql_operator
+        Sql::Expr::OR
+      end
+
+    end
+  end
+end

data/lib/alf/predicate/nodes/qualified_identifier.rb

@@ -0,0 +1,12 @@
+module Alf
+  class Predicate
+    module QualifiedIdentifier
+
+      def to_sql(buffer = "")
+        buffer << qualifier.to_s << Sql::Expr::DOT << name.to_s
+        buffer
+      end
+
+    end
+  end
+end

data/lib/alf/predicate/nodes/tautology.rb

@@ -0,0 +1,12 @@
+module Alf
+  class Predicate
+    module Tautology
+
+      def to_sql(buffer)
+        buffer << Sql::Expr::TRUE
+        buffer
+      end
+
+    end
+  end
+end

data/lib/alf/sql.rb

@@ -0,0 +1,15 @@
+require_relative 'predicate/nodes'
+require_relative 'algebra/operand'
+
+require_relative 'sql/version'
+require_relative 'sql/loader'
+module Alf
+  module Sql
+
+  end # module Sql
+end # module Alf
+require_relative 'sql/grammar'
+require_relative 'sql/processor'
+require_relative 'sql/cog'
+require_relative 'sql/builder'
+require_relative 'sql/compiler'

data/lib/alf/sql/builder.rb

@@ -0,0 +1,152 @@
+module Alf
+  module Sql
+    class Builder
+
+      DISTINCT     = Grammar.sexpr([:set_quantifier, "distinct"])
+      ALL          = Grammar.sexpr([:set_quantifier, "all"])
+      IS_TABLE_DEE = Grammar.sexpr([:select_list,
+                                     [:select_item,
+                                       [:literal, true],
+                                       [:column_name, "is_table_dee"]]])
+      SELECT_STAR  = Grammar.sexpr([:select_star])
+
+      def self.builder(meth)
+        old = instance_method(meth)
+        define_method(meth) do |*args, &bl|
+          Grammar.sexpr(old.bind(self).call(*args, &bl))
+        end
+      end
+
+      def initialize(start = 0)
+        @next_qualifier = (start || 0)
+      end
+
+      def distinct
+        DISTINCT
+      end
+      builder :distinct
+
+      def all
+        ALL
+      end
+      builder :all
+
+      def name_intro(name, sexpr)
+        [:name_intro, table_name(name), sexpr]
+      end
+      builder :name_intro
+
+      def select_all(heading, name, qualifier = next_qualifier!)
+        [ :select_exp, all,
+          select_list(heading, qualifier),
+          from_clause(name, qualifier) ]
+      end
+      builder :select_all
+
+      def select_is_table_dee(subquery)
+        [ :select_exp, all, is_table_dee,
+          [:where_clause, exists(subquery)] ]
+      end
+      builder :select_is_table_dee
+
+      def is_table_dee
+        IS_TABLE_DEE
+      end
+      builder :is_table_dee
+
+      def select_list(heading, qualifier)
+        attrs = heading.to_attr_list.to_a
+        attrs.map{|a| select_item(qualifier, a) }.unshift(:select_list)
+      end
+      builder :select_list
+
+      def select_item(qualifier, name, as = name)
+        [:select_item,
+          qualified_name(qualifier, name.to_s),
+          column_name(as.to_s)]
+      end
+      builder :select_item
+
+      def select_star
+        SELECT_STAR
+      end
+      builder :select_star
+
+      def from_clause(table_name, qualifier)
+        [:from_clause,
+          table_as(table_name, qualifier) ]
+      end
+      builder :from_clause
+
+      def table_as(table, qualifier)
+        table = case table
+                when String, Symbol then table_name(table)
+                else table
+                end
+        [:table_as,
+          table,
+          range_var_name(qualifier) ]
+      end
+      builder :table_as
+
+      def qualified_name(qualifier, name)
+        [:qualified_name,
+          range_var_name(qualifier),
+          column_name(name) ]
+      end
+      builder :qualified_name
+
+      def range_var_name(qualifier)
+        [:range_var_name, qualifier]
+      end
+      builder :range_var_name
+
+      def column_name(name)
+        [:column_name, name]
+      end
+      builder :column_name
+
+      def table_name(name)
+        [:table_name, name]
+      end
+      builder :table_name
+
+      def exists(subquery)
+        Predicate::Grammar.sexpr [ :exists, subquery ]
+      end
+
+      def order_by_clause(ordering, &desaliaser)
+        ordering.to_a.map{|(s,d)|
+          if s.composite?
+            raise NotSupportedError, "SQL order by does not support composite selectors"
+          end
+          name = s.outcoerce.to_s
+          name = (desaliaser && desaliaser[name]) || column_name(name)
+          [:order_by_term, name, d.to_s]
+        }.unshift(:order_by_clause)
+      end
+      builder :order_by_clause
+
+      def limit_clause(limit)
+        [:limit_clause, limit]
+      end
+      builder :limit_clause
+
+      def offset_clause(limit)
+        [:offset_clause, limit]
+      end
+      builder :offset_clause
+
+      def from_self(sexpr)
+        Processor::FromSelf.new(self).call(sexpr)
+      end
+
+    public
+
+      def next_qualifier!
+        "t#{@next_qualifier += 1}"
+      end
+
+    end
+  end
+end

data/lib/alf/sql/cog.rb

@@ -0,0 +1,32 @@
+module Alf
+  module Sql
+    class Cog
+      include Alf::Compiler::Cog
+
+      def initialize(expr, compiler, sexpr)
+        super(expr, compiler)
+        @sexpr = sexpr
+      end
+      attr_reader :sexpr
+      alias :to_sexpr :sexpr
+
+      def cog_orders
+        [ sexpr.ordering ].compact
+      end
+
+      def should_be_reused?
+        sexpr.should_be_reused?
+      end
+
+      def to_sql(buffer = "")
+        sexpr.to_sql(buffer)
+      end
+
+      def each(&bl)
+        raise NotSupportedError,\
+          "This is an abstract SQL compilation result. Please use alf-sequel."
+      end
+
+    end # module Cog
+  end # module Sql
+end # module Alf

data/lib/alf/sql/compiler.rb

@@ -0,0 +1,137 @@
+module Alf
+  module Sql
+    class Compiler < Alf::Compiler
+
+      def join(plan)
+        Builder.new
+      end
+
+      def supports_reuse?
+        true
+      end
+
+      def reuse(plan, cog)
+        rewrite(plan, cog.expr, cog, Processor::Requalify, [])
+      end
+
+      def compile(plan, expr, compiled, usage_count)
+        cog = super
+        if (usage_count > 1) and cog.should_be_reused?
+          cog = rewrite(plan, cog.expr, cog, Processor::FromSelf, [])
+        end
+        cog
+      end
+
+      ### base
+
+      def on_leaf_operand(plan, expr)
+        fresh_cog(expr, builder(plan).select_all(expr.heading, expr.name))
+      end
+
+      ### non-relational
+
+      def on_clip(plan, expr, compiled)
+        rewrite(plan, expr, compiled, Processor::Clip, [expr.attributes, :is_table_dee])
+      end
+
+      def on_sort(plan, expr, compiled)
+        if compiled.orderedby?(expr.ordering)
+          rebind(plan, expr, compiled)
+        else
+          rewrite(plan, expr, compiled, Processor::OrderBy, [expr.ordering])
+        end
+      end
+
+      ### relational
+
+      def on_frame(plan, expr, compiled)
+        compiled = plan.recompile(compiled){|p|
+          p.sort(expr.operand, expr.total_ordering)
+        }
+        rewrite(plan, expr, compiled, Processor::LimitOffset, [expr.limit, expr.offset])
+      end
+
+      def on_intersect(plan, expr, left, right)
+        rewrite(plan, expr, left, Processor::Merge, [:intersect, right.sexpr])
+      end
+
+      def on_join(plan, expr, left, right)
+        rewrite(plan, expr, left, Processor::Join, [right.sexpr])
+      end
+
+      def on_matching(plan, expr, left, right)
+        rewrite(plan, expr, left, Processor::SemiJoin, [right.sexpr, false])
+      end
+
+      def on_minus(plan, expr, left, right)
+        rewrite(plan, expr, left, Processor::Merge, [:except, right.sexpr])
+      end
+
+      def on_not_matching(plan, expr, left, right)
+        rewrite(plan, expr, left, Processor::SemiJoin, [right.sexpr, true])
+      end
+
+      def on_page(plan, expr, compiled)
+        index, size = expr.page_index, expr.page_size
+        compiled = plan.recompile(compiled){|p|
+          ordering = expr.total_ordering
+          ordering = ordering.reverse if index < 0
+          p.sort(expr.operand, ordering)
+        }
+        rewrite(plan, expr, compiled, Processor::LimitOffset, [size, (index.abs - 1) * size])
+      end
+
+      def on_project(plan, expr, compiled)
+        compiled = plan.recompile(compiled){|p|
+          p.clip(expr.operand, expr.stay_attributes)
+        }
+        preserving = expr.key_preserving? rescue false
+        if not(preserving) and not(expr.stay_attributes.empty?)
+          compiled = rewrite(plan, expr, compiled, Processor::Distinct)
+        end
+        rebind(plan, expr, compiled)
+      end
+
+      def on_rename(plan, expr, compiled)
+        rewrite(plan, expr, compiled, Processor::Rename, [expr.renaming])
+      end
+
+      def on_restrict(plan, expr, compiled)
+        rewrite(plan, expr, compiled, Processor::Where, [expr.predicate])
+      end
+
+      # def on_summarize(plan, expr, compiled)
+      #   # -> SQL's GROUP-BY
+      # end
+
+      def on_union(plan, expr, left, right)
+        rewrite(plan, expr, left, Processor::Merge, [:union, right.sexpr])
+      end
+
+    protected
+
+      def builder(plan)
+        plan.options(self)
+      end
+
+      def cog_class
+        Cog
+      end
+
+      def fresh_cog(expr, sexpr)
+        cog_class.new(expr, self, sexpr)
+      end
+
+      def rewrite(plan, expr, compiled, processor, args = [])
+        builder  = builder(plan)
+        rewrited = processor.new(*args.push(builder)).call(compiled.sexpr)
+        cog_class.new(expr, self, rewrited)
+      end
+
+      def rebind(plan, expr, compiled)
+        cog_class.new(expr, self, compiled.sexpr)
+      end
+
+    end # class Compilable
+  end # module Sql
+end # module Alf

data/lib/alf/sql/grammar.rb

@@ -0,0 +1,44 @@
+module Alf
+  module Sql
+    Grammar = Sexpr.load(Path.dir/'grammar.sexp.yml')
+    module Grammar
+
+      def tagging_reference
+        Sql
+      end
+
+      def default_tagging_module
+        Expr
+      end
+
+    end # module Grammar
+  end # module Sql
+end # module Alf
+require_relative "nodes/expr"
+require_relative "nodes/set_operator"
+require_relative "nodes/literal"
+require_relative "nodes/column_name"
+require_relative "nodes/qualified_name"
+require_relative "nodes/range_var_name"
+require_relative "nodes/select_exp"
+require_relative "nodes/set_quantifier"
+require_relative "nodes/select_list"
+require_relative "nodes/select_star"
+require_relative "nodes/select_item"
+require_relative "nodes/from_clause"
+require_relative "nodes/table_as"
+require_relative "nodes/subquery_as"
+require_relative "nodes/table_name"
+require_relative "nodes/order_by_clause"
+require_relative "nodes/order_by_term"
+require_relative "nodes/limit_clause"
+require_relative "nodes/offset_clause"
+require_relative "nodes/union"
+require_relative "nodes/intersect"
+require_relative "nodes/except"
+require_relative "nodes/with_exp"
+require_relative "nodes/with_spec"
+require_relative "nodes/name_intro"
+require_relative "nodes/where_clause"
+require_relative "nodes/cross_join"
+require_relative "nodes/inner_join"