sequel 3.3.0 → 3.4.0

data/lib/sequel/adapters/amalgalite.rb

@@ -29,7 +29,7 @@ module Sequel
       
       # Return datetime types as instances of Sequel.datetime_class
       def datetime(s)
-        Sequel.string_to_datetime(s)
+        Sequel.database_to_application_timestamp(s)
       end
       
       # Don't raise an error if the value is a string and the declared

data/lib/sequel/adapters/firebird.rb

@@ -202,7 +202,6 @@ module Sequel
       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'with distinct limit columns from join where group having compounds order'.freeze
 
       # Yield all rows returned by executing the given SQL and converting
@@ -248,6 +247,10 @@ module Sequel
       def insert_select(*values)
         naked.clone(default_server_opts(:sql=>insert_returning_sql(nil, *values))).single_record
       end
+      
+      def requires_sql_standard_datetimes?
+        true
+      end
 
       # The order of clauses in the SELECT SQL statement
       def select_clause_order
@@ -273,18 +276,10 @@ module Sequel
         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

data/lib/sequel/adapters/jdbc.rb

@@ -197,13 +197,18 @@ module Sequel
       # Values are subhashes with two keys, :columns and :unique.  The value of :columns
       # is an array of symbols of column names.  The value of :unique is true or false
       # depending on if the index is unique.
-      def indexes(table)
-        indexes = {}
+      def indexes(table, opts={})
         m = output_identifier_meth
-        metadata(:getIndexInfo, nil, nil, input_identifier_meth.call(table), false, true) do |r|
+        im = input_identifier_meth
+        schema, table = schema_and_table(table)
+        schema ||= opts[:schema]
+        schema = im.call(schema) if schema
+        table = im.call(table)
+        indexes = {}
+        metadata(:getIndexInfo, nil, schema, table, false, true) do |r|
           next unless name = r[:column_name]
           next if respond_to?(:primary_key_index_re, true) and r[:index_name] =~ primary_key_index_re 
-          i = indexes[m.call(r[:index_name])] ||= {:columns=>[], :unique=>!r[:non_unique]}
+          i = indexes[m.call(r[:index_name])] ||= {:columns=>[], :unique=>[false, 0].include?(r[:non_unique])}
           i[:columns] << m.call(name)
         end
         indexes
@@ -324,6 +329,8 @@ module Sequel
         case arg
         when Integer
           cps.setInt(i, arg)
+        when Sequel::SQL::Blob
+          cps.setBytes(i, arg.to_java_bytes)
         when String
           cps.setString(i, arg)
         when Date, Java::JavaSql::Date
@@ -332,8 +339,12 @@ module Sequel
           cps.setTimestamp(i, arg)
         when Float
           cps.setDouble(i, arg)
+        when TrueClass, FalseClass
+          cps.setBoolean(i, arg)
         when nil
           cps.setNull(i, JavaSQL::Types::NULL)
+        else
+          cps.setObject(i, arg)
         end
       end
       
@@ -348,12 +359,13 @@ module Sequel
         conn
       end
       
-      # All tables in this database
+      # Parse the table schema for the given table.
       def schema_parse_table(table, opts={})
         m = output_identifier_meth
         im = input_identifier_meth
         ds = dataset
         schema, table = schema_and_table(table)
+        schema ||= opts[:schema]
         schema = im.call(schema) if schema
         table = im.call(table)
         pks, ts = [], []
@@ -361,7 +373,7 @@ module Sequel
           pks << h[:column_name]
         end
         metadata(:getColumns, nil, schema, table, nil) do |h|
-          ts << [m.call(h[:column_name]), {:type=>schema_column_type(h[:type_name]), :db_type=>h[:type_name], :default=>(h[:column_def] == '' ? nil : h[:column_def]), :allow_null=>(h[:nullable] != 0), :primary_key=>pks.include?(h[:column_name])}]
+          ts << [m.call(h[:column_name]), {:type=>schema_column_type(h[:type_name]), :db_type=>h[:type_name], :default=>(h[:column_def] == '' ? nil : h[:column_def]), :allow_null=>(h[:nullable] != 0), :primary_key=>pks.include?(h[:column_name]), :column_size=>h[:column_size]}]
         end
         ts
       end
