sequel 4.41.0 → 4.42.0

data/lib/sequel/adapters/mysql.rb

@@ -337,7 +337,7 @@ module Sequel
       def split_multiple_result_sets
         raise(Error, "Can't split multiple statements on a graphed dataset") if opts[:graph]
         ds = clone(:split_multiple_result_sets=>true)
-        ds.row_proc = proc{|x| x.map{|h| row_proc.call(h)}} if row_proc
+        ds = ds.with_row_proc(proc{|x| x.map{|h| row_proc.call(h)}}) if row_proc
         ds
       end
       

data/lib/sequel/adapters/mysql2.rb

@@ -236,28 +236,12 @@ module Sequel
           "sql = self; opts = Hash[opts]; opts[:arguments] = bind_arguments",
           Sequel::Dataset::UnnumberedArgumentMapper,
           %w"execute execute_dui execute_insert")
-
-        # Create a named prepared statement that is stored in the
-        # database (and connection) for reuse.
-        def prepare(type, name=nil, *values)
-          ps = to_prepared_statement(type, values)
-          ps.extend(PreparedStatementMethods)
-          if name
-            ps.prepared_statement_name = name
-            db.set_prepared_statement(name, ps)
-          end
-          ps
-        end
       end
 
       # Yield all rows matching this dataset.
       def fetch_rows(sql)
         execute(sql) do |r|
-          self.columns = if identifier_output_method
-            r.fields.map!{|c| output_identifier(c.to_s)}
-          else
-            r.fields
-          end
+          self.columns = r.fields.map!{|c| output_identifier(c.to_s)}
           r.each(:cast_booleans=>convert_tinyint_to_bool?){|h| yield h}
         end
         self
@@ -296,6 +280,16 @@ module Sequel
         super
       end
 
+      if NativePreparedStatements
+        def bound_variable_modules
+          [PreparedStatementMethods]
+        end
+
+        def prepared_statement_modules
+          [PreparedStatementMethods]
+        end
+      end
+
       # Handle correct quoting of strings using ::Mysql2::Client#escape.
       def literal_string_append(sql, v)
         s = db.synchronize(@opts[:server]){|c| c.escape(v)}

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

@@ -16,7 +16,6 @@ module Sequel
     # support via ODBC.
     module MSSQL
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::MSSQL::DatabaseMethods
         LAST_INSERT_ID_SQL='SELECT SCOPE_IDENTITY()'.freeze
         

data/lib/sequel/adapters/oracle.rb

@@ -355,13 +355,6 @@ module Sequel
       BindArgumentMethods = prepared_statements_module(:bind, ArgumentMapper)
       PreparedStatementMethods = prepared_statements_module(:prepare, BindArgumentMethods)
 
-      # Execute the given type of statement with the hash of values.
-      def call(type, bind_vars={}, *values, &block)
-        ps = to_prepared_statement(type, values)
-        ps.extend(BindArgumentMethods)
-        ps.call(bind_vars, &block)
-      end
-      
       def fetch_rows(sql)
         execute(sql) do |cursor|
           cps = db.conversion_procs
@@ -378,19 +371,6 @@ module Sequel
         self
       end
 
-      # Prepare the given type of query with the given name and store
-      # it in the database.  Note that a new native prepared statement is
-      # created on each call to this prepared statement.
-      def prepare(type, name=nil, *values)
-        ps = to_prepared_statement(type, values)
-        ps.extend(PreparedStatementMethods)
-        if name
-          ps.prepared_statement_name = name
-          db.set_prepared_statement(name, ps)
-        end
-        ps
-      end
-      
       # Oracle requires type specifiers for placeholders, at least
       # if you ever want to use a nil/NULL value as the value for
       # the placeholder.
@@ -415,6 +395,14 @@ module Sequel
       def prepared_arg_placeholder
         PREPARED_ARG_PLACEHOLDER
       end
+
+      def bound_variable_modules
+        [BindArgumentMethods]
+      end
+
+      def prepared_statement_modules
+        [PreparedStatementMethods]
+      end
     end
   end
 end

data/lib/sequel/adapters/postgres.rb

