sequel 3.10.0 → 3.11.0

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

@@ -28,8 +28,7 @@ module Sequel
           stmt = conn.createStatement
           begin
             sql = opts[:prepared] ? 'SELECT @@IDENTITY' : 'SELECT SCOPE_IDENTITY()'
-            log_info(sql)
-            rs = stmt.executeQuery(sql)
+            rs = log_yield(sql){stmt.executeQuery(sql)}
             rs.next
             rs.getInt(1)
           ensure

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

@@ -48,6 +48,12 @@ module Sequel
             end
           end
         end
+
+        # MySQL 5.1.12 JDBC adapter requires this to be true,
+        # and previous versions don't mind.
+        def requires_return_generated_keys?
+          true
+        end
       end
       
       # Dataset class for MySQL datasets accessed via JDBC.
@@ -63,6 +69,11 @@ module Sequel
         def replace(*args)
           execute_insert(replace_sql(*args))
         end
+        
+        # MySQL on JDBC does provides an accurate number of rows matched.
+        def provides_accurate_rows_matched?
+          true
+        end
       end
     end
   end

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

@@ -20,27 +20,24 @@ module Sequel
         
         # Use JDBC connection's setAutoCommit to false to start transactions
         def begin_transaction(conn)
-          log_info(TRANSACTION_BEGIN)
-          conn.setAutoCommit(false)
+          log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
           conn
         end
         
         # Use JDBC connection's commit method to commit transactions
         def commit_transaction(conn)
-          log_info(TRANSACTION_COMMIT)
-          conn.commit
+          log_yield(TRANSACTION_COMMIT){conn.commit}
         end
         
         # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
         def remove_transaction(conn)
           conn.setAutoCommit(true) if conn
-          super
+          @transactions.delete(Thread.current)
         end
         
         # Use JDBC connection's rollback method to rollback transactions
         def rollback_transaction(conn)
-          log_info(TRANSACTION_ROLLBACK)
-          conn.rollback
+          log_yield(TRANSACTION_ROLLBACK){conn.rollback}
         end
       end
       

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

@@ -18,7 +18,7 @@ module Sequel
           method = block_given? ? :executeQuery : :execute
           stmt = createStatement
           begin
-            rows = stmt.send(method, sql)
+            rows = @db.log_yield(sql){stmt.send(method, sql)}
             yield(rows) if block_given?
           rescue NativeException => e
             raise_error(e)
@@ -78,6 +78,13 @@ module Sequel
         def last_insert_id(conn, opts)
           insert_result(conn, opts[:table], opts[:values])
         end
+        
+        # Override shared postgresql adapter method to actually log,
+        # since on JDBC the first argument is a statement and not a
+        # connection, so it wouldn't be logged otherwise.
+        def log_connection_execute(stmt, sql) 
+          log_yield(sql){stmt.execute(sql)}
+        end
       end
       
       # Dataset subclass used for datasets that connect to PostgreSQL via JDBC.

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

@@ -32,6 +32,18 @@ module Sequel
           o = super
           uri == 'jdbc:sqlite::memory:' ? o.merge(:max_connections=>1) : o
         end
+        
+        # Execute the connection pragmas on the connection.
+        def setup_connection(conn)
+          conn = super(conn)
+          begin
+            stmt = conn.createStatement
+            connection_pragmas.each{|s| log_yield(s){stmt.execute(s)}}
+          ensure
+            stmt.close if stmt
+          end
+          conn
+        end
       end
       
       # Dataset class for SQLite datasets accessed via JDBC.

data/lib/sequel/adapters/mysql.rb

@@ -85,6 +85,10 @@ module Sequel
       #   inserted row.
       # * :charset - Same as :encoding (:encoding takes precendence)
       # * :compress - Set to false to not compress results from the server
+      # * :config_default_group - The default group to read from the in
+      #   the MySQL config file.
+      # * :config_local_infile - If provided, sets the Mysql::OPT_LOCAL_INFILE
+      #   option on the connection with the given value.
       # * :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.