@@ -459,7 +471,7 @@ module Sequel
       def convert_type(v)
         case v
         when Java::JavaSQL::Timestamp, Java::JavaSQL::Time
-          Sequel.string_to_datetime(v.to_string)
+          Sequel.database_to_application_timestamp(v.to_string)
         when Java::JavaSQL::Date
           Sequel.string_to_date(v.to_string)
         when Java::JavaIo::BufferedReader
@@ -468,6 +480,8 @@ module Sequel
           lines.join("\n")
         when Java::JavaMath::BigDecimal
           BigDecimal.new(v.to_string)
+        when Java::byte[]
+          Sequel::SQL::Blob.new(String.from_java_bytes(v))
         else
           v
         end

data/lib/sequel/adapters/mysql.rb

@@ -1,4 +1,5 @@
 require 'mysql'
+raise(LoadError, "require 'mysql' did not define Mysql::CLIENT_MULTI_RESULTS!\n  You are probably using the pure ruby mysql.rb driver,\n  which Sequel does not support. You need to install\n  the C based adapter, and make sure that the mysql.so\n  file is loaded instead of the mysql.rb file.\n") unless defined?(Mysql::CLIENT_MULTI_RESULTS)
 Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
 
 module Sequel
@@ -28,7 +29,7 @@ module Sequel
       [2, 3, 8, 9, 13, 247, 248]  => lambda{|v| v.to_i},                  # integer
       [4, 5]  => lambda{|v| v.to_f},                                      # float
       [10, 14]  => lambda{|v| convert_date_time(:string_to_date, v)},     # date
-      [7, 12] => lambda{|v| convert_date_time(:string_to_datetime, v)},   # datetime
+      [7, 12] => lambda{|v| convert_date_time(:database_to_application_timestamp, v)},   # datetime
       [11]  => lambda{|v| convert_date_time(:string_to_time, v)},         # time
       [249, 250, 251, 252]  => lambda{|v| Sequel::SQL::Blob.new(v)}       # blob
     }

data/lib/sequel/adapters/odbc.rb

@@ -89,9 +89,8 @@ module Sequel
     class Dataset < Sequel::Dataset
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
-      ODBC_TIMESTAMP_FORMAT = "{ts '%Y-%m-%d %H:%M:%S'}".freeze
-      ODBC_TIMESTAMP_FORMAT_USEC = "{ts '%Y-%m-%d %H:%M:%S.%%i'}".freeze
       ODBC_DATE_FORMAT = "{d '%Y-%m-%d'}".freeze
+      TIMESTAMP_FORMAT="{ts '%Y-%m-%d %H:%M:%S%N'}".freeze
 
       def fetch_rows(sql, &block)
         execute(sql) do |s|
@@ -110,14 +109,6 @@ module Sequel
       end
       
       private
-      
-      def _literal_datetime(v, usec)
-        if usec >= 1000
-          v.strftime(ODBC_TIMESTAMP_FORMAT_USEC) % (usec.to_f/1000).round
-        else
-          v.strftime(ODBC_TIMESTAMP_FORMAT)
-        end
-      end
 
       def convert_odbc_value(v)
         # When fetching a result set, the Ruby ODBC driver converts all ODBC 
@@ -128,25 +119,24 @@ module Sequel
         # ODBCColumn#mapSqlTypeToGenericType and Column#klass.
         case v
         when ::ODBC::TimeStamp
-          DateTime.new(v.year, v.month, v.day, v.hour, v.minute, v.second)
+          Sequel.database_to_application_timestamp([v.year, v.month, v.day, v.hour, v.minute, v.second])
         when ::ODBC::Time
-          now = DateTime.now
-          Time.gm(now.year, now.month, now.day, v.hour, v.minute, v.second)
+          Sequel.database_to_application_timestamp([now.year, now.month, now.day, v.hour, v.minute, v.second])
         when ::ODBC::Date
           Date.new(v.year, v.month, v.day)
         else
           v
         end
       end
+      
+      def default_timestamp_format
+        TIMESTAMP_FORMAT
+      end
 
       def literal_date(v)
         v.strftime(ODBC_DATE_FORMAT)
       end
       
-      def literal_datetime(v)
-        _literal_datetime(v, v.sec_fraction * 86400000000)
-      end
-      
       def literal_false
         BOOL_FALSE
       end
