sequel 4.45.0 → 4.46.0

data/doc/security.rdoc

@@ -23,6 +23,7 @@ could conceivably be abused to do so:
 * Sequel.def_adapter_method (private)
 * Sequel::SQL::Expression.to_s_method (private)
 * Sequel::Plugins::HookClassMethods::ClassMethods#add_hook_type
+* Sequel::Plugins.def_dataset_methods
 
 As long as you don't call those with user input, you should not be
 vulnerable to code execution.
@@ -196,6 +197,14 @@ for plain strings as literal strings in update methods.
 The Sequel::Dataset#lock_style and Sequel::Model#lock! methods also treat
 an input string as SQL code. This method should not be called with user input.
 
+==== SQL Fragment passed to Virtual Row #` method
+
+Virtual row blocks currently support a #` method for using literal SQL:
+
+  DB[:table].where{a > `some SQL`}
+
+This method should not be called with user input.
+
 ==== SQL Type Names
 
 In general, most places where Sequel needs to use an SQL type that should

data/doc/sql.rdoc

@@ -239,8 +239,8 @@ If the database supports window functions, Sequel can handle them by calling the
   DB[:albums].select{function(:col1).over(:partition=>col2, :order=>col3)}
   # SELECT function(col1) OVER (PARTITION BY col2 ORDER BY col3) FROM albums
 
-  DB[:albums].select{function(c1, c2).over(:partition=>[c3, c4], :order=>[c5, c6])}
-  # SELECT function(c1, c2) OVER (PARTITION BY c3, c4 ORDER BY c5, c6) FROM albums
+  DB[:albums].select{function(c1, c2).over(:partition=>[c3, c4], :order=>[c5, c6.desc])}
+  # SELECT function(c1, c2) OVER (PARTITION BY c3, c4 ORDER BY c5, c6 DESC) FROM albums
 
 === Schema Qualified Functions
 

data/doc/testing.rdoc

@@ -158,11 +158,11 @@ SEQUEL_DUPLICATE_COLUMNS_HANDLER :: Use the duplicate columns handler extension
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
 SEQUEL_FREEZE_DATASETS :: Use the freeze_datasets extension when running the specs
 SEQUEL_FREEZE_DATABASE :: Freeze the database before running the integration specs
+SEQUEL_IDENTIFIER_MANGLING :: Use the identifier_mangling extension when running the specs
 SEQUEL_MODEL_PREPARED_STATEMENTS :: Use the prepared_statements and prepared_statements_associations plugins when running the specs
 SEQUEL_NO_AUTO_LITERAL_STRINGS :: Use the no_auto_string_literals extension when running the specs
 SEQUEL_NO_CACHE_ASSOCIATIONS :: Don't cache association metadata when running the specs
 SEQUEL_NO_CHECK_SQLS :: Don't check for specific SQL syntax when running the specs
-SEQUEL_NO_MANGLE :: Don't use the identifier_mangling extension when runnsing the specs
 SEQUEL_NO_PENDING :: Don't skip any specs, try running all specs (note, can cause lockups for some adapters)
 SEQUEL_NO_SPLIT_SYMBOLS :: Turn off symbol splitting when running the specs
 SKIPPED_TEST_WARN :: Warn when skipping any tests because libraries aren't available

data/doc/validations.rdoc

@@ -496,7 +496,6 @@ This will make sure that all string columns in the model are validated to make s
 If you forget to call +super+, the validations that you defined in <tt>Sequel::Model</tt> will not be enforced.  It's a good idea to call super whenever you override one of <tt>Sequel::Model</tt>'s methods, unless you specifically do not want the default behavior.
 
 == <tt>Sequel::Model::Errors</tt>
-'
 As mentioned earlier, <tt>Sequel::Model::Errors</tt> is a subclass of Hash with a few special methods, the most common of which are described here:
 
 === +add+
@@ -513,7 +512,7 @@ As mentioned earlier, <tt>Sequel::Model::Errors</tt> is a subclass of Hash with
 
 If you want to make some validations dependent upon the results of other validations, you may want to use +on+ inside your validates method:
 
-  validates_integer(:release_date) if errors.on(:record_date)
+  validates_integer(:release_date) unless errors.on(:record_date)
 
 Here, you don't care about validating the release date if there were validation errors for the record date.
 

