sequel 3.34.0 → 3.35.0

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

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

@@ -41,7 +41,7 @@ module Sequel
         # arguments.
         def execute_prepared_statement(ps_name, opts, &block)
           args = opts[:arguments]
-          ps = prepared_statements[ps_name]
+          ps = prepared_statement(ps_name)
           sql = ps.prepared_sql
           synchronize(opts[:server]) do |conn|
             unless conn.prepared_statements[ps_name] == sql
@@ -137,7 +137,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

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

@@ -217,6 +217,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 :ILIKE, :'NOT ILIKE'
           sql << ILIKE_0
           literal_append(sql, args.at(0))