@@ -93,8 +97,8 @@ module Sequel
       def connect(server)
         opts = server_opts(server)
         conn = Mysql.init
-        # reads additional options defined under the [client] tag in the mysql configuration file
-        conn.options(Mysql::READ_DEFAULT_GROUP, "client")
+        conn.options(Mysql::READ_DEFAULT_GROUP, opts[:config_default_group] || "client")
+        conn.options(Mysql::OPT_LOCAL_INFILE, opts[:config_local_infile]) if opts.has_key?(:config_local_infile)
         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)
@@ -153,8 +157,7 @@ module Sequel
       # yield the connection if a block is given.
       def _execute(conn, sql, opts)
         begin
-          log_info(sql)
-          r = conn.query(sql)
+          r = log_yield(sql){conn.query(sql)}
           if opts[:type] == :select
             yield r if r
           elsif block_given?
@@ -320,7 +323,13 @@ module Sequel
       def fetch_rows(sql, &block)
         execute(sql) do |r|
           i = -1
-          cols = r.fetch_fields.map{|f| [output_identifier(f.name), MYSQL_TYPES[f.type], i+=1]}
+          cols = r.fetch_fields.map do |f| 
+            # Pretend tinyint is another integer type if its length is not 1, to
+            # avoid casting to boolean if Sequel::MySQL.convert_tinyint_to_bool
+            # is set.
+            type_proc = f.type == 1 && f.length != 1 ? MYSQL_TYPES[2] : MYSQL_TYPES[f.type]
+            [output_identifier(f.name), type_proc, i+=1]
+          end
           @columns = cols.map{|c| c.first}
           if opts[:split_multiple_result_sets]
             s = []

data/lib/sequel/adapters/odbc.rb

@@ -45,10 +45,9 @@ module Sequel
       end
     
       def execute(sql, opts={})
-        log_info(sql)
         synchronize(opts[:server]) do |conn|
           begin
-            r = conn.run(sql)
+            r = log_yield(sql){conn.run(sql)}
             yield(r) if block_given?
           rescue ::ODBC::Error, ArgumentError => e
             raise_error(e)
@@ -60,10 +59,9 @@ module Sequel
       end
       
       def execute_dui(sql, opts={})
-        log_info(sql)
         synchronize(opts[:server]) do |conn|
           begin
-            conn.do(sql)
+            log_yield(sql){conn.do(sql)}
           rescue ::ODBC::Error, ArgumentError => e
             raise_error(e)
           end

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

@@ -16,13 +16,11 @@ module Sequel
         
         # 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)
+              log_yield(sql){conn.do(sql)}
               begin
-                s = conn.run(LAST_INSERT_ID_SQL)
+                s = log_yield(LAST_INSERT_ID_SQL){conn.run(LAST_INSERT_ID_SQL)}
                 if (rows = s.fetch_all) and (row = rows.first)
                   Integer(row.first)
                 end

data/lib/sequel/adapters/openbase.rb

@@ -20,9 +20,8 @@ module Sequel
       end
     
       def execute(sql, opts={})
-        log_info(sql)
         synchronize(opts[:server]) do |conn|
-          r = conn.execute(sql)
+          r = log_yield(sql){conn.execute(sql)}
           yield(r) if block_given?
           r
         end

data/lib/sequel/adapters/oracle.rb

@@ -60,10 +60,9 @@ module Sequel
       end
 
       def execute(sql, opts={})
-        log_info(sql)
         synchronize(opts[:server]) do |conn|
           begin
-            r = conn.exec(sql)
+            r = log_yield(sql){conn.exec(sql)}
             yield(r) if block_given?
             r
           rescue OCIException => e
@@ -76,14 +75,12 @@ module Sequel
       private
       
       def begin_transaction(conn)
