sequel 3.34.1 → 3.35.0

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

@@ -28,9 +28,22 @@ module Sequel
           end
         end
       end
-      
       class Dataset < ODBC::Dataset
         include Sequel::MSSQL::DatasetMethods
+
+        private
+
+        # Use ODBC format, not Microsoft format, as the ODBC layer does
+        # some translation.
+        def default_timestamp_format
+          TIMESTAMP_FORMAT
+        end
+
+        # Use ODBC format, not Microsoft format, as the ODBC layer does
+        # some translation.
+        def literal_date(v)
+          v.strftime(ODBC_DATE_FORMAT)
+        end
       end
     end
   end

data/lib/sequel/adapters/oracle.rb

@@ -126,7 +126,7 @@ module Sequel
       end
 
       def execute_prepared_statement(conn, type, name, opts)
-        ps = prepared_statements[name]
+        ps = prepared_statement(name)
         sql = ps.prepared_sql
         if cursora = conn.prepared_statements[name]
           cursor, cursor_sql = cursora
@@ -243,7 +243,7 @@ module Sequel
 
         # Default values
         defaults = begin
-          metadata_dataset.from(:dba_tab_cols).
+          metadata_dataset.from(:user_tab_cols).
             where(:table_name=>im.call(table)).
             to_hash(:column_name, :data_default)
         rescue DatabaseError
@@ -370,19 +370,6 @@ module Sequel
         ps.call(bind_vars, &block)
       end
       
-      # Prepare the given type of query with the given name and store
-      # it in the database.  Note that a new native prepared statement is
-      # created on each call to this prepared statement.
-      def prepare(type, name=nil, *values)
-        ps = to_prepared_statement(type, values)
-        ps.extend(PreparedStatementMethods)
-        if name
-          ps.prepared_statement_name = name
-          db.prepared_statements[name] = ps
-        end
-        ps
-      end
-      
       def fetch_rows(sql)
         execute(sql) do |cursor|
           offset = @opts[:offset]
@@ -403,14 +390,15 @@ module Sequel
         self
       end
 
-      # Create a named prepared statement that is stored in the
-      # database (and connection) for reuse.
+      # Prepare the given type of query with the given name and store
+      # it in the database.  Note that a new native prepared statement is
+      # created on each call to this prepared statement.
       def prepare(type, name=nil, *values)
         ps = to_prepared_statement(type, values)
         ps.extend(PreparedStatementMethods)
         if name
           ps.prepared_statement_name = name
-          db.prepared_statements[name] = ps
+          db.set_prepared_statement(name, ps)
         end
         ps
       end

data/lib/sequel/adapters/postgres.rb

@@ -12,7 +12,7 @@ rescue LoadError => e
     class PGconn
       unless method_defined?(:escape_string)
         if self.respond_to?(:escape)
-          # If there is no escape_string instead method, but there is an
+          # If there is no escape_string instance method, but there is an
           # escape class method, use that instead.
           def escape_string(str)
             Sequel::Postgres.force_standard_strings ? str.gsub("'", "''") : self.class.escape(str)
@@ -91,24 +91,29 @@ module Sequel
     NAN             = 0.0/0.0
     PLUS_INFINITY   = 1.0/0.0
     MINUS_INFINITY  = -1.0/0.0
+    NAN_STR             = 'NaN'.freeze
+    PLUS_INFINITY_STR   = 'Infinity'.freeze
+    MINUS_INFINITY_STR  = '-Infinity'.freeze
+    TRUE_STR = 't'.freeze
+    DASH_STR = '-'.freeze
     
     TYPE_TRANSLATOR = tt = Class.new do
-      def boolean(s) s == 't' end
+      def boolean(s) s == TRUE_STR end
       def bytea(s) ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s)) end
       def integer(s) s.to_i end
       def float(s) 
         case s
-        when 'NaN'
+        when NAN_STR
           NAN
-        when 'Infinity'
+        when PLUS_INFINITY_STR
           PLUS_INFINITY
