sequel 3.2.0 → 3.3.0

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

@@ -27,12 +27,23 @@ module Sequel
         def alter_table_sql(table, op)
           case op[:op]
           when :add_column
-            if op.delete(:primary_key)
-              sql = super(table, op)
-              [sql, "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})"]
+            if (pk = op.delete(:primary_key)) || (ref = op.delete(:table))
+              sqls = [super(table, op)]
+              sqls << "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})" if pk
+              if ref
+                op[:table] = ref
+                sqls << "ALTER TABLE #{quote_schema_table(table)} ADD FOREIGN KEY (#{quote_identifier(op[:name])}) #{column_references_sql(op)}"
+              end
+              sqls
             else
               super(table, op)
             end
+          when :rename_column
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} RENAME TO #{quote_identifier(op[:new_name])}"
+          when :set_column_null
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} SET#{' NOT' unless op[:null]} NULL"
+          when :set_column_type
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}"
           else
             super(table, op)
           end

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

@@ -0,0 +1,51 @@
+Sequel.require 'adapters/shared/mssql'
+
+module Sequel
+  module JDBC
+    class Database
+      # Alias the generic JDBC version so it can be called directly later
+      alias jdbc_schema_parse_table schema_parse_table
+    end
+    
+    # Database and Dataset instance methods for MSSQL specific
+    # support via JDBC.
+    module MSSQL
+      # Database instance methods for MSSQL databases accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::MSSQL::DatabaseMethods
+        
+        # Return instance of Sequel::JDBC::MSSQL::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::MSSQL::Dataset.new(self, opts)
+        end
+        
+        private
+        
+        # Get the last inserted id using SCOPE_IDENTITY().
+        def last_insert_id(conn, opts={})
+          stmt = conn.createStatement
+          begin
+            sql = opts[:prepared] ? 'SELECT @@IDENTITY' : 'SELECT SCOPE_IDENTITY()'
+            log_info(sql)
+            rs = stmt.executeQuery(sql)
+            rs.next
+            rs.getInt(1)
+          ensure
+            stmt.close
+          end
+        end
+        
+        # Call the generic JDBC version instead of MSSQL version,
+        # since the JDBC version handles primary keys.
+        def schema_parse_table(table, opts={})
+          jdbc_schema_parse_table(table, opts)
+        end
+      end
+      
+      # Dataset class for MSSQL datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::MSSQL::DatasetMethods
+      end
+    end
+  end
+end

data/lib/sequel/adapters/mysql.rb

@@ -7,31 +7,40 @@ module Sequel
   # A class level convert_invalid_date_time accessor exists if
   # the native adapter is used.  If set to nil or :nil, the adapter treats dates
   # like 0000-00-00 and times like 838:00:00 as nil values.  If set to :string,
-  # it returns the strings as is.  If is false by default, which means that
+  # it returns the strings as is.  It is false by default, which means that
   # invalid dates and times will raise errors.
