sequel 4.49.0 → 5.0.0

data/lib/sequel/database/schema_methods.rb

@@ -7,40 +7,19 @@ module Sequel
     # These methods execute code on the database that modifies the database's schema.
     # ---------------------
 
-    AUTOINCREMENT = 'AUTOINCREMENT'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :AUTOINCREMENT)
-    COMMA_SEPARATOR = ', '.freeze
-    Sequel::Deprecation.deprecate_constant(self, :COMMA_SEPARATOR)
-    NOT_NULL = ' NOT NULL'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :NOT_NULL)
-    NULL = ' NULL'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :NULL)
-    PRIMARY_KEY = ' PRIMARY KEY'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :PRIMARY_KEY)
-    TEMPORARY = 'TEMPORARY '.freeze
-    Sequel::Deprecation.deprecate_constant(self, :TEMPORARY)
-    UNDERSCORE = '_'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE)
-    UNIQUE = ' UNIQUE'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :UNIQUE)
-    UNSIGNED = ' UNSIGNED'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :UNSIGNED)
-    DEFAULT_JOIN_TABLE_COLUMN_OPTIONS = {:null=>false}
-    Sequel::Deprecation.deprecate_constant(self, :DEFAULT_JOIN_TABLE_COLUMN_OPTIONS)
-
     # The order of column modifiers to use when defining a column.
-    COLUMN_DEFINITION_ORDER = [:collate, :default, :null, :unique, :primary_key, :auto_increment, :references]#.freeze # SEQUEL5
+    COLUMN_DEFINITION_ORDER = [:collate, :default, :null, :unique, :primary_key, :auto_increment, :references].freeze
 
     # The alter table operations that are combinable.
     COMBINABLE_ALTER_TABLE_OPS = [:add_column, :drop_column, :rename_column,
       :set_column_type, :set_column_default, :set_column_null,
-      :add_constraint, :drop_constraint]#.freeze # SEQUEL5
+      :add_constraint, :drop_constraint].freeze
 
     # Adds a column to the specified table. This method expects a column name,
     # a datatype and optionally a hash with additional constraints and options:
     #
-    #   DB.add_column :items, :name, :text, :unique => true, :null => false
-    #   DB.add_column :items, :category, :text, :default => 'ruby'
+    #   DB.add_column :items, :name, String, unique: true, null: false
+    #   DB.add_column :items, :category, String, default: 'ruby'
     #
     # See <tt>alter_table</tt>.
     def add_column(table, *args)
@@ -50,9 +29,10 @@ module Sequel
     # Adds an index to a table for the given columns:
     # 
     #   DB.add_index :posts, :title
-    #   DB.add_index :posts, [:author, :title], :unique => true
+    #   DB.add_index :posts, [:author, :title], unique: true
     #
     # Options:
+    #
     # :ignore_errors :: Ignore any DatabaseErrors that are raised
     # :name :: Name to use for index instead of default
     #
@@ -64,16 +44,17 @@ module Sequel
       rescue DatabaseError
         raise unless e
       end
+      nil
     end
     
     # Alters the given table with the specified block. Example:
     #
     #   DB.alter_table :items do
-    #     add_column :category, :text, :default => 'ruby'
+    #     add_column :category, String, default: 'ruby'
     #     drop_column :category
     #     rename_column :cntr, :counter
-    #     set_column_type :value, :float
-    #     set_column_default :value, :float
+    #     set_column_type :value, Float
+    #     set_column_default :value, 4.2
     #     add_index [:group, :category]
     #     drop_index [:group, :category]
     #   end
@@ -83,13 +64,8 @@ module Sequel
     # available for index definition.
     #
     # See <tt>Schema::AlterTableGenerator</tt> and the {"Migrations and Schema Modification" guide}[rdoc-ref:doc/migration.rdoc].
-    def alter_table(name, generator=(arg_not_given=true; nil), &block)
-      if generator
-        Sequel::Deprecation.deprecate("Passing a Sequel::Schema::AlterTableGenerator instance as the second argument to Sequel::Database#alter_table ", "Pass a block to Sequel::Database#alter_table instead")
-      else
-        Sequel::Deprecation.deprecate("Passing a second argument to Sequel::Database#alter_table :generator option", "Pass only a single argument to the method") unless arg_not_given
-        generator = alter_table_generator(&block)
-      end
+    def alter_table(name, &block)
+      generator = alter_table_generator(&block)
       remove_cached_schema(name)
       apply_alter_table_generator(name, generator)
       nil
@@ -104,7 +80,7 @@ module Sequel
     # Create a join table using a hash of foreign keys to referenced
     # table names.  Example:
     #