data/lib/sequel/adapters/ado.rb

@@ -83,9 +83,11 @@ module Sequel
         CONVERSION_PROCS[i] = method
       end
     end
+    # CONVERSION_PROCS.freeze # SEQUEL5
 
     class Database < Sequel::Database
       DISCONNECT_ERROR_RE = /Communication link failure/
+      Sequel::Deprecation.deprecate_constant(self, :DISCONNECT_ERROR_RE)
 
       set_adapter_scheme :ado
 
@@ -201,6 +203,10 @@ module Sequel
         super
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       # The ADO adapter's default provider doesn't support transactions, since it 
       # creates a new native connection for each query.  So Sequel only attempts
       # to use transactions if an explicit :provider is given.
@@ -217,7 +223,7 @@ module Sequel
       end
 
       def disconnect_error?(e, opts)
-        super || (e.is_a?(::WIN32OLERuntimeError) && e.message =~ DISCONNECT_ERROR_RE)
+        super || (e.is_a?(::WIN32OLERuntimeError) && e.message =~ /Communication link failure/)
       end
 
       def rollback_transaction(conn, opts=OPTS)
@@ -227,8 +233,7 @@ module Sequel
     
     class Dataset < Sequel::Dataset
       Database::DatasetClass = self
-
-
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
 
       def fetch_rows(sql)
         execute(sql) do |recordset|

data/lib/sequel/adapters/ado/access.rb

@@ -15,7 +15,7 @@ module Sequel
           :tables  => 20,
           :views   => 23,
           :foreign_keys => 27
-        }
+        }#.freeze # SEQUEL5
         
         attr_reader :type, :criteria
 
@@ -42,7 +42,8 @@ module Sequel
             131 => "DECIMAL",
             201 => "TEXT",
             205 => "IMAGE"
-          }
+          }#.freeze # SEQUEL5
+          #DATA_TYPE.each_value(&:freeze) # SEQUEL5
           
           def initialize(row)
             @row = row
@@ -90,7 +91,9 @@ module Sequel
         include Sequel::Database::SplitAlterTable
     
         DECIMAL_TYPE_RE = /decimal/io
+        Sequel::Deprecation.deprecate_constant(self, :DECIMAL_TYPE_RE)
         LAST_INSERT_ID = "SELECT @@IDENTITY".freeze
+        Sequel::Deprecation.deprecate_constant(self, :LAST_INSERT_ID)
 
         # Remove cached schema after altering a table, since otherwise it can be cached
         # incorrectly in the rename column case.
@@ -111,7 +114,8 @@ module Sequel
           synchronize(opts[:server]) do |conn|
             begin
               log_connection_yield(sql, conn){conn.Execute(sql)}
-              res = log_connection_yield(LAST_INSERT_ID, conn){conn.Execute(LAST_INSERT_ID)}
+              last_insert_sql = "SELECT @@IDENTITY"
+              res = log_connection_yield(last_insert_sql, conn){conn.Execute(last_insert_sql)}
               res.getRows.transpose.each{|r| return r.shift}
             rescue ::WIN32OLERuntimeError => e
               raise_error(e)
@@ -240,7 +244,7 @@ module Sequel
                                 idx["COLUMN_NAME"] == row["COLUMN_NAME"] &&
                                 idx["PRIMARY_KEY"]
                               },
-              :type =>  if row.db_type =~ DECIMAL_TYPE_RE && row.scale == 0
+              :type =>  if row.db_type =~ /decimal/i && row.scale == 0
                           :integer
                         else
                           schema_column_type(row.db_type)

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

@@ -12,6 +12,7 @@ module Sequel
         # Query to use to get the number of rows affected by an update or
         # delete query.
         ROWS_AFFECTED = "SELECT @@ROWCOUNT AS AffectedRows"
+        Sequel::Deprecation.deprecate_constant(self, :ROWS_AFFECTED)
         
         # Issue a separate query to get the rows modified.  ADO appears to
         # use pass by reference with an integer variable, which is obviously
@@ -21,7 +22,8 @@ module Sequel
           synchronize(opts[:server]) do |conn|
             begin
               log_connection_yield(sql, conn){conn.Execute(sql)}
