sequel 3.4.0 → 3.5.0

data/lib/sequel/adapters/shared/mysql.rb

@@ -97,7 +97,7 @@ module Sequel
           opts[:null] = o == :set_column_null ? op[:null] : opts[:allow_null]
           opts[:default] = o == :set_column_default ? op[:default] : opts[:ruby_default]
           opts.delete(:default) if opts[:default] == nil
-          "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(opts)}"
+          "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(opts))}"
         when :drop_index
           "#{drop_index_sql(table, op)} ON #{quote_schema_table(table)}"
         else
@@ -199,7 +199,10 @@ module Sequel
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
       COMMA_SEPARATOR = ', '.freeze
-      SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
+      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'from where order limit')
+      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'ignore into columns values on_duplicate_key_update')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
+      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'table set where order limit')
       
       # MySQL specific syntax for LIKE/REGEXP searches, as well as
       # string concatenation.
@@ -217,14 +220,6 @@ module Sequel
           super(op, args)
         end
       end
-      
-      # MySQL supports ORDER and LIMIT clauses in DELETE statements.
-      def delete_sql
-        sql = super
-        sql << " ORDER BY #{expression_list(opts[:order])}" if opts[:order]
-        sql << " LIMIT #{opts[:limit]}" if opts[:limit]
-        sql
-      end
 
       # Adds full text filter
       def full_text_search(cols, terms, opts = {})
@@ -305,8 +300,7 @@ module Sequel
 
       # MySQL specific syntax for inserting multiple values at once.
       def multi_insert_sql(columns, values)
-        values = values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)
-        ["#{insert_sql_base}#{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES #{values}#{insert_sql_suffix}"]
+        [insert_sql(columns, LiteralString.new('VALUES ' + values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)))]
       end
       
       # MySQL uses the nonstandard ` (backtick) for quoting identifiers.
@@ -367,31 +361,55 @@ module Sequel
         false
       end
 
-      # MySQL supports ORDER and LIMIT clauses in UPDATE statements.
-      def update_sql(values)
-        sql = super
-        sql << " ORDER BY #{expression_list(opts[:order])}" if opts[:order]
-        sql << " LIMIT #{opts[:limit]}" if opts[:limit]
-        sql
+      private
+
+      # MySQL supports the ORDER BY and LIMIT clauses for DELETE statements
+      def delete_clause_methods
+        DELETE_CLAUSE_METHODS
       end
 
-      private
+      # MySQL supports the IGNORE and ON DUPLICATE KEY UPDATE clauses for INSERT statements
+      def insert_clause_methods
+        INSERT_CLAUSE_METHODS
+      end
+
+      # MySQL doesn't use the SQL standard DEFAULT VALUES.
+      def insert_columns_sql(sql)
+        values = opts[:values]
+        if values.is_a?(Array) && values.empty?
+          sql << " ()"
+        else
+          super
+        end
+      end
 
       # MySQL supports INSERT IGNORE INTO
-      def insert_sql_base
-        "INSERT #{'IGNORE ' if opts[:insert_ignore]}INTO "
+      def insert_ignore_sql(sql)
+        sql << " IGNORE" if opts[:insert_ignore]
       end
 
       # MySQL supports INSERT ... ON DUPLICATE KEY UPDATE
-      def insert_sql_suffix
-        on_duplicate_key_update_sql if opts[:on_duplicate_key_update]
+      def insert_on_duplicate_key_update_sql(sql)
+        sql << on_duplicate_key_update_sql if opts[:on_duplicate_key_update]
       end
 
-      # MySQL doesn't use the SQL standard DEFAULT VALUES.
-      def insert_default_values_sql
-        "#{insert_sql_base}#{source_list(@opts[:from])} () VALUES ()"
+      # MySQL doesn't use the standard DEFAULT VALUES for empty values.
+      def insert_values_sql(sql)
+        values = opts[:values]
+        if values.is_a?(Array) && values.empty?
+          sql << " VALUES ()"
+        else
+          super
+        end
       end