-    #   create_join_table(:cat_id=>:cats, :dog_id=>:dogs)
+    #   create_join_table:cat_id: :cats, dog_id: :dogs)
     #   # CREATE TABLE cats_dogs (
     #   #  cat_id integer NOT NULL REFERENCES cats,
     #   #  dog_id integer NOT NULL REFERENCES dogs,
@@ -121,11 +97,11 @@ module Sequel
     # be option hashes, so long as the option hashes have a :table
     # entry giving the table referenced:
     #
-    #   create_join_table(:cat_id=>{:table=>:cats, :type=>:Bignum}, :dog_id=>:dogs)
+    #   create_join_table(cat_id: {table: :cats, type: :Bignum}, dog_id: :dogs)
     #   
     # You can provide a second argument which is a table options hash:
     #
-    #   create_join_table({:cat_id=>:cats, :dog_id=>:dogs}, :temp=>true)
+    #   create_join_table({cat_id: :cats, dog_id: :dogs}, temp: true)
     #
     # Some table options are handled specially:
     #
@@ -134,7 +110,7 @@ module Sequel
     # :no_index :: Set to true not to create the second index.
     # :no_primary_key :: Set to true to not create the primary key.
     def create_join_table(hash, options=OPTS)
-      keys = hash.keys.sort_by(&:to_s)
+      keys = hash.keys.sort
       create_table(join_table_name(hash, options), options) do
         keys.each do |key|
           v = hash[key]
@@ -147,6 +123,7 @@ module Sequel
         primary_key(keys) unless options[:no_primary_key]
         index(keys.reverse, options[:index_options] || {}) unless options[:no_index]
       end
+      nil
     end
 
     # Forcibly create a join table, attempting to drop it if it already exists, then creating it.
@@ -168,7 +145,7 @@ module Sequel
     #
     #   DB.create_table :posts do
     #     primary_key :id
-    #     column :title, :text
+    #     column :title, String
     #     String :content
     #     index :title
     #   end
@@ -201,10 +178,6 @@ module Sequel
     # See <tt>Schema::CreateTableGenerator</tt> and the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
     def create_table(name, options=OPTS, &block)
       remove_cached_schema(name)
-      if options.is_a?(Schema::CreateTableGenerator)
-        Sequel::Deprecation.deprecate("Passing a Sequel::Schema::CreateTableGenerator instance as the second argument to Sequel::Database#create_table", "Use the Sequel::Database#create_table :generator option instead")
-        options = {:generator=>options}
-      end
       if sql = options[:as]
         raise(Error, "can't provide both :as option and block to create_table") if block
         create_table_as(name, sql, options)
@@ -212,8 +185,8 @@ module Sequel
         generator = options[:generator] || create_table_generator(&block)
         create_table_from_generator(name, generator, options)
         create_table_indexes_from_generator(name, generator, options)
-        nil
       end
+      nil
     end
 
     # Forcibly create a table, attempting to drop it if it already exists, then creating it.
@@ -251,7 +224,7 @@ module Sequel
     # Creates a view, replacing a view with the same name if one already exists.
     #
     #   DB.create_or_replace_view(:some_items, "SELECT * FROM items WHERE price < 100")
-    #   DB.create_or_replace_view(:some_items, DB[:items].where(:category => 'ruby'))
+    #   DB.create_or_replace_view(:some_items, DB[:items].where(category: 'ruby'))
     #
     # For databases where replacing a view is not natively supported, support
     # is emulated by dropping a view with the same name before creating the view.
@@ -263,6 +236,7 @@ module Sequel
       end
 
       create_view(name, source, options)
+      nil
     end
     
     # Creates a view based on a dataset or an SQL string:
@@ -271,11 +245,11 @@ module Sequel
     #   # CREATE VIEW cheap_items AS
     #   # SELECT * FROM items WHERE price < 100
     #
-    #   DB.create_view(:ruby_items, DB[:items].where(:category => 'ruby'))
+    #   DB.create_view(:ruby_items, DB[:items].where(category: 'ruby'))
     #   # CREATE VIEW ruby_items AS
     #   # SELECT * FROM items WHERE (category = 'ruby')
     #
-    #   DB.create_view(:checked_items, DB[:items].where(:foo), :check=>true)
+    #   DB.create_view(:checked_items, DB[:items].where(:foo), check: true)
     #   # CREATE VIEW checked_items AS
     #   # SELECT * FROM items WHERE foo
     #   # WITH CHECK OPTION