+  #
+  #   Sequel::MySQL.convert_invalid_date_time = true
+  #
+  # Sequel converts the column type tinyint(1) to a boolean by default when
+  # using the native MySQL adapter.  You can turn off the conversion to use
+  # tinyint as an integer:
+  #
+  #   Sequel.convert_tinyint_to_bool = false
   module MySQL
     # Mapping of type numbers to conversion procs
     MYSQL_TYPES = {}
 
     # Use only a single proc for each type to save on memory
     MYSQL_TYPE_PROCS = {
-      [0, 246]  => lambda{|v| BigDecimal.new(v)},                       # decimal
-      [1]  => lambda{|v| Sequel.convert_tinyint_to_bool ? v.to_i != 0 : v.to_i}, # tinyint
-      [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
-      [11]  => lambda{|v| convert_date_time(:string_to_time, v)},       # time
-      [249, 250, 251, 252]  => lambda{|v| Sequel::SQL::Blob.new(v)}     # blob
+      [0, 246]  => lambda{|v| BigDecimal.new(v)},                         # decimal
+      [1]  => lambda{|v| convert_tinyint_to_bool ? v.to_i != 0 : v.to_i}, # tinyint
+      [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
+      [11]  => lambda{|v| convert_date_time(:string_to_time, v)},         # time
+      [249, 250, 251, 252]  => lambda{|v| Sequel::SQL::Blob.new(v)}       # blob
     }
     MYSQL_TYPE_PROCS.each do |k,v|
       k.each{|n| MYSQL_TYPES[n] = v}
     end
     
     @convert_invalid_date_time = false
+    @convert_tinyint_to_bool = true
 
     class << self
-      attr_accessor :convert_invalid_date_time
+      attr_accessor :convert_invalid_date_time, :convert_tinyint_to_bool
     end
 
     # If convert_invalid_date_time is nil, :nil, or :string and
@@ -149,8 +158,10 @@ module Sequel
             yield r if r
             if conn.respond_to?(:next_result) && conn.next_result
               loop do
-                r.free
-                r = nil
+                if r
+                  r.free
+                  r = nil
+                end
                 begin
                   r = conn.use_result
                 rescue Mysql::Error
@@ -222,6 +233,11 @@ module Sequel
           _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
         end
       end
+      
+      # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
+      def schema_column_type(db_type)
+        Sequel::MySQL.convert_tinyint_to_bool && db_type == 'tinyint(1)' ? :boolean : super
+      end
     end
     
     # Dataset class for MySQL datasets accessed via the native driver.

data/lib/sequel/adapters/odbc.rb

@@ -12,8 +12,8 @@ module Sequel
         super(opts)
         case opts[:db_type]
         when 'mssql'
-          Sequel.require 'adapters/shared/mssql'
-          extend Sequel::MSSQL::DatabaseMethods
+          Sequel.require 'adapters/odbc/mssql'
+          extend Sequel::ODBC::MSSQL::DatabaseMethods
         when 'progress'
           Sequel.require 'adapters/shared/progress'
           extend Sequel::Progress::DatabaseMethods
@@ -50,6 +50,8 @@ module Sequel
           begin
             r = conn.run(sql)
             yield(r) if block_given?
+          rescue ::ODBC::Error => e
+            raise_error(e)
           ensure
             r.drop if r
           end
@@ -59,12 +61,22 @@ module Sequel
       
       def execute_dui(sql, opts={})
         log_info(sql)
-        synchronize(opts[:server]){|conn| conn.do(sql)}
+        synchronize(opts[:server]) do |conn|
+          begin
+            conn.do(sql)
+          rescue ::ODBC::Error => e
+            raise_error(e)
+          end
+        end
       end
-      alias_method :do, :execute_dui
+      alias do execute_dui
 
       private
       
+      def connection_pool_default_options
+        super.merge(:pool_convert_exceptions=>false)
+      end
+      
       def connection_execute_method
         :do
       end
@@ -78,27 +90,34 @@ module Sequel
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
       ODBC_TIMESTAMP_FORMAT = "{ts '%Y-%m-%d %H:%M:%S'}".freeze
-      ODBC_TIMESTAMP_AFTER_SECONDS =
-        ODBC_TIMESTAMP_FORMAT.index( '%S' ).succ - ODBC_TIMESTAMP_FORMAT.length
+      ODBC_TIMESTAMP_FORMAT_USEC = "{ts '%Y-%m-%d %H:%M:%S.%%i'}".freeze
       ODBC_DATE_FORMAT = "{d '%Y-%m-%d'}".freeze
-      UNTITLED_COLUMN = 'untitled_%d'.freeze
 
       def fetch_rows(sql, &block)
         execute(sql) do |s|
-          untitled_count = 0
-          @columns = s.columns(true).map do |c|
-            if (n = c.name).empty?
-              n = UNTITLED_COLUMN % (untitled_count += 1)
+          i = -1
+          cols = s.columns(true).map{|c| [output_identifier(c.name), i+=1]}
+          @columns = cols.map{|c| c.at(0)}
+          if rows = s.fetch_all
+            rows.each do |row|
+              hash = {}
+              cols.each{|n,i| hash[n] = convert_odbc_value(row[i])}
+              yield hash
             end
-            output_identifier(n)
           end
-          rows = s.fetch_all
-          rows.each {|row| yield hash_row(row)} if rows
         end
         self
       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 
@@ -119,24 +138,13 @@ 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
+        _literal_datetime(v, v.sec_fraction * 86400000000)
       end
       
       def literal_false
@@ -148,9 +156,7 @@ module Sequel
       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
+        _literal_datetime(v, v.usec)
       end
     end
   end

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

@@ -0,0 +1,44 @@
+Sequel.require 'adapters/shared/mssql'
+
+module Sequel
+  module ODBC
+    # Database and Dataset instance methods for MSSQL specific
+    # support via ODBC.
+    module MSSQL
+      module DatabaseMethods
+        include Sequel::MSSQL::DatabaseMethods
+        LAST_INSERT_ID_SQL='SELECT SCOPE_IDENTITY()'
+        
+        # Return an instance of Sequel::ODBC::MSSQL::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::ODBC::MSSQL::Dataset.new(self, opts)
+        end
+        
+        # Return the last inserted identity value.
+        def execute_insert(sql, opts={})
+          log_info(sql)
+          synchronize(opts[:server]) do |conn|
+            begin
+              conn.do(sql)
+              log_info(LAST_INSERT_ID_SQL)
+              begin
+                s = conn.run(LAST_INSERT_ID_SQL)
+                if (rows = s.fetch_all) and (row = rows.first)
+                  Integer(row.first)
+                end
+              ensure
+                s.drop if s
+              end
+            rescue ::ODBC::Error => e
+              raise_error(e)
+            end
+          end
+        end
+      end
+      
+      class Dataset < ODBC::Dataset
+        include Sequel::MSSQL::DatasetMethods
+      end
+    end
+  end
+end

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

@@ -5,6 +5,8 @@ module Sequel
       SQL_BEGIN = "BEGIN TRANSACTION".freeze
       SQL_COMMIT = "COMMIT TRANSACTION".freeze
       SQL_ROLLBACK = "ROLLBACK TRANSACTION".freeze
+      SQL_ROLLBACK_TO_SAVEPOINT = 'ROLLBACK TRANSACTION autopoint_%d'.freeze
+      SQL_SAVEPOINT = 'SAVE TRANSACTION autopoint_%d'.freeze
       TEMPORARY = "#".freeze
       
       # Microsoft SQL Server uses the :mssql type.
@@ -12,42 +14,142 @@ module Sequel
         :mssql
       end
 
-      def dataset(opts = nil)
-        ds = super
-        ds.extend(DatasetMethods)
-        ds
+      # Microsoft SQL Server supports using the INFORMATION_SCHEMA to get
+      # information on tables.
+      def tables(opts={})
+        m = output_identifier_meth
+        metadata_dataset.from(:information_schema__tables___t).
+          select(:table_name).
+          filter(:table_type=>'BASE TABLE', :table_schema=>(opts[:schema]||default_schema||'dbo').to_s).
+          map{|x| m.call(x[:table_name])}
+      end
+        
+      # MSSQL supports savepoints, though it doesn't support committing/releasing them savepoint
+      def supports_savepoints?
+        true
       end
 
       private
-
+      
+      # MSSQL uses the IDENTITY(1,1) column for autoincrementing columns.
       def auto_increment_sql
         AUTO_INCREMENT
       end
+      
+      # MSSQL specific syntax for altering tables.
+      def alter_table_sql(table, op)
+        case op[:op]
+        when :add_column
+          "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
+        when :rename_column
+          "SP_RENAME #{literal("#{quote_schema_table(table)}.#{quote_identifier(op[:name])}")}, #{literal(op[:new_name].to_s)}, 'COLUMN'"
+        when :set_column_type
+          "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}"
+        when :set_column_null
+          sch = schema(table).find{|k,v| k.to_s == op[:name].to_s}.last
+          type = {:type=>sch[:db_type]}
+          type[:size] = sch[:max_chars] if sch[:max_chars]
+          "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(type)} #{'NOT ' unless op[:null]}NULL"
+        when :set_column_default
+          "ALTER TABLE #{quote_schema_table(table)} ADD CONSTRAINT #{quote_identifier("sequel_#{table}_#{op[:name]}_def")} DEFAULT #{literal(op[:default])} FOR #{quote_identifier(op[:name])}"
+        else
+          super(table, op)
+        end
+      end
+      
+      # SQL to start a new savepoint
+      def begin_savepoint_sql(depth)
+        SQL_SAVEPOINT % depth
+      end
 
       # SQL to BEGIN a transaction.
       def begin_transaction_sql
         SQL_BEGIN
       end
+      
+      # Commit the active transaction on the connection, does not commit/release
+      # savepoints.
+      def commit_transaction(conn)
+        log_connection_execute(conn, commit_transaction_sql) unless Thread.current[:sequel_transaction_depth] > 1
+      end
 
       # SQL to COMMIT a transaction.
       def commit_transaction_sql
         SQL_COMMIT
       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]))} ON #{quote_schema_table(table)}"
