sequel 2.10.0 → 2.11.0

data/lib/sequel_core/adapters/db2.rb

@@ -75,17 +75,6 @@ module Sequel
     class Dataset < Sequel::Dataset
       MAX_COL_SIZE = 256
       
-      def literal(v)
-        case v
-        when Time
-          literal(v.iso8601)
-        when Date, DateTime
-          literal(v.to_s)
-        else
-          super
-        end
-      end
-
       def fetch_rows(sql)
         execute(sql) do |sth|
           @column_info = get_column_info(sth)

data/lib/sequel_core/adapters/dbi.rb

@@ -76,17 +76,6 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      def literal(v)
-        case v
-        when Time
-          literal(v.iso8601)
-        when Date, DateTime
-          literal(v.to_s)
-        else
-          super
-        end
-      end
-
       def fetch_rows(sql, &block)
         execute(sql) do |s|
           begin

data/lib/sequel_core/adapters/do.rb

@@ -175,18 +175,6 @@ module Sequel
     
     # Dataset class for Sequel::DataObjects::Database objects.
     class Dataset < Sequel::Dataset
-      # Handle the usual time class overrides.
-      def literal(v)
-        case v
-        when Time
-          literal(v.iso8601)
-        when Date, DateTime
-          literal(v.to_s)
-        else
-          super
-        end
-      end
-      
       # Execute the SQL on the database and yield the rows as hashes
       # with symbol keys.
       def fetch_rows(sql)

data/lib/sequel_core/adapters/firebird.rb

@@ -1,4 +1,5 @@
 require 'fb'
+require 'sequel_core/adapters/utils/unsupported'
 
 module Sequel
   # The Sequel Firebird adapter requires the ruby fb driver located at
@@ -214,6 +215,7 @@ module Sequel
 
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
+      NULL = LiteralString.new('NULL').freeze
       COMMA_SEPARATOR = ', '.freeze
       FIREBIRD_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
       SELECT_CLAUSE_ORDER = %w'distinct limit columns from join where group having compounds order'.freeze
@@ -239,7 +241,7 @@ module Sequel
       # Insert given values into the database.
       def insert(*values)
         if !@opts[:sql]
-          single_value(:sql=>insert_returning_pk_sql(*values))
+          single_value(default_server_opts(:sql=>insert_returning_pk_sql(*values)))
         else
           execute_insert(insert_sql(*values), :table=>opts[:from].first,
             :values=>values.size == 1 ? values.first : values)
@@ -249,7 +251,7 @@ module Sequel
       # Use the RETURNING clause to return the primary key of the inserted record, if it exists
       def insert_returning_pk_sql(*values)
         pk = db.primary_key(opts[:from].first)
-        insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : 'NULL'.lit, *values)
+        insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : NULL, *values)
       end
 
       # Use the RETURNING clause to return the columns listed in returning.
@@ -259,20 +261,7 @@ module Sequel
 
       # Insert a record returning the record inserted
       def insert_select(*values)
-        single_record(:naked=>true, :sql=>insert_returning_sql(nil, *values))
-      end
-
-      def literal(v)
-        case v
-        when Time, DateTime
-          "#{v.strftime(FIREBIRD_TIMESTAMP_FORMAT)}.#{sprintf("%04d",v.usec / 100)}'"
-        when TrueClass
-          BOOL_TRUE
-        when FalseClass
-          BOOL_FALSE
-        else
-          super
-        end
+        single_record(default_server_opts(:naked=>true, :sql=>insert_returning_sql(nil, *values)))
       end
 
       # The order of clauses in the SELECT SQL statement
@@ -293,6 +282,22 @@ module Sequel
           m
         end
       end
+
+      def literal_datetime(v)
+        "#{v.strftime(FIREBIRD_TIMESTAMP_FORMAT)}.#{sprintf("%04d",(v.sec_fraction * 864000000))}'"
+      end
+
+      def literal_false
+        BOOL_FALSE
+      end
+
+      def literal_time(v)
+        "#{v.strftime(FIREBIRD_TIMESTAMP_FORMAT)}.#{sprintf("%04d",v.usec / 100)}'"
+      end
+
+      def literal_true
+        BOOL_TRUE
+      end
     end
   end
 end

