sequel_core 1.5.1 → 2.0.0

data/lib/sequel_core/core_sql.rb

@@ -1,35 +1,108 @@
-# Array extensions
+# This file holds the extensions to core ruby classes that relate to the creation of SQL
+# code.
+
 class Array
+  # Return a Sequel::SQL::ComplexExpression created from this array, not matching any of the
+  # conditions.
+  def ~
+    sql_expr_if_all_two_pairs(:OR, true)
+  end
+
+  # Return a Sequel::SQL::ComplexExpression created from this array, matching all of the
+  # conditions.
+  def sql_expr
+    sql_expr_if_all_two_pairs
+  end
+
+  # Return a Sequel::SQL::ComplexExpression created from this array, matching none
+  # of the conditions.
+  def sql_negate
+    sql_expr_if_all_two_pairs(:AND, true)
+  end
+
+  # Return a Sequel::SQL::ComplexExpression created from this array, matching any of the
+  # conditions.
+  def sql_or
+    sql_expr_if_all_two_pairs(:OR)
+  end
+
+  # Return a Sequel::SQL::ComplexExpression representing an SQL string made up of the
+  # concatenation of this array's elements.  If an argument is passed
+  # it is used in between each element of the array in the SQL
+  # concatenation.
+  def sql_string_join(joiner=nil)
+    if joiner
+      args = self.inject([]) do |m, a|
+        m << a
+        m << joiner
+      end
+      args.pop
+    else
+      args = self
+    end
+    args = args.collect{|a| a.is_one_of?(Symbol, ::Sequel::SQL::Expression, ::Sequel::LiteralString, TrueClass, FalseClass, NilClass) ? a : a.to_s}
+    ::Sequel::SQL::ComplexExpression.new(:'||', *args)
+  end
+
   # Concatenates an array of strings into an SQL string. ANSI SQL and C-style
   # comments are removed, as well as excessive white-space.
   def to_sql