@@ -154,10 +144,6 @@ module Sequel
       def literal_true
         BOOL_TRUE
       end
-
-      def literal_time(v)
-        _literal_datetime(v, v.usec)
-      end
     end
   end
 end

data/lib/sequel/adapters/oracle.rb

@@ -129,7 +129,7 @@ module Sequel
       def literal_other(v)
         case v
         when OraDate
-          literal_time(Time.local(*v.to_a))
+          literal(Sequel.database_to_application_timestamp(v))
         else
           super
         end

data/lib/sequel/adapters/postgres.rb

@@ -65,6 +65,11 @@ rescue LoadError => e
       unless defined?(CONNECTION_OK)
         CONNECTION_OK = -1
       end
+      unless method_defined?(:status)
+        def status
+          CONNECTION_OK
+        end
+      end
     end
     class PGresult 
       alias_method :nfields, :num_fields unless method_defined?(:nfields) 
@@ -94,7 +99,7 @@ module Sequel
       [790, 1700] => lambda{|s| BigDecimal.new(s)}, # numeric
       [1082] => lambda{|s| @use_iso_date_format ? Date.new(*s.split("-").map{|x| x.to_i}) : Sequel.string_to_date(s)}, # date
       [1083, 1266] => lambda{|s| Sequel.string_to_time(s)}, # time
-      [1114, 1184] => lambda{|s| Sequel.string_to_datetime(s)}, # timestamp
+      [1114, 1184] => lambda{|s| Sequel.database_to_application_timestamp(s)}, # timestamp
     }
     PG_TYPE_PROCS.each do |k,v|
       k.each{|n| PG_TYPES[n] = v}

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

@@ -148,6 +148,7 @@ module Sequel
       SELECT_CLAUSE_ORDER = %w'with limit distinct columns from table_options join where group order having compounds'.freeze
       TIMESTAMP_FORMAT = "'%Y-%m-%d %H:%M:%S'".freeze
       WILDCARD = LiteralString.new('*').freeze
+      CONSTANT_MAP = {:CURRENT_DATE=>'CAST(CURRENT_TIMESTAMP AS DATE)'.freeze, :CURRENT_TIME=>'CAST(CURRENT_TIMESTAMP AS TIME)'.freeze}
       
       # MSSQL uses + for string concatenation
       def complex_expression_sql(op, args)
@@ -159,6 +160,11 @@ module Sequel
         end
       end
       
+      # MSSQL doesn't support the SQL standard CURRENT_DATE or CURRENT_TIME
+      def constant_sql(constant)
+        CONSTANT_MAP[constant] || super
+      end
+      
       # When returning all rows, if an offset is used, delete the row_number column
       # before yielding the row.
       def each(&block)
@@ -222,6 +228,11 @@ module Sequel
         false
       end
       
+      # MSSQL supports timezones in literal timestamps
+      def supports_timestamp_timezones?
+        true
+      end
+      
       # MSSQL 2005+ supports window functions
       def supports_window_functions?
         true

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

@@ -198,7 +198,6 @@ module Sequel
     module DatasetMethods
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
-      TIMESTAMP_FORMAT = "'%Y-%m-%d %H:%M:%S'".freeze
       COMMA_SEPARATOR = ', '.freeze
       SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
       
@@ -360,6 +359,13 @@ module Sequel
       def supports_intersect_except?
         false
       end
+      
+      # MySQL does support fractional timestamps in literal timestamps, but it
+      # ignores them.  Also, using them seems to cause problems on 1.9.  Since
+      # they are ignored anyway, not using them is probably best.
+      def supports_timestamp_usecs?
+        false
+      end
 
       # MySQL supports ORDER and LIMIT clauses in UPDATE statements.
       def update_sql(values)
@@ -385,22 +391,12 @@ module Sequel
       def insert_default_values_sql
         "#{insert_sql_base}#{source_list(@opts[:from])} () VALUES ()"
       end
-
-      # Use MySQL Timestamp format
-      def literal_datetime(v)
-        v.strftime(TIMESTAMP_FORMAT)
-      end
-
+      
       # Use 0 for false on MySQL
       def literal_false
         BOOL_FALSE
       end
 