data/lib/sequel_core/adapters/informix.rb

@@ -1,3 +1,4 @@
+require 'sequel_core/adapters/utils/unsupported'
 require 'informix'
 
 module Sequel
@@ -39,17 +40,6 @@ module Sequel
 
       SELECT_CLAUSE_ORDER = %w'limit distinct columns from join where having group compounds order'.freeze
 
-      def literal(v)
-        case v
-        when Time
-          literal(v.iso8601)
-        when Date, DateTime
-          literal(v.to_s)
-        else
-          super
-        end
-      end
-
       def fetch_rows(sql, &block)
         execute(sql) do |cursor|
           begin

data/lib/sequel_core/adapters/jdbc.rb

@@ -1,5 +1,5 @@
 require 'java'
-require 'sequel_core/dataset/stored_procedures'
+require 'sequel_core/adapters/utils/stored_procedures'
 
 module Sequel
   # Houses Sequel's JDBC support when running on JRuby.
@@ -414,18 +414,6 @@ module Sequel
         self
       end
       
-      # Use the ISO values for dates and times.
-      def literal(v)
-        case v
-        when Time
-          literal(v.iso8601)
-        when Date, DateTime, Java::JavaSql::Timestamp, Java::JavaSql::Date
-          literal(v.to_s)
-        else
-          super
-        end
-      end
-      
       # Create a named prepared statement that is stored in the
       # database (and connection) for reuse.
       def prepare(type, name=nil, values=nil)

data/lib/sequel_core/adapters/jdbc/h2.rb

@@ -1,3 +1,5 @@
+require 'sequel_core/adapters/utils/date_format'
+
 module Sequel
   module JDBC
     # Database and Dataset support for H2 databases accessed via JDBC.
@@ -52,17 +54,7 @@ module Sequel
       
       # Dataset class for H2 datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
-        # Use H2 syntax for Date, DateTime, and Time types.
-        def literal(v)
-          case v
-          when Date
-            v.strftime("DATE '%Y-%m-%d'") 
-          when DateTime, Time
-            v.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S'")
-          else
-            super
-          end
-        end
+        include Dataset::SQLStandardDateFormat
       end
     end
   end

data/lib/sequel_core/adapters/jdbc/mysql.rb

@@ -46,27 +46,10 @@ module Sequel
           execute_insert(insert_sql(*values))
         end
         
-        # Handle time types correctly
-        def literal(v)
-          case v
-          when Time, DateTime
-            v.strftime("'%Y-%m-%d %H:%M:%S'")
-          else
-            super
-          end
-        end
-        
         # Use execute_insert to execute the replace_sql.
         def replace(*args)
           execute_insert(replace_sql(*args))
         end
-        
-        private
-        
-        # Call execute_insert on the database.
-        def execute_insert(sql, opts={})
-          @db.execute_insert(sql, {:server=>@opts[:server] || :default}.merge(opts))
-        end
       end
     end
   end

data/lib/sequel_core/adapters/jdbc/postgresql.rb

@@ -91,21 +91,9 @@ module Sequel
           ps
         end
         
-        # Convert Java::JavaSql::Timestamps correctly, and handle Strings
-        # similar to the native postgres adapter.
-        def literal(v)
-          case v
-          when LiteralString
-            v
-          when SQL::Blob
-            super
-          when String
-            db.synchronize{|c| "'#{c.escape_string(v)}'"}
-          when Java::JavaSql::Timestamp
-            "TIMESTAMP #{literal(v.to_s)}"
-          else
-            super
-          end
+        # Literalize strings similar to the native postgres adapter
+        def literal_string(v)
+          db.synchronize{|c| "'#{c.escape_string(v)}'"}
         end
       end
     end

data/lib/sequel_core/adapters/mysql.rb

@@ -1,6 +1,6 @@
 require 'mysql'
 require 'sequel_core/adapters/shared/mysql'
