sequel 4.45.0 → 4.46.0

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

@@ -18,8 +18,10 @@ module Sequel
     module DatabaseMethods
       include UnmodifiedIdentifiers::DatabaseMethods
 
-      AUTO_VACUUM = [:none, :full, :incremental].freeze
       PRIMARY_KEY_INDEX_RE = /\Asqlite_autoindex_/.freeze
+      Sequel::Deprecation.deprecate_constant(self, :PRIMARY_KEY_INDEX_RE)
+
+      AUTO_VACUUM = [:none, :full, :incremental].freeze
       SYNCHRONOUS = [:off, :normal, :full].freeze
       TABLES_FILTER = Sequel.~(:name=>'sqlite_sequence'.freeze) & {:type => 'table'.freeze}
       TEMP_STORE = [:default, :file, :memory].freeze
@@ -28,7 +30,7 @@ module Sequel
         :deferred => "BEGIN DEFERRED TRANSACTION".freeze,
         :immediate => "BEGIN IMMEDIATE TRANSACTION".freeze,
         :exclusive => "BEGIN EXCLUSIVE TRANSACTION".freeze,
-        nil => Sequel::Database::SQL_BEGIN,
+        nil => "BEGIN".freeze
       }.freeze
 
       # Whether to use integers for booleans in the database.  SQLite recommends
@@ -114,7 +116,7 @@ module Sequel
         indexes = {}
         metadata_dataset.with_sql("PRAGMA index_list(?)", im.call(table)).each do |r|
           # :only_autocreated internal option can be used to get only autocreated indexes
-          next if (!!(r[:name] =~ PRIMARY_KEY_INDEX_RE) ^ !!opts[:only_autocreated])
+          next if (!!(r[:name] =~ /\Asqlite_autoindex_/) ^ !!opts[:only_autocreated])
           indexes[m.call(r[:name])] = {:unique=>r[:unique].to_i==1}
         end
         indexes.each do |k, v|
@@ -125,6 +127,7 @@ module Sequel
 
       # Get the value of the given PRAGMA.
       def pragma_get(name)
+        Sequel::Deprecation.deprecate('Database#{pragma_get,auto_vacuum,case_sensitive_like,foreign_keys,synchronous,temp_store} on SQLite', "These methods may not be safe when using multiple connections, call fetch(#{"PRAGMA #{name}".inspect}).single_value if you really want to get the pragma value")
         self["PRAGMA #{name}"].single_value
       end
       
@@ -135,6 +138,7 @@ module Sequel
       # modifications should be done when the connection is created, using
       # an option provided when creating the Database object.
       def pragma_set(name, value)
+        Sequel::Deprecation.deprecate('Database#{pragma_set,auto_vacuum=,case_sensitive_like=,foreign_keys=,synchronous=,temp_store=} on SQLite', "These methods are not thread safe or safe when using multiple connections, pass the appropriate option when connecting to set the pragma correctly for all connections")
         execute_ddl("PRAGMA #{name} = #{value}")
       end
 
@@ -239,8 +243,8 @@ module Sequel
       # Run all alter_table commands in a transaction.  This is technically only
       # needed for drop column.
       def apply_alter_table(table, ops)
-        fks = foreign_keys
-        self.foreign_keys = false if fks
+        fks = fetch("PRAGMA foreign_keys")
+        run "PRAGMA foreign_keys = 0" if fks
         transaction do 
           if ops.length > 1 && ops.all?{|op| op[:op] == :add_constraint}
             # If you are just doing constraints, apply all of them at the same time,
@@ -253,7 +257,7 @@ module Sequel
           end
         end
       ensure
-        self.foreign_keys = true if fks
+        run "PRAGMA foreign_keys = 1" if fks
       end
 
       # SQLite supports limited table modification.  You can add a column
@@ -545,28 +549,50 @@ module Sequel
       include Dataset::Replace
       include UnmodifiedIdentifiers::DatasetMethods
 
-      CONSTANT_MAP = {:CURRENT_DATE=>"date(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIMESTAMP=>"datetime(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIME=>"time(CURRENT_TIMESTAMP, 'localtime')".freeze}
-      EMULATED_FUNCTION_MAP = {:char_length=>'length'.freeze}
-      EXTRACT_MAP = {:year=>"'%Y'", :month=>"'%m'", :day=>"'%d'", :hour=>"'%H'", :minute=>"'%M'", :second=>"'%f'"}
-      NOT_SPACE = Dataset::NOT_SPACE
-      COMMA = Dataset::COMMA
-      PAREN_CLOSE = Dataset::PAREN_CLOSE
-      AS = Dataset::AS
-      APOS = Dataset::APOS
+      CONSTANT_MAP = {:CURRENT_DATE=>"date(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIMESTAMP=>"datetime(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIME=>"time(CURRENT_TIMESTAMP, 'localtime')".freeze}#.freeze # SEQUEL5
+      EXTRACT_MAP = {:year=>"'%Y'", :month=>"'%m'", :day=>"'%d'", :hour=>"'%H'", :minute=>"'%M'", :second=>"'%f'"}#.freeze # SEQUEL5
+      #EXTRACT_MAP.each_value(&:freeze) # SEQUEL5
+
+      NOT_SPACE = 'NOT '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :NOT_SPACE)
+      COMMA = ', '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :COMMA)
+      PAREN_CLOSE = ')'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :PAREN_CLOSE)
+      AS = ' AS '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :AS)
+      APOS = "'".freeze
+      Sequel::Deprecation.deprecate_constant(self, :APOS)
       EXTRACT_OPEN = "CAST(strftime(".freeze