@@ -755,37 +755,19 @@ module Sequel
           end
         end
 
-        BindArgumentMethods = prepared_statements_module(:bind, [ArgumentMapper, ::Sequel::Postgres::DatasetMethods::PreparedStatementMethods], %w'execute execute_dui')
-
-        PreparedStatementMethods = prepared_statements_module(:prepare, BindArgumentMethods, %w'execute execute_dui') do
-          # Raise a more obvious error if you attempt to call a unnamed prepared statement.
-          def call(*)
-            raise Error, "Cannot call prepared statement without a name" if prepared_statement_name.nil?
-            super
-          end
-        end
-        
-        # Execute the given type of statement with the hash of values.
-        def call(type, bind_vars=OPTS, *values, &block)
-          ps = to_prepared_statement(type, values)
-          ps.extend(BindArgumentMethods)
-          ps.call(bind_vars, &block)
-        end
-
-        # Prepare the given type of statement with the given name, and store
-        # it in the database to be called later.
-        def prepare(type, name=nil, *values)
-          ps = to_prepared_statement(type, values)
-          ps.extend(PreparedStatementMethods)
-          if name
-            ps.prepared_statement_name = name
-            db.set_prepared_statement(name, ps)
-          end
-          ps
-        end
+        BindArgumentMethods = prepared_statements_module(:bind, [ArgumentMapper], %w'execute execute_dui')
+        PreparedStatementMethods = prepared_statements_module(:prepare, BindArgumentMethods, %w'execute execute_dui')
         
         private
         
+        def bound_variable_modules
+          [BindArgumentMethods]
+        end
+
+        def prepared_statement_modules
+          [PreparedStatementMethods]
+        end
+
         # PostgreSQL uses $N for placeholders instead of ?, so use a $
         # as the placeholder.
         def prepared_arg_placeholder
@@ -834,7 +816,7 @@ module Sequel
         end
       end
       
-      # Set the @columns based on the result set, and return the array of
+      # Set the columns based on the result set, and return the array of
       # field numers, type conversion procs, and name symbol arrays.
       def fetch_rows_set_cols(res)
         cols = []

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

@@ -1,13 +1,13 @@
 # frozen-string-literal: true
 
-module Sequel
-  require 'adapters/utils/emulate_offset_with_reverse_and_count'
+Sequel.require %w'emulate_offset_with_reverse_and_count unmodified_identifiers', 'adapters/utils'
 
+module Sequel
   module Access
     Sequel::Database.set_shared_adapter_scheme(:access, self)
 
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
+      include UnmodifiedIdentifiers::DatabaseMethods
 
       # Access uses type :access as the database_type
       def database_type
@@ -16,7 +16,7 @@ module Sequel
 
       # Doesn't work, due to security restrictions on MSysObjects
       #def tables
-      #  from(:MSysObjects).filter(:Type=>1, :Flags=>0).select_map(:Name).map(&:to_sym)
+      #  from(:MSysObjects).where(:Type=>1, :Flags=>0).select_map(:Name).map(&:to_sym)
       #end
       
       # Access doesn't support renaming tables from an SQL query,
@@ -61,14 +61,6 @@ module Sequel
         "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
       end
       
-      def identifier_input_method_default
-        nil
-      end
-      
-      def identifier_output_method_default
-        nil
-      end
-      
       # Access doesn't have a 64-bit integer type, so use integer and hope
       # the user isn't using more than 32 bits.
       def type_literal_generic_bignum_symbol(column)
@@ -91,6 +83,7 @@ module Sequel
         Dataset.def_sql_method(self, :select, %w'select distinct limit columns into from join where group order having compounds')
       end)
       include EmulateOffsetWithReverseAndCount
+      include UnmodifiedIdentifiers::DatasetMethods
 
       DATE_FORMAT = '#%Y-%m-%d#'.freeze
       TIMESTAMP_FORMAT = '#%Y-%m-%d %H:%M:%S#'.freeze

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

@@ -1,15 +1,14 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/utils/split_alter_table'
+Sequel.require %w'split_alter_table unmodified_identifiers', 'adapters/utils'
 
 module Sequel
   module Cubrid
     Sequel::Database.set_shared_adapter_scheme(:cubrid, self)
 
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
       include Sequel::Database::SplitAlterTable