-        log_info(TRANSACTION_BEGIN)
-        conn.autocommit = false
+        log_yield(TRANSACTION_BEGIN){conn.autocommit = false}
         conn
       end
       
       def commit_transaction(conn)
-        log_info(TRANSACTION_COMMIT)
-        conn.commit
+        log_yield(TRANSACTION_COMMIT){conn.commit}
       end
 
       def disconnect_connection(c)
@@ -96,8 +93,7 @@ module Sequel
       end
       
       def rollback_transaction(conn)
-        log_info(TRANSACTION_ROLLBACK)
-        conn.rollback
+        log_yield(TRANSACTION_ROLLBACK){conn.rollback}
       end
     end
     

data/lib/sequel/adapters/postgres.rb

@@ -133,7 +133,6 @@ module Sequel
         super
         if Postgres.use_iso_date_format
           sql = "SET DateStyle = 'ISO'"
-          @db.log_info(sql)
           execute(sql)
         end
         @prepared_statements = {} if SEQUEL_POSTGRES_USES_PG
@@ -160,7 +159,7 @@ module Sequel
       # Execute the given SQL with this connection.  If a block is given,
       # yield the results, otherwise, return the number of changed rows.
       def execute(sql, args=nil)
-        q = check_disconnect_errors{args ? async_exec(sql, args) : async_exec(sql)}
+        q = check_disconnect_errors{@db.log_yield(sql, args){args ? async_exec(sql, args) : async_exec(sql)}}
         begin
           block_given? ? yield(q) : q.cmd_tuples
         ensure
@@ -225,7 +224,6 @@ module Sequel
       def execute(sql, opts={}, &block)
         check_database_errors do
           return execute_prepared_statement(sql, opts, &block) if Symbol === sql
-          log_info(sql, opts[:arguments])
           synchronize(opts[:server]){|conn| conn.execute(sql, opts[:arguments], &block)}
         end
       end
@@ -235,7 +233,6 @@ module Sequel
       def execute_insert(sql, opts={})
         return execute(sql, opts) if Symbol === sql
         check_database_errors do
-          log_info(sql, opts[:arguments])
           synchronize(opts[:server]) do |conn|
             conn.execute(sql, opts[:arguments])
             insert_result(conn, opts[:table], opts[:values])
@@ -278,16 +275,12 @@ module Sequel
         synchronize(opts[:server]) do |conn|
           unless conn.prepared_statements[ps_name] == sql
             if conn.prepared_statements.include?(ps_name)
-              s = "DEALLOCATE #{ps_name}"
-              log_info(s)
-              conn.execute(s) unless conn.prepared_statements[ps_name] == sql
+              conn.execute("DEALLOCATE #{ps_name}") unless conn.prepared_statements[ps_name] == sql
             end
             conn.prepared_statements[ps_name] = sql
-            log_info("PREPARE #{ps_name} AS #{sql}")
-            conn.check_disconnect_errors{conn.prepare(ps_name, sql)}
+            conn.check_disconnect_errors{log_yield("PREPARE #{ps_name} AS #{sql}"){conn.prepare(ps_name, sql)}}
           end
-          log_info("EXECUTE #{ps_name}", args)
-          q = conn.check_disconnect_errors{conn.exec_prepared(ps_name, args)}
+          q = conn.check_disconnect_errors{log_yield("EXECUTE #{ps_name}", args){conn.exec_prepared(ps_name, args)}}
           if opts[:table] && opts[:values]
             insert_result(conn, opts[:table], opts[:values])
           else

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

@@ -12,6 +12,10 @@ module Sequel
       SQL_SAVEPOINT = 'SAVE TRANSACTION autopoint_%d'.freeze
       TEMPORARY = "#".freeze
       
+      # The types to check for 0 scale to transform :decimal types
+      # to :integer.
+      DECIMAL_TYPE_RE = /number|numeric|decimal/io
+      
       # Microsoft SQL Server uses the :mssql type.
       def database_type
         :mssql
@@ -64,9 +68,11 @@ module Sequel
           "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"
