sequel 3.34.1 → 3.35.0

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

@@ -25,11 +25,6 @@ module Sequel
           super
         end
       end
-      
-      # Dataset class for SQLite datasets accessed via DataObjects.
-      class Dataset < DataObjects::Dataset
-        include Sequel::SQLite::DatasetMethods
-      end
     end
   end
 end

data/lib/sequel/adapters/firebird.rb

@@ -31,7 +31,7 @@ module Sequel
       def execute(sql, opts={})
         begin
           synchronize(opts[:server]) do |conn|
-            if conn.transaction_started && !@transactions.has_key?(conn)
+            if conn.transaction_started && !_trans(conn)
               conn.rollback
               raise DatabaseDisconnectError, "transaction accidently left open, rolling back and disconnecting"
             end

data/lib/sequel/adapters/ibmdb.rb

@@ -227,7 +227,7 @@ module Sequel
       # Execute a prepared statement named by name on the database.
       def execute_prepared_statement(ps_name, opts)
         args = opts[:arguments]
-        ps = prepared_statements[ps_name]
+        ps = prepared_statement(ps_name)
         sql = ps.prepared_sql
         synchronize(opts[:server]) do |conn|
           unless conn.prepared_statements.fetch(ps_name, []).first == sql
@@ -444,7 +444,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/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/jdbc/db2.rb

@@ -42,11 +42,6 @@ module Sequel
           PRIMARY_KEY_INDEX_RE
         end
       end
-      
-      # Dataset class for DB2 datasets accessed via JDBC.
-      class Dataset < JDBC::Dataset
-        include Sequel::DB2::DatasetMethods
-      end
     end
   end
 end

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

@@ -37,6 +37,11 @@ module Sequel
           end
         end
         
+        # Derby supports transaction DDL statements.
+        def supports_transactional_ddl?
+          true
+        end
+
         private
         
         # Derby optimizes away Sequel's default check of SELECT NULL FROM table,
@@ -70,10 +75,30 @@ module Sequel
           sql << " NOT NULL" if column.fetch(:null, column[:allow_null]) == false
         end
     
-        # Temporary table creation on Derby use DECLARE instead of CREATE.
+        # Add NOT LOGGED for temporary tables to improve performance.
         def create_table_sql(name, generator, options)
+          s = super
+          s << ' NOT LOGGED' if options[:temp]
+          s
+        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
+
+        # Derby currently only requires WITH NO DATA, with a separate insert
+        # to import data.
+        def create_table_as_sql(name, sql, options)
+          "#{create_table_prefix_sql(name, options)} AS #{sql} WITH NO DATA"
+        end
+
+        # Temporary table creation on Derby uses DECLARE instead of CREATE.
+        def create_table_prefix_sql(name, options)
           if options[:temp]
-            "DECLARE GLOBAL TEMPORARY TABLE #{quote_identifier(name)} (#{column_list_sql(generator)}) NOT LOGGED"
+            "DECLARE GLOBAL TEMPORARY TABLE #{quote_identifier(name)}"
           else
             super
           end
@@ -167,6 +192,8 @@ module Sequel
             super(sql, :LIKE, [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1))])
           when :"NOT ILIKE"
             super(sql, :"NOT LIKE", [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1))])
+          when :%
+            sql << complex_expression_arg_pairs(args){|a, b| "MOD(#{literal(a)}, #{literal(b)})"}
           when :&, :|, :^, :<<, :>>
             raise Error, "Derby doesn't support the #{op} operator"
           when :'B~'

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

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

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

@@ -48,7 +48,7 @@ module Sequel
         # If the :prepare option is given and we aren't in a savepoint,
         # prepare the transaction for a two-phase commit.
         def commit_transaction(conn, opts={})
-          if (s = opts[:prepare]) && @transactions[conn][:savepoint_level] <= 1
+          if (s = opts[:prepare]) && _trans(conn)[:savepoint_level] <= 1
             log_connection_execute(conn, "PREPARE COMMIT #{s}")
           else
             super

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

@@ -47,6 +47,11 @@ module Sequel
           end
         end
 
+        # HSQLDB requires parens around the SELECT, and the WITH DATA syntax.
+        def create_table_as_sql(name, sql, options)
+          "#{create_table_prefix_sql(name, options)} AS (#{sql}) WITH DATA"
+        end
+
         # Use IDENTITY() to get the last inserted id.
         def last_insert_id(conn, opts={})
           statement(conn) do |stmt|
@@ -112,6 +117,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~'
             sql << BITCOMP_OPEN
             literal_append(sql, args.at(0))

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

@@ -16,11 +16,6 @@ module Sequel
           nil
         end
       end
-      
-      # Dataset class for Informix datasets accessed via JDBC.
-      class Dataset < JDBC::Dataset
-        include Sequel::Informix::DatasetMethods
-      end
     end
   end
 end

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/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.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