sequel 2.4.0 → 2.5.0

data/lib/sequel_core/adapters/sqlite.rb

@@ -78,7 +78,7 @@ module Sequel
             conn.transaction{result = yield(conn)}
             result
           rescue ::Exception => e
-            raise (SQLite3::Exception === e ? Error.new(e.message) : e) unless Error::Rollback === e
+            transaction_error(e, SQLite3::Exception)
           end
         end
       end
@@ -92,7 +92,7 @@ module Sequel
           log_info(sql, opts[:arguments])
           synchronize(opts[:server]){|conn| yield conn}
         rescue SQLite3::Exception => e
-          raise Error::InvalidStatement, "#{sql}\r\n#{e.message}"
+          raise_error(e)
         end
       end
       

data/lib/sequel_core/core_ext.rb

@@ -160,18 +160,18 @@ class String
   # Converts a string into a Date object.
   def to_date
     begin
-      Date.parse(self)
+      Date.parse(self, Sequel.convert_two_digit_years)
     rescue => e
-      raise Sequel::Error::InvalidValue, "Invalid date value '#{self}' (#{e.message})"
+      raise Sequel::Error::InvalidValue, "Invalid Date value '#{self}' (#{e.message})"
     end
   end
 
   # Converts a string into a DateTime object.
   def to_datetime
     begin
-      DateTime.parse(self)
+      DateTime.parse(self, Sequel.convert_two_digit_years)
     rescue => e
-      raise Sequel::Error::InvalidValue, "Invalid date value '#{self}' (#{e.message})"
+      raise Sequel::Error::InvalidValue, "Invalid DateTime value '#{self}' (#{e.message})"
     end
   end
 
@@ -179,9 +179,13 @@ class String
   # value of Sequel.datetime_class
   def to_sequel_time
     begin
-      Sequel.datetime_class.parse(self)
+      if Sequel.datetime_class == DateTime
+        DateTime.parse(self, Sequel.convert_two_digit_years)
+      else
+        Sequel.datetime_class.parse(self)
+      end
     rescue => e
-      raise Sequel::Error::InvalidValue, "Invalid time value '#{self}' (#{e.message})"
+      raise Sequel::Error::InvalidValue, "Invalid #{Sequel.datetime_class} value '#{self}' (#{e.message})"
     end
   end
 
@@ -190,7 +194,7 @@ class String
     begin
       Time.parse(self)
     rescue => e
-      raise Sequel::Error::InvalidValue, "Invalid time value '#{self}' (#{e.message})"
+      raise Sequel::Error::InvalidValue, "Invalid Time value '#{self}' (#{e.message})"
     end
   end
 end

data/lib/sequel_core/database.rb

@@ -371,7 +371,7 @@ module Sequel
         rescue Exception => e
           log_info(SQL_ROLLBACK)
           conn.execute(SQL_ROLLBACK)
-          raise e unless Error::Rollback === e
+          transaction_error(e)
         ensure
           unless e
             log_info(SQL_COMMIT)
@@ -495,6 +495,23 @@ module Sequel
     def connection_pool_default_options
       {}
     end
+
+    # Convert the given exception to a DatabaseError, keeping message
+    # and traceback.
+    def raise_error(exception, opts={})
+      if !opts[:classes] || exception.is_one_of?(*opts[:classes])
+        e = DatabaseError.new("#{exception.class} #{exception.message}")
+        e.set_backtrace(exception.backtrace)
+        raise e
+      else
+        raise exception
+      end
+    end
+
+    # Raise a database error unless the exception is an Error::Rollback.
+    def transaction_error(e, *classes)
+      raise_error(e, :classes=>classes) unless Error::Rollback === e
+    end
   end
 end
 

data/lib/sequel_core/dataset.rb

@@ -52,7 +52,8 @@ module Sequel
     group group_and_count group_by having inner_join intersect invert join
     left_outer_join limit naked or order order_by order_more paginate query reject
     reverse reverse_order right_outer_join select select_all select_more