@@ -299,7 +273,7 @@ module Sequel
     #               option.  Since a recursive view requires a union that isn't
     #               in a subquery, if you are providing a Dataset as the source
     #               argument, if should probably call the union method with the
-    #               :all=>true and :from_self=>false options.
+    #               all: true and from_self: false options.
     def create_view(name, source, options = OPTS)
       execute_ddl(create_view_sql(name, source, options))
       remove_cached_schema(name)
@@ -315,7 +289,7 @@ module Sequel
       alter_table(table) {drop_column(*args)}
     end
     
-    # Removes an index for the given table and column/s:
+    # Removes an index for the given table and column(s):
     #
     #   DB.drop_index :posts, :title
     #   DB.drop_index :posts, [:author, :title]
@@ -328,7 +302,7 @@ module Sequel
     # Drop the join table that would have been created with the
     # same arguments to create_join_table:
     #
-    #   drop_join_table(:cat_id=>:cats, :dog_id=>:dogs)
+    #   drop_join_table(cat_id: :cats, dog_id: :dogs)
     #   # DROP TABLE cats_dogs
     def drop_join_table(hash, options=OPTS)
       drop_table(join_table_name(hash, options), options)
@@ -338,7 +312,7 @@ module Sequel
     #
     #   DB.drop_table(:posts) # DROP TABLE posts
     #   DB.drop_table(:posts, :comments)
-    #   DB.drop_table(:posts, :comments, :cascade=>true)
+    #   DB.drop_table(:posts, :comments, cascade: true)
     def drop_table(*names)
       options = names.last.is_a?(Hash) ? names.pop : {}
       names.each do |n|
@@ -366,14 +340,15 @@ module Sequel
           drop_table(name, options) if table_exists?(name)
         end
       end
+      nil
     end
     
     # Drops one or more views corresponding to the given names:
     #
     #   DB.drop_view(:cheap_items)
     #   DB.drop_view(:cheap_items, :pricey_items)
-    #   DB.drop_view(:cheap_items, :pricey_items, :cascade=>true)
-    #   DB.drop_view(:cheap_items, :pricey_items, :if_exists=>true)
+    #   DB.drop_view(:cheap_items, :pricey_items, cascade: true)
+    #   DB.drop_view(:cheap_items, :pricey_items, if_exists: true)
     #
     # Options:
     # :cascade :: Also drop objects depending on this view.
@@ -458,6 +433,7 @@ module Sequel
     def alter_table_op_sql(table, op)
       meth = "alter_table_#{op[:op]}_sql"
       if respond_to?(meth, true)
+        # Allow calling private methods as alter table op sql methods are private
         send(meth, table, op)
       else
         raise Error, "Unsupported ALTER TABLE operation: #{op[:op]}"
@@ -500,7 +476,7 @@ module Sequel
       "DROP CONSTRAINT #{quoted_name}#{' CASCADE' if op[:cascade]}"
     end
 
-    # The SQL to execute to modify the DDL for the given table name.  op
+    # The SQL to execute to modify the table.  op
     # should be one of the operations returned by the AlterTableGenerator.
     def alter_table_sql(table, op)
       case op[:op]
@@ -513,8 +489,8 @@ module Sequel
       end
     end
 
-    # Array of SQL DDL modification statements for the given table,
-    # corresponding to the DDL changes specified by the operations.
+    # Array of SQL statements used to modify the table,
+    # corresponding to changes specified by the operations.
     def alter_table_sql_list(table, operations)
       if supports_combining_alter_table_ops?
         grouped_ops = []
@@ -554,7 +530,7 @@ module Sequel
       COLUMN_DEFINITION_ORDER
     end
 
-    # SQL DDL fragment containing the column creation SQL for the given column.
+    # SQL fragment containing the column creation SQL for the given column.
     def column_definition_sql(column)
       sql = String.new
       sql << "#{quote_identifier(column[:name])} #{type_literal(column)}"
@@ -629,12 +605,12 @@ module Sequel
       (generator.columns.map{|c| column_definition_sql(c)} + generator.constraints.map{|c| constraint_definition_sql(c)}).join(', ')
     end
 
-    # SQL DDL fragment for column foreign key references (column constraints)
+    # SQL fragment for column foreign key references (column constraints)
     def column_references_column_constraint_sql(column)
       column_references_sql(column)
     end
 
-    # SQL DDL fragment for column foreign key references
+    # SQL fragment for column foreign key references
     def column_references_sql(column)
       sql = String.new
       sql << " REFERENCES #{quote_schema_table(column[:table])}"
@@ -645,7 +621,7 @@ module Sequel
       sql
     end
   