+      include UnmodifiedIdentifiers::DatabaseMethods
 
       AUTOINCREMENT = 'AUTO_INCREMENT'.freeze
       COLUMN_DEFINITION_ORDER = [:auto_increment, :default, :null, :unique, :primary_key, :references]
@@ -143,16 +142,6 @@ module Sequel
         DATABASE_ERROR_REGEXPS
       end
 
-      # CUBRID is case insensitive, so don't modify identifiers
-      def identifier_input_method_default
-        nil
-      end
-
-      # CUBRID is case insensitive, so don't modify identifiers
-      def identifier_output_method_default
-        nil
-      end
-
       # CUBRID does not support named column constraints.
       def supports_named_column_constraints?
         false
@@ -175,6 +164,8 @@ module Sequel
     end
     
     module DatasetMethods
+      include UnmodifiedIdentifiers::DatasetMethods
+
       COMMA = Sequel::Dataset::COMMA
       LIMIT = Sequel::Dataset::LIMIT
       BOOL_FALSE = '0'.freeze

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

@@ -14,8 +14,6 @@ module Sequel
     end
 
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
       AUTOINCREMENT = 'GENERATED ALWAYS AS IDENTITY'.freeze
       NOT_NULL      = ' NOT NULL'.freeze
       NULL          = ''.freeze
@@ -322,6 +320,10 @@ module Sequel
         end
       end
 
+      def quote_identifiers?
+        @opts.fetch(:quote_identifiers, false)
+      end
+
       def supports_cte?(type=:select)
         type == :select
       end

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

@@ -5,8 +5,6 @@ module Sequel
     Sequel::Database.set_shared_adapter_scheme(:firebird, self)
 
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
       AUTO_INCREMENT = ''.freeze
       TEMPORARY = 'GLOBAL TEMPORARY '.freeze
 
@@ -40,7 +38,7 @@ module Sequel
       end
 
       def sequences(opts=OPTS)
-        ds = self[:"rdb$generators"].server(opts[:server]).filter(:"rdb$system_flag" => 0).select(:"rdb$generator_name")
+        ds = self[:"rdb$generators"].server(opts[:server]).where(:"rdb$system_flag" => 0).select(:"rdb$generator_name")
         block_given? ? yield(ds) : ds.map{|r| ds.send(:output_identifier, r[:"rdb$generator_name"])}
       end
 
@@ -143,7 +141,7 @@ module Sequel
       end
 
       def tables_or_views(type, opts)
-        ds = self[:"rdb$relations"].server(opts[:server]).filter(:"rdb$relation_type" => type, Sequel::SQL::Function.new(:COALESCE, :"rdb$system_flag", 0) => 0).select(:"rdb$relation_name")
+        ds = self[:"rdb$relations"].server(opts[:server]).where(:"rdb$relation_type" => type, Sequel::SQL::Function.new(:COALESCE, :"rdb$system_flag", 0) => 0).select(:"rdb$relation_name")
         ds.map{|r| ds.send(:output_identifier, r[:"rdb$relation_name"].rstrip)}
       end
 

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

@@ -5,8 +5,6 @@ module Sequel
     Sequel::Database.set_shared_adapter_scheme(:informix, self)
 
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
       TEMPORARY = 'TEMP '.freeze
 
       # Informix uses the :informix database type
@@ -34,6 +32,10 @@ module Sequel
 
       Dataset.def_sql_method(self, :select, %w'select limit distinct columns from join where having group compounds order')
 
+      def quote_identifiers?
+        @opts.fetch(:quote_identifiers, false)
+      end
+
       # Informix does not support INTERSECT or EXCEPT
       def supports_intersect_except?
         false

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

@@ -13,8 +13,6 @@ module Sequel
     end
 
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
       AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
       SERVER_VERSION_RE = /^(\d+)\.(\d+)\.(\d+)/.freeze
       SERVER_VERSION_SQL = "SELECT CAST(SERVERPROPERTY('ProductVersion') AS varchar)".freeze