+      Sequel::Deprecation.deprecate_constant(self, :EXTRACT_OPEN)
       EXTRACT_CLOSE = ') AS '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :EXTRACT_CLOSE)
       NUMERIC = 'NUMERIC'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :NUMERIC)
       INTEGER = 'INTEGER'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :INTEGER)
       BACKTICK = '`'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BACKTICK)
       BACKTICK_RE = /`/.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BACKTICK_RE)
       DOUBLE_BACKTICK = '``'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :DOUBLE_BACKTICK)
       BLOB_START = "X'".freeze
+      Sequel::Deprecation.deprecate_constant(self, :BLOB_START)
       HSTAR = "H*".freeze
+      Sequel::Deprecation.deprecate_constant(self, :HSTAR)
       DATE_OPEN = "date(".freeze
+      Sequel::Deprecation.deprecate_constant(self, :DATE_OPEN)
       DATETIME_OPEN = "datetime(".freeze
+      Sequel::Deprecation.deprecate_constant(self, :DATETIME_OPEN)
       ONLY_OFFSET = " LIMIT -1 OFFSET ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :ONLY_OFFSET)
       OR = " OR ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :OR)
       SELECT_VALUES = "VALUES ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SELECT_VALUES)
+      EMULATED_FUNCTION_MAP = {:char_length=>'length'.freeze}
+      Sequel::Deprecation.deprecate_constant(self, :EMULATED_FUNCTION_MAP)
 
       Dataset.def_sql_method(self, :delete, [['if db.sqlite_version >= 30803', %w'with delete from where'], ["else", %w'delete from where']])
       Dataset.def_sql_method(self, :insert, [['if db.sqlite_version >= 30803', %w'with insert conflict into columns values'], ["else", %w'insert conflict into columns values']])
@@ -575,13 +601,13 @@ module Sequel
 
       def cast_sql_append(sql, expr, type)
         if type == Time or type == DateTime
-          sql << DATETIME_OPEN
+          sql << "datetime("
           literal_append(sql, expr)
-          sql << PAREN_CLOSE
+          sql << ')'
         elsif type == Date
-          sql << DATE_OPEN
+          sql << "date("
           literal_append(sql, expr)
-          sql << PAREN_CLOSE
+          sql << ')'
         else
           super
         end
@@ -592,7 +618,7 @@ module Sequel
       def complex_expression_sql_append(sql, op, args)
         case op
         when :"NOT LIKE", :"NOT ILIKE"
-          sql << NOT_SPACE
+          sql << 'NOT '
           complex_expression_sql_append(sql, (op == :"NOT ILIKE" ? :ILIKE : :LIKE), args)
         when :^
           complex_expression_arg_pairs_append(sql, args){|a, b| Sequel.lit(["((~(", " & ", ")) & (", " | ", "))"], a, b, a, b)}
@@ -605,7 +631,7 @@ module Sequel
             sql << '1'
           else
             sql << '('
-            arg = args.at(0)
+            arg = args[0]
             if exp < 0
               invert = true
               exp = exp.abs
@@ -616,17 +642,17 @@ module Sequel
               sql << " * "
             end
             literal_append(sql, arg)
-            sql << PAREN_CLOSE
+            sql << ')'
             if invert
               sql << "))"
             end
           end
         when :extract
-          part = args.at(0)
+          part = args[0]
           raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]
-          sql << EXTRACT_OPEN << format << COMMA
-          literal_append(sql, args.at(1))
-          sql << EXTRACT_CLOSE << (part == :second ? NUMERIC : INTEGER) << PAREN_CLOSE
+          sql << "CAST(strftime(" << format << ', '
+          literal_append(sql, args[1])
+          sql << ') AS ' << (part == :second ? 'NUMERIC' : 'INTEGER') << ')'
         else
           super
         end
@@ -669,7 +695,7 @@ module Sequel
       
       # SQLite uses the nonstandard ` (backtick) for quoting identifiers.
       def quoted_identifier_append(sql, c)
