sequel 2.9.0 → 2.10.0

data/lib/sequel_core/database/schema.rb

@@ -55,15 +55,15 @@ module Sequel
     #   end
     #
     # See Schema::Generator.
-    def create_table(name, generator=nil, &block)
-      generator ||= Schema::Generator.new(self, &block)
-      create_table_sql_list(name, *generator.create_info).flatten.each {|sql| execute_ddl(sql)}
+    def create_table(name, options={}, &block)
+      options = {:generator=>options} if options.is_a?(Schema::Generator)
+      create_table_sql_list(name, *((options[:generator] || Schema::Generator.new(self, &block)).create_info << options)).flatten.each {|sql| execute_ddl(sql)}
     end
     
     # Forcibly creates a table. If the table already exists it is dropped.
-    def create_table!(name, generator=nil, &block)
+    def create_table!(name, options={}, &block)
       drop_table(name) rescue nil
-      create_table(name, generator, &block)
+      create_table(name, options, &block)
     end
     
     # Creates a view, replacing it if it already exists:

data/lib/sequel_core/dataset.rb

@@ -71,6 +71,12 @@ module Sequel
 
     # The database that corresponds to this dataset
     attr_accessor :db
+    
+    # Set the method to call on identifiers going into the database for this dataset
+    attr_accessor :identifier_input_method
+    
+    # Set the method to call on identifiers coming the database for this dataset
+    attr_accessor :identifier_output_method
 
     # The hash of options for this dataset, keys are symbols.
     attr_accessor :opts
@@ -83,9 +89,6 @@ module Sequel
     # fetch_rows to return.
     attr_accessor :row_proc
 
-    # Whether to upcase identifiers for this dataset
-    attr_writer :upcase_identifiers
-    
     # Constructs a new instance of a dataset with an associated database and 
     # options. Datasets are usually constructed by invoking Database methods:
     #
@@ -100,7 +103,8 @@ module Sequel
     def initialize(db, opts = nil)
       @db = db
       @quote_identifiers = db.quote_identifiers? if db.respond_to?(:quote_identifiers?)
-      @upcase_identifiers = db.upcase_identifiers? if db.respond_to?(:upcase_identifiers?)
+      @identifier_input_method = db.identifier_input_method if db.respond_to?(:identifier_input_method)
+      @identifier_output_method = db.identifier_output_method if db.respond_to?(:identifier_output_method)
       @opts = opts || {}
       @row_proc = nil
       @transform = nil
@@ -221,7 +225,7 @@ module Sequel
     # Inserts values into the associated table.  The returned value is generally
     # the value of the primary key for the inserted row, but that is adapter dependent.
     def insert(*values)
-      execute_dui(insert_sql(*values))
+      execute_insert(insert_sql(*values))
     end
   
     # Returns a string representation of the dataset including the class name 
@@ -419,9 +423,13 @@ module Sequel
       end
     end
     
+    def upcase_identifiers=(v)
+      @identifier_input_method = v ? :upcase : nil
+    end
+    
     # Whether this dataset upcases identifiers.
     def upcase_identifiers?
-      @upcase_identifiers
+      @identifier_input_method == :upcase
     end
     
     # Updates values for the dataset.  The returned value is generally the
@@ -468,6 +476,17 @@ module Sequel
     def execute_dui(sql, opts={}, &block)
       @db.execute_dui(sql, {:server=>@opts[:server] || :default}.merge(opts), &block)
     end
+    
+    # Execute the given SQL on the database using execute_insert.
+    def execute_insert(sql, opts={}, &block)
+      @db.execute_insert(sql, {:server=>@opts[:server] || :default}.merge(opts), &block)
+    end
+    
+    # Modify the identifier returned from the database based on the
+    # identifier_output_method.
+    def input_identifier(v)
+      (i = identifier_input_method) ? v.to_s.send(i) : v.to_s
+    end
 
     # Modify the receiver with the results of sending the meth, args, and block
     # to the receiver and merging the options of the resulting dataset into