-              res = log_connection_yield(ROWS_AFFECTED, conn){conn.Execute(ROWS_AFFECTED)}
+              rows_affected_sql = "SELECT @@ROWCOUNT AS AffectedRows"
+              res = log_connection_yield(rows_affected_sql, conn){conn.Execute(rows_affected_sql)}
               res.getRows.transpose.each{|r| return r.shift}
             rescue ::WIN32OLERuntimeError => e
               raise_error(e)

data/lib/sequel/adapters/amalgalite.rb

@@ -145,6 +145,10 @@ module Sequel
         o
       end
       
+      def dataset_class_default
+        Dataset
+      end
+
       # Both main error classes that Amalgalite raises
       def database_error_classes
         [::Amalgalite::Error, ::Amalgalite::SQLite3::Error]
@@ -156,6 +160,7 @@ module Sequel
       include ::Sequel::SQLite::DatasetMethods
 
       Database::DatasetClass = self
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
       
       # Yield a hash for each row in the dataset.
       def fetch_rows(sql)

data/lib/sequel/adapters/cubrid.rb

@@ -11,13 +11,15 @@ module Sequel
        ::Cubrid::DATE => lambda{|t| Date.new(t.year, t.month, t.day)},
        ::Cubrid::TIME => lambda{|t| SQLTime.create(t.hour, t.min, t.sec)},
        21 => lambda(&:to_i)
-     }
+     }#.freeze # SEQUEL5
 
     class Database < Sequel::Database
       include Sequel::Cubrid::DatabaseMethods
 
       ROW_COUNT = "SELECT ROW_COUNT()".freeze
+      Sequel::Deprecation.deprecate_constant(self, :ROW_COUNT)
       LAST_INSERT_ID = "SELECT LAST_INSERT_ID()".freeze
+      Sequel::Deprecation.deprecate_constant(self, :LAST_INSERT_ID)
 
       set_adapter_scheme :cubrid
       
@@ -59,14 +61,14 @@ module Sequel
 
                 # Work around bugs by using the ROW_COUNT function.
                 begin
-                  r2 = conn.query(ROW_COUNT)
+                  r2 = conn.query("SELECT ROW_COUNT()")
                   r2.each{|a| return a.first.to_i}
                 ensure
                   r2.close if r2
                 end
               when :insert
                 begin
-                  r2 = conn.query(LAST_INSERT_ID)
+                  r2 = conn.query("SELECT LAST_INSERT_ID()")
                   r2.each{|a| return a.first.to_i}
                 ensure
                   r2.close if r2
@@ -99,11 +101,15 @@ module Sequel
       private
 
       def begin_transaction(conn, opts=OPTS)
-        log_connection_yield(TRANSACTION_BEGIN, conn){conn.auto_commit = false}
+        log_connection_yield("Transaction.begin", conn){conn.auto_commit = false}
       end
       
       def commit_transaction(conn, opts=OPTS)
-        log_connection_yield(TRANSACTION_COMMIT, conn){conn.commit}
+        log_connection_yield('Transaction.commit', conn){conn.commit}
+      end
+
+      def dataset_class_default
+        Dataset
       end
 
       def database_error_classes
@@ -119,21 +125,24 @@ module Sequel
       # This doesn't actually work, as the cubrid ruby driver
       # does not implement transactions correctly.
       def rollback_transaction(conn, opts=OPTS)
-        log_connection_yield(TRANSACTION_ROLLBACK, conn){conn.rollback}
+        log_connection_yield('Transaction.rollback', conn){conn.rollback}
       end
     end
     
     class Dataset < Sequel::Dataset
       include Sequel::Cubrid::DatasetMethods
       COLUMN_INFO_NAME = "name".freeze
+      Sequel::Deprecation.deprecate_constant(self, :COLUMN_INFO_NAME)
       COLUMN_INFO_TYPE = "type_name".freeze
+      Sequel::Deprecation.deprecate_constant(self, :COLUMN_INFO_TYPE)
 
       Database::DatasetClass = self
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
       
       def fetch_rows(sql)
         execute(sql) do |stmt|
           begin
-            cols = stmt.column_info.map{|c| [output_identifier(c[COLUMN_INFO_NAME]), CUBRID_TYPE_PROCS[c[COLUMN_INFO_TYPE]]]}
+            cols = stmt.column_info.map{|c| [output_identifier(c["name"]), CUBRID_TYPE_PROCS[c["type_name"]]]}
             self.columns = cols.map(&:first)
             stmt.each do |r|
               row = {}