-    set_graph_aliases set_model sort sort_by unfiltered union unordered where'.collect{|x| x.to_sym}
+    set_defaults set_graph_aliases set_model set_overrides sort sort_by
+    unfiltered union unordered where'.collect{|x| x.to_sym}
 
     NOTIMPL_MSG = "This method must be overridden in Sequel adapters".freeze
     STOCK_TRANSFORMS = {
@@ -183,14 +184,15 @@ module Sequel
       end
     end
 
-    # Deletes the records in the dataset. Adapters should override this method.
+    # Deletes the records in the dataset.  The returned value is generally the
+    # number of records deleted, but that is adapter dependent.
     def delete(*args)
       execute_dui(delete_sql(*args))
     end
     
     # Iterates over the records in the dataset.
     def each(opts = nil, &block)
-      if graph = @opts[:graph]
+      if @opts[:graph] and !(opts && opts[:graph] == false)
         graph_each(opts, &block)
       else
         row_proc = @row_proc unless opts && opts[:naked]
@@ -205,13 +207,14 @@ module Sequel
     end
 
     # Executes a select query and fetches records, passing each record to the
-    # supplied block. Adapters should override this method.
+    # supplied block.  The yielded records are generally hashes with symbol keys,
+    # but that is adapter dependent.
     def fetch_rows(sql, &block)
       raise NotImplementedError, NOTIMPL_MSG
     end
   
-    # Inserts values into the associated table. Adapters should override this
-    # method.
+    # 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))
     end
@@ -260,6 +263,12 @@ module Sequel
       update(*args)
     end
 
+    # Set the default values for insert and update statements.  The values passed
+    # to insert or update are merged into this hash.
+    def set_defaults(hash)
+      clone(:defaults=>(@opts[:defaults]||{}).merge(hash))
+    end
+
     # Associates or disassociates the dataset with a model(s). If
     # nil is specified, the dataset is turned into a naked dataset and returns
     # records as hashes. If a model class specified, the dataset is modified
@@ -342,6 +351,12 @@ module Sequel
       self
     end
     
+    # Set values that override hash arguments given to insert and update statements.
+    # This hash is merged into the hash provided to insert or update.
+    def set_overrides(hash)
+      clone(:overrides=>hash.merge(@opts[:overrides]||{}))
+    end
+
     # Sets a value transform which is used to convert values loaded and saved
     # to/from the database. The transform should be supplied as a hash. Each
     # value in the hash should be an array containing two proc objects - one
@@ -399,7 +414,8 @@ module Sequel
       end
     end
     
-    # Updates values for the dataset. Adapters should override this method.
+    # Updates values for the dataset.  The returned value is generally the
+    # number of rows updated, but that is adapter dependent.
     def update(*args)
       execute_dui(update_sql(*args))
     end

data/lib/sequel_core/dataset/convenience.rb

@@ -184,7 +184,7 @@ module Sequel
     # Returns the first value of the first record in the dataset.
     # Returns nil if dataset is empty.
     def single_value(opts = nil)
-      if r = naked.single_record(opts)
+      if r = single_record((opts||{}).merge(:graph=>false, :naked=>true))
         r.values.first
       end
     end

data/lib/sequel_core/dataset/sql.rb

@@ -70,6 +70,10 @@ module Sequel
     def delete_sql(opts = nil)
       opts = opts ? @opts.merge(opts) : @opts
 
+      if sql = opts[:sql]
+        return sql
+      end
+
       if opts[:group]
         raise Error::InvalidOperation, "Grouped datasets cannot be deleted from"
       elsif opts[:from].is_a?(Array) && opts[:from].size > 1
@@ -256,41 +260,46 @@ module Sequel
     #   dataset.insert_sql(:a => 1, :b => 2) #=>
     #     'INSERT INTO items (a, b) VALUES (1, 2)'
     def insert_sql(*values)
-      if values.empty?
-        insert_default_values_sql
-      else
-        values = values[0] if values.size == 1
-        
-        # if hash or array with keys we need to transform the values
-        if @transform && (values.is_a?(Hash) || (values.is_a?(Array) && values.keys))
-          values = transform_save(values)
+      if sql = @opts[:sql]
+        return sql
+      end
+
+      from = source_list(@opts[:from])
+      case values.size
+      when 0
+        values = {}
+      when 1
+        vals = values.at(0)
+        if vals.is_one_of?(Hash, Dataset, Array)
+          values = vals
+        elsif vals.respond_to?(:values)
+          values = vals.values
         end
-        from = source_list(@opts[:from])
-
-        case values
-        when Array
-          if values.empty?
-            insert_default_values_sql
-          else
-            "INSERT INTO #{from} VALUES #{literal(values)}"
-          end
-        when Hash
-          if values.empty?
-            insert_default_values_sql
-          else
-            fl, vl = [], []
-            values.each {|k, v| fl << literal(k.is_a?(String) ? k.to_sym : k); vl << literal(v)}
-            "INSERT INTO #{from} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
-          end
-        when Dataset
-          "INSERT INTO #{from} #{literal(values)}"
+      end
+
+      case values
+      when Array
+        if values.empty?
+          insert_default_values_sql
+        else
+          "INSERT INTO #{from} VALUES #{literal(values)}"
+        end
+      when Hash
+        values = @opts[:defaults].merge(values) if @opts[:defaults]
+        values = values.merge(@opts[:overrides]) if @opts[:overrides]
+        values = transform_save(values) if @transform
+        if values.empty?
+          insert_default_values_sql
         else
-          if values.respond_to?(:values)
-            insert_sql(values.values)
-          else
-            "INSERT INTO #{from} VALUES (#{literal(values)})"
+          fl, vl = [], []
+          values.each do |k, v|
+            fl << literal(String === k ? k.to_sym : k)
+            vl << literal(v)
           end
+          "INSERT INTO #{from} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
         end
+      when Dataset
+        "INSERT INTO #{from} #{literal(values)}"
       end
     end
     
@@ -698,6 +707,10 @@ module Sequel
     def update_sql(values = {}, opts = nil)
       opts = opts ? @opts.merge(opts) : @opts
 
+      if sql = opts[:sql]
+        return sql
+      end
+
       if opts[:group]
         raise Error::InvalidOperation, "A grouped dataset cannot be updated"
       elsif (opts[:from].size > 1) or opts[:join]
@@ -706,6 +719,8 @@ module Sequel
       
       sql = "UPDATE #{source_list(@opts[:from])} SET "
       set = if values.is_a?(Hash)
+        values = opts[:defaults].merge(values) if opts[:defaults]
+        values = values.merge(opts[:overrides]) if opts[:overrides]
         # get values from hash
         values = transform_save(values) if @transform
         values.map do |k, v|

data/lib/sequel_core/exceptions.rb

@@ -27,4 +27,8 @@ module Sequel
     # A transaction block will catch this error and won't pass further up the stack.
     class Rollback < Error ; end
   end  
+
+  # Generic error raised by the database adapters, indicating a
+  # problem originating from the database server.
+  class DatabaseError < Error; end
 end

data/lib/sequel_core/schema/generator.rb

@@ -48,6 +48,8 @@ module Sequel
       #   to whatever the database default is.
       # * :on_delete - Specify the behavior of this column when being deleted.
       #   See Schema::SQL#on_delete_clause for options.
+      # * :on_update - Specify the behavior of this column when being updated.
+      #   See Schema::SQL#on_delete_clause for options.
       # * :size - The size of the column, generally used with string
       #   columns to specify the maximum number of characters the column will hold.
       # * :unique - Mark the column is unique, generally has the same effect as
@@ -62,7 +64,8 @@ module Sequel
       # Adds a named constraint (or unnamed if name is nil) to the DDL,
       # with the given block or args.
       def constraint(name, *args, &block)
-        @columns << {:name => name, :type => :check, :check => block || args}
+        @columns << {:name => name, :type => :check, :check => block || args,
+                     :constraint_type => :check}
       end
       
       # Return the DDL created by the generator as a array of two elements,
@@ -85,6 +88,7 @@ module Sequel
         else
           raise(Error, "The seconds 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)
       end
       
@@ -118,6 +122,7 @@ module Sequel
       # can optionally provide a type argument and/or an options hash argument
       # to change the primary key options. See column for available options.
       def primary_key(name, *args)
+        return composite_primary_key(name, *args) if name.is_a?(Array)
         @primary_key = @db.serial_primary_key_options.merge({:name => name})
         
         if opts = args.pop
@@ -129,7 +134,7 @@ module Sequel
         end
         @primary_key
       end
-      
+
       # The name of the primary key for this table, if it has a primary key.
       def primary_key_name
         @primary_key[:name] if @primary_key
@@ -143,6 +148,21 @@ module Sequel
       # Add a unique index on the given columns to the DDL.
       def unique(columns, opts = {})
         index(columns, opts.merge(:unique => true))
+        @columns << {:type => :check, :constraint_type => :unique,
+                     :name => nil, :columns => Array(columns)}.merge(opts)
+      end
+
+      private
+
+      def composite_primary_key(columns, *args)
+        opts = args.pop || {}
+        @columns << {:type => :check, :constraint_type => :primary_key,
+                     :name => nil, :columns => columns}.merge(opts)
+      end
+
+      def composite_foreign_key(columns, opts)
+        @columns << {:type => :check, :constraint_type => :foreign_key,
+                     :name => nil, :columns => columns }.merge(opts)
       end
     end
   
@@ -170,12 +190,18 @@ module Sequel
       # See Generator#constraint.
       def add_constraint(name, *args, &block)
         @operations << {:op => :add_constraint, :name => name, :type => :check, \
-          :check => block || args}
+          :constraint_type => :check, :check => block || args}
+      end
+
+      def add_unique_constraint(columns, opts = {})
+        @operations << {:op => :add_constraint, :type => :check,
+          :constraint_type => :unique, :columns => Array(columns)}.merge(opts)
       end
 
       # Add a foreign key with the given name and referencing the given table
       # to the DDL for the table.  See Generator#column for the available options.
       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))
       end
       