-        sql << BACKTICK << c.to_s.gsub(BACKTICK_RE, DOUBLE_BACKTICK) << BACKTICK
+        sql << '`' << c.to_s.gsub('`', '``') << '`'
       end
       
       # When a qualified column is selected on SQLite and the qualifier
@@ -752,7 +778,7 @@ module Sequel
       def as_sql_append(sql, aliaz, column_aliases=nil)
         raise Error, "sqlite does not support derived column lists" if column_aliases
         aliaz = aliaz.value if aliaz.is_a?(SQL::Identifier)
-        sql << AS
+        sql << ' AS '
         literal_append(sql, aliaz.to_s)
       end
 
@@ -780,19 +806,19 @@ module Sequel
 
       # SQL fragment specifying a list of identifiers
       def identifier_list(columns)
-        columns.map{|i| quote_identifier(i)}.join(COMMA)
+        columns.map{|i| quote_identifier(i)}.join(', ')
       end
     
       # Add OR clauses to SQLite INSERT statements
       def insert_conflict_sql(sql)
         if resolution = @opts[:insert_conflict]
-          sql << OR << resolution.to_s.upcase
+          sql << " OR " << resolution.to_s.upcase
         end
       end
 
       # SQLite uses a preceding X for hex escaping strings
       def literal_blob_append(sql, v)
-        sql << BLOB_START << v.unpack(HSTAR).first << APOS
+        sql <<  "X'" << v.unpack("H*").first << "'"
       end
 
       # Respect the database integer_booleans setting, using 0 or 'f'.
@@ -811,6 +837,15 @@ module Sequel
         db.sqlite_version >= 30711 ? :values : :union
       end
 
+      # Emulate the char_length function with length
+      def native_function_name(emulated_function)
+        if emulated_function == :char_length
+          'length'
+        else
+          super
+        end
+      end
+
       # SQLite does not support FOR UPDATE, but silently ignore it
       # instead of raising an error for compatibility with other
       # databases.
@@ -819,13 +854,13 @@ module Sequel
       end
 
       def select_only_offset_sql(sql)
-        sql << ONLY_OFFSET
+        sql << " LIMIT -1 OFFSET "
         literal_append(sql, @opts[:offset])
       end
   
       # Support VALUES clause instead of the SELECT clause to return rows.
       def select_values_sql(sql)
-        sql << SELECT_VALUES
+        sql << "VALUES "
         expression_list_append(sql, opts[:values])
       end
 

data/lib/sequel/adapters/sqlanywhere.rb

@@ -37,12 +37,14 @@ module Sequel
     }.each do |k,v|
       k.each{|n| SQLANYWHERE_TYPES[n] = v}
     end
+    # SQLANYWHERE_TYPES.freeze # SEQUEL5
 
     # Database class for SQLAnywhere databases used with Sequel.
     class Database < Sequel::Database
       include Sequel::SqlAnywhere::DatabaseMethods
 
       DEFAULT_CONFIG = { :user => 'dba', :password => 'sql' }
