sequel 4.9.0 → 4.10.0

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

@@ -145,6 +145,14 @@ module Sequel
         super && (server_version <= 50512 || server_version >= 50523)
       end
 
+      # Support fractional timestamps on MySQL 5.6.5+ if the :fractional_seconds
+      # Database option is used.  Technically, MySQL 5.6.4+ supports them, but
+      # automatic initialization of datetime values wasn't supported to 5.6.5+,
+      # and this is related to that.
+      def supports_timestamp_usecs?
+        @supports_timestamp_usecs ||= server_version >= 50605 && typecast_value_boolean(opts[:fractional_seconds])
+      end
+
       # MySQL supports transaction isolation levels
       def supports_transaction_isolation_levels?
         true
@@ -185,7 +193,11 @@ module Sequel
             sql = super
             op[:table] = related
             op[:key] ||= primary_key_from_schema(related)
-            sql << ", ADD FOREIGN KEY (#{quote_identifier(op[:name])})#{column_references_sql(op)}"
+            sql << ", ADD "
+            if constraint_name = op.delete(:foreign_key_constraint_name)
+              sql << "CONSTRAINT #{quote_identifier(constraint_name)} "
+            end
+            sql << "FOREIGN KEY (#{quote_identifier(op[:name])})#{column_references_sql(op)}"
           else
             super
           end
@@ -292,9 +304,8 @@ module Sequel
       # Use XA START to start a new prepared transaction if the :prepare
       # option is given.
       def begin_transaction(conn, opts=OPTS)
-        if (s = opts[:prepare]) && (th = _trans(conn))[:savepoint_level] == 0
+        if (s = opts[:prepare]) && savepoint_level(conn) == 1
           log_connection_execute(conn, "XA START #{literal(s)}")
-          th[:savepoint_level] += 1
         else
           super
         end
@@ -315,7 +326,7 @@ module Sequel
       # Prepare the XA transaction for a two-phase commit if the
       # :prepare option is given.
       def commit_transaction(conn, opts=OPTS)
-        if (s = opts[:prepare]) && _trans(conn)[:savepoint_level] <= 1
+        if (s = opts[:prepare]) && savepoint_level(conn) <= 1
           log_connection_execute(conn, "XA END #{literal(s)}")
           log_connection_execute(conn, "XA PREPARE #{literal(s)}")
         else
@@ -421,7 +432,7 @@ module Sequel
 
       # Rollback the currently open XA transaction
       def rollback_transaction(conn, opts=OPTS)
-        if (s = opts[:prepare]) && _trans(conn)[:savepoint_level] <= 1
+        if (s = opts[:prepare]) && savepoint_level(conn) <= 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)}")
@@ -462,6 +473,12 @@ module Sequel
         end
       end
 
+      # Split DROP INDEX ops on MySQL 5.6+, as dropping them in the same
+      # statement as dropping a related foreign key causes an error.
+      def split_alter_table_op?(op)
+        server_version >= 50600 && (op[:op] == :drop_index || (op[:op] == :drop_constraint && op[:type] == :unique))
+      end
+
       # MySQL can combine multiple alter table ops into a single query.
       def supports_combining_alter_table_ops?
         true
@@ -496,7 +513,9 @@ module Sequel
       # MySQL has both datetime and timestamp classes, most people are going
       # to want datetime
       def type_literal_generic_datetime(column)
-        if column[:default] == Sequel::CURRENT_TIMESTAMP
+        if supports_timestamp_usecs?
+          :'datetime(6)'
+        elsif column[:default] == Sequel::CURRENT_TIMESTAMP
           :timestamp
         else
           :datetime
@@ -504,9 +523,17 @@ module Sequel
       end
 
       # MySQL has both datetime and timestamp classes, most people are going
-      # to want datetime
+      # to want datetime.
       def type_literal_generic_time(column)