+      end
+      
+      # SQL to rollback to a savepoint
+      def rollback_savepoint_sql(depth)
+        SQL_ROLLBACK_TO_SAVEPOINT % depth
+      end
+      
       # SQL to ROLLBACK a transaction.
       def rollback_transaction_sql
         SQL_ROLLBACK
       end
+      
+      # MSSQL uses the INFORMATION_SCHEMA to hold column information.  This method does
+      # not support the parsing of primary key information.
+      def schema_parse_table(table_name, opts)
+        m = output_identifier_meth
+        m2 = input_identifier_meth
+        ds = metadata_dataset.from(:information_schema__tables___t).
+         join(:information_schema__columns___c, :table_catalog=>:table_catalog,
+              :table_schema => :table_schema, :table_name => :table_name).
+         select(:column_name___column, :data_type___db_type, :character_maximum_length___max_chars, :column_default___default, :is_nullable___allow_null).
+         filter(:c__table_name=>m2.call(table_name.to_s))
+        if schema = opts[:schema] || default_schema
+          ds.filter!(:table_schema=>schema)
+        end
+        ds.map do |row|
+          row[:allow_null] = row[:allow_null] == 'YES' ? true : false
+          row[:default] = nil if blank_object?(row[:default])
+          row[:type] = schema_column_type(row[:db_type])
+          [m.call(row.delete(:column)), row]
+        end
+      end
 
       # SQL fragment for marking a table as temporary
       def temporary_table_sql
         TEMPORARY
       end