@@ -194,6 +220,7 @@ module Sequel
       # Add a primary key to the DDL for the table.  See Generator#column
       # for the available options.
       def add_primary_key(name, opts = {})
+        return add_composite_primary_key(name, opts) if name.is_a?(Array)
         opts = @db.serial_primary_key_options.merge(opts)
         add_column(name, opts.delete(:type), opts)
       end
@@ -233,6 +260,19 @@ module Sequel
       def set_column_type(name, type)
         @operations << {:op => :set_column_type, :name => name, :type => type}
       end
+
+      private
+
+      def add_composite_primary_key(columns, opts)
+        @operations << {:op => :add_constraint, :type => :check,
+          :constraint_type => :primary_key, :columns => columns}.merge(opts)
+      end
+
+      def add_composite_foreign_key(columns, table, opts)
+        @operations << {:op => :add_constraint, :type => :check,
+          :constraint_type => :foreign_key, :columns => columns,
+          :table => table}.merge(opts)
+      end
     end
   end
 end

data/lib/sequel_core/schema/sql.rb

@@ -22,28 +22,29 @@ module Sequel
       def alter_table_sql(table, op)
         quoted_table = quote_identifier(table)
         quoted_name = quote_identifier(op[:name]) if op[:name]
-        case op[:op]
+        alter_table_op = case op[:op]
         when :add_column