-        column[:only_time] ? :time : type_literal_generic_datetime(column)
+        if column[:only_time]
+          if supports_timestamp_usecs?
+            :'time(6)'
+          else
+            :time
+          end
+        else
+          type_literal_generic_datetime(column)
+        end
       end
 
       # MySQL doesn't have a true boolean class, so it uses tinyint(1)
@@ -522,10 +549,6 @@ module Sequel
       COMMA_SEPARATOR = ', '.freeze
       FOR_SHARE = ' LOCK IN SHARE MODE'.freeze
       SQL_CALC_FOUND_ROWS = ' SQL_CALC_FOUND_ROWS'.freeze
-      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'delete from where order limit')
-      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
@@ -566,6 +589,15 @@ module Sequel
       BLOB_START = "0x".freeze
       EMPTY_BLOB = "''".freeze
       HSTAR = "H*".freeze
+      CURRENT_TIMESTAMP_56 = 'CURRENT_TIMESTAMP(6)'.freeze
+
+      # Comes directly from MySQL's documentation, used for queries with limits without offsets
+      ONLY_OFFSET = ",18446744073709551615".freeze
+
+      Dataset.def_sql_method(self, :delete, %w'delete from where order limit')
+      Dataset.def_sql_method(self, :insert, %w'insert ignore into columns values on_duplicate_key_update')
+      Dataset.def_sql_method(self, :select, %w'select distinct calc_found_rows columns from join where group having compounds order limit lock')
+      Dataset.def_sql_method(self, :update, %w'update ignore table set where order limit')
 
       include Sequel::Dataset::Replace
 
@@ -610,6 +642,18 @@ module Sequel
         end
       end
       
+      # MySQL's CURRENT_TIMESTAMP does not use fractional seconds,
+      # even if the database itself supports fractional seconds. If
+      # MySQL 5.6.4+ is being used, use a value that will return
+      # fractional seconds.
+      def constant_sql_append(sql, constant)
+        if constant == :CURRENT_TIMESTAMP && supports_timestamp_usecs?
+          sql << CURRENT_TIMESTAMP_56
+        else
+          super
+        end
+      end
+
       # Use GROUP BY instead of DISTINCT ON if arguments are provided.
       def distinct(*args)
         args.empty? ? super : group(*args)
@@ -706,13 +750,6 @@ module Sequel
         clone(:on_duplicate_key_update => args)
       end
 
-      # MySQL specific syntax for inserting multiple values at once.
-      def multi_insert_sql(columns, values)
-        sql = LiteralString.new('VALUES ')
-        expression_list_append(sql, values.map{|r| Array(r)})
-        [insert_sql(columns, sql)]
-      end
-      
       # MySQL uses the nonstandard ` (backtick) for quoting identifiers.
       def quoted_identifier_append(sql, c)
         sql << BACKTICK << c.to_s.gsub(BACKTICK_RE, DOUBLE_BACKTICK) << BACKTICK
@@ -734,6 +771,11 @@ module Sequel
         false
       end
       
+      # MySQL does not support limits in correlated subqueries (or any subqueries that use IN).
+      def supports_limits_in_correlated_subqueries?
+        false
+      end
+    
       # MySQL supports modifying joined datasets
       def supports_modifying_joins?
         true
@@ -754,7 +796,7 @@ module Sequel
       # ignores them.  Also, using them seems to cause problems on 1.9.  Since
       # they are ignored anyway, not using them is probably best.
       def supports_timestamp_usecs?
-        false
+        db.supports_timestamp_usecs?
       end
       
       # Sets up the update methods to use UPDATE IGNORE.
@@ -769,11 +811,6 @@ module Sequel
       
       private
 
-      # MySQL supports the ORDER BY and LIMIT clauses for DELETE statements
-      def delete_clause_methods
-        DELETE_CLAUSE_METHODS
-      end
-      
       # Consider the first table in the joined dataset is the table to delete
       # from, but include the others for the purposes of selecting rows.
       def delete_from_sql(sql)
