sequel 3.47.0 → 3.48.0

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

@@ -84,6 +84,7 @@ module Sequel
       end      
 
       module DatabaseMethods
+        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::Access::DatabaseMethods
         include Sequel::Database::SplitAlterTable
     

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

@@ -6,6 +6,7 @@ module Sequel
     # support via ADO.
     module MSSQL
       module DatabaseMethods
+        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::MSSQL::DatabaseMethods
         # Query to use to get the number of rows affected by an update or
         # delete query.

data/lib/sequel/adapters/db2.rb

@@ -44,12 +44,6 @@ module Sequel
       # Hash of connection procs for converting
       attr_reader :conversion_procs
 
-      def initialize(opts={})
-        super
-        @conversion_procs = DB2_TYPES.dup
-        @conversion_procs[DB2CLI::SQL_TYPE_TIMESTAMP] = method(:to_application_timestamp_db2)
-      end
-
       def connect(server)
         opts = server_opts(server)
         dbc = checked_error("Could not allocate database connection"){DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_DBC, NullHandle)}
@@ -65,7 +59,10 @@ module Sequel
       def execute(sql, opts={}, &block)
         synchronize(opts[:server]){|conn| log_connection_execute(conn, sql, &block)}
       end
-      alias do execute
+      def do(*a, &block)
+        Sequel::Deprecation.deprecate('Database#do', 'Please use Database#execute')
+        execute(*a, &block)
+      end
 
       def execute_insert(sql, opts={})
         synchronize(opts[:server]) do |conn|
@@ -116,6 +113,11 @@ module Sequel
 
       private
 
+      def adapter_initialize
+        @conversion_procs = DB2_TYPES.dup
+        @conversion_procs[DB2CLI::SQL_TYPE_TIMESTAMP] = method(:to_application_timestamp_db2)
+      end
+
       def database_error_classes
         [DB2Error]
       end

data/lib/sequel/adapters/dbi.rb

@@ -20,20 +20,6 @@ module Sequel
         :sqlrelay => "SQLRelay"
       }
       
-      def initialize(opts)
-        super
-        case @opts[:db_type]
-        when 'mssql'
-          Sequel.ts_require 'adapters/shared/mssql'
-          extend Sequel::MSSQL::DatabaseMethods
-          def self.dataset(*args)
-            ds = super
-            ds.extend Sequel::MSSQL::DatasetMethods
-            ds
-          end
-        end
-      end
-
       # Converts a uri to an options hash. These options are then passed
       # to a newly created database object.
       def self.uri_to_options(uri) # :nodoc:
@@ -75,10 +61,24 @@ module Sequel
         end
       end
       
-      def do(sql, opts={})
+      def execute_dui(sql, opts={})
         synchronize(opts[:server]){|conn| log_yield(sql){conn.do(sql)}}
       end
-      alias_method :execute_dui, :do
+      def do(*a, &block)
+        Sequel::Deprecation.deprecate('Database#do', 'Please use Database#execute_dui')
+        execute_dui(*a, &block)
+      end
+
+      private
+
+      def adapter_initialize
+        case @opts[:db_type]
+        when 'mssql'
+          Sequel.require 'adapters/shared/mssql'
+          extend Sequel::MSSQL::DatabaseMethods
+          extend_datasets Sequel::MSSQL::DatasetMethods
+        end
+      end
     end
     
     class Dataset < Sequel::Dataset

data/lib/sequel/adapters/do.rb

