sequel 3.34.0 → 3.35.0

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

@@ -5,11 +5,6 @@ module Sequel
     # Database and Dataset instance methods for JTDS specific
     # support via JDBC.
     module JTDS
-      # Database instance methods for JTDS databases accessed via JDBC.
-      module DatabaseMethods
-        include Sequel::JDBC::MSSQL::DatabaseMethods
-      end
-      
       # Dataset class for JTDS datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::MSSQL::DatasetMethods

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

@@ -62,11 +62,6 @@ module Sequel
           conn
         end
       end
-      
-      # Dataset class for MySQL datasets accessed via JDBC.
-      class Dataset < JDBC::Dataset
-        include Sequel::MySQL::DatasetMethods
-      end
     end
   end
 end

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

@@ -7,32 +7,6 @@ module Sequel
     # Adapter, Database, and Dataset support for accessing a PostgreSQL
     # database via JDBC.
     module Postgres
-      # Methods to add to the JDBC adapter/connection to allow it to work
-      # with the shared PostgreSQL code.
-      module AdapterMethods
-        include Sequel::Postgres::AdapterMethods
-        
-        # Give the JDBC adapter a direct execute method, which creates
-        # a statement with the given sql and executes it.
-        def execute(sql, args=nil)
-          method = block_given? ? :executeQuery : :execute
-          @db.send(:statement, self) do |stmt|
-            rows = @db.log_yield(sql){stmt.send(method, sql)}
-            yield(rows) if block_given?
-          end
-        end
-        
-        private
-        
-        # JDBC specific method of getting specific values from a result set.
-        def single_value(r)
-          unless r.nil?
-            r.next
-            r.getString(1) unless r.getRow == 0
-          end
-        end
-      end
-    
       # Methods to add to Database instances that access PostgreSQL via
       # JDBC.
       module DatabaseMethods
@@ -55,19 +29,14 @@ module Sequel
           arg.nil? ? cps.setNull(i, JavaSQL::Types::NULL) : super
         end
 
-        # Extend the adapter with the JDBC PostgreSQL AdapterMethods
+        # Execute the connection configuration SQL queries on the connection.
         def setup_connection(conn)
           conn = super(conn)
-          conn.extend(Sequel::JDBC::Postgres::AdapterMethods)
-          conn.db = self
-          conn.apply_connection_settings
+          statement(conn) do |stmt|
+            connection_configuration_sqls.each{|sql| log_yield(sql){stmt.execute(sql)}}
+          end
           conn
         end
-        
-        # Call insert_result with the table and values specified in the opts.
-        def last_insert_id(conn, opts)
-          insert_result(conn, opts[:table], opts[:values])
-        end
       end
       
       # Dataset subclass used for datasets that connect to PostgreSQL via JDBC.

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

@@ -54,11 +54,6 @@ module Sequel
           conn
         end
       end
-      
-      # Dataset class for SQLite datasets accessed via JDBC.
-      class Dataset < JDBC::Dataset
-        include Sequel::SQLite::DatasetMethods
-      end
     end
   end
 end

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

@@ -61,11 +61,6 @@ module Sequel
           super.extend(MetadataDatasetMethods)
         end
       end
-      
-      # Dataset class for SQLServer datasets accessed via JDBC.
-      class Dataset < JDBC::Dataset
-        include Sequel::MSSQL::DatasetMethods
-      end
     end
   end
 end

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

@@ -24,7 +24,7 @@ module Sequel
       # Use JDBC connection's setAutoCommit to false to start transactions
       def begin_transaction(conn, opts={})
         if supports_savepoints?
-          th = @transactions[conn]
+          th = _trans(conn)
           if sps = th[:savepoints]
             sps << log_yield(TRANSACTION_SAVEPOINT){conn.set_savepoint}
           else
@@ -40,7 +40,7 @@ module Sequel
       # Use JDBC connection's commit method to commit transactions
       def commit_transaction(conn, opts={})
         if supports_savepoints?
-          sps = @transactions[conn][:savepoints]
+          sps = _trans(conn)[:savepoints]
           if sps.empty?
             log_yield(TRANSACTION_COMMIT){conn.commit}
           elsif supports_releasing_savepoints?
@@ -54,7 +54,7 @@ module Sequel
       # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
       def remove_transaction(conn, committed)
         if supports_savepoints?
-          sps = @transactions[conn][:savepoints]
+          sps = _trans(conn)[:savepoints]
           conn.setAutoCommit(true) if sps.empty?
           sps.pop
         else