+      
+      # MSSQL has both datetime and timestamp classes, most people are going
+      # to want datetime
+      def type_literal_generic_datetime(column)
+        :datetime
+      end
+
+      # MSSQL has both datetime and timestamp classes, most people are going
+      # to want datetime
+      def type_literal_generic_time(column)
+        column[:only_time] ? :time : :datetime
+      end
+      
+      # MSSQL doesn't have a true boolean class, so it uses bit
+      def type_literal_generic_trueclass(column)
+        :bit
+      end
+      
+      # MSSQL uses image type for blobs
+      def type_literal_generic_file(column)
+        :image
+      end
     end
   
     module DatasetMethods
+      BOOL_TRUE = '1'.freeze
+      BOOL_FALSE = '0'.freeze
       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
+      
+      # MSSQL uses + for string concatenation
       def complex_expression_sql(op, args)
         case op
         when :'||'
@@ -57,10 +159,18 @@ module Sequel
         end
       end
       
+      # When returning all rows, if an offset is used, delete the row_number column
+      # before yielding the row.
+      def each(&block)
+        @opts[:offset] ? super{|r| r.delete(row_number_column); yield r} : super(&block)
+      end
+      
+      # MSSQL uses the CONTAINS keyword for full text search
       def full_text_search(cols, terms, opts = {})
         filter("CONTAINS (#{literal(cols)}, #{literal(terms)})")
       end
       