@@ -477,5 +496,11 @@ module Sequel
       @opts.merge!(copy.opts)
       self
     end
+    
+    # Modify the identifier returned from the database based on the
+    # identifier_output_method.
+    def output_identifier(v)
+      (i = identifier_output_method) ? v.to_s.send(i).to_sym : v.to_sym
+    end
   end
 end

data/lib/sequel_core/dataset/convenience.rb

@@ -1,7 +1,7 @@
 module Sequel
   class Dataset
     COMMA_SEPARATOR = ', '.freeze
-    COUNT_OF_ALL_AS_COUNT = :count['*'.lit].as(:count)
+    COUNT_OF_ALL_AS_COUNT = SQL::Function.new(:count, '*'.lit).as(:count)
 
     # Returns the first record matching the conditions.
     def [](*conditions)
@@ -16,7 +16,7 @@ module Sequel
 
     # Returns the average value for the given column.
     def avg(column)
-      get(:avg[column])
+      get(SQL::Function.new(:avg, column))
     end
     
     # Returns true if no records exists in the dataset
@@ -40,11 +40,11 @@ module Sequel
     #   ds.first(:id=>2) => {:id=>2}
     #   ds.first("id = 3") => {:id=>3}
     #   ds.first("id = ?", 4) => {:id=>4}
-    #   ds.first{:id > 2} => {:id=>5}
-    #   ds.order(:id).first{:id > 2} => {:id=>3}
-    #   ds.first{:id > 2} => {:id=>5}
-    #   ds.first("id > ?", 4){:id < 6) => {:id=>5}
-    #   ds.order(:id).first(2){:id < 2} => [{:id=>1}]
+    #   ds.first{|o| o.id > 2} => {:id=>5}
+    #   ds.order(:id).first{|o| o.id > 2} => {:id=>3}
+    #   ds.first{|o| o.id > 2} => {:id=>5}
+    #   ds.first("id > ?", 4){|o| o.id < 6} => {:id=>5}
+    #   ds.order(:id).first(2){|o| o.id < 2} => [{:id=>1}]
     def first(*args, &block)
       ds = block ? filter(&block) : self
 
@@ -97,12 +97,12 @@ module Sequel
 
     # Returns the maximum value for the given column.
     def max(column)
-      get(:max[column])
+      get(SQL::Function.new(:max, column))
     end
 
     # Returns the minimum value for the given column.
     def min(column)
-      get(:min[column])
+      get(SQL::Function.new(:min, column))
     end
 
     # Inserts multiple records into the associated table. This method can be
@@ -170,7 +170,7 @@ module Sequel
     # Returns a Range object made from the minimum and maximum values for the
     # given column.
     def range(column)
-      if r = select(:min[column].as(:v1), :max[column].as(:v2)).first
+      if r = select(SQL::Function.new(:min, column).as(:v1), SQL::Function.new(:max, column).as(:v2)).first
         (r[:v1]..r[:v2])
       end
     end
@@ -191,7 +191,7 @@ module Sequel
     
     # Returns the sum for the given column.
     def sum(column)
-      get(:sum[column])
+      get(SQL::Function.new(:sum, column))
     end
 
     # Returns true if the table exists.  Will raise an error

data/lib/sequel_core/dataset/query.rb

@@ -5,13 +5,13 @@ module Sequel
     #
     #   dataset = DB[:items].query do
     #     select :x, :y, :z
-    #     filter((:x > 1) & (:y > 2))
+    #     filter{|o| (o.x > 1) & (o.y > 2)}
     #     order :z.desc
     #   end
     #
     # Which is the same as:
     #
-    #  dataset = DB[:items].select(:x, :y, :z).filter((:x > 1) & (:y > 2)).order(:z.desc)
+    #  dataset = DB[:items].select(:x, :y, :z).filter{|o| (o.x > 1) & (o.y > 2)}.order(:z.desc)
     #
     # Note that inside a call to query, you cannot call each, insert, update,
     # or delete (or any method that calls those), or Sequel will raise an