-      
+
+      # MySQL allows a LIMIT in DELETE and UPDATE statements.
+      def limit_sql(sql)
+        sql << " LIMIT #{@opts[:limit]}" if @opts[:limit]
+      end
+      alias delete_limit_sql limit_sql
+      alias update_limit_sql limit_sql
+
       # Use 0 for false on MySQL
       def literal_false
         BOOL_FALSE
@@ -420,10 +438,15 @@ module Sequel
           " ON DUPLICATE KEY UPDATE #{updating.join(COMMA_SEPARATOR)}"
         end
       end
-      
-      # MySQL does not support the SQL WITH clause
-      def select_clause_order
-        SELECT_CLAUSE_ORDER
+
+      # MySQL does not support the SQL WITH clause for SELECT statements
+      def select_clause_methods
+        SELECT_CLAUSE_METHODS
+      end
+
+      # MySQL supports the ORDER BY and LIMIT clauses for UPDATE statements
+      def update_clause_methods
+        UPDATE_CLAUSE_METHODS
       end
     end
   end

data/lib/sequel/adapters/shared/oracle.rb

@@ -94,12 +94,13 @@ module Sequel
     end
     
     module DatasetMethods
-      SELECT_CLAUSE_ORDER = %w'with distinct columns from join where group having compounds order limit'.freeze
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with distinct columns from join where group having compounds order limit')
 
       # Oracle uses MINUS instead of EXCEPT, and doesn't support EXCEPT ALL
-      def except(dataset, all = false)
-        raise(Sequel::Error, "EXCEPT ALL not supported") if all
-        compound_clone(:minus, dataset, all)
+      def except(dataset, opts={})
+        opts = {:all=>opts} unless opts.is_a?(Hash)
+        raise(Sequel::Error, "EXCEPT ALL not supported") if opts[:all]
+        compound_clone(:minus, dataset, opts)
       end
 
       def empty?
@@ -139,13 +140,23 @@ module Sequel
         "#{expression} #{quote_identifier(aliaz)}"
       end
 
+      # The strftime format to use when literalizing the time.
+      def default_timestamp_format
+        "TIMESTAMP '%Y-%m-%d %H:%M:%S%N %z'".freeze
+      end
+
+      # Use a colon for the timestamp offset, since Oracle appears to require it.
+      def format_timestamp_offset(hour, minute)
+        sprintf("%+03i:%02i", hour, minute)
+      end
+
       # Oracle uses the SQL standard of only doubling ' inside strings.
       def literal_string(v)
         "'#{v.gsub("'", "''")}'"
       end
 
-      def select_clause_order
-        SELECT_CLAUSE_ORDER
+      def select_clause_methods
+        SELECT_CLAUSE_METHODS
       end
 
       # Modify the SQL to add the list of tables to select FROM

data/lib/sequel/adapters/shared/postgres.rb

@@ -587,8 +587,8 @@ module Sequel
       QUERY_PLAN = 'QUERY PLAN'.to_sym
       ROW_EXCLUSIVE = 'ROW EXCLUSIVE'.freeze
       ROW_SHARE = 'ROW SHARE'.freeze
-      SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit lock'.freeze
-      SELECT_CLAUSE_ORDER_84 = %w'with distinct columns from join where group having window compounds order limit lock'.freeze
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'distinct columns from join where group having compounds order limit lock')
+      SELECT_CLAUSE_METHODS_84 = Dataset.clause_methods(:select, %w'with distinct columns from join where group having window compounds order limit lock')
       SHARE = 'SHARE'.freeze
       SHARE_ROW_EXCLUSIVE = 'SHARE ROW EXCLUSIVE'.freeze
       SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
@@ -668,7 +668,8 @@ module Sequel
 
       # Insert a record returning the record inserted
       def insert_select(*values)
-        naked.clone(default_server_opts(:sql=>insert_returning_sql(nil, *values))).single_record if server_version >= 80200
+        return if opts[:disable_insert_returning] || server_version < 80200
+        naked.clone(default_server_opts(:sql=>insert_returning_sql(nil, *values))).single_record
       end
 
       # Locks the table with the specified mode.
@@ -689,8 +690,7 @@ module Sequel
         return super if server_version < 80200
         
         # postgresql 8.2 introduces support for multi-row insert
