sequel 3.33.0 → 3.34.0

data/lib/sequel/adapters/mysql2.rb

@@ -70,6 +70,16 @@ module Sequel
         conn
       end
 
+      # Return the number of matched rows when executing a delete/update statement.
+      def execute_dui(sql, opts={})
+        execute(sql, opts){|c| return c.affected_rows}
+      end
+
+      # Return the last inserted id when executing an insert statement.
+      def execute_insert(sql, opts={})
+        execute(sql, opts){|c| return c.last_id}
+      end
+
       # Return the version of the MySQL server two which we are connecting.
       def server_version(server=nil)
         @server_version ||= (synchronize(server){|conn| conn.server_info[:id]} || super)
@@ -82,7 +92,7 @@ module Sequel
       # yield the connection if a block is given.
       def _execute(conn, sql, opts)
         begin
-          r = log_yield(sql){conn.query(sql, :symbolize_keys => true, :database_timezone => timezone, :application_timezone => Sequel.application_timezone)}
+          r = log_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql){conn.query(sql, :symbolize_keys => true, :database_timezone => timezone, :application_timezone => Sequel.application_timezone)}
           if opts[:type] == :select
             yield r if r
           elsif block_given?
@@ -131,13 +141,8 @@ module Sequel
 
       Database::DatasetClass = self
 
-      # Delete rows matching this dataset
-      def delete
-        execute_dui(delete_sql){|c| return c.affected_rows}
-      end
-
       # Yield all rows matching this dataset.
-      def fetch_rows(sql, &block)
+      def fetch_rows(sql)
         execute(sql) do |r|
           if identifier_output_method
             cols = r.fields
@@ -152,27 +157,12 @@ module Sequel
             end
           else
             @columns = r.fields
-            r.each(:cast_booleans => db.convert_tinyint_to_bool, &block)
+            r.each(:cast_booleans => db.convert_tinyint_to_bool){|h| yield h}
           end
         end
         self
       end
 
-      # Insert a new value into this dataset
-      def insert(*values)
-        execute_dui(insert_sql(*values)){|c| return c.last_id}
-      end
-
-      # Replace (update or insert) the matching row.
-      def replace(*args)
-        execute_dui(replace_sql(*args)){|c| return c.last_id}
-      end
-
-      # Update the matching rows.
-      def update(values={})
-        execute_dui(update_sql(values)){|c| return c.affected_rows}
-      end
-
       private
 
       # Set the :type option to :select if it hasn't been set.
@@ -180,11 +170,6 @@ module Sequel
         super(sql, {:type=>:select}.merge(opts), &block)
       end
 
-      # Set the :type option to :dui if it hasn't been set.
-      def execute_dui(sql, opts={}, &block)
-        super(sql, {:type=>:dui}.merge(opts), &block)
-      end
-
       # Handle correct quoting of strings using ::Mysql2::Client#escape.
       def literal_string_append(sql, v)
         sql << "'" << db.synchronize{|c| c.escape(v)} << "'"

data/lib/sequel/adapters/oracle.rb

@@ -136,11 +136,17 @@ module Sequel
           end
         end
         unless cursor
-          cursor = log_yield("Preparing #{name}: #{sql}"){conn.parse(sql)}
+          cursor = log_yield("PREPARE #{name}: #{sql}"){conn.parse(sql)}
           conn.prepared_statements[name] = [cursor, sql]
         end
         args = cursor_bind_params(conn, cursor, opts[:arguments])
-        r = log_yield("Executing #{name}", args){cursor.exec}
+        log_sql = "EXECUTE #{name}"
+        if ps.log_sql
+          log_sql << " ("
+          log_sql << sql
+          log_sql << ")"
+        end
+        r = log_yield(log_sql, args){cursor.exec}
         if block_given?
           yield(cursor)
         elsif type == :insert

data/lib/sequel/adapters/postgres.rb

@@ -111,13 +111,14 @@ module Sequel
       def date(s) ::Date.new(*s.split("-").map{|x| x.to_i}) end
     end.new
 
-    # Hash with type name symbols and callable values for converting PostgreSQL types.
+    # Hash with type name strings/symbols and callable values for converting PostgreSQL types.
     # Non-builtin types that don't have fixed numbers should use this to register
     # conversion procs.
