bmg 0.9.1 → 0.10.0

data/lib/bmg/sequel/type_inference.rb

@@ -0,0 +1,42 @@
+module Bmg
+  module Sequel
+    class TypeInference
+
+      def initialize(sequel_db)
+        @sequel_db = sequel_db
+      end
+      attr_reader :sequel_db
+
+      def call(name)
+        Type.new
+          .with_attrlist(attrlist(name))
+          .with_keys(keys(name))
+      end
+
+      def attrlist(name)
+        sequel_db.schema(name).map{|(k,v)| k }
+      end
+
+      def keys(name)
+        # take the indexes
+        indexes = sequel_db
+          .indexes(name)
+          .values
+          .select{|i| i[:unique] == true }
+          .map{|i| i[:columns] }
+          .sort{|a1, a2| a1.size <=> a2.size }
+
+        # take single keys as well
+        key = sequel_db
+          .schema(name)
+          .select{|(colname, colinfo)| colinfo[:primary_key] }
+          .map(&:first)
+
+        indexes.unshift(key) unless key.empty?
+
+        indexes
+      end
+
+    end # class TypeInference
+  end # module Sequel
+end # module Bmg

data/lib/bmg/sql.rb

@@ -0,0 +1,20 @@
+require 'sexpr'
+module Bmg
+
+  module Sql
+  end
+
+  def sql(table, type = Type::ANY)
+    builder = Sql::Builder.new
+    sexpr = builder.select_star_from(table)
+    Sql::Relation.new(type, builder, sexpr).spied(main_spy)
+  end
+  module_function :sql
+
+end # module Bmg
+require_relative 'sql/ext/predicate'
+require_relative 'sql/grammar'
+require_relative 'sql/processor'
+require_relative 'sql/builder'
+require_relative 'sql/dialect'
+require_relative 'sql/relation'

data/lib/bmg/sql/builder.rb

@@ -0,0 +1,177 @@
+module Bmg
+  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"]]])
+
+      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_star_from(name, qualifier = next_qualifier!)
+        [ :select_exp,
+          all,
+          select_star(qualifier),
+          from_clause(name, qualifier) ]
+      end
+      builder :select_star_from
+
+      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(attrs, qualifier)
+        attrs = attrs.to_attr_list if attrs.respond_to?(:to_attr_list)
+        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(qualifier = next_qualifier!)
+        [:select_star, [:range_var_name, qualifier]]
+      end
+      builder :select_star
+
+      def from_clause(table, qualifier)
+        arg = case table
+        when String, Symbol  then table_as(table, qualifier)
+        when Expr            then subquery_as(table, qualifier)
+        else                      native_table_as(table, qualifier)
+        end
+        [ :from_clause, arg ]
+      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 subquery_as(subquery, qualifier)
+        [:subquery_as,
+          subquery,
+          range_var_name(qualifier) ]
+      end
+      builder :table_as
+
+      def native_table_as(table, qualifier)
+        [ :native_table_as,
+          table,
+          range_var_name(qualifier) ]
+      end
+
+      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{|(name,direction)|
+          name = name.to_s
+          name = (desaliaser && desaliaser[name]) || column_name(name)
+          [:order_by_term, name, direction ? direction.to_s : "asc"]
+        }.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 last_qualifier
+        "t#{@next_qualifier}"
+      end
+
+      def next_qualifier!
+        "t#{@next_qualifier += 1}"
+      end
+
+    end
+  end
+end

data/lib/bmg/sql/dialect.rb

@@ -0,0 +1,15 @@
+module Bmg
+  module Sql
+    class Dialect
+
+      def self.default
+        Dialect.new
+      end
+
+      def quote_identifier(identifier)
+        %Q{"#{identifier}"}
+      end
+
+    end # class Dialect
+  end # module Sql
+end # module Bmg

data/lib/bmg/sql/ext/predicate.rb

@@ -0,0 +1,23 @@
+class Predicate
+  Sql = ::Bmg::Sql
+end
+require_relative 'predicate/expr'
+require_relative 'predicate/dyadic_comp'
+require_relative 'predicate/nadic_bool'
+require_relative 'predicate/tautology'
+require_relative 'predicate/contradiction'
+require_relative 'predicate/identifier'
+require_relative 'predicate/qualified_identifier'
+require_relative 'predicate/and'
+require_relative 'predicate/or'
+require_relative 'predicate/not'
+require_relative 'predicate/eq'
+require_relative 'predicate/neq'
+require_relative 'predicate/gt'
+require_relative 'predicate/gte'
+require_relative 'predicate/lt'
+require_relative 'predicate/lte'
+require_relative 'predicate/in'
+require_relative 'predicate/exists'
+require_relative 'predicate/literal'
+require_relative 'predicate/native'