-        values = values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)
-        ["#{insert_sql_base}#{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES #{values}"]
+        [insert_sql(columns, LiteralString.new('VALUES ' + values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)))]
       end
       
       # PostgreSQL supports timezones in literal timestamps
@@ -737,8 +737,8 @@ module Sequel
       end
 
       # The order of clauses in the SELECT SQL statement
-      def select_clause_order
-        server_version >= 80400 ? SELECT_CLAUSE_ORDER_84 : SELECT_CLAUSE_ORDER
+      def select_clause_methods
+        server_version >= 80400 ? SELECT_CLAUSE_METHODS_84 : SELECT_CLAUSE_METHODS
       end
 
       # SQL fragment for named window specifications

data/lib/sequel/adapters/shared/progress.rb

@@ -15,7 +15,7 @@ module Sequel
     end
   
     module DatasetMethods
-      SELECT_CLAUSE_ORDER = %w'limit distinct columns from join where group order having compounds'.freeze
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'limit distinct columns from join where group order having compounds')
 
       # Progress requires SQL standard datetimes
       def requires_sql_standard_datetimes?
@@ -29,8 +29,8 @@ module Sequel
 
       private
 
-      def select_clause_order
-        SELECT_CLAUSE_ORDER
+      def select_clause_methods
+        SELECT_CLAUSE_METHODS
       end
 
       # Progress uses TOP for limit, but it is only supported in Progress 10.

data/lib/sequel/adapters/shared/sqlite.rb

@@ -235,7 +235,7 @@ module Sequel
     
     # Instance methods for datasets that connect to an SQLite database
     module DatasetMethods