+          type = sch[:db_type]
+          if [:string, :decimal].include?(sch[:type]) and size = (sch[:max_chars] || sch[:column_size])
+            type += "(#{size}#{", #{sch[:scale]}" if sch[:scale] && sch[:scale].to_i > 0})"
+          end
+          "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(:type=>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
@@ -107,6 +113,11 @@ module Sequel
         ds
       end
       
+      # Use SP_RENAME to rename the table
+      def rename_table_sql(name, new_name)
+        "SP_RENAME #{quote_schema_table(name)}, #{quote_schema_table(new_name)}"
+      end
+      
       # SQL to rollback to a savepoint
       def rollback_savepoint_sql(depth)
         SQL_ROLLBACK_TO_SAVEPOINT % depth
@@ -125,7 +136,7 @@ module Sequel
         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).
+         select(:column_name___column, :data_type___db_type, :character_maximum_length___max_chars, :column_default___default, :is_nullable___allow_null, :numeric_precision___column_size, :numeric_scale___scale).
          filter(:c__table_name=>m2.call(table_name.to_s))
         if schema = opts[:schema] || default_schema
           ds.filter!(:c__table_schema=>schema)
@@ -133,7 +144,11 @@ module Sequel
         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])
+          row[:type] = if row[:db_type] =~ DECIMAL_TYPE_RE && row[:scale] == 0
+            :integer
+          else
+            schema_column_type(row[:db_type])
+          end
           [m.call(row.delete(:column)), row]
         end
       end
@@ -183,7 +198,7 @@ module Sequel
       COMMA_SEPARATOR = ', '.freeze
       DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'with from output from2 where')
       INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'with into columns output values')
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with limit distinct columns into from lock join where group having order compounds')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with distinct limit columns into from lock join where group having order compounds')
       UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'with table set output from where')
       NOLOCK = ' WITH (NOLOCK)'.freeze
       UPDLOCK = ' WITH (UPDLOCK)'.freeze
@@ -301,11 +316,9 @@ module Sequel
         raise(Error, 'MSSQL requires an order be provided if using an offset') unless order = @opts[:order]
         dsa1 = dataset_alias(1)
         rn = row_number_column
-        sel = [Sequel::SQL::WindowFunction.new(SQL::Function.new(:ROW_NUMBER), Sequel::SQL::Window.new(:order=>order)).as(rn)]
-        sel.unshift(WILDCARD) unless osel = @opts[:select] and !osel.empty?
         subselect_sql(unlimited.
           unordered.
-          select_more(*sel).
+          select_append{ROW_NUMBER(:over, :order=>order){}.as(rn)}.
           from_self(:alias=>dsa1).
           limit(@opts[:limit]).
           where(SQL::Identifier.new(rn) > o))

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

@@ -131,9 +131,9 @@ module Sequel
       
       # Use MySQL specific syntax for engine type and character encoding
       def create_table_sql(name, generator, options = {})
-        engine = options.include?(:engine) ? options[:engine] : Sequel::MySQL.default_engine
-        charset = options.include?(:charset) ? options[:charset] : Sequel::MySQL.default_charset
-        collate = options.include?(:collate) ? options[:collate] : Sequel::MySQL.default_collate
+        engine = options.fetch(:engine, Sequel::MySQL.default_engine)
+        charset = options.fetch(:charset, Sequel::MySQL.default_charset)
+        collate = options.fetch(:collate, Sequel::MySQL.default_collate)
         generator.columns.each do |c|
           if t = c.delete(:table)
             generator.foreign_key([c[:name]], t, c.merge(:name=>nil, :type=>:foreign_key))
@@ -250,6 +250,11 @@ module Sequel
         end
       end
       
+      # Use GROUP BY instead of DISTINCT ON if arguments are provided.
+      def distinct(*args)
+        args.empty? ? super : group(*args)
+      end
+      
       # Return a cloned dataset which will use LOCK IN SHARE MODE to lock returned rows.
       def for_share
         lock_style(:share)