-        when '-Infinity'
+        when MINUS_INFINITY_STR
           MINUS_INFINITY
         else
           s.to_f 
         end
       end
-      def date(s) ::Date.new(*s.split("-").map{|x| x.to_i}) end
+      def date(s) ::Date.new(*s.split(DASH_STR).map{|x| x.to_i}) end
     end.new
 
     # Hash with type name strings/symbols and callable values for converting PostgreSQL types.
@@ -149,8 +154,6 @@ module Sequel
     class Adapter < ::PGconn
       DISCONNECT_ERROR_RE = /\Acould not receive data from server: Software caused connection abort/
       
-      include Sequel::Postgres::AdapterMethods
-
       self.translate_results = false if respond_to?(:translate_results=)
       
       # Hash of prepared statements for this connection.  Keys are
@@ -158,18 +161,6 @@ module Sequel
       # are SQL strings.
       attr_reader(:prepared_statements) if SEQUEL_POSTGRES_USES_PG
       
-      # Apply connection settings for this connection.  Current sets
-      # the date style to ISO in order make Date object creation in ruby faster,
-      # if Postgres.use_iso_date_format is true.
-      def apply_connection_settings
-        super
-        if Postgres.use_iso_date_format
-          sql = "SET DateStyle = 'ISO'"
-          execute(sql)
-        end
-        @prepared_statements = {} if SEQUEL_POSTGRES_USES_PG
-      end
-
       # Raise a Sequel::DatabaseDisconnectError if a PGError is raised and
       # the connection status cannot be determined or it is not OK.
       def check_disconnect_errors
@@ -210,11 +201,6 @@ module Sequel
       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)
-        r.getvalue(0, 0) unless r.nil? || (r.ntuples == 0)
-      end
     end
     
     # Database class for PostgreSQL databases used with Sequel and the
@@ -223,7 +209,7 @@ module Sequel
       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
+      INFINITE_DATETIME_VALUES = ([PLUS_INFINITY, MINUS_INFINITY] + INFINITE_TIMESTAMP_STRINGS).freeze
       
       set_adapter_scheme :postgres
 
@@ -299,8 +285,9 @@ module Sequel
             conn.async_exec("set client_encoding to '#{encoding}'")
           end
         end
-        conn.db = self
-        conn.apply_connection_settings
+        conn.instance_variable_set(:@db, self)
+        conn.instance_variable_set(:@prepared_statements, {}) if SEQUEL_POSTGRES_USES_PG
+        connection_configuration_sqls.each{|sql| conn.execute(sql)}
         @conversion_procs ||= get_conversion_procs(conn)
         conn
       end
@@ -312,19 +299,7 @@ module Sequel
           synchronize(opts[:server]){|conn| conn.execute(sql, opts[:arguments], &block)}
         end
       end
-      
-      # Insert the values into the table and return the primary key (if
-      # automatically generated).
-      def execute_insert(sql, opts={})
-        return execute(sql, opts) if Symbol === sql
-        check_database_errors do
-          synchronize(opts[:server]) do |conn|
-            conn.execute(sql, opts[:arguments])
-            insert_result(conn, opts[:table], opts[:values])
-          end
-        end
-      end
-      
+
       if SEQUEL_POSTGRES_USES_PG
         # +copy_table+ uses PostgreSQL's +COPY+ SQL statement to return formatted
         # results directly to the caller.  This method is only supported if pg is the
@@ -470,6 +445,13 @@ module Sequel
         end
       end
 
+      # Set the DateStyle to ISO if configured, for faster date parsing.
+      def connection_configuration_sqls
+        sqls = super
+        sqls << "SET DateStyle = 'ISO'" if Postgres.use_iso_date_format
+        sqls
+      end
+
       # Disconnect given connection
       def disconnect_connection(conn)
         begin
@@ -487,7 +469,7 @@ module Sequel
       # of rows changed.  If the :insert option is passed, return the value
       # of the primary key for the last inserted row.
       def execute_prepared_statement(name, opts={})
-        ps = prepared_statements[name]
+        ps = prepared_statement(name)
         sql = ps.prepared_sql
         ps_name = name.to_s
         synchronize(opts[:server]) do |conn|