-      # Use MySQL Timestamp format
-      def literal_time(v)
-        v.strftime(TIMESTAMP_FORMAT)
-      end
-
       # Use 1 for true on MySQL
       def literal_true
         BOOL_TRUE

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

@@ -121,6 +121,11 @@ module Sequel
         false
       end
       
+      # Oracle supports timezones in literal timestamps.
+      def supports_timestamp_timezones?
+        true
+      end
+      
       # Oracle supports window functions
       def supports_window_functions?
         true
@@ -143,6 +148,14 @@ module Sequel
         SELECT_CLAUSE_ORDER
       end
 
+      # Modify the SQL to add the list of tables to select FROM
+      # Oracle doesn't support select without FROM clause
+      # so add the dummy DUAL table if the dataset doesn't select
+      # from a table.
+      def select_from_sql(sql)
+        sql << " FROM #{source_list(@opts[:from] || ['DUAL'])}"
+      end
+
       # Oracle requires a subselect to do limit and offset
       def select_limit_sql(sql)
         if limit = @opts[:limit]

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

@@ -693,6 +693,11 @@ module Sequel
         ["#{insert_sql_base}#{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES #{values}"]
       end
       
+      # PostgreSQL supports timezones in literal timestamps
+      def supports_timestamp_timezones?
+        true
+      end
+      
       # PostgreSQL 8.4+ supports window functions
       def supports_window_functions?
         server_version >= 80400
@@ -716,11 +721,6 @@ module Sequel
         "'#{v.gsub(/[\000-\037\047\134\177-\377]/){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"}}'"
       end
 
-      # PostgreSQL supports fractional timestamps
-      def literal_datetime(v)
-        "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d", (v.sec_fraction * 86400000000).to_i)}'"
-      end
-
       # PostgreSQL uses FALSE for false values
       def literal_false
         BOOL_FALSE
@@ -736,11 +736,6 @@ module Sequel
         BOOL_TRUE
       end
 
-      # PostgreSQL supports fractional times
-      def literal_time(v)
-        "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d",v.usec)}'"
-      end
-
       # The order of clauses in the SELECT SQL statement
       def select_clause_order
         server_version >= 80400 ? SELECT_CLAUSE_ORDER_84 : SELECT_CLAUSE_ORDER

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

@@ -10,7 +10,9 @@ module Sequel
       # Run all alter_table commands in a transaction.  This is technically only
       # needed for drop column.
       def alter_table(name, generator=nil, &block)
-        transaction{super}
+        remove_cached_schema(name)
+        generator ||= Schema::AlterTableGenerator.new(self, &block)
+        transaction{generator.operations.each{|op| alter_table_sql_list(name, [op]).flatten.each{|sql| execute_ddl(sql)}}}
       end
 
       # A symbol signifying the value of the auto_vacuum PRAGMA.
@@ -164,6 +166,7 @@ module Sequel
       # from the existing table into the new table, deleting the existing table
       # and renaming the new table to the existing table's name.
       def duplicate_table(table, opts={})
+        remove_cached_schema(table)
         def_columns = defined_columns_for(table)
         old_columns = def_columns.map{|c| c[:name]}
         opts[:old_columns_proc].call(old_columns) if opts[:old_columns_proc]
@@ -233,6 +236,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
+      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.
       # SQLite is case insensitive (depending on pragma), so use LIKE for
@@ -249,6 +253,11 @@ module Sequel
         end
       end
       
+      # MSSQL doesn't support the SQL standard CURRENT_DATE or CURRENT_TIME
+      def constant_sql(constant)
+        CONSTANT_MAP[constant] || super
+      end
+      
       # SQLite performs a TRUNCATE style DELETE if no filter is specified.
       # Since we want to always return the count of records, add a condition
       # that is always true and then delete.
@@ -284,6 +293,12 @@ module Sequel
       def supports_is_true?
         false
       end
+      
+      # SQLite supports timezones in literal timestamps, since it stores them
+      # as text.
+      def supports_timestamp_timezones?
+        true
+      end
 
       private
       
@@ -304,6 +319,11 @@ module Sequel
       def select_clause_order
         SELECT_CLAUSE_ORDER
       end
+      
+      # SQLite treats a DELETE with no WHERE clause as a TRUNCATE
+      def _truncate_sql(table)
+        "DELETE FROM #{table}"
+      end
     end
   end
 end