+      # MSSQL uses a UNION ALL statement to insert multiple values at once.
       def multi_insert_sql(columns, values)
         values = values.map {|r| "SELECT #{expression_list(r)}" }.join(" UNION ALL ")
         ["#{insert_sql_base}#{source_list(@opts[:from])} (#{identifier_list(columns)}) #{values}"]
@@ -70,34 +180,99 @@ module Sequel
       def nolock
         clone(:table_options => "(NOLOCK)")
       end
-
+      
+      # MSSQL uses [] to quote identifiers
       def quoted_identifier(name)
         "[#{name}]"
       end
+      
+      # MSSQL Requires the use of the ROW_NUMBER window function to emulate
+      # an offset.  This implementation requires MSSQL 2005 or greater (offset
+      # can't be emulated well in MSSQL 2000).
+      # 
+      # The implementation is ugly, cloning the current dataset and modifying
+      # the clone to add a ROW_NUMBER window function (and some other things),
+      # then using the modified clone in a CTE which is selected from.
+      #
+      # If offset is used, an order must be provided, because the use of ROW_NUMBER
+      # requires an order.
+      def select_sql
+        return super unless o = @opts[:offset]
+        raise(Error, 'MSSQL requires an order be provided if using an offset') unless order = @opts[:order]
+        dsa1 = dataset_alias(1)
+        dsa2 = dataset_alias(2)
+        rn = row_number_column
+        unlimited.
+          unordered.
+          from_self(:alias=>dsa2).
+          select{[WILDCARD, ROW_NUMBER(:over, :order=>order){}.as(rn)]}.
+          from_self(:alias=>dsa1).
+          limit(@opts[:limit]).
+          where(rn > o).
+          select_sql
+      end
 
       # Microsoft SQL Server does not support INTERSECT or EXCEPT
       def supports_intersect_except?
         false
       end
       
+      # MSSQL does not support IS TRUE
+      def supports_is_true?
+        false
+      end
+      
       # MSSQL 2005+ supports window functions
       def supports_window_functions?
         true
       end
 
       private
-
+      
+      # MSSQL uses a literal hexidecimal number for blob strings
+      def literal_blob(v)
+        blob = '0x'
+        v.each_byte{|x| blob << sprintf('%02x', x)}
+        blob
+      end
+      
+      # Use unicode string syntax for all strings
       def literal_string(v)
         "N#{super}"
       end
+      
+      # Use MSSQL Timestamp format
+      def literal_datetime(v)
+        v.strftime(TIMESTAMP_FORMAT)
+      end
+      
+      # Use 0 for false on MSSQL
+      def literal_false
+        BOOL_FALSE
+      end
+      
+      # Use MSSQL Timestamp format
+      def literal_time(v)
+        v.strftime(TIMESTAMP_FORMAT)
+      end
+
+      # Use 1 for true on MSSQL
+      def literal_true
+        BOOL_TRUE
+      end
+      
+      # The alias to use for the row_number column when emulating OFFSET
+      def row_number_column
+        :x_sequel_row_number_x
+      end
 
+      # MSSQL adds the limit before the columns
       def select_clause_order
         SELECT_CLAUSE_ORDER
       end
 
-      # MSSQL uses TOP for limit, with no offset support
+      # MSSQL uses TOP for limit
       def select_limit_sql(sql)
-        raise(Error, "OFFSET not supported") if @opts[:offset]
         sql << " TOP #{@opts[:limit]}" if @opts[:limit]
       end