+      Sequel::Deprecation.deprecate_constant(self, :DEFAULT_CONFIG)
 
       attr_accessor :api
 
@@ -106,6 +108,7 @@ module Sequel
       private
 
       LAST_INSERT_ID = 'SELECT @@IDENTITY'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :LAST_INSERT_ID)
       def _execute(conn, type, sql, opts)
         unless rs = log_connection_yield(sql, conn){@api.sqlany_execute_direct(conn, sql)}
           result, errstr = @api.sqlany_error(conn)
@@ -118,7 +121,7 @@ module Sequel
         when :rows
           return @api.sqlany_affected_rows(rs)
         when :insert
-          _execute(conn, :select, LAST_INSERT_ID, opts){|r| return @api.sqlany_get_column(r, 0)[1] if r && @api.sqlany_fetch_next(r) == 1}
+          _execute(conn, :select, 'SELECT @@IDENTITY', opts){|r| return @api.sqlany_get_column(r, 0)[1] if r && @api.sqlany_fetch_next(r) == 1}
         end
       ensure
         @api.sqlany_commit(conn) unless in_transaction?
@@ -133,6 +136,10 @@ module Sequel
         raise LoadError, "Could not initialize SQLAnywhere DBCAPI library" if @api.sqlany_init == 0
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       def log_connection_execute(conn, sql)
         _execute(conn, nil, sql, OPTS)
       end
@@ -143,6 +150,7 @@ module Sequel
       include Sequel::SqlAnywhere::DatasetMethods
 
       Database::DatasetClass = self
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
 
       # Yield all rows matching this dataset.  If the dataset is set to
       # split multiple statements, yield arrays of hashes one per statement

data/lib/sequel/adapters/sqlite.rb

@@ -74,6 +74,7 @@ module Sequel
     }.each do |k,v|
       k.each{|n| SQLITE_TYPES[n] = v}
     end
+    # SQLITE_TYPES.freeze # SEQUEL5
     
     # Database class for SQLite databases used with Sequel and the
     # ruby-sqlite3 driver.
@@ -275,6 +276,10 @@ module Sequel
         [SQLite3::Exception, ArgumentError]
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       # Support SQLite exception codes if ruby-sqlite3 supports them.
       # This is disabled by default because ruby-sqlite3 doesn't currently
       # support them (returning nil), and even if it did, it doesn't support
@@ -289,8 +294,10 @@ module Sequel
       include ::Sequel::SQLite::DatasetMethods
 
       Database::DatasetClass = self
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
       
       PREPARED_ARG_PLACEHOLDER = ':'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :PREPARED_ARG_PLACEHOLDER)
       
       # SQLite already supports named bind arguments, so use directly.
       module ArgumentMapper
@@ -367,7 +374,7 @@ module Sequel
 
       # SQLite uses a : before the name of the argument as a placeholder.
       def prepared_arg_placeholder
-        PREPARED_ARG_PLACEHOLDER
+        ':'
       end
     end
   end

data/lib/sequel/adapters/swift.rb

@@ -116,6 +116,10 @@ module Sequel
         [::Swift::Error]
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       # Set the :db entry to the same as the :database entry, since
       # Swift uses :db.
       def server_opts(o)
@@ -133,6 +137,7 @@ module Sequel
     
     class Dataset < Sequel::Dataset
       Database::DatasetClass = self
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
 
       # Set the columns and yield the hashes to the block.
       def fetch_rows(sql)

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

@@ -34,13 +34,15 @@ module Sequel
       # Dataset class for MySQL datasets accessed via Swift.
       class Dataset < Swift::Dataset
         include Sequel::MySQL::DatasetMethods
-        APOS = Dataset::APOS
+
+        APOS = "'".freeze
+        Sequel::Deprecation.deprecate_constant(self, :APOS)
         
         private
         
         # Use Swift's escape method for quoting.
         def literal_string_append(sql, s)
-          sql << APOS << db.synchronize(@opts[:server]){|c| c.escape(s)} << APOS
+          sql << "'" << db.synchronize(@opts[:server]){|c| c.escape(s)} << "'"
         end
       end
     end

data/lib/sequel/adapters/swift/sqlite.rb