@@ -399,12 +397,12 @@ module Sequel
         m = output_identifier_meth
         metadata_dataset.from(Sequel[:information_schema][:tables].as(:t)).
           select(:table_name).
-          filter(:table_type=>type, :table_schema=>(opts[:schema]||'dbo').to_s).
+          where(:table_type=>type, :table_schema=>(opts[:schema]||'dbo').to_s).
           map{|x| m.call(x[:table_name])}
       end
 
       # Always quote identifiers in the metadata_dataset, so schema parsing works.
-      def metadata_dataset
+      def _metadata_dataset
         super.with_quote_identifiers(true)
       end
       
@@ -652,7 +650,7 @@ module Sequel
       # MSSQL uses the CONTAINS keyword for full text search
       def full_text_search(cols, terms, opts = OPTS)
         terms = "\"#{terms.join('" OR "')}\"" if terms.is_a?(Array)
-        filter("CONTAINS (?, ?)", cols, terms)
+        where("CONTAINS (?, ?)", cols, terms)
       end
 
       # Use the OUTPUT clause to get the value of all columns for the newly inserted record.

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

@@ -1,7 +1,6 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/utils/split_alter_table'
-Sequel.require 'adapters/utils/replace'
+Sequel.require %w'replace split_alter_table unmodified_identifiers', 'adapters/utils'
 
 module Sequel
   module MySQL
@@ -38,7 +37,7 @@ module Sequel
     # Methods shared by Database instances that connect to MySQL,
     # currently supported by the native and JDBC adapters.
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
+      include UnmodifiedIdentifiers::DatabaseMethods
 
       AUTO_INCREMENT = 'AUTO_INCREMENT'.freeze
       CAST_TYPES = {String=>:CHAR, Integer=>:SIGNED, Time=>:DATETIME, DateTime=>:DATETIME, Numeric=>:DECIMAL, BigDecimal=>:DECIMAL, File=>:BINARY}
@@ -418,16 +417,6 @@ module Sequel
         metadata_dataset.with_sql('SHOW FULL TABLES').server(opts[:server]).map{|r| m.call(r.values.first) if r.delete(:Table_type) == type}.compact
       end
 
-      # MySQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
-      def identifier_input_method_default
-        nil
-      end
-      
-      # MySQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on output.
-      def identifier_output_method_default
-        nil
-      end
-
       # Handle MySQL specific index SQL syntax
       def index_definition_sql(table_name, index)
         index_name = quote_identifier(index[:name] || default_index_name(table_name, index[:columns]))
@@ -627,6 +616,7 @@ module Sequel
       Dataset.def_sql_method(self, :update, %w'update ignore table set where order limit')
 
       include Sequel::Dataset::Replace
+      include UnmodifiedIdentifiers::DatasetMethods
 
       # MySQL specific syntax for LIKE/REGEXP searches, as well as
       # string concatenation.
@@ -724,7 +714,7 @@ module Sequel
 
       # Adds full text filter
       def full_text_search(cols, terms, opts = OPTS)
-        filter(full_text_sql(cols, terms, opts))
+        where(full_text_sql(cols, terms, opts))
       end
       
       # MySQL specific full text search syntax.

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

@@ -14,8 +14,6 @@ module Sequel
     end
 
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
       TEMPORARY = 'GLOBAL TEMPORARY '.freeze
       AUTOINCREMENT = ''.freeze
 
@@ -265,7 +263,7 @@ module Sequel
           pk = sch.select{|k, v| v[:primary_key]}
           @primary_key_sequences[table] = if pk.length == 1
             seq = "seq_#{table}_#{pk.first.first}"
-            seq.to_sym unless from(:user_sequences).filter(:sequence_name=>input_identifier_meth.call(seq)).empty?
+            seq.to_sym unless from(:user_sequences).where(:sequence_name=>input_identifier_meth.call(seq)).empty?
           end
         end
       end

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

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/utils/pg_types'
+Sequel.require %w'pg_types unmodified_identifiers', 'adapters/utils'
 
 module Sequel
   # Top level module for holding all PostgreSQL-related modules and classes