-    PG_NAMED_TYPES = {}
+    PG_NAMED_TYPES = {} unless defined?(PG_NAMED_TYPES)
 
     # Hash with integer keys and callable values for converting PostgreSQL types.
-    PG_TYPES = {}
+    PG_TYPES = {} unless defined?(PG_TYPES)
+
     {
       [16] => tt.method(:boolean),
       [17] => tt.method(:bytea),
@@ -193,7 +194,8 @@ 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{@db.log_yield(sql, args){args ? async_exec(sql, args) : async_exec(sql)}}
+        args = args.map{|v| @db.bound_variable_arg(v, self)} if args
+        q = check_disconnect_errors{execute_query(sql, args)}
         begin
           block_given? ? yield(q) : q.cmd_tuples
         ensure
@@ -202,6 +204,12 @@ module Sequel
       end
 
       private
+
+      # Return the PGResult object that is returned by executing the given
+      # sql and args.
+      def execute_query(sql, args)
+        @db.log_yield(sql, args){args ? async_exec(sql, args) : async_exec(sql)}
+      end
       
       # Return the requested values for the given row.
       def single_value(r)
@@ -213,21 +221,48 @@ module Sequel
     # pg, postgres, or postgres-pr driver.
     class Database < Sequel::Database
       include Sequel::Postgres::DatabaseMethods
+
+      INFINITE_TIMESTAMP_STRINGS = ['infinity'.freeze, '-infinity'.freeze].freeze
+      INFINITE_DATETIME_VALUES = ([1.0/0.0, -1.0/0.0] + INFINITE_TIMESTAMP_STRINGS).freeze
       
       set_adapter_scheme :postgres
 
       # A hash of conversion procs, keyed by type integer (oid) and
       # having callable values for the conversion proc for that type.
       attr_reader :conversion_procs
+
+      # Whether infinite timestamps should be converted on retrieval.  By default, no
+      # conversion is done, so an error is raised if you attempt to retrieve an infinite
+      # timestamp.  You can set this to :nil to convert to nil, :string to leave
+      # as a string, or :float to convert to an infinite float.
+      attr_accessor :convert_infinite_timestamps
       
       # Add the primary_keys and primary_key_sequences instance variables,
       # so we can get the correct return values for inserted rows.
       def initialize(*args)
         super
+        @convert_infinite_timestamps = false
         @primary_keys = {}
         @primary_key_sequences = {}
       end
 
+      # Convert given argument so that it can be used directly by pg.  Currently, pg doesn't
+      # handle fractional seconds in Time/DateTime or blobs with "\0", and it won't ever
+      # handle Sequel::SQLTime values correctly.  Only public for use by the adapter, shouldn't
+      # be used by external code.
+      def bound_variable_arg(arg, conn)
+        case arg
+        when Sequel::SQL::Blob
+          conn.escape_bytea(arg)
+        when Sequel::SQLTime
+          literal(arg)
+        when DateTime, Time
+          literal(arg)
+        else
+          arg
+        end
+      end
+
       # Connects to the database.  In addition to the standard database
       # options, using the :encoding or :charset option changes the
       # client encoding for the connection, :connect_timeout is a
@@ -402,9 +437,30 @@ module Sequel
           end
         end
       end
+
+      # Reset the database's conversion procs, requires a server query if there
+      # any named types.
+      def reset_conversion_procs
+        synchronize{|conn| @conversion_procs = get_conversion_procs(conn)}
+      end
+
+      # If convert_infinite_timestamps is true and the value is infinite, return an appropriate
+      # value based on the convert_infinite_timestamps setting.
+      def to_application_timestamp(value)
+        if c = convert_infinite_timestamps
+          case value
+          when *INFINITE_TIMESTAMP_STRINGS
+            infinite_timestamp_value(value)
+          else
+            super
+          end
+        else
+          super
+        end
+      end
         
       private
-      
+
       # Convert exceptions raised from the block into DatabaseErrors.
       def check_database_errors
         begin
@@ -434,8 +490,11 @@ module Sequel
         ps = prepared_statements[name]
         sql = ps.prepared_sql
         ps_name = name.to_s
-        args = opts[:arguments]
         synchronize(opts[:server]) do |conn|
+          if args = opts[:arguments]
+            args = args.map{|arg| bound_variable_arg(arg, conn)}
+          end
+
           unless conn.prepared_statements[ps_name] == sql
             if conn.prepared_statements.include?(ps_name)
               conn.execute("DEALLOCATE #{ps_name}") unless conn.prepared_statements[ps_name] == sql
@@ -443,7 +502,15 @@ module Sequel
             conn.prepared_statements[ps_name] = sql
             conn.check_disconnect_errors{log_yield("PREPARE #{ps_name} AS #{sql}"){conn.prepare(ps_name, sql)}}
           end
-          q = conn.check_disconnect_errors{log_yield("EXECUTE #{ps_name}", args){conn.exec_prepared(ps_name, args)}}
+
+          log_sql = "EXECUTE #{ps_name}"
+          if ps.log_sql
+            log_sql << " ("
+            log_sql << sql
+            log_sql << ")"
+          end
+
+          q = conn.check_disconnect_errors{log_yield(log_sql, args){conn.exec_prepared(ps_name, args)}}
           if opts[:table] && opts[:values]
             insert_result(conn, opts[:table], opts[:values])
           else
@@ -456,20 +523,48 @@ module Sequel
         end
       end
 
-      # Return the conversion procs hash to use for this database
+      # Return the conversion procs hash to use for this database.
       def get_conversion_procs(conn)
         procs = PG_TYPES.dup
-        procs[1114] = method(:to_application_timestamp)
-        procs[1184] = method(:to_application_timestamp)
-        conn.execute("SELECT oid, typname FROM pg_type where typtype = 'b'") do |res|
-          res.ntuples.times do |recnum|
-            if pr = PG_NAMED_TYPES[res.getvalue(recnum, 1).untaint.to_sym]
-              procs[res.getvalue(recnum, 0).to_i] ||= pr
+        procs[1184] = procs[1114] = method(:to_application_timestamp)
+        unless (pgnt = PG_NAMED_TYPES).empty?
+          conn.execute("SELECT oid, typname FROM pg_type where typtype = 'b' AND typname IN ('#{pgnt.keys.map{|type| conn.escape_string(type.to_s)}.join("', '")}')") do |res|
+            res.ntuples.times do |i|
+              procs[res.getvalue(i, 0).to_i] ||= pgnt[res.getvalue(i, 1).untaint.to_sym]
             end
           end
         end
         procs
       end
+
+      # Return an appropriate value for the given infinite timestamp string.
+      def infinite_timestamp_value(value)
+        case convert_infinite_timestamps
+        when :nil
+          nil
+        when :string
+          value
+        else
+          value == 'infinity' ? PLUS_INFINITY : MINUS_INFINITY
+        end
+      end
+      
+
+      # If the value is an infinite value (either an infinite float or a string returned by
+      # by PostgreSQL for an infinite timestamp), return it without converting it if
+      # convert_infinite_timestamps is set.
+      def typecast_value_datetime(value)
+        if convert_infinite_timestamps
+          case value
+          when *INFINITE_DATETIME_VALUES
+            value
+          else
+            super
+          end
+        else
+          super
+        end
+      end
     end
     
     # Dataset class for PostgreSQL datasets that use the pg, postgres, or
@@ -481,9 +576,9 @@ module Sequel
       
       # Yield all rows returned by executing the given SQL and converting
       # the types.
-      def fetch_rows(sql, &block)
-        return cursor_fetch_rows(sql, &block) if @opts[:cursor]
-        execute(sql){|res| yield_hash_rows(res, fetch_rows_set_cols(res), &block)}
+      def fetch_rows(sql)
+        return cursor_fetch_rows(sql){|h| yield h} if @opts[:cursor]
+        execute(sql){|res| yield_hash_rows(res, fetch_rows_set_cols(res)){|h| yield h}}
       end
       
       # Uses a cursor for fetching records, instead of fetching the entire result
@@ -630,7 +725,7 @@ module Sequel
       private
       
       # Use a cursor to fetch groups of records at a time, yielding them to the block.
-      def cursor_fetch_rows(sql, &block)
+      def cursor_fetch_rows(sql)
         server_opts = {:server=>@opts[:server] || :read_only}
         db.transaction(server_opts) do 
           begin
@@ -642,12 +737,12 @@ module Sequel
             # Load columns only in the first fetch, so subsequent fetches are faster
             execute(fetch_sql) do |res|
               cols = fetch_rows_set_cols(res)
-              yield_hash_rows(res, cols, &block)
+              yield_hash_rows(res, cols){|h| yield h}
               return if res.ntuples < rows_per_fetch
             end
             loop do
               execute(fetch_sql) do |res|
-                yield_hash_rows(res, cols, &block)
+                yield_hash_rows(res, cols){|h| yield h}
                 return if res.ntuples < rows_per_fetch
               end
             end

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

@@ -310,7 +310,7 @@ module Sequel
         if l = @opts[:limit]
           if l == 1
             sql << FETCH_FIRST_ROW_ONLY
-          elsif l > 1
+          else
             sql << FETCH_FIRST
             literal_append(sql, l)
             sql << ROWS_ONLY

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

@@ -455,7 +455,8 @@ module Sequel
         mutation_method(:output, into, values)
       end
 
-      # MSSQL uses [] to quote identifiers
+      # MSSQL uses [] to quote identifiers.  MSSQL does not support
+      # escaping of ], so you cannot use that character in an identifier.
       def quoted_identifier_append(sql, name)
         sql << BRACKET_OPEN << name.to_s << BRACKET_CLOSE
       end
@@ -546,10 +547,16 @@ module Sequel
 
       private
 
+      # Whether we are using SQL Server 2005 or later.
       def is_2005_or_later?
         server_version >= 9000000
       end
 
+      # Whether we are using SQL Server 2008 or later.
+      def is_2008_or_later?
+        server_version >= 10000000
+      end
+
       # MSSQL supports the OUTPUT clause for DELETE statements.
       # It also allows prepending a WITH clause.
       def delete_clause_methods
@@ -630,7 +637,7 @@ module Sequel
       def select_into_sql(sql)
         if i = @opts[:into]
           sql << INTO
-          table_ref_append(sql, i)
+          identifier_append(sql, i)
         end
       end
 
@@ -669,7 +676,7 @@ module Sequel
         column_list_append(sql, output[:select_list])
         if into = output[:into]
           sql << INTO
-          table_ref_append(sql, into)
+          identifier_append(sql, into)
           if column_list = output[:column_list]
             sql << PAREN_SPACE_OPEN
             source_list_append(sql, column_list)
@@ -691,6 +698,10 @@ module Sequel
         sql << SPACE
         source_list_append(sql, @opts[:from][0..0])
       end
+
+      def uses_with_rollup?
+        !is_2008_or_later?
+      end
     end
   end
 end

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

@@ -51,6 +51,31 @@ module Sequel
         :mysql
       end
 
+      # Use the Information Schema's KEY_COLUMN_USAGE table to get
+      # basic information on foreign key columns, but include the
+      # constraint name.
+      def foreign_key_list(table, opts={})
+        m = output_identifier_meth
+        im = input_identifier_meth
+        ds = metadata_dataset.
+          from(:INFORMATION_SCHEMA__KEY_COLUMN_USAGE).
+          where(:TABLE_NAME=>im.call(table)).
+          exclude(:CONSTRAINT_NAME=>'PRIMARY').
+          exclude(:REFERENCED_TABLE_NAME=>nil).
+          select(:CONSTRAINT_NAME___name, :COLUMN_NAME___column, :REFERENCED_TABLE_NAME___table, :REFERENCED_COLUMN_NAME___key)
+        
+        h = {}
+        ds.each do |row|
+          if r = h[row[:name]]
+            r[:columns] << m.call(row[:column])
+            r[:key] << m.call(row[:key])
+          else
+            h[row[:name]] = {:name=>m.call(row[:name]), :columns=>[m.call(row[:column])], :table=>m.call(row[:table]), :key=>[m.call(row[:key])]}
+          end
+        end
+        h.values
+      end
+
       # Use SHOW INDEX FROM to get the index information for the
       # table.
       #
@@ -407,6 +432,8 @@ module Sequel
       STRAIGHT_JOIN = 'STRAIGHT_JOIN'.freeze
       NATURAL_LEFT_JOIN = 'NATURAL LEFT JOIN'.freeze
       BACKTICK = '`'.freeze
+      BACKTICK_RE = /`/.freeze
+      DOUBLE_BACKTICK = '``'.freeze
       EMPTY_COLUMNS = " ()".freeze
       EMPTY_VALUES = " VALUES ()".freeze
       IGNORE = " IGNORE".freeze
@@ -415,6 +442,10 @@ module Sequel
       EQ_VALUES = '=VALUES('.freeze
       EQ = '='.freeze
       WITH_ROLLUP = ' WITH ROLLUP'.freeze
+      MATCH_AGAINST = ["(MATCH ".freeze, " AGAINST (".freeze, "))".freeze].freeze
+      MATCH_AGAINST_BOOLEAN = ["(MATCH ".freeze, " AGAINST (".freeze, " IN BOOLEAN MODE))".freeze].freeze
+      EXPLAIN = 'EXPLAIN '.freeze
+      EXPLAIN_EXTENDED = 'EXPLAIN EXTENDED '.freeze
       
       # MySQL specific syntax for LIKE/REGEXP searches, as well as
       # string concatenation.
@@ -466,6 +497,17 @@ module Sequel
         clone(:calc_found_rows => true)
       end
       
+      # Return the results of an EXPLAIN query as a string. Options:
+      # :extended :: Use EXPLAIN EXPTENDED instead of EXPLAIN if true.
+      def explain(opts={})
+        # Load the PrettyTable class, needed for explain output
+        Sequel.extension(:_pretty_table) unless defined?(Sequel::PrettyTable)
+
+        ds = db.send(:metadata_dataset).with_sql((opts[:extended] ? EXPLAIN_EXTENDED : EXPLAIN) + select_sql).naked
+        rows = ds.all
+        Sequel::PrettyTable.string(rows, ds.columns)
+      end
+
       # Return a cloned dataset which will use LOCK IN SHARE MODE to lock returned rows.
       def for_share
         lock_style(:share)
@@ -479,7 +521,7 @@ module Sequel
       # MySQL specific full text search syntax.
       def full_text_sql(cols, terms, opts = {})
         terms = terms.join(' ') if terms.is_a?(Array)
-        SQL::PlaceholderLiteralString.new("MATCH ? AGAINST (?#{" IN BOOLEAN MODE" if opts[:boolean]})", [Array(cols), terms], true)
+        SQL::PlaceholderLiteralString.new((opts[:boolean] ? MATCH_AGAINST_BOOLEAN : MATCH_AGAINST), [Array(cols), terms])
       end
 
       # MySQL allows HAVING clause on ungrouped datasets.
@@ -552,14 +594,24 @@ module Sequel
       
       # MySQL uses the nonstandard ` (backtick) for quoting identifiers.
       def quoted_identifier_append(sql, c)
-        sql << BACKTICK << c.to_s << BACKTICK
+        sql << BACKTICK << c.to_s.gsub(BACKTICK_RE, DOUBLE_BACKTICK) << BACKTICK
       end
       
+      # Execute a REPLACE statement on the database.
+      def replace(*values)
+        execute_insert(replace_sql(*values))
+      end
+
       # MySQL specific syntax for REPLACE (aka UPSERT, or update if exists,
       # insert if it doesn't).
       def replace_sql(*values)
         clone(:replace=>true).insert_sql(*values)
       end
+
+      # Replace multiple rows in a single query.
+      def multi_replace(*values)
+        clone(:replace=>true).multi_insert(*values)
+      end
       
       # MySQL can emulate DISTINCT ON with its non-standard GROUP BY implementation,
       # though the rows returned cannot be made deterministic through ordering.
@@ -730,15 +782,6 @@ module Sequel
         SELECT_CLAUSE_METHODS
       end
       
-      # MySQL supports ROLLUP via nonstandard SQL syntax
-      def select_group_sql(sql)
-        if group = @opts[:group]
-          sql << GROUP_BY
-          expression_list_append(sql, group)
-          sql << WITH_ROLLUP if @opts[:group_options] == :rollup
-        end
-      end
-
       # Support FOR SHARE locking when using the :share lock style.
       def select_lock_sql(sql)
         @opts[:lock] == :share ? (sql << FOR_SHARE) : super
@@ -753,6 +796,11 @@ module Sequel
       def update_clause_methods
         UPDATE_CLAUSE_METHODS
       end
+
+      # MySQL uses WITH ROLLUP syntax.
+      def uses_with_rollup?
+        true
+      end
     end
   end
 end