data/lib/sequel_core/dataset/sql.rb

@@ -76,7 +76,7 @@ module Sequel
 
     # Formats a DELETE statement using the given options and dataset options.
     # 
-    #   dataset.filter(:price >= 100).delete_sql #=>
+    #   dataset.filter{|o| o.price >= 100}.delete_sql #=>
     #     "DELETE FROM items WHERE (price >= 100)"
     def delete_sql(opts = nil)
       opts = opts ? @opts.merge(opts) : @opts
@@ -163,13 +163,13 @@ module Sequel
     #     "SELECT * FROM items WHERE price < 100"
     #   dataset.filter(:active).sql #=>
     #     "SELECT * FROM items WHERE :active
-    #   dataset.filter(:price < 100).sql #=>
+    #   dataset.filter{|o| o.price < 100}.sql #=>
     #     "SELECT * FROM items WHERE (price < 100)"
     # 
     # Multiple filter calls can be chained for scoping:
     #
     #   software = dataset.filter(:category => 'software')
-    #   software.filter(price < 100).sql #=>
+    #   software.filter{|o| o.price < 100}.sql #=>
     #     "SELECT * FROM items WHERE ((category = 'software') AND (price < 100))"
     #
     # See doc/dataset_filters.rdoc for more examples and details.
@@ -572,8 +572,8 @@ module Sequel
     # being quoted, returns name as a string.  If identifiers are being quoted
     # quote the name with quoted_identifier.
     def quote_identifier(name)
-      name = name.to_s
-      name = name.upcase if upcase_identifiers?
+      return name if name.is_a?(LiteralString)
+      name = input_identifier(name)
       name = quoted_identifier(name) if quote_identifiers?
       name
     end
@@ -590,7 +590,7 @@ module Sequel
     # should be overridden by subclasses to provide quoting not matching the
     # SQL standard, such as backtick (used by MySQL and SQLite).
     def quoted_identifier(name)
-      "\"#{name}\""
+      "\"#{name.to_s.gsub('"', '""')}\""
     end
 
     # Returns a copy of the dataset with the order reversed. If no order is

data/lib/sequel_core/exceptions.rb

@@ -31,6 +31,10 @@ module Sequel
   # Generic error raised by the database adapters, indicating a
   # problem originating from the database server.
   class DatabaseError < Error; end
+  
+  # Error raised when the Sequel is unable to connect to the database with the
+  # connection parameters it was given.
+  class DatabaseConnectionError < DatabaseError; end
 
   # Error that should be raised by adapters when they determine that the connection
   # to the database has been lost.  Instructs the connection pool code to 

data/lib/sequel_core/migration.rb

@@ -6,9 +6,9 @@ module Sequel
   #     def up
   #       create_table :sessions do
   #         primary_key :id
-  #         varchar   :session_id, :size => 32, :unique => true
-  #         timestamp :created_at
-  #         text      :data
+  #         String :session_id, :size => 32, :unique => true
+  #         DateTime :created_at
+  #         text :data
   #       end
   #     end
   # 
@@ -21,7 +21,7 @@ module Sequel
   #   class AlterItems < Sequel::Migration
   #     def up
   #       alter_table :items do
-  #         add_column :category, :text, :default => 'ruby'
+  #         add_column :category, String, :default => 'ruby'
   #       end
   #     end
   # 

data/lib/sequel_core/schema/generator.rb

@@ -13,6 +13,10 @@ module Sequel
     # allowing users to specify column type as a method instead of using
     # the column method, which makes for a nicer DSL.
     class Generator