@@ -40,7 +40,7 @@ module Sequel
         
         # Use Swift's escape method for quoting.
         def literal_string_append(sql, s)
-          sql << APOS << db.synchronize(@opts[:server]){|c| c.escape(s)} << APOS
+          sql << "'" << db.synchronize(@opts[:server]){|c| c.escape(s)} << "'"
         end
       end
     end

data/lib/sequel/adapters/tinytds.rb

@@ -131,10 +131,16 @@ module Sequel
         end
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       TINYTDS_DISCONNECT_ERRORS = /\A(Attempt to initiate a new Adaptive Server operation with results pending|The request failed to run because the batch is aborted, this can be caused by abort signal sent from client|Adaptive Server connection timed out)/
+      Sequel::Deprecation.deprecate_constant(self, :TINYTDS_DISCONNECT_ERRORS)
+
       # Return true if the :conn argument is present and not active.
       def disconnect_error?(e, opts)
-        super || (opts[:conn] && !opts[:conn].active?) || ((e.is_a?(::TinyTds::Error) && TINYTDS_DISCONNECT_ERRORS.match(e.message)))
+        super || (opts[:conn] && !opts[:conn].active?) || ((e.is_a?(::TinyTds::Error) && /\A(Attempt to initiate a new Adaptive Server operation with results pending|The request failed to run because the batch is aborted, this can be caused by abort signal sent from client|Adaptive Server connection timed out)/.match(e.message)))
       end
 
       # Dispose of any possible results of execution.
@@ -180,6 +186,7 @@ module Sequel
       include Sequel::MSSQL::DatasetMethods
 
       Database::DatasetClass = self
+      Sequel::Deprecation.deprecate_constant(Database, :DatasetClass)
       
       # SQLite already supports named bind arguments, so use directly.
       module ArgumentMapper
@@ -247,8 +254,8 @@ module Sequel
       
       # Properly escape the given string +v+.
       def literal_string_append(sql, v)
-        sql << (mssql_unicode_strings ? UNICODE_STRING_START : APOS)
-        sql << db.synchronize(@opts[:server]){|c| c.escape(v)}.gsub(BACKSLASH_CRLF_RE, BACKSLASH_CRLF_REPLACE) << APOS
+        sql << (mssql_unicode_strings ? "N'" : "'")
+        sql << db.synchronize(@opts[:server]){|c| c.escape(v)}.gsub(/\\((?:\r\n)|\n)/, '\\\\\\\\\\1\\1') << "'"
       end
 
       def prepared_statement_modules

data/lib/sequel/adapters/utils/emulate_offset_with_reverse_and_count.rb

@@ -32,7 +32,7 @@ module Sequel
       row_count = @opts[:offset_total_count] || ds.clone(:append_sql=>String.new, :placeholder_literal_null=>true).count
       dsa1 = dataset_alias(1)
 
-      if o.is_a?(Symbol) && @opts[:bind_vars] && (match = Sequel::Dataset::PreparedStatementMethods::PLACEHOLDER_RE.match(o.to_s))
+      if o.is_a?(Symbol) && @opts[:bind_vars] && (match = /\A\$(.*)\z/.match(o.to_s))
         # Handle use of bound variable offsets.  Unfortunately, prepared statement
         # bound variable offsets cannot be handled, since the bound variable value
         # isn't available until later.

data/lib/sequel/adapters/utils/emulate_offset_with_row_number.rb

@@ -36,7 +36,7 @@ module Sequel
       sql = @opts[:append_sql] || String.new
       subselect_sql_append(sql, unlimited.
         unordered.
-        select_append{ROW_NUMBER{}.over(:order=>order).as(rn)}.
+        select_append(Sequel.function(:ROW_NUMBER).over(:order=>order).as(rn)).
         from_self(:alias=>dsa1).
         select(*columns).
         limit(@opts[:limit]).

data/lib/sequel/adapters/utils/mysql_mysql2.rb

@@ -13,6 +13,7 @@ module Sequel
         Can't connect to local MySQL server through socket
         MySQL server has gone away
         Lost connection to MySQL server during query
+        MySQL client is not connected
         This connection is still waiting for a result, try again once you have the result
         closed MySQL connection
         END