sequel 4.41.0 → 4.42.0

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

@@ -3,8 +3,6 @@
 module Sequel
   module Progress
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
       # Progress uses the :progress database type.
       def database_type
         :progress

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

@@ -13,8 +13,6 @@ module Sequel
     end
 
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
       attr_reader :conversion_procs
 
       # Override the default SqlAnywhere.convert_smallint_to_bool setting for this database.

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

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/utils/replace'
+Sequel.require %w'replace unmodified_identifiers', 'adapters/utils'
 
 module Sequel
   module SQLite
@@ -16,7 +16,7 @@ module Sequel
     # can be used to set PRAGMAs on connections in a thread-safe manner:
     # :auto_vacuum, :foreign_keys, :synchronous, and :temp_store.
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
+      include UnmodifiedIdentifiers::DatabaseMethods
 
       AUTO_VACUUM = [:none, :full, :incremental].freeze
       PRIMARY_KEY_INDEX_RE = /\Asqlite_autoindex_/.freeze
@@ -279,7 +279,7 @@ module Sequel
         when :drop_constraint
           case op[:type]
           when :primary_key
-            duplicate_table(table){|columns| columns.each{|s| s[:primary_key] = nil}}
+            duplicate_table(table){|columns| columns.each{|s| s[:primary_key] = s[:auto_increment] = nil}}
           when :foreign_key
             if op[:columns]
               duplicate_table(table, :skip_foreign_key_columns=>op[:columns])
@@ -365,7 +365,6 @@ module Sequel
         cols.each do |c|
           c[:default] = LiteralString.new(c[:default]) if c[:default]
           c[:type] = c[:db_type]
-          c.delete(:auto_increment)
         end
         cols
       end
@@ -442,16 +441,6 @@ module Sequel
         a
       end
 
-      # SQLite folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
-      def identifier_input_method_default
-        nil
-      end
-      
-      # SQLite folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on output.
-      def identifier_output_method_default
-        nil
-      end
-      
       # Does the reverse of on_delete_clause, eg. converts strings like +'SET NULL'+
       # to symbols +:set_null+.
       def on_delete_sql_to_sym str
@@ -471,18 +460,32 @@ module Sequel
 
       # Parse the output of the table_info pragma
       def parse_pragma(table_name, opts)
-        metadata_dataset.with_sql("PRAGMA table_info(?)", input_identifier_meth(opts[:dataset]).call(table_name)).map do |row|
+        pks = 0
+        sch = metadata_dataset.with_sql("PRAGMA table_info(?)", input_identifier_meth(opts[:dataset]).call(table_name)).map do |row|
           row.delete(:cid)
           row[:allow_null] = row.delete(:notnull).to_i == 0
           row[:default] = row.delete(:dflt_value)
           row[:default] = nil if blank_object?(row[:default]) || row[:default] == 'NULL'
           row[:db_type] = row.delete(:type)
           if row[:primary_key] = row.delete(:pk).to_i > 0
+            pks += 1
+            # Guess that an integer primary key uses auto increment,
+            # since that is Sequel's default and SQLite does not provide
+            # a way to introspect whether it is actually autoincrementing.
             row[:auto_increment] = row[:db_type].downcase == 'integer'
           end
           row[:type] = schema_column_type(row[:db_type])
           row
         end
+
+        if pks > 1
+          # SQLite does not allow use of auto increment for tables
+          # with composite primary keys, so remove auto_increment
+          # if composite primary keys are detected.
+          sch.each{|r| r.delete(:auto_increment)}
+        end
+
+        sch
       end
       
       # SQLite supports schema parsing using the table_info PRAGMA, so
@@ -497,7 +500,7 @@ module Sequel
       # Backbone of the tables and views support.
       def tables_and_views(filter, opts)
         m = output_identifier_meth
-        metadata_dataset.from(:sqlite_master).server(opts[:server]).filter(filter).map{|r| m.call(r[:name])}
+        metadata_dataset.from(:sqlite_master).server(opts[:server]).where(filter).map{|r| m.call(r[:name])}
       end
 
       # SQLite only supports AUTOINCREMENT on integer columns, not