@@ -14,20 +14,20 @@ module Sequel
     # Contains procs keyed on sub adapter type that extend the
     # given database object so it supports the correct database type.
     DATABASE_SETUP = {:postgres=>proc do |db|
-        Sequel.tsk_require 'do_postgres'
-        Sequel.ts_require 'adapters/do/postgres'
+        require 'do_postgres'
+        Sequel.require 'adapters/do/postgres'
         db.extend(Sequel::DataObjects::Postgres::DatabaseMethods)
         db.extend_datasets Sequel::Postgres::DatasetMethods
       end,
       :mysql=>proc do |db|
-        Sequel.tsk_require 'do_mysql'
-        Sequel.ts_require 'adapters/do/mysql'
+        require 'do_mysql'
+        Sequel.require 'adapters/do/mysql'
         db.extend(Sequel::DataObjects::MySQL::DatabaseMethods)
         db.dataset_class = Sequel::DataObjects::MySQL::Dataset
       end,
       :sqlite3=>proc do |db|
-        Sequel.tsk_require 'do_sqlite3'
-        Sequel.ts_require 'adapters/do/sqlite'
+        require 'do_sqlite3'
+        Sequel.require 'adapters/do/sqlite'
         db.extend(Sequel::DataObjects::SQLite::DatabaseMethods)
         db.extend_datasets Sequel::SQLite::DatasetMethods
         db.set_integer_booleans
@@ -44,18 +44,6 @@ module Sequel
 
       set_adapter_scheme :do
       
-      # Call the DATABASE_SETUP proc directly after initialization,
-      # so the object always uses sub adapter specific code.  Also,
-      # raise an error immediately if the connection doesn't have a
-      # uri, since DataObjects requires one.
-      def initialize(opts)
-        super
-        raise(Error, "No connection string specified") unless uri
-        if prok = DATABASE_SETUP[subadapter.to_sym]
-          prok.call(self)
-        end
-      end
-      
       # Setup a DataObjects::Connection to the database.
       def connect(server)
         setup_connection(::DataObjects::Connection.new(uri(server_opts(server))))
@@ -119,6 +107,17 @@ module Sequel
 
       private
       
+      # Call the DATABASE_SETUP proc directly after initialization,
+      # so the object always uses sub adapter specific code.  Also,
+      # raise an error immediately if the connection doesn't have a
+      # uri, since DataObjects requires one.
+      def adapter_initialize
+        raise(Error, "No connection string specified") unless uri
+        if prok = DATABASE_SETUP[subadapter.to_sym]
+          prok.call(self)
+        end
+      end
+      
       # Method to call on a statement object to execute SQL that does
       # not return any rows.
       def connection_execute_method

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

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

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

@@ -10,11 +10,13 @@ module Sequel
       # Methods to add to Database instances that access PostgreSQL via
       # DataObjects.
       module DatabaseMethods
+        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::Postgres::DatabaseMethods
         
         # Add the primary_keys and primary_key_sequences instance variables,
         # so we can get the correct return values for inserted rows.
         def self.extended(db)
+          super
           db.send(:initialize_postgres_adapter)
         end
         

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

@@ -6,6 +6,7 @@ module Sequel
     module SQLite
       # Instance methods for SQLite Database objects accessed via DataObjects.
       module DatabaseMethods
+        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::SQLite::DatabaseMethods
         
         private

data/lib/sequel/adapters/firebird.rb

@@ -12,13 +12,6 @@ module Sequel
 
       DISCONNECT_ERRORS = /Unsuccessful execution caused by a system error that precludes successful execution of subsequent statements/
 
-      # Add the primary_keys instance variables.
-      # so we can get the correct return values for inserted rows.
-      def initialize(*args)
-        super
-        @primary_keys = {}
-      end
-
       def connect(server)
         opts = server_opts(server)
 
@@ -54,6 +47,11 @@ module Sequel
 
       private
 
+      # Add the primary_keys instance variable so we can get the correct return values for inserted rows.
+      def adapter_initialize
+        @primary_keys = {}
+      end
+
       def begin_transaction(conn, opts={})
         log_yield(TRANSACTION_BEGIN) do
           begin

data/lib/sequel/adapters/ibmdb.rb

@@ -157,8 +157,14 @@ module Sequel
         IBM_DB.field_precision(@stmt, key)
       end
 
-      # Free the memory related to this result set.
+      # Free the memory related to this statement.
       def free
+        IBM_DB.free_stmt(@stmt)
+      end
+
+      # Free the memory related to this result set, only useful for prepared
+      # statements which have a different result set on every call.
+      def free_result
         IBM_DB.free_result(@stmt)
       end
 
@@ -176,12 +182,6 @@ module Sequel
       # Hash of connection procs for converting
       attr_reader :conversion_procs
 
-      def initialize(opts={})
-        super
-        @conversion_procs = DB2_TYPES.dup
-        @conversion_procs[:timestamp] = method(:to_application_timestamp)
-      end
-
       # REORG the related table whenever it is altered.  This is not always
       # required, but it is necessary for compatibilty with other Sequel
       # code in many cases.
@@ -229,7 +229,7 @@ module Sequel
           else
             _execute(c, sql, opts)
           end
-          _execute(c, "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1", opts){|stmt| i = stmt.fetch_array.first.to_i; stmt.free; i}
+          _execute(c, "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1", opts){|stmt| i = stmt.fetch_array.first.to_i; i}
         end
       rescue Connection::Error => e
         raise_error(e)
@@ -251,15 +251,15 @@ module Sequel
             log_sql << sql
             log_sql << ")"
           end
-          stmt = log_yield(log_sql, args){conn.execute_prepared(ps_name, *args)}
-          if block_given?
-            begin
+          begin
+            stmt = log_yield(log_sql, args){conn.execute_prepared(ps_name, *args)}
+            if block_given?
               yield(stmt)
-            ensure
-              stmt.free
+            else  
+              stmt.affected
             end
-          else  
-            stmt.affected
+          ensure
+            stmt.free_result if stmt
           end
         end
       end
@@ -289,14 +289,17 @@ module Sequel
       def _execute(conn, sql, opts)
         stmt = log_yield(sql){conn.execute(sql)}
         if block_given?
-          begin
-            yield(stmt)
-          ensure
-            stmt.free
-          end
+          yield(stmt)
         else  
           stmt.affected
         end
+      ensure
+        stmt.free if stmt
+      end
+
+      def adapter_initialize
+        @conversion_procs = DB2_TYPES.dup
+        @conversion_procs[:timestamp] = method(:to_application_timestamp)
       end
 
       # IBM_DB uses an autocommit setting instead of sending SQL queries.

data/lib/sequel/adapters/informix.rb

@@ -17,12 +17,18 @@ module Sequel
       def execute_dui(sql, opts={})
         synchronize(opts[:server]){|c| log_yield(sql){c.immediate(sql)}}
       end
-      alias_method :do, :execute_dui
+      def do(*a, &block)
+        Sequel::Deprecation.deprecate('Database#do', 'Please use Database#execute_dui')
+        execute_dui(*a, &block)
+      end
       
       def execute(sql, opts={})
         synchronize(opts[:server]){|c| yield log_yield(sql){c.cursor(sql)}}
       end
-      alias_method :query, :execute
+      def query(*a, &block)
+        Sequel::Deprecation.deprecate('Database#query', 'Please use Database#execute')
+        execute(*a, &block)
+      end
     end
     
     class Dataset < Sequel::Dataset

data/lib/sequel/adapters/jdbc.rb

@@ -32,7 +32,7 @@ module Sequel
     DATABASE_SETUP = {:postgresql=>proc do |db|
         JDBC.load_gem(:Postgres)
         org.postgresql.Driver
-        Sequel.ts_require 'adapters/jdbc/postgresql'
+        Sequel.require 'adapters/jdbc/postgresql'
         db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
         db.dataset_class = Sequel::JDBC::Postgres::Dataset
         org.postgresql.Driver
@@ -40,7 +40,7 @@ module Sequel
       :mysql=>proc do |db|
         JDBC.load_gem(:MySQL)
         com.mysql.jdbc.Driver
-        Sequel.ts_require 'adapters/jdbc/mysql'
+        Sequel.require 'adapters/jdbc/mysql'
         db.extend(Sequel::JDBC::MySQL::DatabaseMethods)
         db.extend_datasets Sequel::MySQL::DatasetMethods
         com.mysql.jdbc.Driver
@@ -48,7 +48,7 @@ module Sequel
       :sqlite=>proc do |db|
         JDBC.load_gem(:SQLite3)
         org.sqlite.JDBC
-        Sequel.ts_require 'adapters/jdbc/sqlite'
+        Sequel.require 'adapters/jdbc/sqlite'
         db.extend(Sequel::JDBC::SQLite::DatabaseMethods)
         db.extend_datasets Sequel::SQLite::DatasetMethods
         db.set_integer_booleans
@@ -56,14 +56,14 @@ module Sequel
       end,
       :oracle=>proc do |db|
         Java::oracle.jdbc.driver.OracleDriver
-        Sequel.ts_require 'adapters/jdbc/oracle'
+        Sequel.require 'adapters/jdbc/oracle'
         db.extend(Sequel::JDBC::Oracle::DatabaseMethods)
         db.dataset_class = Sequel::JDBC::Oracle::Dataset
         Java::oracle.jdbc.driver.OracleDriver
       end,
       :sqlserver=>proc do |db|
         com.microsoft.sqlserver.jdbc.SQLServerDriver
-        Sequel.ts_require 'adapters/jdbc/sqlserver'
+        Sequel.require 'adapters/jdbc/sqlserver'
         db.extend(Sequel::JDBC::SQLServer::DatabaseMethods)
         db.extend_datasets Sequel::MSSQL::DatasetMethods
         db.send(:set_mssql_unicode_strings)
@@ -72,7 +72,7 @@ module Sequel
       :jtds=>proc do |db|
         JDBC.load_gem(:JTDS)
         Java::net.sourceforge.jtds.jdbc.Driver
-        Sequel.ts_require 'adapters/jdbc/jtds'
+        Sequel.require 'adapters/jdbc/jtds'
         db.extend(Sequel::JDBC::JTDS::DatabaseMethods)
         db.dataset_class = Sequel::JDBC::JTDS::Dataset
         db.send(:set_mssql_unicode_strings)
@@ -81,7 +81,7 @@ module Sequel
       :h2=>proc do |db|
         JDBC.load_gem(:H2)
         org.h2.Driver
-        Sequel.ts_require 'adapters/jdbc/h2'
+        Sequel.require 'adapters/jdbc/h2'
         db.extend(Sequel::JDBC::H2::DatabaseMethods)
         db.dataset_class = Sequel::JDBC::H2::Dataset
         org.h2.Driver
@@ -89,7 +89,7 @@ module Sequel
       :hsqldb=>proc do |db|
         JDBC.load_gem(:HSQLDB)
         org.hsqldb.jdbcDriver
-        Sequel.ts_require 'adapters/jdbc/hsqldb'
+        Sequel.require 'adapters/jdbc/hsqldb'
         db.extend(Sequel::JDBC::HSQLDB::DatabaseMethods)
         db.dataset_class = Sequel::JDBC::HSQLDB::Dataset
         org.hsqldb.jdbcDriver
@@ -97,49 +97,49 @@ module Sequel
       :derby=>proc do |db|
         JDBC.load_gem(:Derby)
         org.apache.derby.jdbc.EmbeddedDriver
-        Sequel.ts_require 'adapters/jdbc/derby'
+        Sequel.require 'adapters/jdbc/derby'
         db.extend(Sequel::JDBC::Derby::DatabaseMethods)
         db.dataset_class = Sequel::JDBC::Derby::Dataset
         org.apache.derby.jdbc.EmbeddedDriver
       end,
       :as400=>proc do |db|
         com.ibm.as400.access.AS400JDBCDriver
-        Sequel.ts_require 'adapters/jdbc/as400'
+        Sequel.require 'adapters/jdbc/as400'
         db.extend(Sequel::JDBC::AS400::DatabaseMethods)
         db.dataset_class = Sequel::JDBC::AS400::Dataset
         com.ibm.as400.access.AS400JDBCDriver
       end,
       :"informix-sqli"=>proc do |db|
         com.informix.jdbc.IfxDriver
-        Sequel.ts_require 'adapters/jdbc/informix'
+        Sequel.require 'adapters/jdbc/informix'
         db.extend(Sequel::JDBC::Informix::DatabaseMethods)
         db.extend_datasets Sequel::Informix::DatasetMethods
         com.informix.jdbc.IfxDriver
       end,
       :db2=>proc do |db|
         com.ibm.db2.jcc.DB2Driver
-        Sequel.ts_require 'adapters/jdbc/db2'
+        Sequel.require 'adapters/jdbc/db2'
         db.extend(Sequel::JDBC::DB2::DatabaseMethods)
         db.dataset_class = Sequel::JDBC::DB2::Dataset
         com.ibm.db2.jcc.DB2Driver
       end,
       :firebirdsql=>proc do |db|
         org.firebirdsql.jdbc.FBDriver
-        Sequel.ts_require 'adapters/jdbc/firebird'
+        Sequel.require 'adapters/jdbc/firebird'
         db.extend(Sequel::JDBC::Firebird::DatabaseMethods)
         db.extend_datasets Sequel::Firebird::DatasetMethods
         org.firebirdsql.jdbc.FBDriver
       end,
       :jdbcprogress=>proc do |db|
         com.progress.sql.jdbc.JdbcProgressDriver
-        Sequel.ts_require 'adapters/jdbc/progress'
+        Sequel.require 'adapters/jdbc/progress'
         db.extend(Sequel::JDBC::Progress::DatabaseMethods)
         db.extend_datasets Sequel::Progress::DatasetMethods
         com.progress.sql.jdbc.JdbcProgressDriver
       end,
       :cubrid=>proc do |db|
         Java::cubrid.jdbc.driver.CUBRIDDriver
-        Sequel.ts_require 'adapters/jdbc/cubrid'
+        Sequel.require 'adapters/jdbc/cubrid'
         db.extend(Sequel::JDBC::Cubrid::DatabaseMethods)
         db.extend_datasets Sequel::Cubrid::DatasetMethods
         Java::cubrid.jdbc.driver.CUBRIDDriver
@@ -150,7 +150,7 @@ module Sequel
     # works for PostgreSQL, MySQL, and SQLite.
     def self.load_gem(name)
       begin
-        Sequel.tsk_require "jdbc/#{name.to_s.downcase}"
+        require "jdbc/#{name.to_s.downcase}"
       rescue LoadError
         # jdbc gem not used, hopefully the user has the .jar in their CLASSPATH
       else
@@ -177,24 +177,6 @@ module Sequel
       # fetching rows.
       attr_accessor :convert_types
 
-      # Call the DATABASE_SETUP proc directly after initialization,
-      # so the object always uses sub adapter specific code.  Also,
-      # raise an error immediately if the connection doesn't have a
-      # uri, since JDBC requires one.
-      def initialize(opts)
-        super
-        @connection_prepared_statements = {}
-        @connection_prepared_statements_mutex = Mutex.new
-        @convert_types = typecast_value_boolean(@opts.fetch(:convert_types, true))
-        raise(Error, "No connection string specified") unless uri
-        
-        resolved_uri = jndi? ? get_uri_from_jndi : uri
-
-        if match = /\Ajdbc:([^:]+)/.match(resolved_uri) and prok = DATABASE_SETUP[match[1].to_sym]
-          @driver = prok.call(self)
-        end        
-      end
-      
       # Execute the given stored procedure with the give name. If a block is
       # given, the stored procedure should return rows.
       def call_sproc(name, opts = {})
@@ -350,6 +332,23 @@ module Sequel
 
       private
          
+      # Call the DATABASE_SETUP proc directly after initialization,
+      # so the object always uses sub adapter specific code.  Also,
+      # raise an error immediately if the connection doesn't have a
+      # uri, since JDBC requires one.
+      def adapter_initialize
+        @connection_prepared_statements = {}
+        @connection_prepared_statements_mutex = Mutex.new
+        @convert_types = typecast_value_boolean(@opts.fetch(:convert_types, true))
+        raise(Error, "No connection string specified") unless uri
+        
+        resolved_uri = jndi? ? get_uri_from_jndi : uri
+
+        if match = /\Ajdbc:([^:]+)/.match(resolved_uri) and prok = DATABASE_SETUP[match[1].to_sym]
+          @driver = prok.call(self)
+        end        
+      end
+      
       # Yield the native prepared statements hash for the given connection
       # to the block in a thread-safe manner.
       def cps_sync(conn, &block)
@@ -390,7 +389,7 @@ module Sequel
       # variables, and execute it.
       def execute_prepared_statement(name, opts={})
         args = opts[:arguments]
-        if Dataset === name
+        if name.is_a?(Dataset)
           ps = name
           name = ps.prepared_statement_name
         else
@@ -575,14 +574,19 @@ module Sequel
           next if schema_parse_table_skip?(h, schema)
           pks << h[:column_name]
         end
+        schemas = []
         metadata(:getColumns, nil, schema, table, nil) do |h|
           next if schema_parse_table_skip?(h, schema)
           s = {:type=>schema_column_type(h[:type_name]), :db_type=>h[:type_name], :default=>(h[:column_def] == '' ? nil : h[:column_def]), :allow_null=>(h[:nullable] != 0), :primary_key=>pks.include?(h[:column_name]), :column_size=>h[:column_size], :scale=>h[:decimal_digits]}
           if s[:db_type] =~ DECIMAL_TYPE_RE && s[:scale] == 0
             s[:type] = :integer
           end
+          schemas << h[:table_schem] unless schemas.include?(h[:table_schem])
           ts << [m.call(h[:column_name]), s]
         end
+        if schemas.length > 1
+          Sequel::Deprecation.deprecate('Schema parsing in the jdbc adapter resulted in columns being returned for a table with the same name in multiple schemas.  This will raise an Error starting in Sequel 4.  Please explicitly qualify your table with a schema.')
+        end
         ts
       end