@@ -511,14 +493,10 @@ module Sequel
           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
-            begin
-              block_given? ? yield(q) : q.cmd_tuples
-            ensure
-              q.clear
-            end
+          begin
+            block_given? ? yield(q) : q.cmd_tuples
+          ensure
+            q.clear
           end
         end
       end
@@ -549,6 +527,10 @@ module Sequel
         end
       end
       
+      # Don't log, since logging is done by the underlying connection.
+      def log_connection_execute(conn, sql)
+        conn.execute(sql)
+      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
@@ -573,6 +555,7 @@ module Sequel
       include Sequel::Postgres::DatasetMethods
 
       Database::DatasetClass = self
+      APOS = Sequel::Dataset::APOS
       
       # Yield all rows returned by executing the given SQL and converting
       # the types.
@@ -708,7 +691,7 @@ module Sequel
           ps.extend(PreparedStatementMethods)
           if name
             ps.prepared_statement_name = name
-            db.prepared_statements[name] = ps
+            db.set_prepared_statement(name, ps)
           end
           ps
         end
@@ -766,12 +749,12 @@ module Sequel
       
       # Use the driver's escape_bytea
       def literal_blob_append(sql, v)
-        sql << "'" << db.synchronize{|c| c.escape_bytea(v)} << "'"
+        sql << APOS << db.synchronize{|c| c.escape_bytea(v)} << APOS
       end
       
       # Use the driver's escape_string
       def literal_string_append(sql, v)
-        sql << "'" << db.synchronize{|c| c.escape_string(v)} << "'"
+        sql << APOS << db.synchronize{|c| c.escape_string(v)} << APOS
       end
       
       # For each row in the result set, yield a hash with column name symbol

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

@@ -131,12 +131,24 @@ module Sequel
         super
       end
 
+      # Insert data from the current table into the new table after
+      # creating the table, since it is not possible to do it in one step.
+      def create_table_as(name, sql, options)
+        super
+        from(name).insert(sql.is_a?(Dataset) ? sql : dataset.with_sql(sql))
+      end
+
+      # DB2 requires parens around the SELECT, and DEFINITION ONLY at the end.
+      def create_table_as_sql(name, sql, options)
+        "#{create_table_prefix_sql(name, options)} AS (#{sql}) DEFINITION ONLY"
+      end
+
       # Here we use DGTT which has most backward compatibility, which uses
       # DECLARE instead of CREATE. CGTT can only be used after version 9.7.
       # http://www.ibm.com/developerworks/data/library/techarticle/dm-0912globaltemptable/
-      def create_table_sql(name, generator, options)
+      def create_table_prefix_sql(name, options)
         if options[:temp]
-          "DECLARE GLOBAL TEMPORARY TABLE #{quote_identifier(name)} (#{column_list_sql(generator)})"
+          "DECLARE GLOBAL TEMPORARY TABLE #{quote_identifier(name)}"
         else
           super
         end
@@ -221,6 +233,8 @@ module Sequel
           sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
         when :>>
           sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
+        when :%
+          sql << complex_expression_arg_pairs(args){|a, b| "MOD(#{literal(a)}, #{literal(b)})"}
         when :'B~'
           literal_append(sql, SQL::Function.new(:BITNOT, *args))
         when :extract

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

@@ -72,6 +72,11 @@ module Sequel
         true
       end
 
+      # MSSQL supports transaction DDL statements.
+      def supports_transactional_ddl?
+        true
+      end
+
       # Microsoft SQL Server supports using the INFORMATION_SCHEMA to get
       # information on tables.
       def tables(opts={})
@@ -141,7 +146,7 @@ module Sequel
       # Commit the active transaction on the connection, does not commit/release
       # savepoints.
       def commit_transaction(conn, opts={})
-        log_connection_execute(conn, commit_transaction_sql) unless @transactions[conn][:savepoint_level] > 1
+        log_connection_execute(conn, commit_transaction_sql) unless _trans(conn)[:savepoint_level] > 1
       end
 
       # SQL to COMMIT a transaction.