+      # Classes specifying generic types that Sequel will convert to database-specific types.
+      GENERIC_TYPES=[String, Integer, Fixnum, Bignum, Float, Numeric, BigDecimal,
+      Date, DateTime, Time, File, TrueClass, FalseClass]
+      
       # Set the database in which to create the table, and evaluate the block
       # in the context of this object.
       def initialize(db, &block)
@@ -23,6 +27,16 @@ module Sequel
         instance_eval(&block) if block
       end
       
+      # Add a method for each of the given types that creates a column
+      # with that type as a constant.  Types given should either already
+      # be constants/classes or a capitalized string/symbol with the same name
+      # as a constant/class.
+      def self.add_type_method(*types)
+        types.each do |type|
+          class_eval "def #{type}(name, opts={}); column(name, #{type}, opts); end"
+        end
+      end
+      
       # Add a unnamed constraint to the DDL, specified by the given block
       # or args.
       def check(*args, &block)
@@ -87,10 +101,10 @@ module Sequel
         when NilClass
           opts
         else
-          raise(Error, "The seconds argument to foreign_key should be a Hash, Symbol, or nil")
+          raise(Error, "The second argument to foreign_key should be a Hash, Symbol, or nil")
         end
         return composite_foreign_key(name, opts) if name.is_a?(Array)
-        column(name, :integer, opts)
+        column(name, Integer, opts)
       end
       
       # Add a full text index on the given columns to the DDL.
@@ -173,6 +187,8 @@ module Sequel
         @columns << {:type => :check, :constraint_type => :foreign_key,
                      :name => nil, :columns => columns }.merge(opts)
       end
+      
+      add_type_method(*GENERIC_TYPES)
     end
   
     # Schema::AlterTableGenerator is an internal class that the user is not expected
@@ -222,7 +238,7 @@ module Sequel
       # use the composite key syntax even if it is only one column.
       def add_foreign_key(name, table, opts = {})
         return add_composite_foreign_key(name, table, opts) if name.is_a?(Array)
-        add_column(name, :integer, {:table=>table}.merge(opts))
+        add_column(name, Integer, {:table=>table}.merge(opts))
       end
       
       # Add a full text index on the given columns to the DDL for the table.

data/lib/sequel_core/schema/sql.rb

@@ -12,7 +12,11 @@ module Sequel
       SET_DEFAULT = 'SET DEFAULT'.freeze
       SET_NULL = 'SET NULL'.freeze
       TYPES = Hash.new {|h, k| k}
-      TYPES[:double] = 'double precision'
+      TYPES.merge!(:double=>'double precision', String=>'varchar',
+        Integer=>'integer', Fixnum=>'integer', Bignum=>'bigint',
+        Float=>'double precision', BigDecimal=>'numeric', Numeric=>'numeric',
+        Date=>'date', DateTime=>'timestamp', Time=>'timestamp', File=>'blob',
+        TrueClass=>'boolean', FalseClass=>'boolean')
       UNDERSCORE = '_'.freeze
       UNIQUE = ' UNIQUE'.freeze
       UNSIGNED = ' UNSIGNED'.freeze
@@ -110,7 +114,7 @@ module Sequel
       # Array of SQL DDL statements, the first for creating a table with the given
       # name and column specifications, and the others for specifying indexes on
       # the table.
-      def create_table_sql_list(name, columns, indexes = nil)
+      def create_table_sql_list(name, columns, indexes = nil, options = {})
         sql = ["CREATE TABLE #{quote_schema_table(name)} (#{column_list_sql(columns)})"]
         sql.concat(index_list_sql_list(name, indexes)) if indexes && !indexes.empty?
         sql
@@ -215,6 +219,8 @@ module Sequel
       # * :schema - An explicit schema to use.  It may also be implicitly provided
       #   via the table name.
       def schema(table = nil, opts={})
+        raise(Error, 'schema parsing is not implemented on this database') unless respond_to?(:schema_parse_table, true)
+
         if table
           sch, table_name = schema_and_table(table)
           quoted_name = quote_schema_table(table)
@@ -236,29 +242,20 @@ module Sequel
           end
         end
         