@@ -109,7 +109,7 @@ module Sequel
 
     # Methods shared by Database instances that connect to PostgreSQL.
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
+      include UnmodifiedIdentifiers::DatabaseMethods
 
       PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
       RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session|relation "(.*)" does not exist/.freeze
@@ -352,7 +352,7 @@ module Sequel
         # entry is schema qualified as well.
         if schema
           ref_ds = ref_ds.join(Sequel[:pg_namespace].as(:nsp2), :oid=>Sequel[:cl2][:relnamespace]).
-            select_more{nsp2[:nspname].as(:schema)}
+            select_append{nsp2[:nspname].as(:schema)}
         end
 
         h = {}
@@ -508,7 +508,7 @@ module Sequel
             0
           end
         end
-        warn 'Sequel no longer supports PostgreSQL <8.2, some things may not work' if @server_version < 80200
+        Sequel::Deprecation.deprecate('Sequel no longer supports PostgreSQL <8.2, some things may not work.') if @server_version < 80200
         @server_version
       end
 
@@ -581,7 +581,7 @@ module Sequel
       # the database.
       def type_supported?(type)
         @supported_types ||= {}
-        @supported_types.fetch(type){@supported_types[type] = (from(:pg_type).filter(:typtype=>'b', :typname=>type.to_s).count > 0)}
+        @supported_types.fetch(type){@supported_types[type] = (from(:pg_type).where(:typtype=>'b', :typname=>type.to_s).count > 0)}
       end
 
       # Creates a dataset that uses the VALUES clause:
@@ -1005,16 +1005,6 @@ module Sequel
         procs
       end
 
-      # PostgreSQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
-      def identifier_input_method_default
-        nil
-      end
-
-      # PostgreSQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on output.
-      def identifier_output_method_default
-        nil
-      end
-
       # PostgreSQL specific index SQL.
       def index_definition_sql(table_name, index)
         cols = index[:columns]
@@ -1048,7 +1038,7 @@ module Sequel
 
       # Backbone of the tables and views support.
       def pg_class_relname(type, opts)
-        ds = metadata_dataset.from(:pg_class).filter(:relkind=>type).select(:relname).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace)
+        ds = metadata_dataset.from(:pg_class).where(:relkind=>type).select(:relname).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace)
         ds = filter_schema(ds, opts)
         m = output_identifier_meth
         if block_given?
@@ -1226,6 +1216,8 @@ module Sequel
 
     # Instance methods for datasets that connect to a PostgreSQL database.
     module DatasetMethods
+      include UnmodifiedIdentifiers::DatasetMethods
+
       ACCESS_SHARE = 'ACCESS SHARE'.freeze
       ACCESS_EXCLUSIVE = 'ACCESS EXCLUSIVE'.freeze
       BOOL_FALSE = 'false'.freeze
@@ -1271,28 +1263,6 @@ module Sequel
       Dataset.def_sql_method(self, :select, [['if opts[:values]', %w'values order limit'], ['elsif 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.
-        def run
-          if @prepared_type == :insert && (opts[:returning_pk] || !opts[:returning])
-            fetch_rows(prepared_sql){|r| return r.values.first}
-          else
-            super
-          end
-        end
-
-        def prepared_sql
-          return @prepared_sql if @prepared_sql
-          if @prepared_type == :insert && !opts[:returning]
-            @opts[:returning] = insert_pk
-            @opts[:returning_pk] = true
-          end
-          super
-          @prepared_sql
-        end
-      end
-
       # Return the results of an EXPLAIN ANALYZE query as a string
       def analyze
         explain(:analyze=>true)
@@ -1819,6 +1789,14 @@ module Sequel
         true
       end
 
+      def to_prepared_statement(type, *a)
+        if type == :insert && !@opts.has_key?(:returning)
+          returning(insert_pk).send(:to_prepared_statement, :insert_pk, *a)
+        else
+          super
+        end
+      end
+
       # Concatenate the expressions with a space in between
       def full_text_string_join(cols)
         cols = Array(cols).map{|x| SQL::Function.new(:COALESCE, x, EMPTY_STRING)}