@@ -511,6 +514,7 @@ module Sequel
     # Instance methods for datasets that connect to an SQLite database
     module DatasetMethods
       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}

data/lib/sequel/adapters/sqlite.rb

@@ -310,13 +310,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
-      
       # Yield a hash for each row in the dataset.
       def fetch_rows(sql)
         execute(sql) do |result|
@@ -339,19 +332,6 @@ module Sequel
         end
       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
-      
       private
       
       # The base type name for a given type, without any parenthetical part.
@@ -364,6 +344,14 @@ module Sequel
         sql << "'" << ::SQLite3::Database.quote(v) << "'"
       end
 
+      def bound_variable_modules
+        [BindArgumentMethods]
+      end
+
+      def prepared_statement_modules
+        [PreparedStatementMethods]
+      end
+
       # SQLite uses a : before the name of the argument as a placeholder.
       def prepared_arg_placeholder
         PREPARED_ARG_PLACEHOLDER

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

@@ -10,7 +10,6 @@ module Sequel
     module MySQL
       # Database instance methods for MySQL databases accessed via Swift.
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::MySQL::DatabaseMethods
         
         private

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

@@ -12,7 +12,6 @@ module Sequel
     module Postgres
       # Methods to add to Database instances that access PostgreSQL via Swift.
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::Postgres::DatabaseMethods
         
         # Add the primary_keys and primary_key_sequences instance variables,

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