@@ -788,12 +825,6 @@ module Sequel
         end
       end
 
-      # MySQL supports the IGNORE and ON DUPLICATE KEY UPDATE clauses for INSERT statements
-      def insert_clause_methods
-        INSERT_CLAUSE_METHODS
-      end
-      alias replace_clause_methods insert_clause_methods
-
       # MySQL doesn't use the SQL standard DEFAULT VALUES.
       def insert_columns_sql(sql)
         values = opts[:values]
@@ -905,11 +936,17 @@ module Sequel
         BOOL_TRUE
       end
       
-      # MySQL does not support the SQL WITH clause for SELECT statements
-      def select_clause_methods
-        SELECT_CLAUSE_METHODS
+      # MySQL supports multiple rows in INSERT.
+      def multi_insert_sql_strategy
+        :values
       end
-      
+
+      def select_only_offset_sql(sql)
+        sql << LIMIT
+        literal_append(sql, @opts[:offset])
+        sql << ONLY_OFFSET
+      end
+  
       # Support FOR SHARE locking when using the :share lock style.
       def select_lock_sql(sql)
         @opts[:lock] == :share ? (sql << FOR_SHARE) : super
@@ -920,11 +957,6 @@ module Sequel
         sql << SQL_CALC_FOUND_ROWS if opts[:calc_found_rows]
       end
 
-      # MySQL supports the ORDER BY and LIMIT clauses for UPDATE statements
-      def update_clause_methods
-        UPDATE_CLAUSE_METHODS
-      end
-
       # MySQL uses WITH ROLLUP syntax.
       def uses_with_rollup?
         true

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

@@ -247,7 +247,6 @@ module Sequel
     end
 
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with select distinct columns from join where group having compounds order lock')
       ROW_NUMBER_EXPRESSION = LiteralString.new('ROWNUM').freeze
       SPACE = Dataset::SPACE
       APOS = Dataset::APOS
@@ -259,9 +258,13 @@ module Sequel
       BOOL_FALSE = "'N'".freeze
       BOOL_TRUE = "'Y'".freeze
       HSTAR = "H*".freeze
-      DUAL = ['DUAL'.freeze].freeze
+      DUAL = ' FROM DUAL'.freeze
       BITAND_PROC = lambda{|a, b| Sequel.lit(["CAST(BITAND(", ", ", ") AS INTEGER)"], a, b)}
 
+      include(Module.new do
+        Dataset.def_sql_method(self, :select, %w'with select distinct columns from join where group having compounds order lock')
+      end)
+
       def complex_expression_sql_append(sql, op, args)
         case op
         when :&
@@ -334,7 +337,7 @@ module Sequel
       def select_sql
         return super if @opts[:sql]
         if o = @opts[:offset]
-          columns = clone(:append_sql=>'').columns
+          columns = clone(:append_sql=>'', :placeholder_literal_null=>true).columns
           dsa1 = dataset_alias(1)
           rn = row_number_column
           limit = @opts[:limit]
@@ -366,6 +369,10 @@ module Sequel
         true
       end
 
+      def supports_cte?(type=:select)
+        type == :select
+      end
+
       # Oracle supports GROUP BY CUBE
       def supports_group_cube?
         true
@@ -386,6 +393,16 @@ module Sequel
         false
       end
       
+      # Oracle does not support limits in correlated subqueries.
+      def supports_limits_in_correlated_subqueries?
+        false
+      end
+    
+      # Oracle does not support offsets in correlated subqueries.
+      def supports_offsets_in_correlated_subqueries?
+        false
+      end
+
       # Oracle does not support SELECT *, column
       def supports_select_all_and_column?
         false
@@ -420,6 +437,10 @@ module Sequel
         TIMESTAMP_FORMAT
       end
 