-    # SQL DDL fragment for table foreign key references (table constraints)
+    # SQL fragment for table foreign key references (table constraints)
     def column_references_table_constraint_sql(constraint)
       "FOREIGN KEY #{literal(constraint[:columns])}#{column_references_sql(constraint)}"
     end
@@ -655,7 +631,7 @@ module Sequel
       COMBINABLE_ALTER_TABLE_OPS.include?(op[:op])
     end
 
-    # SQL DDL fragment specifying a constraint on a table.
+    # SQL fragment specifying a constraint on a table.
     def constraint_definition_sql(constraint)
       sql = String.new
       sql << "CONSTRAINT #{quote_identifier(constraint[:name])} " if constraint[:name] 
@@ -679,7 +655,7 @@ module Sequel
       sql
     end
 
-    # SQL DDL fragment specifying the deferrable constraint attributes.
+    # SQL fragment specifying the deferrable constraint attributes.
     def constraint_deferrable_sql_append(sql, defer)
       case defer
       when nil
@@ -707,14 +683,15 @@ module Sequel
       e = options[:ignore_index_errors] || options[:if_not_exists]
       generator.indexes.each do |index|
         begin
-          transaction(:savepoint=>:only){index_sql_list(name, [index]).each{|sql| execute_ddl(sql)}}
+          pr = proc{index_sql_list(name, [index]).each{|sql| execute_ddl(sql)}}
+          supports_transactional_ddl? ? transaction(:savepoint=>:only, &pr) : pr.call
         rescue Error
           raise unless e
         end
       end
     end
 
-    # DDL statement for creating a table with the given name, columns, and options
+    # SQL statement for creating a table with the given name, columns, and options
     def create_table_sql(name, generator, options)
       unless supports_named_column_constraints?
         # Split column constraints into table constraints if they have a name
@@ -747,30 +724,30 @@ module Sequel
       "#{create_table_prefix_sql(name, options)} (#{column_list_sql(generator)})"
     end
 
-    # Run a command to create the table with the given name from the given
+    # Run SQL statement to create the table with the given name from the given
     # SELECT sql statement.
     def create_table_as(name, sql, options)
       sql = sql.sql if sql.is_a?(Sequel::Dataset)
       run(create_table_as_sql(name, sql, options))
     end
     
-    # DDL statement for creating a table from the result of a SELECT statement.
+    # SQL statement for creating a table from the result of a SELECT statement.
     # +sql+ should be a string representing a SELECT query.
     def create_table_as_sql(name, sql, options)
       "#{create_table_prefix_sql(name, options)} AS #{sql}"
     end
 
-    # DDL fragment for initial part of CREATE TABLE statement
+    # SQL fragment for initial part of CREATE TABLE statement
     def create_table_prefix_sql(name, options)
       "CREATE #{temporary_table_sql if options[:temp]}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
     end
 
-    # DDL fragment for initial part of CREATE VIEW statement
+    # SQL fragment for initial part of CREATE VIEW statement
     def create_view_prefix_sql(name, options)
       create_view_sql_append_columns("CREATE #{'OR REPLACE 'if options[:replace]}VIEW #{quote_schema_table(name)}", options[:columns])
     end
 
-    # DDL statement for creating a view.
+    # SQL statement for creating a view.
     def create_view_sql(name, source, options)
       source = source.sql if source.is_a?(Dataset)
       sql = String.new
@@ -831,14 +808,18 @@ module Sequel
           args = nil
         elsif arg.is_a?(String)
           args = [Sequel.lit(*args)]
-        elsif arg.is_a?(Array) && arg.first.is_a?(String)
-          args = [Sequel.lit(*arg)]
+        elsif arg.is_a?(Array)
+          if arg.first.is_a?(String)
+            args = [Sequel.lit(*arg)]
+          elsif arg.length > 1
+            args = [Sequel.&(*arg)]
+          end
         end
       end
       schema_utility_dataset.literal(schema_utility_dataset.send(:filter_expr, *args, &block))
     end
 
-    # SQL DDL statement for creating an index for the table with the given name
+    # SQL statement for creating an index for the table with the given name
     # and index specifications.
     def index_definition_sql(table_name, index)
       index_name = index[:name] || default_index_name(table_name, index[:columns])
@@ -847,7 +828,7 @@ module Sequel
       "CREATE #{'UNIQUE ' if index[:unique]}INDEX #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}#{" WHERE #{filter_expr(index[:where])}" if index[:where]}"
     end
   
-    # Array of SQL DDL statements, one for each index specification,
+    # Array of SQL statements, one for each index specification,
     # for the given table.
     def index_sql_list(table_name, indexes)
       indexes.map{|i| index_definition_sql(table_name, i)}