@@ -152,10 +157,19 @@ module Sequel
       # MSSQL uses the name of the table to decide the difference between
       # a regular and temporary table, with temporary table names starting with
       # a #.
-      def create_table_sql(name, generator, options)
-        "CREATE TABLE #{quote_schema_table(options[:temp] ? "##{name}" : name)} (#{column_list_sql(generator)})"
+      def create_table_prefix_sql(name, options)
+        "CREATE TABLE #{quote_schema_table(options[:temp] ? "##{name}" : name)}"
       end
       
+      # MSSQL doesn't support CREATE TABLE AS, it only supports SELECT INTO.
+      # Emulating CREATE TABLE AS using SELECT INTO is only possible if a dataset
+      # is given as the argument, it can't work with a string, so raise an
+      # Error if a string is given.
+      def create_table_as(name, ds, options)
+        raise(Error, "must provide dataset instance as value of create_table :as option on MSSQL") unless ds.is_a?(Sequel::Dataset)
+        run(ds.into(name).sql)
+      end
+    
       # The name of the constraint for setting the default value on the table and column.
       def default_constraint_name(table, column)
         from(:sysobjects___c_obj).
@@ -325,12 +339,16 @@ module Sequel
       OUTPUT_INSERTED = " OUTPUT INSERTED.*".freeze
       HEX_START = '0x'.freeze
       UNICODE_STRING_START = "N'".freeze
+      BACKSLASH_CRLF_RE = /\\((?:\r\n)|\n)/.freeze
+      BACKSLASH_CRLF_REPLACE = '\\\\\\\\\\1\\1'.freeze
       TOP_PAREN = " TOP (".freeze
       TOP = " TOP ".freeze
       OUTPUT = " OUTPUT ".freeze
       HSTAR = "H*".freeze
       CASE_SENSITIVE_COLLATION = 'Latin1_General_CS_AS'.freeze
       CASE_INSENSITIVE_COLLATION = 'Latin1_General_CI_AS'.freeze
+      DEFAULT_TIMESTAMP_FORMAT = "'%Y-%m-%dT%H:%M:%S%N%z'".freeze
+      FORMAT_DATE = "'%Y%m%d'".freeze
 
       # Allow overriding of the mssql_unicode_strings option at the dataset level.
       attr_accessor :mssql_unicode_strings
@@ -557,6 +575,13 @@ module Sequel
         server_version >= 10000000
       end
 
+      # Use strict ISO-8601 format with T between date and time,
+      # since that is the format that is multilanguage and not
+      # DATEFORMAT dependent.
+      def default_timestamp_format
+        DEFAULT_TIMESTAMP_FORMAT
+      end
+
       # MSSQL supports the OUTPUT clause for DELETE statements.
       # It also allows prepending a WITH clause.
       def delete_clause_methods
@@ -612,18 +637,24 @@ module Sequel
         sql << HEX_START << v.unpack(HSTAR).first
       end
       
-      # Optionally use unicode string syntax for all strings. Don't double
-      # backslashes.
-      def literal_string_append(sql, v)
-        sql << (mssql_unicode_strings ? UNICODE_STRING_START : APOS)
-        sql << v.gsub(APOS_RE, DOUBLE_APOS) << APOS
+      # Use YYYYmmdd format, since that's the only want that is
+      # multilanguage and not DATEFORMAT dependent.
+      def literal_date(v)
+        v.strftime(FORMAT_DATE)
       end
-      
+
       # Use 0 for false on MSSQL
       def literal_false
         BOOL_FALSE
       end
 
+      # Optionally use unicode string syntax for all strings. Don't double
+      # backslashes.
+      def literal_string_append(sql, v)
+        sql << (mssql_unicode_strings ? UNICODE_STRING_START : APOS)
+        sql << v.gsub(APOS_RE, DOUBLE_APOS).gsub(BACKSLASH_CRLF_RE, BACKSLASH_CRLF_REPLACE) << APOS
+      end
+      
       # Use 1 for true on MSSQL
       def literal_true
         BOOL_TRUE

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