data/lib/sequel/adapters/do.rb

@@ -33,6 +33,7 @@ module Sequel
     # use a pool size at least as large as the pool size being used by Sequel.
     class Database < Sequel::Database
       DISCONNECT_ERROR_RE = /terminating connection due to administrator command/
+      Sequel::Deprecation.deprecate_constant(self, :DISCONNECT_ERROR_RE)
 
       set_adapter_scheme :do
       
@@ -121,9 +122,13 @@ module Sequel
         [::DataObjects::Error]
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       # Recognize DataObjects::ConnectionError instances as disconnect errors.
       def disconnect_error?(e, opts)
-        super || (e.is_a?(::DataObjects::Error) && (e.is_a?(::DataObjects::ConnectionError) || e.message =~ DISCONNECT_ERROR_RE))
+        super || (e.is_a?(::DataObjects::Error) && (e.is_a?(::DataObjects::ConnectionError) || e.message =~ /terminating connection due to administrator command/))
       end
       
       # Execute SQL on the connection by creating a command first
@@ -141,6 +146,7 @@ module Sequel
     # Dataset class for Sequel::DataObjects::Database objects.
     class Dataset < Sequel::Dataset
       Database::DatasetClass = self
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
 
       # Execute the SQL on the database and yield the rows as hashes
       # with symbol keys.

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

@@ -43,9 +43,13 @@ module Sequel
       # Dataset class for MySQL datasets accessed via DataObjects.
       class Dataset < DataObjects::Dataset
         include Sequel::MySQL::DatasetMethods
-        APOS = Dataset::APOS
-        APOS_RE = Dataset::APOS_RE
-        DOUBLE_APOS = Dataset::DOUBLE_APOS
+
+        APOS = "'".freeze
+        Sequel::Deprecation.deprecate_constant(self, :APOS)
+        APOS_RE = /'/.freeze
+        Sequel::Deprecation.deprecate_constant(self, :APOS_RE)
+        DOUBLE_APOS = "''".freeze
+        Sequel::Deprecation.deprecate_constant(self, :DOUBLE_APOS)
         
         # The DataObjects MySQL driver uses the number of rows actually modified in the update,
         # instead of the number of matched by the filter.
@@ -57,7 +61,7 @@ module Sequel
         
         # do_mysql sets NO_BACKSLASH_ESCAPES, so use standard SQL string escaping
         def literal_string_append(sql, s)
-          sql << APOS << s.gsub(APOS_RE, DOUBLE_APOS) << APOS
+          sql << "'" << s.gsub("'", "''") << "'"
         end
       end
     end

data/lib/sequel/adapters/ibmdb.rb

@@ -26,7 +26,7 @@ module Sequel
       :blob => ::Sequel::SQL::Blob.method(:new),
       :time => ::Sequel.method(:string_to_time),
       :date => ::Sequel.method(:string_to_date)
-    }
+    }#.freeze # SEQUEL5
 
     # Wraps an underlying connection to DB2 using IBM_DB.
     class Connection
@@ -291,14 +291,14 @@ module Sequel
       # IBM_DB uses an autocommit setting instead of sending SQL queries.
       # So starting a transaction just turns autocommit off.
       def begin_transaction(conn, opts=OPTS)
-        log_connection_yield(TRANSACTION_BEGIN, conn){conn.autocommit = false}
+        log_connection_yield('Transaction.begin', conn){conn.autocommit = false}
         set_transaction_isolation(conn, opts)
       end
 
       # This commits transaction in progress on the
       # connection and sets autocommit back on.
       def commit_transaction(conn, opts=OPTS)
-        log_connection_yield(TRANSACTION_COMMIT, conn){conn.commit}
+        log_connection_yield('Transaction.commit', conn){conn.commit}
       end
     
       def database_error_classes
@@ -309,6 +309,10 @@ module Sequel
         exception.sqlstate
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       # Don't convert smallint to boolean for the metadata
       # dataset, since the DB2 metadata does not use
       # boolean columns, and some smallint columns are
@@ -340,7 +344,7 @@ module Sequel
       # This rolls back the transaction in progress on the
       # connection and sets autocommit back on.
       def rollback_transaction(conn, opts=OPTS)