@@ -288,23 +293,19 @@ module Sequel
         end
       end
       
-      # Sets up multi_insert or import to use INSERT IGNORE.
+      # Sets up the insert methods to use INSERT IGNORE.
       # Useful if you have a unique key and want to just skip
       # inserting rows that violate the unique key restriction.
       #
-      # Example:
-      #
-      # dataset.insert_ignore.multi_insert(
-      #  [{:name => 'a', :value => 1}, {:name => 'b', :value => 2}]
-      # )
-      #
-      # INSERT IGNORE INTO tablename (name, value) VALUES (a, 1), (b, 2)
-      #
+      #   dataset.insert_ignore.multi_insert(
+      #    [{:name => 'a', :value => 1}, {:name => 'b', :value => 2}]
+      #   )
+      #   # INSERT IGNORE INTO tablename (name, value) VALUES (a, 1), (b, 2)
       def insert_ignore
         clone(:insert_ignore=>true)
       end
       
-      # Sets up multi_insert or import to use ON DUPLICATE KEY UPDATE
+      # Sets up the insert methods to use ON DUPLICATE KEY UPDATE
       # If you pass no arguments, ALL fields will be
       # updated with the new values.  If you pass the fields you
       # want then ONLY those field will be updated.
@@ -312,22 +313,17 @@ module Sequel
       # Useful if you have a unique key and want to update
       # inserting rows that violate the unique key restriction.
       #
-      # Examples:
-      #
-      # dataset.on_duplicate_key_update.multi_insert(
-      #  [{:name => 'a', :value => 1}, {:name => 'b', :value => 2}]
-      # )
-      #
-      # INSERT INTO tablename (name, value) VALUES (a, 1), (b, 2)
-      # ON DUPLICATE KEY UPDATE name=VALUES(name), value=VALUES(value)
-      #
-      # dataset.on_duplicate_key_update(:value).multi_insert(
-      #  [{:name => 'a', :value => 1}, {:name => 'b', :value => 2}]
-      # )
-      #
-      # INSERT INTO tablename (name, value) VALUES (a, 1), (b, 2)
-      # ON DUPLICATE KEY UPDATE value=VALUES(value)
+      #   dataset.on_duplicate_key_update.multi_insert(
+      #    [{:name => 'a', :value => 1}, {:name => 'b', :value => 2}]
+      #   )
+      #   # INSERT INTO tablename (name, value) VALUES (a, 1), (b, 2)
+      #   # ON DUPLICATE KEY UPDATE name=VALUES(name), value=VALUES(value)
       #
+      #   dataset.on_duplicate_key_update(:value).multi_insert(
+      #     [{:name => 'a', :value => 1}, {:name => 'b', :value => 2}]
+      #   )
+      #   # INSERT INTO tablename (name, value) VALUES (a, 1), (b, 2)
+      #   # ON DUPLICATE KEY UPDATE value=VALUES(value)
       def on_duplicate_key_update(*args)
         clone(:on_duplicate_key_update => args)
       end
@@ -337,6 +333,12 @@ module Sequel
         [insert_sql(columns, LiteralString.new('VALUES ' + values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)))]
       end
       
+      # MySQL uses the number of rows actually modified in the update,
+      # instead of the number of matched by the filter.
+      def provides_accurate_rows_matched?
+        false
+      end
+      
       # MySQL uses the nonstandard ` (backtick) for quoting identifiers.
       def quoted_identifier(c)
         "`#{c}`"
@@ -348,9 +350,10 @@ module Sequel
         clone(:replace=>true).insert_sql(*values)
       end
       
-      #  does not support DISTINCT ON
+      # MySQL can emulate DISTINCT ON with its non-standard GROUP BY implementation,
+      # though the rows returned cannot be made deterministic through ordering.
       def supports_distinct_on?
-        false
+        true
       end
 
       # MySQL does not support INTERSECT or EXCEPT