+      def empty_from_sql
+        DUAL
+      end
+
       # If this dataset is associated with a sequence, return the most recently
       # inserted sequence value.
       def execute_insert(sql, opts=OPTS)
@@ -457,18 +478,9 @@ module Sequel
         BOOL_TRUE
       end
 
-      # Use the Oracle-specific SQL clauses (no limit, since it is emulated).
-      def select_clause_methods
-        SELECT_CLAUSE_METHODS
-      end
-
-      # Modify the SQL to add the list of tables to select FROM
-      # Oracle doesn't support select without FROM clause
-      # so add the dummy DUAL table if the dataset doesn't select
-      # from a table.
-      def select_from_sql(sql)
-        sql << FROM
-        source_list_append(sql, @opts[:from] || DUAL)
+      # Oracle can insert multiple rows using a UNION
+      def multi_insert_sql_strategy
+        :union
       end
 
       # Oracle supports quoted function names.

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

@@ -410,6 +410,8 @@ module Sequel
       # any named types.
       def reset_conversion_procs
         @conversion_procs = get_conversion_procs
+        conversion_procs_updated
+        @conversion_procs
       end
 
       # Reset the primary key sequence for the given table, basing it on the
@@ -540,6 +542,7 @@ module Sequel
           convert_named_procs_to_procs(named_procs).each do |oid, pr|
             procs[oid] ||= pr
           end
+          conversion_procs_updated
         end
       end
 
@@ -596,7 +599,7 @@ module Sequel
       # If the :prepare option is given and we aren't in a savepoint,
       # prepare the transaction for a two-phase commit.
       def commit_transaction(conn, opts=OPTS)
-        if (s = opts[:prepare]) && _trans(conn)[:savepoint_level] <= 1
+        if (s = opts[:prepare]) && savepoint_level(conn) <= 1
           log_connection_execute(conn, "PREPARE TRANSACTION #{literal(s)}")
         else
           super
@@ -658,6 +661,11 @@ module Sequel
         end
       end
 
+      # Callback used when conversion procs are updated.
+      def conversion_procs_updated
+        nil
+      end
+
       # Convert the hash of named conversion procs into a hash a oid conversion procs. 
       def convert_named_procs_to_procs(named_procs)
         h = {}
@@ -674,6 +682,7 @@ module Sequel
         oids.each do |oid|
           procs[oid] = PG_TYPES[oid]
         end
+        conversion_procs_updated
       end
 
       EXCLUSION_CONSTRAINT_SQL_STATE = '23P01'.freeze
@@ -1094,27 +1103,19 @@ module Sequel
       BOOL_FALSE = 'false'.freeze
       BOOL_TRUE = 'true'.freeze
       COMMA_SEPARATOR = ', '.freeze
-      DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'delete from using where returning')
-      DELETE_CLAUSE_METHODS_91 = Dataset.clause_methods(:delete, %w'with delete from using where returning')
       EXCLUSIVE = 'EXCLUSIVE'.freeze
       EXPLAIN = 'EXPLAIN '.freeze
       EXPLAIN_ANALYZE = 'EXPLAIN ANALYZE '.freeze
       FOR_SHARE = ' FOR SHARE'.freeze
-      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'insert into columns values returning')
-      INSERT_CLAUSE_METHODS_91 = Dataset.clause_methods(:insert, %w'with insert into columns values returning')
       NULL = LiteralString.new('NULL').freeze
       PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
       QUERY_PLAN = 'QUERY PLAN'.to_sym
       ROW_EXCLUSIVE = 'ROW EXCLUSIVE'.freeze
       ROW_SHARE = 'ROW SHARE'.freeze
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct columns from join where group having compounds order limit lock')
-      SELECT_CLAUSE_METHODS_84 = Dataset.clause_methods(:select, %w'with select distinct columns from join where group having window compounds order limit lock')
       SHARE = 'SHARE'.freeze
       SHARE_ROW_EXCLUSIVE = 'SHARE ROW EXCLUSIVE'.freeze
       SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
       SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