@@ -67,7 +67,7 @@ module Sequel
       # Use JDBC connection's rollback method to rollback transactions
       def rollback_transaction(conn, opts={})
         if supports_savepoints?
-          sps = @transactions[conn][:savepoints]
+          sps = _trans(conn)[:savepoints]
           if sps.empty?
             log_yield(TRANSACTION_ROLLBACK){conn.rollback}
           else

data/lib/sequel/adapters/jdbc.rb

@@ -39,14 +39,14 @@ module Sequel
       :mysql=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/mysql'
         db.extend(Sequel::JDBC::MySQL::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::MySQL::Dataset
+        db.extend_datasets Sequel::MySQL::DatasetMethods
         JDBC.load_gem('mysql')
         com.mysql.jdbc.Driver
       end,
       :sqlite=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/sqlite'
         db.extend(Sequel::JDBC::SQLite::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::SQLite::Dataset
+        db.extend_datasets Sequel::SQLite::DatasetMethods
         db.set_integer_booleans
         JDBC.load_gem('sqlite3')
         org.sqlite.JDBC
@@ -60,13 +60,13 @@ module Sequel
       :sqlserver=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/sqlserver'
         db.extend(Sequel::JDBC::SQLServer::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::SQLServer::Dataset
+        db.extend_datasets Sequel::MSSQL::DatasetMethods
         db.send(:set_mssql_unicode_strings)
         com.microsoft.sqlserver.jdbc.SQLServerDriver
       end,
       :jtds=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/jtds'
-        db.extend(Sequel::JDBC::JTDS::DatabaseMethods)
+        db.extend(Sequel::JDBC::MSSQL::DatabaseMethods)
         db.dataset_class = Sequel::JDBC::JTDS::Dataset
         db.send(:set_mssql_unicode_strings)
         JDBC.load_gem('jtds')
@@ -102,19 +102,19 @@ module Sequel
       :"informix-sqli"=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/informix'
         db.extend(Sequel::JDBC::Informix::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::Informix::Dataset
+        db.extend_datasets Sequel::Informix::DatasetMethods
         com.informix.jdbc.IfxDriver
       end,
       :db2=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/db2'
         db.extend(Sequel::JDBC::DB2::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::DB2::Dataset
+        db.extend_datasets Sequel::DB2::DatasetMethods
         com.ibm.db2.jcc.DB2Driver
       end,
       :firebirdsql=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/firebird'
         db.extend(Sequel::JDBC::Firebird::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::Firebird::Dataset
+        db.extend_datasets Sequel::Firebird::DatasetMethods
         org.firebirdsql.jdbc.FBDriver
       end
     }
@@ -151,6 +151,8 @@ module Sequel
       # 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
         
@@ -312,8 +314,15 @@ module Sequel
 
       private
          
-      # Close given adapter connections
+      # Yield the native prepared statements hash for the given connection
+      # to the block in a thread-safe manner.
+      def cps_sync(conn, &block)
+        @connection_prepared_statements_mutex.synchronize{yield(@connection_prepared_statements[conn] ||= {})}
+      end
+
+      # Close given adapter connections, and delete any related prepared statements.
       def disconnect_connection(c)
+        @connection_prepared_statements_mutex.synchronize{@connection_prepared_statements.delete(c)}
         c.close
       end
       
@@ -336,16 +345,16 @@ module Sequel
           ps = name
           name = ps.prepared_statement_name
         else
-          ps = prepared_statements[name]
+          ps = prepared_statement(name)
         end
         sql = ps.prepared_sql
         synchronize(opts[:server]) do |conn|
-          if name and cps = conn.prepared_statements[name] and cps[0] == sql
+          if name and cps = cps_sync(conn){|cpsh| cpsh[name]} and cps[0] == sql
             cps = cps[1]
           else
             log_yield("CLOSE #{name}"){cps[1].close} if cps
             cps = log_yield("PREPARE#{" #{name}:" if name} #{sql}"){conn.prepareStatement(sql)}
-            conn.prepared_statements[name] = [sql, cps] if name
+            cps_sync(conn){|cpsh| cpsh[name] = [sql, cps]} if name
           end
           i = 0
           args.each{|arg| set_ps_arg(cps, arg, i+=1)}
@@ -476,14 +485,9 @@ module Sequel
         end
       end
       
-      # Add a prepared_statements accessor to the connection,
-      # and set it to an empty hash.  This is used to store
-      # adapter specific prepared statements.
+      # Return the connection.  Used to do configuration on the
+      # connection object before adding it to the connection pool.
       def setup_connection(conn)
-        class << conn
-          attr_accessor :prepared_statements
-        end
-        conn.prepared_statements = {}
         conn
       end
       
@@ -608,7 +612,7 @@ module Sequel
         ps.extend(PreparedStatementMethods)
         if name
           ps.prepared_statement_name = name
-          db.prepared_statements[name] = ps
+          db.set_prepared_statement(name, ps)
         end
         ps
       end

data/lib/sequel/adapters/mysql2.rb

@@ -1,4 +1,4 @@
-require 'mysql2' unless defined? Mysql2
+require 'mysql2'
 Sequel.require %w'shared/mysql_prepared_statements', 'adapters'
 
 module Sequel

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

@@ -28,9 +28,22 @@ module Sequel
           end
         end
       end
-      
       class Dataset < ODBC::Dataset
         include Sequel::MSSQL::DatasetMethods
+
+        private
+
+        # Use ODBC format, not Microsoft format, as the ODBC layer does
+        # some translation.
+        def default_timestamp_format
+          TIMESTAMP_FORMAT
+        end
+
+        # Use ODBC format, not Microsoft format, as the ODBC layer does
+        # some translation.
+        def literal_date(v)
+          v.strftime(ODBC_DATE_FORMAT)
+        end
       end
     end
   end

data/lib/sequel/adapters/odbc.rb

@@ -22,9 +22,9 @@ module Sequel
           extend Sequel::Progress::DatabaseMethods
           extend_datasets(Sequel::Progress::DatasetMethods)
         when 'db2'
-          Sequel.ts_require 'adapters/odbc/db2'
-          extend Sequel::ODBC::DB2::DatabaseMethods
-          @dataset_class = Sequel::ODBC::DB2::Dataset
+          Sequel.ts_require 'adapters/shared/db2'
+          extend ::Sequel::DB2::DatabaseMethods
+          extend_datasets ::Sequel::DB2::DatasetMethods
         end
       end
 

data/lib/sequel/adapters/oracle.rb

@@ -126,7 +126,7 @@ module Sequel
       end
 
       def execute_prepared_statement(conn, type, name, opts)
-        ps = prepared_statements[name]
+        ps = prepared_statement(name)
         sql = ps.prepared_sql
         if cursora = conn.prepared_statements[name]
           cursor, cursor_sql = cursora
@@ -243,7 +243,7 @@ module Sequel
 
         # Default values
         defaults = begin
-          metadata_dataset.from(:dba_tab_cols).
+          metadata_dataset.from(:user_tab_cols).
             where(:table_name=>im.call(table)).
             to_hash(:column_name, :data_default)
         rescue DatabaseError
@@ -370,19 +370,6 @@ module Sequel
         ps.call(bind_vars, &block)
       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.prepared_statements[name] = ps
-        end
-        ps
-      end
-      
       def fetch_rows(sql)
         execute(sql) do |cursor|
           offset = @opts[:offset]
@@ -403,14 +390,15 @@ module Sequel
         self
       end
 
-      # Create a named prepared statement that is stored in the
-      # database (and connection) for reuse.
+      # 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.prepared_statements[name] = ps
+          db.set_prepared_statement(name, ps)
         end
         ps
       end

data/lib/sequel/adapters/postgres.rb

@@ -12,7 +12,7 @@ rescue LoadError => e
     class PGconn
       unless method_defined?(:escape_string)
         if self.respond_to?(:escape)
-          # If there is no escape_string instead method, but there is an
+          # If there is no escape_string instance method, but there is an
           # escape class method, use that instead.
           def escape_string(str)
             Sequel::Postgres.force_standard_strings ? str.gsub("'", "''") : self.class.escape(str)
@@ -91,24 +91,29 @@ module Sequel
     NAN             = 0.0/0.0
     PLUS_INFINITY   = 1.0/0.0
     MINUS_INFINITY  = -1.0/0.0
+    NAN_STR             = 'NaN'.freeze
+    PLUS_INFINITY_STR   = 'Infinity'.freeze
+    MINUS_INFINITY_STR  = '-Infinity'.freeze
+    TRUE_STR = 't'.freeze
+    DASH_STR = '-'.freeze
     
     TYPE_TRANSLATOR = tt = Class.new do
-      def boolean(s) s == 't' end
+      def boolean(s) s == TRUE_STR end
       def bytea(s) ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s)) end
       def integer(s) s.to_i end
       def float(s) 
         case s
-        when 'NaN'
+        when NAN_STR
           NAN
-        when 'Infinity'
+        when PLUS_INFINITY_STR
           PLUS_INFINITY
-        when '-Infinity'
+        when MINUS_INFINITY_STR
           MINUS_INFINITY
         else
           s.to_f 
         end
       end
-      def date(s) ::Date.new(*s.split("-").map{|x| x.to_i}) end
+      def date(s) ::Date.new(*s.split(DASH_STR).map{|x| x.to_i}) end
     end.new
 
     # Hash with type name strings/symbols and callable values for converting PostgreSQL types.
@@ -149,8 +154,6 @@ module Sequel
     class Adapter < ::PGconn
       DISCONNECT_ERROR_RE = /\Acould not receive data from server: Software caused connection abort/
       
-      include Sequel::Postgres::AdapterMethods
-
       self.translate_results = false if respond_to?(:translate_results=)
       
       # Hash of prepared statements for this connection.  Keys are
@@ -158,18 +161,6 @@ module Sequel
       # are SQL strings.
       attr_reader(:prepared_statements) if SEQUEL_POSTGRES_USES_PG
       
-      # Apply connection settings for this connection.  Current sets
-      # the date style to ISO in order make Date object creation in ruby faster,
-      # if Postgres.use_iso_date_format is true.
-      def apply_connection_settings
-        super
-        if Postgres.use_iso_date_format
-          sql = "SET DateStyle = 'ISO'"
-          execute(sql)
-        end
-        @prepared_statements = {} if SEQUEL_POSTGRES_USES_PG
-      end
-
       # Raise a Sequel::DatabaseDisconnectError if a PGError is raised and
       # the connection status cannot be determined or it is not OK.
       def check_disconnect_errors
@@ -210,11 +201,6 @@ module Sequel
       def execute_query(sql, args)
         @db.log_yield(sql, args){args ? async_exec(sql, args) : async_exec(sql)}
       end
-      
-      # Return the requested values for the given row.
-      def single_value(r)
-        r.getvalue(0, 0) unless r.nil? || (r.ntuples == 0)
-      end
     end
     
     # Database class for PostgreSQL databases used with Sequel and the
@@ -223,7 +209,7 @@ module Sequel
       include Sequel::Postgres::DatabaseMethods
 
       INFINITE_TIMESTAMP_STRINGS = ['infinity'.freeze, '-infinity'.freeze].freeze
-      INFINITE_DATETIME_VALUES = ([1.0/0.0, -1.0/0.0] + INFINITE_TIMESTAMP_STRINGS).freeze
+      INFINITE_DATETIME_VALUES = ([PLUS_INFINITY, MINUS_INFINITY] + INFINITE_TIMESTAMP_STRINGS).freeze
       
       set_adapter_scheme :postgres
 
@@ -299,8 +285,9 @@ module Sequel
             conn.async_exec("set client_encoding to '#{encoding}'")
           end
         end
-        conn.db = self
-        conn.apply_connection_settings
+        conn.instance_variable_set(:@db, self)
+        conn.instance_variable_set(:@prepared_statements, {}) if SEQUEL_POSTGRES_USES_PG
+        connection_configuration_sqls.each{|sql| conn.execute(sql)}
         @conversion_procs ||= get_conversion_procs(conn)
         conn
       end
@@ -312,19 +299,7 @@ module Sequel
           synchronize(opts[:server]){|conn| conn.execute(sql, opts[:arguments], &block)}
         end
       end
-      
-      # Insert the values into the table and return the primary key (if
-      # automatically generated).
-      def execute_insert(sql, opts={})
-        return execute(sql, opts) if Symbol === sql
-        check_database_errors do
-          synchronize(opts[:server]) do |conn|
-            conn.execute(sql, opts[:arguments])
-            insert_result(conn, opts[:table], opts[:values])
-          end
-        end
-      end
-      
+
       if SEQUEL_POSTGRES_USES_PG
         # +copy_table+ uses PostgreSQL's +COPY+ SQL statement to return formatted
         # results directly to the caller.  This method is only supported if pg is the
@@ -470,6 +445,13 @@ module Sequel
         end
       end
 
+      # Set the DateStyle to ISO if configured, for faster date parsing.
+      def connection_configuration_sqls
+        sqls = super
+        sqls << "SET DateStyle = 'ISO'" if Postgres.use_iso_date_format
+        sqls
+      end
+
       # Disconnect given connection
       def disconnect_connection(conn)
         begin
@@ -487,7 +469,7 @@ module Sequel
       # of rows changed.  If the :insert option is passed, return the value
       # of the primary key for the last inserted row.
       def execute_prepared_statement(name, opts={})
-        ps = prepared_statements[name]
+        ps = prepared_statement(name)
         sql = ps.prepared_sql
         ps_name = name.to_s
         synchronize(opts[:server]) do |conn|
@@ -511,14 +493,10 @@ module Sequel
           end
 
           q = conn.check_disconnect_errors{log_yield(log_sql, args){conn.exec_prepared(ps_name, args)}}
-          if opts[:table] && opts[:values]
-            insert_result(conn, opts[:table], opts[:values])
-          else
-            begin
-              block_given? ? yield(q) : q.cmd_tuples
-            ensure
-              q.clear
-            end
+          begin
+            block_given? ? yield(q) : q.cmd_tuples
+          ensure
+            q.clear
           end
         end
       end
@@ -549,6 +527,10 @@ module Sequel
         end
       end
       
+      # Don't log, since logging is done by the underlying connection.
+      def log_connection_execute(conn, sql)
+        conn.execute(sql)
+      end
 
       # If the value is an infinite value (either an infinite float or a string returned by
       # by PostgreSQL for an infinite timestamp), return it without converting it if
@@ -573,6 +555,7 @@ module Sequel
       include Sequel::Postgres::DatasetMethods
 
       Database::DatasetClass = self
+      APOS = Sequel::Dataset::APOS
       
       # Yield all rows returned by executing the given SQL and converting
       # the types.
@@ -708,7 +691,7 @@ module Sequel
           ps.extend(PreparedStatementMethods)
           if name
             ps.prepared_statement_name = name
-            db.prepared_statements[name] = ps
+            db.set_prepared_statement(name, ps)
           end
           ps
         end
@@ -766,12 +749,12 @@ module Sequel
       
       # Use the driver's escape_bytea
       def literal_blob_append(sql, v)
-        sql << "'" << db.synchronize{|c| c.escape_bytea(v)} << "'"
+        sql << APOS << db.synchronize{|c| c.escape_bytea(v)} << APOS
       end
       
       # Use the driver's escape_string
       def literal_string_append(sql, v)
-        sql << "'" << db.synchronize{|c| c.escape_string(v)} << "'"
+        sql << APOS << db.synchronize{|c| c.escape_string(v)} << APOS
       end
       
       # For each row in the result set, yield a hash with column name symbol

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

@@ -131,12 +131,24 @@ module Sequel
         super
       end
 
+      # Insert data from the current table into the new table after
+      # creating the table, since it is not possible to do it in one step.
+      def create_table_as(name, sql, options)
+        super
+        from(name).insert(sql.is_a?(Dataset) ? sql : dataset.with_sql(sql))
+      end
+
+      # DB2 requires parens around the SELECT, and DEFINITION ONLY at the end.
+      def create_table_as_sql(name, sql, options)
+        "#{create_table_prefix_sql(name, options)} AS (#{sql}) DEFINITION ONLY"
+      end
+
       # Here we use DGTT which has most backward compatibility, which uses
       # DECLARE instead of CREATE. CGTT can only be used after version 9.7.
       # http://www.ibm.com/developerworks/data/library/techarticle/dm-0912globaltemptable/
-      def create_table_sql(name, generator, options)
+      def create_table_prefix_sql(name, options)
         if options[:temp]
-          "DECLARE GLOBAL TEMPORARY TABLE #{quote_identifier(name)} (#{column_list_sql(generator)})"
+          "DECLARE GLOBAL TEMPORARY TABLE #{quote_identifier(name)}"
         else
           super
         end
@@ -221,6 +233,8 @@ module Sequel
           sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} * POWER(2, #{literal(b)}))"}
         when :>>
           sql << complex_expression_arg_pairs(args){|a, b| "(#{literal(a)} / POWER(2, #{literal(b)}))"}
+        when :%
+          sql << complex_expression_arg_pairs(args){|a, b| "MOD(#{literal(a)}, #{literal(b)})"}
         when :'B~'
           literal_append(sql, SQL::Function.new(:BITNOT, *args))
         when :extract