-      SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
       CONSTANT_MAP = {:CURRENT_DATE=>"date(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIMESTAMP=>"datetime(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIME=>"time(CURRENT_TIMESTAMP, 'localtime')".freeze}
     
       # SQLite does not support pattern matching via regular expressions.
@@ -265,20 +265,6 @@ module Sequel
         @opts[:where] ? super : filter(1=>1).delete
       end
       
-      # Insert the values into the database.
-      def insert(*values)
-        execute_insert(insert_sql(*values))
-      end
-      
-      # Allow inserting of values directly from a dataset.
-      def insert_sql(*values)
-        if (values.size == 1) && values.first.is_a?(Sequel::Dataset)
-          "#{insert_sql_base}#{source_list(@opts[:from])} #{values.first.sql};"
-        else
-          super(*values)
-        end
-      end
-      
       # SQLite uses the nonstandard ` (backtick) for quoting identifiers.
       def quoted_identifier(c)
         "`#{c}`"
@@ -316,8 +302,8 @@ module Sequel
       end
       
       # SQLite does not support the SQL WITH clause
-      def select_clause_order
-        SELECT_CLAUSE_ORDER
+      def select_clause_methods
+        SELECT_CLAUSE_METHODS
       end
       
       # SQLite treats a DELETE with no WHERE clause as a TRUNCATE

data/lib/sequel/connection_pool.rb

@@ -116,8 +116,8 @@ class Sequel::ConnectionPool
       ensure
         @mutex.synchronize{release(t, server)} if conn && !dde
       end
-    rescue StandardError => e
-      raise e
+    rescue StandardError 
+      raise
     rescue Exception => e
       raise(@convert_exceptions ? RuntimeError.new(e.message) : e)
     end
@@ -168,9 +168,7 @@ class Sequel::ConnectionPool
       begin
         conn = @connection_proc.call(server)
       rescue Exception=>exception
-        e = Sequel::DatabaseConnectionError.new("#{exception.class} #{exception.message}")
-        e.set_backtrace(exception.backtrace)
-        raise e
+        raise Sequel.convert_exception_class(exception, Sequel::DatabaseConnectionError)
       end
       raise(Sequel::DatabaseConnectionError, "Connection parameters not valid") unless conn
       conn
@@ -236,7 +234,7 @@ class Sequel::SingleThreadedPool
     begin
       begin
         yield(c = (@conns[server] ||= @connection_proc.call(server)))
-      rescue Sequel::DatabaseDisconnectError => dde
+      rescue Sequel::DatabaseDisconnectError
         @conns.delete(server)
         @disconnection_proc.call(c) if @disconnection_proc
         raise

data/lib/sequel/core.rb

@@ -59,28 +59,12 @@
 # You can set the SEQUEL_NO_CORE_EXTENSIONS constant or environment variable to have
 # Sequel not extend the core classes.
 module Sequel
-  # The offset of the current time zone from UTC, in seconds.
-  LOCAL_DATETIME_OFFSET_SECS = Time.now.utc_offset
-  
-  # The offset of the current time zone from UTC, as a fraction of a day.
-  LOCAL_DATETIME_OFFSET = respond_to?(:Rational, true) ? Rational(LOCAL_DATETIME_OFFSET_SECS, 60*60*24) : LOCAL_DATETIME_OFFSET_SECS/60/60/24.0
-  
-  @application_timezone = nil
   @convert_two_digit_years = true
-  @database_timezone = nil
   @datetime_class = Time
-  @typecast_timezone = nil
   @virtual_row_instance_eval = true
   
   class << self
     attr_accessor :convert_two_digit_years, :datetime_class, :virtual_row_instance_eval
-    attr_accessor :application_timezone, :database_timezone, :typecast_timezone
-  end
-  
-  # Convert the given Time/DateTime object into the database timezone, used when
-  # literalizing objects in an SQL string.
-  def self.application_to_database_timestamp(v)
-    convert_output_timestamp(v, Sequel.database_timezone)
   end
 
   # Returns true if the passed object could be a specifier of conditions, false otherwise.
@@ -116,20 +100,17 @@ module Sequel
     Database.connect(*args, &block)
   end
   
-  # Convert the given object into an object of Sequel.datetime_class in the
-  # application_timezone.  Used when coverting datetime/timestamp columns
-  # returned by the database.
-  def self.database_to_application_timestamp(v)
-    convert_timestamp(v, Sequel.database_timezone)
-  end
-  
-  # Sets the database, application, and typecasting timezones to the given timezone. 
-  def self.default_timezone=(tz)
-    self.database_timezone = tz
-    self.application_timezone = tz
-    self.typecast_timezone = tz
+  # Convert the exception to the given class.  The given class should be
+  # Sequel::Error or a subclass.  Returns an instance of klass with
+  # the message and backtrace of exception.
+  def self.convert_exception_class(exception, klass)
+    return exception if exception.is_a?(klass)
+    e = klass.new("#{exception.class}: #{exception.message}")
+    e.wrapped_exception = exception
+    e.set_backtrace(exception.backtrace)
+    e
   end
-  
+
   # Load all Sequel extensions given.  Only loads extensions included in this
   # release of Sequel, doesn't load external extensions.
   #
@@ -199,7 +180,7 @@ module Sequel
     begin
       Date.parse(s, Sequel.convert_two_digit_years)
     rescue => e
-      raise InvalidValue, "Invalid Date value #{s.inspect} (#{e.message})"
+      raise convert_exception_class(e, InvalidValue)
     end
   end
 
@@ -213,7 +194,7 @@ module Sequel
         datetime_class.parse(s)
       end
     rescue => e
-      raise InvalidValue, "Invalid #{datetime_class} value #{s.inspect} (#{e.message})"
+      raise convert_exception_class(e, InvalidValue)
     end
   end
 
@@ -222,15 +203,22 @@ module Sequel
     begin
       Time.parse(s)
     rescue => e
-      raise InvalidValue, "Invalid Time value #{s.inspect} (#{e.message})"
+      raise convert_exception_class(e, InvalidValue)
     end
   end
-  
-  # Convert the given object into an object of Sequel.datetime_class in the
-  # application_timezone.  Used when typecasting values when assigning them
-  # to model datetime attributes.
-  def self.typecast_to_application_timestamp(v)
-    convert_timestamp(v, Sequel.typecast_timezone)
+
+  # If the supplied block takes a single argument,
+  # yield a new SQL::VirtualRow instance to the block
+  # argument.  Otherwise, evaluate the block in the context of a new
+  # SQL::VirtualRow instance.
+  def self.virtual_row(&block)
+    vr = SQL::VirtualRow.new
+    case block.arity
+    when -1, 0
+      vr.instance_eval(&block)
+    else
+      block.call(vr)
+    end  
   end
   
   ### Private Class Methods ###
@@ -248,90 +236,18 @@ module Sequel
     end
     connect(opts, &block)
   end
-  
-  # Converts the object from a String, Array, Date, DateTime, or Time into an
-  # instance of Sequel.datetime_class.  If a string and an offset is not given,
-  # assume that the string is already in the given input_timezone.
-  def self.convert_input_timestamp(v, input_timezone) # :nodoc:
-    case v
-    when String
-      v2 = Sequel.string_to_datetime(v)
-      if !input_timezone || Date._parse(v).has_key?(:offset)
-        v2
-      else
-        # Correct for potentially wrong offset if offset is given
-        if v2.is_a?(DateTime)
-          # DateTime assumes UTC if no offset is given
-          v2 = v2.new_offset(LOCAL_DATETIME_OFFSET) - LOCAL_DATETIME_OFFSET if input_timezone == :local
-        else
-          # Time assumes local time if no offset is given
-          v2 = v2.getutc + LOCAL_DATETIME_OFFSET_SECS if input_timezone == :utc
-        end
-        v2
-      end
-    when Array
-      y, mo, d, h, mi, s = v
-      if datetime_class == DateTime
-        DateTime.civil(y, mo, d, h, mi, s, input_timezone == :utc ? 0 : LOCAL_DATETIME_OFFSET)
-      else
-        Time.send(input_timezone == :utc ? :utc : :local, y, mo, d, h, mi, s)
-      end
-    when Time
-      if datetime_class == DateTime
-        v.respond_to?(:to_datetime) ? v.to_datetime : string_to_datetime(v.iso8601)
-      else
-        v
-      end
-    when DateTime
-      if datetime_class == DateTime
-        v
-      else
-        v.respond_to?(:to_time) ? v.to_time : string_to_datetime(v.to_s)
-      end
-    when Date
-      convert_input_timestamp(v.to_s, input_timezone)
-    else
-      raise InvalidValue, "Invalid convert_input_timestamp type: #{v.inspect}"
-    end
-  end
-  
-  # Converts the object to the given output_timezone.
-  def self.convert_output_timestamp(v, output_timezone) # :nodoc:
-    if output_timezone
-      if v.is_a?(DateTime)
-        v.new_offset(output_timezone == :utc ? 0 : LOCAL_DATETIME_OFFSET)
-      else
-        v.send(output_timezone == :utc ? :getutc : :getlocal)
-      end
-    else
-      v
-    end
-  end
-  
-  # Converts the given object from the given input timezone to the
-  # application timezone using convert_input_timestamp and
-  # convert_output_timestamp.
-  def self.convert_timestamp(v, input_timezone) # :nodoc:
-    begin
-      convert_output_timestamp(convert_input_timestamp(v, input_timezone), Sequel.application_timezone)
-    rescue InvalidValue
-      raise
-    rescue
-      raise InvalidValue, "Invalid #{datetime_class} value: #{v.inspect}"
-    end
-  end
 
   # Method that adds a database adapter class method to Sequel that calls
   # Sequel.adapter_method.
   def self.def_adapter_method(*adapters) # :nodoc:
     adapters.each do |adapter|
-      instance_eval("def #{adapter}(*args, &block); adapter_method('#{adapter}', *args, &block) end")
+      instance_eval("def #{adapter}(*args, &block); adapter_method('#{adapter}', *args, &block) end", __FILE__, __LINE__)
     end
   end
 
-  private_class_method :adapter_method, :convert_input_timestamp, :convert_output_timestamp, :convert_timestamp, :def_adapter_method
+  private_class_method :adapter_method, :def_adapter_method
   
-  require(%w"metaprogramming sql connection_pool exceptions dataset database version")
+  require(%w"metaprogramming sql connection_pool exceptions dataset database timezones version")
   require(%w"schema_generator schema_methods schema_sql", 'database')
   require(%w"convenience graph prepared_statements sql", 'dataset')
   require('core_sql') if !defined?(::SEQUEL_NO_CORE_EXTENSIONS) && !ENV.has_key?('SEQUEL_NO_CORE_EXTENSIONS')