-      UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'update table set from where returning')
-      UPDATE_CLAUSE_METHODS_91 = Dataset.clause_methods(:update, %w'with update table set from where returning')
       SPACE = Dataset::SPACE
       FROM = Dataset::FROM
       APOS = Dataset::APOS
@@ -1133,6 +1134,11 @@ module Sequel
       EMPTY_STRING = ''.freeze
       LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each{|s| s.freeze}
 
+      Dataset.def_sql_method(self, :delete, [['if server_version >= 90100', %w'with delete from using where returning'], ['else', %w'delete from using where returning']])
+      Dataset.def_sql_method(self, :insert, [['if server_version >= 90100', %w'with insert into columns values returning'], ['else', %w'insert into columns values returning']])
+      Dataset.def_sql_method(self, :select, [['if server_version >= 80400', %w'with select distinct columns from join where group having window compounds order limit lock'], ['else', %w'select distinct columns from join where group having compounds order limit lock']])
+      Dataset.def_sql_method(self, :update, [['if server_version >= 90100', %w'with update table set from where returning'], ['else', %w'update table set from where returning']])
+
       # Shared methods for prepared statements when used with PostgreSQL databases.
       module PreparedStatementMethods
         # Override insert action to use RETURNING if the server supports it.
@@ -1279,11 +1285,12 @@ module Sequel
         nil
       end
 
-      # PostgreSQL allows inserting multiple rows at once.
-      def multi_insert_sql(columns, values)
-        sql = LiteralString.new('VALUES ')
-        expression_list_append(sql, values.map{|r| Array(r)})
-        [insert_sql(columns, sql)]
+      def supports_cte?(type=:select)
+        if type == :select
+          server_version >= 80400
+        else
+          server_version >= 90100
+        end
       end
 
       # PostgreSQL supports using the WITH clause in subqueries if it
@@ -1393,15 +1400,6 @@ module Sequel
         raise(InvalidOperation, "Joined datasets cannot be truncated") if opts[:join]
       end
 
-      # PostgreSQL allows deleting from joined datasets
-      def delete_clause_methods
-        if server_version >= 90100
-          DELETE_CLAUSE_METHODS_91
-        else
-          DELETE_CLAUSE_METHODS
-        end
-      end
-
       # Only include the primary table in the main delete clause
       def delete_from_sql(sql)
         sql << FROM
@@ -1413,15 +1411,6 @@ module Sequel
         join_from_sql(:USING, sql)
       end
 
-      # PostgreSQL allows a RETURNING clause.
-      def insert_clause_methods
-        if server_version >= 90100
-          INSERT_CLAUSE_METHODS_91
-        else
-          INSERT_CLAUSE_METHODS
-        end
-      end
-
       # Return the primary key to use for RETURNING in an INSERT statement
       def insert_pk
         if (f = opts[:from]) && !f.empty?
@@ -1479,9 +1468,9 @@ module Sequel
         BOOL_TRUE
       end
 
-      # The order of clauses in the SELECT SQL statement
-      def select_clause_methods
-        server_version >= 80400 ? SELECT_CLAUSE_METHODS_84 : SELECT_CLAUSE_METHODS
+      # PostgreSQL supports multiple rows in INSERT.
+      def multi_insert_sql_strategy
+        :values
       end
 
       # PostgreSQL requires parentheses around compound datasets if they use
@@ -1537,15 +1526,6 @@ module Sequel
         SQL::StringExpression.new(:'||', *cols)
       end
 
-      # PostgreSQL splits the main table from the joined tables
-      def update_clause_methods
-        if server_version >= 90100
-          UPDATE_CLAUSE_METHODS_91
-        else
-          UPDATE_CLAUSE_METHODS
-        end
-      end
-
       # Use FROM to specify additional tables in an update query
       def update_from_sql(sql)
         join_from_sql(:FROM, sql)