-        log_connection_yield(TRANSACTION_ROLLBACK, conn){conn.rollback}
+        log_connection_yield('Transaction.rollback', conn){conn.rollback}
       end
 
       # Convert smallint type to boolean if convert_smallint_to_bool is true
@@ -357,6 +361,7 @@ module Sequel
       include Sequel::DB2::DatasetMethods
 
       Database::DatasetClass = self
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
 
       module CallableStatementMethods
         # Extend given dataset with this module so subselects inside subselects in
@@ -403,7 +408,7 @@ module Sequel
             type = :blob if type == :clob && Sequel::DB2.use_clob_as_blob
             columns << [key, cps[type]]
           end
-          cols = columns.map{|c| c.at(0)}
+          cols = columns.map{|c| c[0]}
           self.columns = cols
 
           while res = stmt.fetch_array

data/lib/sequel/adapters/jdbc.rb

@@ -28,6 +28,7 @@ module Sequel
     # The types to check for 0 scale to transform :decimal types
     # to :integer.
     DECIMAL_TYPE_RE = /number|numeric|decimal/io
+    Sequel::Deprecation.deprecate_constant(self, :DECIMAL_TYPE_RE)
     
     # Contains procs keyed on subadapter type that extend the
     # given database object so it supports the correct database type.
@@ -402,6 +403,10 @@ module Sequel
         true
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       # Raise a disconnect error if the SQL state of the cause of the exception indicates so.
       def disconnect_error?(exception, opts)
         cause = exception.respond_to?(:cause) ? exception.cause : exception
@@ -649,7 +654,7 @@ module Sequel
             s[:auto_increment] = h[:is_autoincrement] == "YES"
           end
           s[:max_length] = s[:column_size] if s[:type] == :string
-          if s[:db_type] =~ DECIMAL_TYPE_RE && s[:scale] == 0
+          if s[:db_type] =~ /number|numeric|decimal/i && s[:scale] == 0
             s[:type] = :integer
           end
           schema_column_set_db_type(s)
@@ -704,6 +709,7 @@ module Sequel
       include StoredProcedures
 
       Database::DatasetClass = self
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
       
       PreparedStatementMethods = prepared_statements_module(
         "sql = self; opts = Hash[opts]; opts[:arguments] = bind_arguments",
@@ -802,7 +808,7 @@ module Sequel
           i += 1
           cols << [output_identifier(meta.getColumnLabel(i)), i, convert ? type_convertor(map, meta, meta.getColumnType(i), i) : basic_type_convertor(map, meta, meta.getColumnType(i), i)]
         end
-        self.columns = cols.map{|c| c.at(0)}
+        self.columns = cols.map{|c| c[0]}
 
         while result.next
           row = {}

data/lib/sequel/adapters/jdbc/as400.rb

@@ -23,8 +23,11 @@ module Sequel
         include Sequel::JDBC::Transactions
 
         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)
         
         # AS400 uses the :as400 database type.
         def database_type
@@ -59,19 +62,23 @@ module Sequel
         include EmulateOffsetWithRowNumber
 
         WILDCARD = Sequel::LiteralString.new('*').freeze
+        Sequel::Deprecation.deprecate_constant(self, :WILDCARD)
         FETCH_FIRST_ROW_ONLY = " FETCH FIRST ROW ONLY".freeze
+        Sequel::Deprecation.deprecate_constant(self, :FETCH_FIRST_ROW_ONLY)
         FETCH_FIRST = " FETCH FIRST ".freeze
+        Sequel::Deprecation.deprecate_constant(self, :FETCH_FIRST)
         ROWS_ONLY = " ROWS ONLY".freeze
+        Sequel::Deprecation.deprecate_constant(self, :ROWS_ONLY)
         
         # Modify the sql to limit the number of rows returned
         def select_limit_sql(sql)
           if l = @opts[:limit]
             if l == 1
-              sql << FETCH_FIRST_ROW_ONLY
+              sql << " FETCH FIRST ROW ONLY"
             elsif l > 1
-              sql << FETCH_FIRST
+              sql << " FETCH FIRST "
               literal_append(sql, l)
-              sql << ROWS_ONLY
+              sql << " ROWS ONLY"
             end
           end
         end