@@ -879,7 +860,7 @@ module Sequel
       end
     end
     
-    # SQL DDL ON DELETE fragment to use, based on the given action.
+    # SQL fragment to use for ON DELETE, based on the given action.
     # The following actions are recognized:
     # 
     # :cascade :: Delete rows referencing this row.
@@ -906,7 +887,7 @@ module Sequel
       schema_utility_dataset.quote_schema_table(table)
     end
     
-    # SQL DDL statement for renaming a table.
+    # SQL statement for renaming a table.
     def rename_table_sql(name, new_name)
       "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_schema_table(new_name)}"
     end
@@ -931,7 +912,7 @@ module Sequel
       schema_utility_dataset.split_qualifiers(table_name)
     end
 
-    # SQL DDL fragment for temporary table
+    # SQL fragment for temporary table
     def temporary_table_sql
       'TEMPORARY '
     end
@@ -953,6 +934,7 @@ module Sequel
     def type_literal_generic(column)
       meth = "type_literal_generic_#{column[:type].name.to_s.downcase}"
       if respond_to?(meth, true)
+        # Allow calling private methods as per type literal generic methods are private
         send(meth, column)
       else
         raise Error, "Unsupported ruby class used as database type: #{column[:type]}"
@@ -1046,7 +1028,7 @@ module Sequel
       "#{type}#{literal(Array(elements)) if elements}#{' UNSIGNED' if column[:unsigned]}"
     end
 
-    # Whether clob should be used for String :text=>true columns.
+    # Whether clob should be used for String text: true columns.
     def uses_clob_for_text?
       false
     end

data/lib/sequel/database/transactions.rb

@@ -9,30 +9,10 @@ module Sequel
     # them do.
     # ---------------------
 
-    SQL_BEGIN = 'BEGIN'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :SQL_BEGIN)
-    SQL_COMMIT = 'COMMIT'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :SQL_COMMIT)
-    SQL_RELEASE_SAVEPOINT = 'RELEASE SAVEPOINT autopoint_%d'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :SQL_RELEASE_SAVEPOINT)
-    SQL_ROLLBACK = 'ROLLBACK'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :SQL_ROLLBACK)
-    SQL_ROLLBACK_TO_SAVEPOINT = 'ROLLBACK TO SAVEPOINT autopoint_%d'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :SQL_ROLLBACK_TO_SAVEPOINT)
-    SQL_SAVEPOINT = 'SAVEPOINT autopoint_%d'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :SQL_SAVEPOINT)
-    
-    TRANSACTION_BEGIN = 'Transaction.begin'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_BEGIN)
-    TRANSACTION_COMMIT = 'Transaction.commit'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_COMMIT)
-    TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :TRANSACTION_ROLLBACK)
-
     TRANSACTION_ISOLATION_LEVELS = {:uncommitted=>'READ UNCOMMITTED'.freeze,
       :committed=>'READ COMMITTED'.freeze,
       :repeatable=>'REPEATABLE READ'.freeze,
-      :serializable=>'SERIALIZABLE'.freeze}#.freeze # SEQUEL5
+      :serializable=>'SERIALIZABLE'.freeze}.freeze
     
     # The default transaction isolation level for this database,
     # used for all future transactions.  For MSSQL, this should be set
@@ -284,7 +264,7 @@ module Sequel
       hooks << block
     end
 
-    # Whether the current thread/connection is already inside a transaction
+    # Whether the given connection is already inside a transaction
     def already_in_transaction?(conn, opts)
       _trans(conn) && (!supports_savepoints? || !opts[:savepoint])
     end
@@ -305,7 +285,7 @@ module Sequel
       "SAVEPOINT autopoint_#{depth}"
     end
 
-    # Start a new database connection on the given connection
+    # Start a new database transaction on the given connection
     def begin_new_transaction(conn, opts)
       log_connection_execute(conn, begin_transaction_sql)
       set_transaction_isolation(conn, opts)
@@ -332,7 +312,7 @@ module Sequel
     # Whether to commit the current transaction. Thread.current.status is
     # checked because Thread#kill skips rescue blocks (so exception would be
     # nil), but the transaction should still be rolled back. On Ruby 1.9 (but
-    # not 1.8 or 2.0), the thread status will still be "run", so Thread#kill
+    # not 2.0+), the thread status will still be "run", so Thread#kill
     # will erroneously commit the transaction, and there isn't a workaround.
     def commit_or_rollback_transaction(exception, conn, opts)
       if exception