-          "ALTER TABLE #{quoted_table} ADD COLUMN #{column_definition_sql(op)}"
+          "ADD COLUMN #{column_definition_sql(op)}"
         when :drop_column
-          "ALTER TABLE #{quoted_table} DROP COLUMN #{quoted_name}"
+          "DROP COLUMN #{quoted_name}"
         when :rename_column
-          "ALTER TABLE #{quoted_table} RENAME COLUMN #{quoted_name} TO #{quote_identifier(op[:new_name])}"
+          "RENAME COLUMN #{quoted_name} TO #{quote_identifier(op[:new_name])}"
         when :set_column_type
-          "ALTER TABLE #{quoted_table} ALTER COLUMN #{quoted_name} TYPE #{op[:type]}"
+          "ALTER COLUMN #{quoted_name} TYPE #{op[:type]}"
         when :set_column_default
-          "ALTER TABLE #{quoted_table} ALTER COLUMN #{quoted_name} SET DEFAULT #{literal(op[:default])}"
+          "ALTER COLUMN #{quoted_name} SET DEFAULT #{literal(op[:default])}"
         when :add_index
-          index_definition_sql(table, op)
+          return index_definition_sql(table, op)
         when :drop_index
-          "DROP INDEX #{default_index_name(table, op[:columns])}"
+          return drop_index_sql(table, op)
         when :add_constraint
-          "ALTER TABLE #{quoted_table} ADD #{constraint_definition_sql(op)}"
+          "ADD #{constraint_definition_sql(op)}"
         when :drop_constraint
-          "ALTER TABLE #{quoted_table} DROP CONSTRAINT #{quoted_name}"
+          "DROP CONSTRAINT #{quoted_name}"
         else
           raise Error, "Unsupported ALTER TABLE operation"
         end
+        "ALTER TABLE #{quoted_table} #{alter_table_op}"
       end
 
       # Array of SQL DDL modification statements for the given table,