-require 'sequel_core/dataset/stored_procedures'
+require 'sequel_core/adapters/utils/stored_procedures'
 
 module Sequel
   # Module for holding all MySQL-related classes and modules for Sequel.
@@ -27,10 +27,10 @@ module Sequel
       246 => :to_d,     # MYSQL_TYPE_NEWDECIMAL
       247 => :to_i,     # MYSQL_TYPE_ENUM
       248 => :to_i,      # MYSQL_TYPE_SET
-      249 => :to_blob,     # MYSQL_TYPE_TINY_BLOB
-      250 => :to_blob,     # MYSQL_TYPE_MEDIUM_BLOB
-      251 => :to_blob,     # MYSQL_TYPE_LONG_BLOB
-      252 => :to_blob,     # MYSQL_TYPE_BLOB
+      249 => :to_sequel_blob,     # MYSQL_TYPE_TINY_BLOB
+      250 => :to_sequel_blob,     # MYSQL_TYPE_MEDIUM_BLOB
+      251 => :to_sequel_blob,     # MYSQL_TYPE_LONG_BLOB
+      252 => :to_sequel_blob,     # MYSQL_TYPE_BLOB
       # 253 => :to_s,     # MYSQL_TYPE_VAR_STRING
       # 254 => :to_s,     # MYSQL_TYPE_STRING
       # 255 => :to_s      # MYSQL_TYPE_GEOMETRY
@@ -45,19 +45,30 @@ module Sequel
       # Support stored procedures on MySQL
       def call_sproc(name, opts={}, &block)
         args = opts[:args] || [] 
-        execute("CALL #{name}(#{literal(args) unless args.empty?})", opts.merge(:sproc=>false), &block)
+        execute("CALL #{name}#{args.empty? ? '()' : literal(args)}", opts.merge(:sproc=>false), &block)
       end
       
       # Connect to the database.  In addition to the usual database options,
       # the following options have effect:
       #
-      # * :encoding, :charset - Set all the related character sets for this
+      # * :auto_is_null - Set to true to use MySQL default behavior of having
+      #   a filter for an autoincrement column equals NULL to return the last
+      #   inserted row.
+      # * :charset - Same as :encoding (:encoding takes precendence)
+      # * :compress - Set to false to not compress results from the server
+      # * :encoding - Set all the related character sets for this
       #   connection (connection, client, database, server, and results).
       # * :socket - Use a unix socket file instead of connecting via TCP/IP.
+      # * :timeout - Set the timeout in seconds before the server will
+      #   disconnect this connection.
       def connect(server)
         opts = server_opts(server)
         conn = Mysql.init
         conn.options(Mysql::OPT_LOCAL_INFILE, "client")
+        if encoding = opts[:encoding] || opts[:charset]
+          # set charset _before_ the connect. using an option instead of "SET (NAMES|CHARACTER_SET_*)" works across reconnects
+          conn.options(Mysql::SET_CHARSET_NAME, encoding)
+        end
         conn.real_connect(
           opts[:host] || 'localhost',
           opts[:user],
@@ -67,16 +78,16 @@ module Sequel
           opts[:socket],
           Mysql::CLIENT_MULTI_RESULTS +
           Mysql::CLIENT_MULTI_STATEMENTS +
-          Mysql::CLIENT_COMPRESS
+          (opts[:compress] == false ? 0 : Mysql::CLIENT_COMPRESS)
         )
+
+        # increase timeout so mysql server doesn't disconnect us
+        conn.query("set @@wait_timeout = #{opts[:timeout] || 2592000}")
+
+        # By default, MySQL 'where id is null' selects the last inserted id
+        conn.query("set SQL_AUTO_IS_NULL=0") unless opts[:auto_is_null]
+
         conn.query_with_result = false