data/lib/bmg/sql/ext/predicate/and.rb

@@ -0,0 +1,9 @@
+class Predicate
+  module And
+
+    def to_sql_operator
+      Sql::Expr::AND
+    end
+
+  end
+end

data/lib/bmg/sql/ext/predicate/contradiction.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Contradiction
+
+    def to_sql(buffer, dialect)
+      buffer << Sql::Expr::FALSE
+      buffer
+    end
+
+  end
+end

data/lib/bmg/sql/ext/predicate/dyadic_comp.rb

@@ -0,0 +1,12 @@
+class Predicate
+  module DyadicComp
+
+    def to_sql(buffer, dialect)
+      left.to_sql(buffer, dialect)
+      buffer << Sql::Expr::SPACE << to_sql_operator << Sql::Expr::SPACE
+      right.to_sql(buffer, dialect)
+      buffer
+    end
+
+  end
+end

data/lib/bmg/sql/ext/predicate/eq.rb

@@ -0,0 +1,9 @@
+class Predicate
+  module Eq
+
+    def to_sql_operator
+      Sql::Expr::EQUAL
+    end
+
+  end
+end

data/lib/bmg/sql/ext/predicate/exists.rb

@@ -0,0 +1,12 @@
+class Predicate
+  module Exists
+    include Expr
+
+    def to_sql(buffer, dialect)
+      buffer << Sql::Expr::EXISTS
+      last.to_sql(buffer, dialect)
+      buffer
+    end
+
+  end
+end

data/lib/bmg/sql/ext/predicate/expr.rb

@@ -0,0 +1,18 @@
+class Predicate
+  module Expr
+
+    def to_sql_literal(buffer, value)
+      case value
+      when TrueClass
+        buffer << Sql::Expr::TRUE
+      when FalseClass
+        buffer << Sql::Expr::FALSE
+      when Integer, Float
+        buffer << value.to_s
+      else
+        buffer << Sql::Expr::QUOTE << value.to_s << Sql::Expr::QUOTE
+      end
+    end
+
+  end
+end

data/lib/bmg/sql/ext/predicate/gt.rb

@@ -0,0 +1,9 @@
+class Predicate
+  module Gt
+
+    def to_sql_operator
+      Sql::Expr::GREATER
+    end
+
+  end
+end

data/lib/bmg/sql/ext/predicate/gte.rb

@@ -0,0 +1,9 @@
+class Predicate
+  module Gte
+
+    def to_sql_operator
+      Sql::Expr::GREATER_OR_EQUAL
+    end
+
+  end
+end

data/lib/bmg/sql/ext/predicate/identifier.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Identifier
+
+    def to_sql(buffer, dialect)
+      buffer << dialect.quote_identifier(name)
+      buffer
+    end
+
+  end
+end

data/lib/bmg/sql/ext/predicate/in.rb

@@ -0,0 +1,29 @@
+class Predicate
+  module In
+
+    def subquery?
+      Sql::Expr === last
+    end
+
+    def subquery
+      subquery? ? last : nil
+    end
+
+    def to_sql(buffer, dialect)
+      identifier.to_sql(buffer, dialect)
+      buffer << Sql::Expr::SPACE << Sql::Expr::IN << Sql::Expr::SPACE
+      if subquery?
+        values.to_sql(buffer, dialect)
+      else
+        buffer << Sql::Expr::LEFT_PARENTHESE
+        values.each_with_index do |val,index|
+          buffer << Sql::Expr::COMMA << Sql::Expr::SPACE unless index==0
+          to_sql_literal(buffer, val)
+        end
+        buffer << Sql::Expr::RIGHT_PARENTHESE
+      end
+      buffer
+    end
+
+  end
+end

data/lib/bmg/sql/ext/predicate/literal.rb

@@ -0,0 +1,10 @@
+class Predicate
+  module Literal
+
+    def to_sql(buffer, dialect)
+      to_sql_literal(buffer, value)
+      buffer
+    end
+
+  end
+end

data/lib/bmg/sql/ext/predicate/lt.rb

@@ -0,0 +1,9 @@
+class Predicate
+  module Lt
+
+    def to_sql_operator
+      Sql::Expr::LESS
+    end
+
+  end
+end