@@ -10,7 +10,6 @@ module Sequel
     module SQLite
       # Database instance methods for SQLite databases accessed via Swift.
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::SQLite::DatabaseMethods
 
         DATABASE_ERROR_REGEXPS = {

data/lib/sequel/adapters/tinytds.rb

@@ -243,18 +243,6 @@ module Sequel
         self
       end
       
-      # 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
-      
       private
       
       # Properly escape the given string +v+.
@@ -262,6 +250,10 @@ module Sequel
         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
       end
+
+      def prepared_statement_modules
+        [PreparedStatementMethods]
+      end
     end
   end
 end

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

@@ -45,7 +45,7 @@ module Sequel
       reverse_offset = row_count - o
       ds = if reverse_offset > 0
         ds.limit(reverse_offset).
-          reverse_order(*order).
+          reverse(*order).
           from_self(:alias=>dsa1).
           limit(@opts[:limit]).
           order(*order)

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

@@ -67,14 +67,14 @@ module Sequel
         include Sequel::Dataset::StoredProcedures
        
         StoredProcedureMethods = Sequel::Dataset.send(:prepared_statements_module,
-          "sql = @sproc_name; opts = Hash[opts]; opts[:args] = @sproc_args; opts[:sproc] = true",
+          "sql = @opts[:sproc_name]; opts = Hash[opts]; opts[:args] = @opts[:sproc_args]; opts[:sproc] = true",
           Sequel::Dataset::StoredProcedureMethods, %w'execute execute_dui')
         
         private
 
         # Extend the dataset with the MySQL stored procedure methods.
         def prepare_extend_sproc(ds)
-          ds.extend(StoredProcedureMethods)
+          ds.with_extend(StoredProcedureMethods)
         end
       end
     end

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

@@ -36,45 +36,22 @@ module Sequel
           # Extend given dataset with this module so subselects inside subselects in
           # prepared statements work.
           def subselect_sql_append(sql, ds)
-            ps = ds.to_prepared_statement(:select).clone(:append_sql => sql)
-            ps.extend(CallableStatementMethods)
-            ps = ps.bind(@opts[:bind_vars]) if @opts[:bind_vars]
-            ps.prepared_args = prepared_args
-            ps.prepared_sql
+            ds.clone(:append_sql=>sql, :prepared_args=>prepared_args, :bind_vars=>@opts[:bind_vars]).
+              send(:to_prepared_statement, :select, nil, :extend=>bound_variable_modules).
+              prepared_sql
           end
         end
         
-        PreparedStatementMethods = Sequel::Dataset.send(:prepared_statements_module,
-          :prepare_bind,
-          Sequel::Dataset::UnnumberedArgumentMapper) 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
+        PreparedStatementMethods = Sequel::Dataset.send(:prepared_statements_module, :prepare_bind, Sequel::Dataset::UnnumberedArgumentMapper)
         
-        # MySQL is different in that it supports prepared statements but not bound
-        # variables outside of prepared statements.  The default implementation
-        # breaks the use of subselects in prepared statements, so extend the
-        # temporary prepared statement that this creates with a module that
-        # fixes it.
-        def call(type, bind_arguments={}, *values, &block)
-          ps = to_prepared_statement(type, values)
-          ps.extend(CallableStatementMethods)
-          ps.call(bind_arguments, &block)
+        private
+
+        def bound_variable_modules
+          [CallableStatementMethods]
         end
-        
-        # Store the given type of prepared statement in the associated database
-        # with the given name.
-        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
+
+        def prepared_statement_modules
+          [PreparedStatementMethods]
         end
       end
     end

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

@@ -3,17 +3,16 @@
 module Sequel 
   class Dataset
     module StoredProcedureMethods
+      Dataset.def_deprecated_opts_setter(self, :sproc_type, :sproc_name, :sproc_args)
+
       # The name of the stored procedure to call
-      attr_accessor :sproc_name
-      
-      # The name of the stored procedure to call
-      attr_writer :sproc_args
+      def sproc_name
+        @opts[:sproc_name]
+      end
       
       # Call the stored procedure with the given args
       def call(*args, &block)
-        sp = clone
-        sp.sproc_args = args
-        sp.run(&block)
+        clone(:sproc_args=>args).run(&block)
       end
 
       # Programmer friendly string showing this is a stored procedure,
@@ -24,7 +23,7 @@ module Sequel
       
       # Run the stored procedure with the current args on the database
       def run(&block)
-        case @sproc_type
+        case @opts[:sproc_type]
         when :select, :all
           all(&block)
         when :first
@@ -37,14 +36,6 @@ module Sequel
           delete
         end
       end
-      
-      # Set the type of the stored procedure and override the corresponding _sql
-      # method to return the empty string (since the result will be
-      # ignored anyway).
-      def sproc_type=(type)
-        @sproc_type = type
-        @opts[:sql] = ''
-      end
     end
   
     module StoredProcedures
@@ -58,18 +49,14 @@ module Sequel
       # Transform this dataset into a stored procedure that you can call
       # multiple times with new arguments.
       def prepare_sproc(type, name)
-        sp = clone
-        prepare_extend_sproc(sp)
-        sp.sproc_type = type
-        sp.sproc_name = name
-        sp
+        prepare_extend_sproc(self).clone(:sproc_type=>type, :sproc_name=>name, :sql=>'')
       end
       
       private
       
       # Extend the dataset with the stored procedure methods.
       def prepare_extend_sproc(ds)
-        ds.extend(StoredProcedureMethods)
+        ds.with_extend(StoredProcedureMethods)
       end
     end
   end

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

@@ -0,0 +1,26 @@
+module Sequel
+  module UnmodifiedIdentifiers
+    module DatabaseMethods
+      private
+
+      # Databases that use this module for unquoted identifiers to lowercase.
+      def folds_unquoted_identifiers_to_uppercase?
+        false
+      end
+    end
+
+    module DatasetMethods
+      private
+
+      # Turn the given symbol/string into a symbol, keeping the current case.
+      def output_identifier(v)
+        v == '' ? :untitled : v.to_sym
+      end
+
+      # Turn the given symbol/string into a string, keeping the current case.
+      def input_identifier(v)
+        v.to_s
+      end
+    end
+  end
+end

data/lib/sequel/ast_transformer.rb

@@ -137,11 +137,11 @@ module Sequel
   #
   # So it can handle cases like:
   #
-  #   DB.filter(:a=>1).exclude(:b=>2).where{c > 3}
+  #   DB.where(:a=>1).exclude(:b=>2).where{c > 3}
   #
   # But it cannot handle cases like:
   #
-  #   DB.filter(:a + 1 < 0)
+  #   DB.where(:a + 1 < 0)
   class Unbinder < ASTTransformer
     # The <tt>SQL::ComplexExpression<tt> operates that will be considered
     # for transformation.

data/lib/sequel/database/dataset.rb

@@ -56,7 +56,7 @@ module Sequel
     #   DB.from(:items){id > 2} # SELECT * FROM items WHERE (id > 2)
     def from(*args, &block)
       ds = @default_dataset.from(*args)
-      block ? ds.filter(&block) : ds
+      block ? ds.where(&block) : ds
     end
     
     # Returns a new dataset with the select method invoked.

data/lib/sequel/database/dataset_defaults.rb

@@ -40,12 +40,6 @@ module Sequel
     # an optional options hash.
     attr_reader :dataset_class
 
-    # The identifier input method to use by default for this database (default: adapter default)
-    attr_reader :identifier_input_method
-
-    # The identifier output method to use by default for this database (default: adapter default)
-    attr_reader :identifier_output_method
-
     # If the database has any dataset modules associated with it,
     # use a subclass of the given class that includes the modules
     # as the dataset class.
@@ -93,41 +87,6 @@ module Sequel
       reset_default_dataset
     end
 
-    # Set the method to call on identifiers going into the database:
-    #
-    #   DB[:items] # SELECT * FROM items
-    #   DB.identifier_input_method = :upcase
-    #   DB[:items] # SELECT * FROM ITEMS
-    def identifier_input_method=(v)
-      reset_default_dataset
-      @identifier_input_method = v
-    end
-    
-    # Set the method to call on identifiers coming from the database:
-    #
-    #   DB[:items].first # {:id=>1, :name=>'foo'}
-    #   DB.identifier_output_method = :upcase
-    #   DB[:items].first # {:ID=>1, :NAME=>'foo'}
-    def identifier_output_method=(v)
-      reset_default_dataset
-      @identifier_output_method = v
-    end
-
-    # Set whether to quote identifiers (columns and tables) for this database:
-    #
-    #   DB[:items] # SELECT * FROM items
-    #   DB.quote_identifiers = true
-    #   DB[:items] # SELECT * FROM "items"
-    def quote_identifiers=(v)
-      reset_default_dataset
-      @quote_identifiers = v
-    end
-    
-    # Returns true if the database quotes identifiers.
-    def quote_identifiers?
-      @quote_identifiers
-    end
-    
     private
     
     # The default dataset class to use for the database
@@ -143,35 +102,10 @@ module Sequel
       @default_dataset = dataset
     end
 
-    # The method to apply to identifiers going into the database by default.
-    # Should be overridden in subclasses for databases that fold unquoted
-    # identifiers to lower case instead of uppercase, such as
-    # MySQL, PostgreSQL, and SQLite.
-    def identifier_input_method_default
-      :upcase
-    end
-    
-    # The method to apply to identifiers coming the database by default.
-    # Should be overridden in subclasses for databases that fold unquoted
-    # identifiers to lower case instead of uppercase, such as
-    # MySQL, PostgreSQL, and SQLite.
-    def identifier_output_method_default
-      :downcase
-    end
-    
     # Whether to quote identifiers by default for this database, true
     # by default.
     def quote_identifiers_default
       true
     end
-
-    # Reset the identifier mangling options.  Overrides any already set on
-    # the instance.  Only for internal use by shared adapters.
-    def reset_identifier_mangling
-      @quote_identifiers = @opts.fetch(:quote_identifiers){(qi = Database.quote_identifiers).nil? ? quote_identifiers_default : qi}
-      @identifier_input_method = @opts.fetch(:identifier_input_method){(iim = Database.identifier_input_method).nil? ? identifier_input_method_default : (iim if iim)}
-      @identifier_output_method = @opts.fetch(:identifier_output_method){(iom = Database.identifier_output_method).nil? ? identifier_output_method_default : (iom if iom)}
-      reset_default_dataset
-    end
   end
 end