@@ -223,7 +223,7 @@ module Sequel
       # Use XA START to start a new prepared transaction if the :prepare
       # option is given.
       def begin_transaction(conn, opts={})
-        if (s = opts[:prepare]) && (th = @transactions[conn])[:savepoint_level] == 0
+        if (s = opts[:prepare]) && (th = _trans(conn))[:savepoint_level] == 0
           log_connection_execute(conn, "XA START #{literal(s)}")
           th[:savepoint_level] += 1
         else
@@ -246,7 +246,7 @@ module Sequel
       # Prepare the XA transaction for a two-phase commit if the
       # :prepare option is given.
       def commit_transaction(conn, opts={})
-        if (s = opts[:prepare]) && @transactions[conn][:savepoint_level] <= 1
+        if (s = opts[:prepare]) && _trans(conn)[:savepoint_level] <= 1
           log_connection_execute(conn, "XA END #{literal(s)}")
           log_connection_execute(conn, "XA PREPARE #{literal(s)}")
         else
@@ -335,7 +335,7 @@ module Sequel
 
       # Rollback the currently open XA transaction
       def rollback_transaction(conn, opts={})
-        if (s = opts[:prepare]) && @transactions[conn][:savepoint_level] <= 1
+        if (s = opts[:prepare]) && _trans(conn)[:savepoint_level] <= 1
           log_connection_execute(conn, "XA END #{literal(s)}")
           log_connection_execute(conn, "XA PREPARE #{literal(s)}")
           log_connection_execute(conn, "XA ROLLBACK #{literal(s)}")
@@ -353,7 +353,9 @@ module Sequel
       def schema_parse_table(table_name, opts)
         m = output_identifier_meth(opts[:dataset])
         im = input_identifier_meth(opts[:dataset])
-        metadata_dataset.with_sql("DESCRIBE ?", SQL::Identifier.new(im.call(table_name))).map do |row|
+        table = SQL::Identifier.new(im.call(table_name))
+        table = SQL::QualifiedIdentifier.new(im.call(opts[:schema]), table) if opts[:schema]
+        metadata_dataset.with_sql("DESCRIBE ?", table).map do |row|
           row[:auto_increment] = true if row.delete(:Extra).to_s =~ /auto_increment/io
           row[:allow_null] = row.delete(:Null) == 'YES'
           row[:default] = row.delete(:Default)
@@ -414,6 +416,9 @@ module Sequel
       INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'insert ignore into columns values on_duplicate_key_update')
       SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct calc_found_rows columns from join where group having compounds order limit lock')
       UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'update ignore table set where order limit')
+      APOS = Dataset::APOS
+      APOS_RE = Dataset::APOS_RE
+      DOUBLE_APOS = Dataset::DOUBLE_APOS
       SPACE = Dataset::SPACE
       PAREN_OPEN = Dataset::PAREN_OPEN
       PAREN_CLOSE = Dataset::PAREN_CLOSE
@@ -446,6 +451,8 @@ module Sequel
       MATCH_AGAINST_BOOLEAN = ["(MATCH ".freeze, " AGAINST (".freeze, " IN BOOLEAN MODE))".freeze].freeze
       EXPLAIN = 'EXPLAIN '.freeze
       EXPLAIN_EXTENDED = 'EXPLAIN EXTENDED '.freeze
+      BACKSLASH_RE = /\\/.freeze
+      QUAD_BACKSLASH = "\\\\\\\\".freeze
       
       # MySQL specific syntax for LIKE/REGEXP searches, as well as
       # string concatenation.
@@ -772,6 +779,11 @@ module Sequel
         BOOL_FALSE
       end
 
+      # SQL fragment for String.  Doubles \ and ' by default.
+      def literal_string_append(sql, v)
+        sql << APOS << v.gsub(BACKSLASH_RE, QUAD_BACKSLASH).gsub(APOS_RE, DOUBLE_APOS) << APOS
+      end
+
       # Use 1 for true on MySQL
       def literal_true
         BOOL_TRUE