-        if encoding = opts[:encoding] || opts[:charset]
-          conn.query("set character_set_connection = '#{encoding}'")
-          conn.query("set character_set_client = '#{encoding}'")
-          conn.query("set character_set_database = '#{encoding}'")
-          conn.query("set character_set_server = '#{encoding}'")
-          conn.query("set character_set_results = '#{encoding}'")
-        end
         conn.meta_eval{attr_accessor :prepared_statements}
         conn.prepared_statements = {}
         conn.reconnect = true
@@ -288,18 +299,6 @@ module Sequel
         execute_dui(insert_sql(*values)){|c| c.insert_id}
       end
       
-      # Handle correct quoting of strings using ::MySQL.quote.
-      def literal(v)
-        case v
-        when LiteralString
-          v
-        when String
-          "'#{::Mysql.quote(v)}'"
-        else
-          super
-        end
-      end
-      
       # Store the given type of prepared statement in the associated database
       # with the given name.
       def prepare(type, name=nil, values=nil)
@@ -349,6 +348,11 @@ module Sequel
         super(sql, {:type=>:dui}.merge(opts), &block)
       end
       
+      # Handle correct quoting of strings using ::MySQL.quote.
+      def literal_string(v)
+        "'#{::Mysql.quote(v)}'"
+      end
+      
       # Extend the dataset with the MySQL stored procedure methods.
       def prepare_extend_sproc(ds)
         ds.extend(StoredProcedureMethods)

data/lib/sequel_core/adapters/odbc.rb

@@ -100,25 +100,6 @@ module Sequel
       ODBC_TIMESTAMP_AFTER_SECONDS =
         ODBC_TIMESTAMP_FORMAT.index( '%S' ).succ - ODBC_TIMESTAMP_FORMAT.length
       ODBC_DATE_FORMAT = "{d '%Y-%m-%d'}".freeze
-      
-      def literal(v)
-        case v
-        when true
-          BOOL_TRUE
-        when false
-          BOOL_FALSE
-        when Time, DateTime
-          formatted = v.strftime(ODBC_TIMESTAMP_FORMAT)
-          usec = (Time === v ? v.usec : (v.sec_fraction * 86400000000))
-          formatted.insert(ODBC_TIMESTAMP_AFTER_SECONDS, ".#{(usec.to_f/1000).round}") if usec >= 1000
-          formatted
-        when Date
-          v.strftime(ODBC_DATE_FORMAT)
-        else
-          super
-        end
-      end
-
       UNTITLED_COLUMN = 'untitled_%d'.freeze
 
       def fetch_rows(sql, &block)
@@ -141,15 +122,7 @@ module Sequel
       end
       
       private
-      
-      def hash_row(row)
-        hash = {}
-        row.each_with_index do |v, idx|
-          hash[@columns[idx]] = convert_odbc_value(v)
-        end
-        hash
-      end
-      
+
       def convert_odbc_value(v)
         # When fetching a result set, the Ruby ODBC driver converts all ODBC 
         # SQL types to an equivalent Ruby type; with the exception of
@@ -169,6 +142,39 @@ module Sequel
           v
         end
       end
+      
+      def hash_row(row)
+        hash = {}
+        row.each_with_index do |v, idx|
+          hash[@columns[idx]] = convert_odbc_value(v)
+        end
+        hash
+      end
+      
+      def literal_date(v)
+        v.strftime(ODBC_DATE_FORMAT)
+      end
+      
+      def literal_datetime(v)
+        formatted = v.strftime(ODBC_TIMESTAMP_FORMAT)
+        usec = v.sec_fraction * 86400000000
+        formatted.insert(ODBC_TIMESTAMP_AFTER_SECONDS, ".#{(usec.to_f/1000).round}") if usec >= 1000
+        formatted
+      end
+      
+      def literal_false
+        BOOL_FALSE
+      end
+      
+      def literal_true
+        BOOL_TRUE
+      end
+
+      def literal_time(v)
+        formatted = v.strftime(ODBC_TIMESTAMP_FORMAT)
+        formatted.insert(ODBC_TIMESTAMP_AFTER_SECONDS, ".#{(v.usec.to_f/1000).round}") if usec >= 1000
+        formatted
+      end
     end
   end
 end