+        raise(Error, '#tables does not exist, you must provide a specific table to #schema') if table.nil? && !respond_to?(:tables, true)
+
         @schemas ||= Hash.new do |h,k|
           quote_name = quote_schema_table(k)
           h[quote_name] if h.include?(quote_name)
         end
 
         if table_name
-          if respond_to?(:schema_parse_table, true)
-            cols = schema_parse_table(table_name, opts)
-            raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.blank?
-            @schemas[quoted_name] = cols
-          else
-            raise Error, 'schema parsing is not implemented on this database'
-          end
+          cols = schema_parse_table(table_name, opts)
+          raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.blank?
+          @schemas[quoted_name] = cols
         else
-          if respond_to?(:schema_parse_tables, true)
-            @schemas.merge!(schema_parse_tables(opts))
-          elsif respond_to?(:schema_parse_table, true) and respond_to?(:tables, true)
-            tables.each{|t| @schemas[quote_identifier(t)] = schema_parse_table(t.to_s, opts)}
-            @schemas
-          else
-            @schemas = nil
-            raise Error, 'schema parsing is not implemented on this database'
-          end
+          tables.each{|t| @schemas[quote_schema_table(t)] = schema_parse_table(t.to_s, opts)}
+          @schemas
         end
       end
       
@@ -273,6 +270,12 @@ module Sequel
       def remove_cached_schema(table)
         @schemas.delete(quote_schema_table(table)) if @schemas
       end
+      
+      # Remove the cached schema_utility_dataset, because the identifier
+      # quoting has changed.
+      def reset_schema_utility_dataset
+        @schema_utility_dataset = nil
+      end
 
       # Match the database's column type to a ruby type via a
       # regular expression.  The following ruby types are supported:
@@ -306,9 +309,10 @@ module Sequel
 
       # SQL fragment specifying the type of a given column.
       def type_literal(column)
-        column[:size] ||= 255 if column[:type] == :varchar
+        type = type_literal_base(column)
+        column[:size] ||= 255 if type.to_s == 'varchar'
         elements = column[:size] || column[:elements]
-        "#{type_literal_base(column)}#{literal(Array(elements)) if elements}#{UNSIGNED if column[:unsigned]}"
+        "#{type}#{literal(Array(elements)) if elements}#{UNSIGNED if column[:unsigned]}"
       end
 
       # SQL fragment specifying the base type of a given column,

data/lib/sequel_core/sql.rb

@@ -334,11 +334,6 @@ module Sequel
     #
     #   :price.sql_number/10 > 100
     module ComplexExpressionMethods
-      include BooleanMethods
-      include NumericMethods
-      include StringMethods
-      include InequalityMethods
-
       # Extract a datetime_part (e.g. year, month) from self:
       #
       #   :date.extract(:year) # SQL:  extract(year FROM date)
@@ -365,23 +360,21 @@ module Sequel
       end
     end
 
-    module SpecificExpressionMethods
+    class ComplexExpression
       include AliasMethods
       include CastMethods
       include OrderMethods
     end
 
-    module GenericExpressionMethods
-      include SpecificExpressionMethods
-      include ComplexExpressionMethods
-    end
-
-    class ComplexExpression
-      include SpecificExpressionMethods
-    end
-
     class GenericExpression
-      include GenericExpressionMethods
+      include AliasMethods
+      include CastMethods
+      include OrderMethods
+      include ComplexExpressionMethods
+      include BooleanMethods
+      include NumericMethods
+      include StringMethods
+      include InequalityMethods
     end
 
     ### Classes ###
@@ -864,5 +857,9 @@ module Sequel
   class LiteralString < ::String
     include SQL::OrderMethods
     include SQL::ComplexExpressionMethods
+    include SQL::BooleanMethods
+    include SQL::NumericMethods
+    include SQL::StringMethods
+    include SQL::InequalityMethods
   end
 end