@@ -61,22 +62,14 @@ module Sequel
       # SQL DDL fragment containing the column creation SQL for the given column.
       def column_definition_sql(column)
         return constraint_definition_sql(column) if column[:type] == :check
-        sql = "#{quote_identifier(column[:name])} #{type_literal(TYPES[column[:type]])}"
-        column[:size] ||= 255 if column[:type] == :varchar
-        elements = column[:size] || column[:elements]
-        sql << literal(Array(elements)) if elements
-        sql << UNSIGNED if column[:unsigned]
+        sql = "#{quote_identifier(column[:name])} #{type_literal(column)}"
         sql << UNIQUE if column[:unique]
         sql << NOT_NULL if column[:null] == false
         sql << NULL if column[:null] == true
         sql << " DEFAULT #{literal(column[:default])}" if column.include?(:default)
         sql << PRIMARY_KEY if column[:primary_key]
         sql << " #{auto_increment_sql}" if column[:auto_increment]
-        if column[:table]
-          sql << " REFERENCES #{quote_identifier(column[:table])}"
-          sql << "(#{quote_identifier(column[:key])})" if column[:key]
-          sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
-        end
+        sql << column_references_sql(column) if column[:table]
         sql
       end
       
@@ -85,11 +78,30 @@ module Sequel
       def column_list_sql(columns)
         columns.map{|c| column_definition_sql(c)}.join(COMMA_SEPARATOR)
       end
+
+      # SQL DDL fragment for column foreign key references
+      def column_references_sql(column)
+        sql = " REFERENCES #{quote_identifier(column[:table])}"
+        sql << "(#{Array(column[:key]).map{|x| quote_identifier(x)}.join(COMMA_SEPARATOR)})" if column[:key]
+        sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
+        sql << " ON UPDATE #{on_delete_clause(column[:on_update])}" if column[:on_update]
+        sql
+      end
     
       # SQL DDL fragment specifying a constraint on a table.
       def constraint_definition_sql(constraint)
         sql = constraint[:name] ? "CONSTRAINT #{quote_identifier(constraint[:name])} " : ""
-        sql << "CHECK #{filter_expr(constraint[:check])}"
+        case constraint[:constraint_type]
+        when :primary_key
+          sql << "PRIMARY KEY #{literal(constraint[:columns])}"
+        when :foreign_key
+          sql << "FOREIGN KEY #{literal(constraint[:columns])}"
+          sql << column_references_sql(constraint)
+        when :unique
+          sql << "UNIQUE #{literal(constraint[:columns])}"
+        else
+          sql << "CHECK #{filter_expr(constraint[:check])}"
+        end
         sql
       end
 
@@ -108,6 +120,11 @@ module Sequel
         "#{table_name}_#{columns.join(UNDERSCORE)}_index"
       end
     
+      # The SQL to drop an index for the table.
+      def drop_index_sql(table, op)
+        "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))}"
+      end
+
       # SQL DDL statement to drop the table with the given name.
       def drop_table_sql(name)
         "DROP TABLE #{quote_identifier(name)}"
@@ -127,7 +144,7 @@ module Sequel
         elsif index[:where]
           raise Error, "Partial indexes are not supported for this database"
         else
-          "CREATE #{'UNIQUE ' if index[:unique]}INDEX #{index_name} ON #{quote_identifier(table_name)} #{literal(index[:columns])}"
+          "CREATE #{'UNIQUE ' if index[:unique]}INDEX #{quote_identifier(index_name)} ON #{quote_identifier(table_name)} #{literal(index[:columns])}"
         end
       end
     
@@ -215,10 +232,6 @@ module Sequel
         @schema_utility_dataset ||= dataset
       end
       
-      # SQL fragment specifying the type of a given column.
-      def type_literal(t)
-        t.is_a?(Symbol) ? t.to_s : literal(t)
-      end
 
       private
 
@@ -320,6 +333,19 @@ module Sequel
         end
         schema
       end
+
+      # SQL fragment specifying the type of a given column.
+      def type_literal(column)
+        column[:size] ||= 255 if column[:type] == :varchar
+        elements = column[:size] || column[:elements]
+        "#{type_literal_base(column)}#{literal(Array(elements)) if elements}#{UNSIGNED if column[:unsigned]}"
+      end
+
+      # SQL fragment specifying the base type of a given column,
+      # without the size or elements.
+      def type_literal_base(column)
+        TYPES[column[:type]]
+      end
     end
   end
 end