-    map {|l| (l =~ /^(.*)--/ ? $1 : l).chomp}.join(' '). \
+    map {|l| ((m = /^(.*)--/.match(l)) ? m[1] : l).chomp}.join(' '). \
       gsub(/\/\*.*\*\//, '').gsub(/\s+/, ' ').strip
   end
-end
 
-module Sequel
-  # LiteralString is used to represent literal SQL expressions. An 
-  # LiteralString is copied verbatim into an SQL statement. Instances of
-  # LiteralString can be created by calling String#lit.
-  class LiteralString < ::String
+  private
+
+  # Raise an error if this array is not made up of all two pairs, otherwise create a Sequel::SQL::ComplexExpression from this array.
+  def sql_expr_if_all_two_pairs(*args)
+    raise(Sequel::Error, 'Not all elements of the array are arrays of size 2, so it cannot be converted to an SQL expression') unless all_two_pairs?
+    ::Sequel::SQL::ComplexExpression.from_value_pairs(self, *args)
   end
 end
 
-# String extensions
-class String
-  # Converts a string into an SQL string by removing comments.
-  # See also Array#to_sql.
-  def to_sql
-    split("\n").to_sql
+class Hash
+  # Return a Sequel::SQL::ComplexExpression created from this hash, matching
+  # all of the conditions in this hash and the condition specified by
+  # the given argument.
+  def &(ce)
+    ::Sequel::SQL::ComplexExpression.new(:AND, self, ce)
   end
-  
-  # Splits a string into separate SQL statements, removing comments
-  # and excessive white-space.
-  def split_sql
-    to_sql.split(';').map {|s| s.strip}
+
+  # Return a Sequel::SQL::ComplexExpression created from this hash, matching
+  # all of the conditions in this hash or the condition specified by
+  # the given argument.
+  def |(ce)
+    ::Sequel::SQL::ComplexExpression.new(:OR, self, ce)
+  end
+
+  # Return a Sequel::SQL::ComplexExpression created from this hash, not matching any of the
+  # conditions.
+  def ~
+    ::Sequel::SQL::ComplexExpression.from_value_pairs(self, :OR, true)
+  end
+
+  # Return a Sequel::SQL::ComplexExpression created from this hash, matching all of the
+  # conditions.
+  def sql_expr
+    ::Sequel::SQL::ComplexExpression.from_value_pairs(self)
   end
 
+  # Return a Sequel::SQL::ComplexExpression created from this hash, matching none
+  # of the conditions.
+  def sql_negate
+    ::Sequel::SQL::ComplexExpression.from_value_pairs(self, :AND, true)
+  end
+
+  # Return a Sequel::SQL::ComplexExpression created from this hash, matching any of the
+  # conditions.
+  def sql_or
+    ::Sequel::SQL::ComplexExpression.from_value_pairs(self, :OR)
+  end
+end
+
+class String
+  include Sequel::SQL::ColumnMethods
+
   # Converts a string into an LiteralString, in order to override string
   # literalization, e.g.:
   #
@@ -42,155 +115,52 @@ class String
   def lit
     Sequel::LiteralString.new(self)
   end
-  
   alias_method :expr, :lit
   
-  # Converts a string into a Time object.
-  def to_time
-    begin
-      Time.parse(self)
-    rescue Exception => e
-      raise Sequel::Error::InvalidValue, "Invalid time value '#{self}' (#{e.message})"
-    end
-  end
-
-  # Converts a string into a Date object.
-  def to_date
-    begin
-      Date.parse(self)
-    rescue Exception => e
-      raise Sequel::Error::InvalidValue, "Invalid date value '#{self}' (#{e.message})"
-    end
+  # Splits a string into separate SQL statements, removing comments
+  # and excessive white-space.
+  def split_sql
+    to_sql.split(';').map {|s| s.strip}
   end
-end
-
 
-module Sequel
-  module SQL
-    module ColumnMethods
-      AS = 'AS'.freeze
-      DESC = 'DESC'.freeze
-      ASC = 'ASC'.freeze
-      
-      def as(a); ColumnExpr.new(self, AS, a); end
-      
-      def desc; ColumnExpr.new(self, DESC); end
-      
-      def asc; ColumnExpr.new(self, ASC); end
-
-      def cast_as(t)
-        if t.is_a?(Symbol)
-          t = t.to_s.lit
-        end
-        Sequel::SQL::Function.new(:cast, self.as(t))
-      end
-    end
-
-    class Expression
-      include ColumnMethods
-      def lit; self; end
-    end
-    
-    class ColumnExpr < Expression
-      attr_reader :l, :op, :r
-      def initialize(l, op, r = nil); @l, @op, @r = l, op, r; end
-      
-      def to_s(ds)
-        @r ? \
-          "#{ds.literal(@l)} #{@op} #{ds.literal(@r)}" : \
-          "#{ds.literal(@l)} #{@op}"
-      end
-    end
-    
-    class QualifiedColumnRef < Expression
-      def initialize(t, c); @t, @c = t, c; end
-      
-      def to_s(ds)
-        "#{@t}.#{ds.literal(@c)}"
-      end 
-    end
-    
-    class Function < Expression
-      attr_reader :f, :args
-      def initialize(f, *args); @f, @args = f, args; end
-
-      # Functions are considered equivalent if they
-      # have the same class, function, and arguments.
-      def ==(x)
-         x.class == self.class && @f == x.f && @args == x.args
-      end
-
-      def to_s(ds)
-        args = @args.empty? ? '' : ds.literal(@args)
-        "#{@f}(#{args})"
-      end
-    end
-    
-    class Subscript < Expression
-      def initialize(f, sub); @f, @sub = f, sub; end
-      def |(sub)
-        unless Array === sub
-          sub = [sub]
-        end
-        Subscript.new(@f, @sub << sub)
-      end
-      
-      COMMA_SEPARATOR = ", ".freeze
-      
-      def to_s(ds)
-        "#{@f}[#{@sub.join(COMMA_SEPARATOR)}]"
-      end
-    end
-    
-    class ColumnAll < Expression
-      def initialize(t); @t = t; end
-      def to_s(ds); "#{@t}.*"; end
-    end
+  # Converts a string into an SQL string by removing comments.
+  # See also Array#to_sql.
+  def to_sql
+    split("\n").to_sql
   end
 end
 
-class String
-  include Sequel::SQL::ColumnMethods
-end
-
 class Symbol
   include Sequel::SQL::ColumnMethods
-  def *
+  include Sequel::SQL::ComplexExpressionMethods
+
+  # If no argument is given, returns a Sequel::SQL::ColumnAll object specifying all
+  # columns for this table.
+  # If an argument is given, returns a Sequel::SQL::ComplexExpression using the *
+  # (multiplication) operator with this and the given argument.
+  def *(ce=(arg=false;nil))
+    return super(ce) unless arg == false
     Sequel::SQL::ColumnAll.new(self);
   end
 
-  def [](*args); Sequel::SQL::Function.new(self, *args); end
+  # Returns a Sequel::SQL::Function  with this as the function name,
+  # and the given arguments.
+  def [](*args)
+    Sequel::SQL::Function.new(self, *args)
+  end
+
+  # If the given argument is an Integer or an array containing an Integer, returns
+  # a Sequel::SQL::Subscript with this column and the given arg.
+  # Otherwise returns a Sequel::SQL::ComplexExpression where this column (which should be boolean)
+  # or the given argument is true.
   def |(sub)
-    unless Array === sub
-      sub = [sub]
-    end
-    Sequel::SQL::Subscript.new(self, sub)
+    return super unless (Integer === sub) || ((Array === sub) && sub.any?{|x| Integer === x})
+    Sequel::SQL::Subscript.new(self, Array(sub))
   end
   
-  COLUMN_REF_RE1 = /^(\w+)__(\w+)___(\w+)/.freeze
-  COLUMN_REF_RE2 = /^(\w+)___(\w+)$/.freeze
-  COLUMN_REF_RE3 = /^(\w+)__(\w+)$/.freeze
-
-  # Converts a symbol into a column name. This method supports underscore
-  # notation in order to express qualified (two underscores) and aliased 
-  # (three underscores) columns:
-  #
-  #   ds = DB[:items]
-  #   :abc.to_column_ref(ds) #=> "abc"
-  #   :abc___a.to_column_ref(ds) #=> "abc AS a"
-  #   :items__abc.to_column_ref(ds) #=> "items.abc"
-  #   :items__abc___a.to_column_ref(ds) #=> "items.abc AS a"
-  #
+  # Delegate the creation of the resulting SQL to the given dataset,
+  # since it may be database dependent.
   def to_column_ref(ds)
-    case s = to_s
-    when COLUMN_REF_RE1
-      "#{$1}.#{ds.quote_column_ref($2)} AS #{ds.quote_column_ref($3)}"
-    when COLUMN_REF_RE2
-      "#{ds.quote_column_ref($1)} AS #{ds.quote_column_ref($2)}"
-    when COLUMN_REF_RE3
-      "#{$1}.#{ds.quote_column_ref($2)}"
-    else
-      ds.quote_column_ref(s)
-    end
+    ds.symbol_to_column_ref(self)
   end
 end

data/lib/sequel_core/database/schema.rb

@@ -0,0 +1,156 @@
+module Sequel
+  class Database
+    # Adds a column to the specified table. This method expects a column name,
+    # a datatype and optionally a hash with additional constraints and options:
+    #
+    #   DB.add_column :items, :name, :text, :unique => true, :null => false
+    #   DB.add_column :items, :category, :text, :default => 'ruby'
+    #
+    # See alter_table.
+    def add_column(table, *args)
+      alter_table(table) {add_column(*args)}
+    end
+    
+    # Adds an index to a table for the given columns:
+    # 
+    #   DB.add_index :posts, :title
+    #   DB.add_index :posts, [:author, :title], :unique => true
+    #
+    # See alter_table.
+    def add_index(table, *args)
+      alter_table(table) {add_index(*args)}
+    end
+    
+    # Alters the given table with the specified block. Here are the currently
+    # available operations:
+    #
+    #   DB.alter_table :items do
+    #     add_column :category, :text, :default => 'ruby'
+    #     drop_column :category
+    #     rename_column :cntr, :counter
+    #     set_column_type :value, :float
+    #     set_column_default :value, :float
+    #     add_index [:group, :category]
+    #     drop_index [:group, :category]
+    #   end
+    #
+    # Note that #add_column accepts all the options available for column
+    # definitions using create_table, and #add_index accepts all the options
+    # available for index definition.
+    #
+    # See Schema::AlterTableGenerator.
+    def alter_table(name, &block)
+      g = Schema::AlterTableGenerator.new(self, &block)
+      alter_table_sql_list(name, g.operations).each {|sql| execute(sql)}
+    end
+    
+    # Creates a table with the columns given in the provided block:
+    #
+    #   DB.create_table :posts do
+    #     primary_key :id, :serial
+    #     column :title, :text
+    #     column :content, :text
+    #     index :title
+    #   end
+    #
+    # See Schema::Generator.
+    def create_table(name, &block)
+      g = Schema::Generator.new(self, &block)
+      create_table_sql_list(name, *g.create_info).each {|sql| execute(sql)}
+    end
+    
+    # Forcibly creates a table. If the table already exists it is dropped.
+    def create_table!(name, &block)
+      drop_table(name) rescue nil
+      create_table(name, &block)
+    end
+    
+    # Creates a view, replacing it if it already exists:
+    #
+    #   DB.create_or_replace_view(:cheap_items, "SELECT * FROM items WHERE price < 100")
+    #   DB.create_or_replace_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
+    def create_or_replace_view(name, source)
+      source = source.sql if source.is_a?(Dataset)
+      execute("CREATE OR REPLACE VIEW #{name} AS #{source}")
+    end
+    
+    # Creates a view based on a dataset or an SQL string:
+    #
+    #   DB.create_view(:cheap_items, "SELECT * FROM items WHERE price < 100")
+    #   DB.create_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
+    def create_view(name, source)
+      source = source.sql if source.is_a?(Dataset)
+      execute("CREATE VIEW #{name} AS #{source}")
+    end
+    
+    # Removes a column from the specified table:
+    #
+    #   DB.drop_column :items, :category
+    #
+    # See alter_table.
+    def drop_column(table, *args)
+      alter_table(table) {drop_column(*args)}
+    end
+    
+    # Removes an index for the given table and column/s:
+    #
+    #   DB.drop_index :posts, :title
+    #   DB.drop_index :posts, [:author, :title]
+    #
+    # See alter_table.
+    def drop_index(table, columns)
+      alter_table(table) {drop_index(columns)}
+    end
+    
+    # Drops one or more tables corresponding to the given table names:
+    #
+    #   DB.drop_table(:posts, :comments)
+    def drop_table(*names)
+      names.each {|n| execute(drop_table_sql(n))}
+    end
+    
+    # Drops a view:
+    #
+    #   DB.drop_view(:cheap_items)
+    def drop_view(name)
+      execute("DROP VIEW #{name}")
+    end
+
+    # Renames a table:
+    #
+    #   DB.tables #=> [:items]
+    #   DB.rename_table :items, :old_items
+    #   DB.tables #=> [:old_items]
+    def rename_table(*args)
+      execute(rename_table_sql(*args))
+    end
+    
+    # Renames a column in the specified table. This method expects the current
+    # column name and the new column name:
+    #
+    #   DB.rename_column :items, :cntr, :counter
+    #
+    # See alter_table.
+    def rename_column(table, *args)
+      alter_table(table) {rename_column(*args)}
+    end
+    
+    # Sets the default value for the given column in the given table:
+    #
+    #   DB.set_column_default :items, :category, 'perl!'
+    #
+    # See alter_table.
+    def set_column_default(table, *args)
+      alter_table(table) {set_column_default(*args)}
+    end
+    
+    # Set the data type for the given column in the given table:
+    #
+    #   DB.set_column_type :items, :price, :float
+    #
+    # See alter_table.
+    def set_column_type(table, *args)
+      alter_table(table) {set_column_type(*args)}
+    end
+  end
+end