sequel 3.40.0 → 3.41.0

data/lib/sequel/adapters/postgres.rb

@@ -229,6 +229,14 @@ module Sequel
         conn
       end
       
+      # Disconnect given connection
+      def disconnect_connection(conn)
+        begin
+          conn.finish
+        rescue PGError
+        end
+      end
+      
       # Execute the given SQL with the given args on an available connection.
       def execute(sql, opts={}, &block)
         synchronize(opts[:server]){|conn| check_database_errors{_execute(conn, sql, opts, &block)}}
@@ -453,14 +461,10 @@ module Sequel
         sqls
       end
 
-      # Disconnect given connection
-      def disconnect_connection(conn)
-        begin
-          conn.finish
-        rescue PGError
-        end
+      def database_error_classes
+        [PGError]
       end
-      
+
       # Execute the prepared statement with the given name on an available
       # connection, using the given args.  If the connection has not prepared
       # a statement with the given name yet, prepare it.  If the connection
@@ -479,8 +483,8 @@ module Sequel
 
         unless conn.prepared_statements[ps_name] == sql
           conn.execute("DEALLOCATE #{ps_name}") if conn.prepared_statements.include?(ps_name)
-          conn.prepared_statements[ps_name] = sql
           conn.check_disconnect_errors{log_yield("PREPARE #{ps_name} AS #{sql}"){conn.prepare(ps_name, sql)}}
+          conn.prepared_statements[ps_name] = sql
         end
 
         log_sql = "EXECUTE #{ps_name}"

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

@@ -176,6 +176,11 @@ module Sequel
         "CALL ADMIN_CMD(#{literal("REORG TABLE #{table}")})"
       end
 
+      # Treat clob as blob if use_clob_as_blob is true
+      def schema_column_type(db_type)
+        (::Sequel::DB2::use_clob_as_blob && db_type.downcase == 'clob') ? :blob : super
+      end
+
       # We uses the clob type by default for Files.
       # Note: if user select to use blob, then insert statement should use 
       # use this for blob value:

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

@@ -154,6 +154,7 @@ module Sequel
       INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'insert into columns values returning')
       FIRST = " FIRST ".freeze
       SKIP = " SKIP ".freeze
+      DEFAULT_FROM = " FROM RDB$DATABASE"
       
       # Insert given values into the database.
       def insert(*values)
@@ -206,6 +207,15 @@ module Sequel
         SELECT_CLAUSE_METHODS
       end
       
+        # Use a default FROM table if the dataset does not contain a FROM table.
+        def select_from_sql(sql)
+          if @opts[:from]
+            super
+          else
+            sql << DEFAULT_FROM
+          end
+        end
+
       def select_limit_sql(sql)
         if l = @opts[:limit]
           sql << FIRST

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

@@ -13,6 +13,7 @@ module Sequel
       SQL_ROLLBACK_TO_SAVEPOINT = 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION autopoint_%d'.freeze
       SQL_SAVEPOINT = 'SAVE TRANSACTION autopoint_%d'.freeze
       MSSQL_DEFAULT_RE = /\A(?:\(N?('.*')\)|\(\((-?\d+(?:\.\d+)?)\)\))\z/
+      FOREIGN_KEY_ACTION_MAP = {0 => :no_action, 1 => :cascade, 2 => :set_null, 3 => :set_default}.freeze
 
       include Sequel::Database::SplitAlterTable
       
@@ -36,6 +37,47 @@ module Sequel
         false
       end
 
+      # Return foreign key information using the system views, including
+      # :name, :on_delete, and :on_update entries in the hashes.
+      def foreign_key_list(table, opts={})
+        m = output_identifier_meth
+        im = input_identifier_meth
+        schema, table = schema_and_table(table)
+        current_schema = m.call(get(Sequel.function('schema_name')))
+        fk_action_map = FOREIGN_KEY_ACTION_MAP
+        ds = metadata_dataset.from(:sys__foreign_keys___fk).
+          join(:sys__foreign_key_columns___fkc, :constraint_object_id => :object_id).
+          join(:sys__all_columns___pc, :object_id => :fkc__parent_object_id,     :column_id => :fkc__parent_column_id).
+          join(:sys__all_columns___rc, :object_id => :fkc__referenced_object_id, :column_id => :fkc__referenced_column_id).
+          where{{object_schema_name(:fk__parent_object_id) => im.call(schema || current_schema)}}.
+          where{{object_name(:fk__parent_object_id) => im.call(table)}}.
+          select{[:fk__name, 
+                  :fk__delete_referential_action, 
+                  :fk__update_referential_action, 
+                  :pc__name___column, 
+                  :rc__name___referenced_column, 
+                  object_schema_name(:fk__referenced_object_id).as(:schema), 
+                  object_name(:fk__referenced_object_id).as(:table)]}.
+          order(:name, :fkc__constraint_column_id)
+        h = {}
+        ds.each do |row|
+          if r = h[row[:name]]
+            r[:columns] << m.call(row[:column])
+            r[:key] << m.call(row[:referenced_column])
+          else
+            referenced_schema = m.call(row[:schema])
+            referenced_table = m.call(row[:table])
+            h[row[:name]] = { :name      => m.call(row[:name]), 
+                              :table     => (referenced_schema == current_schema) ? referenced_table : :"#{referenced_schema}__#{referenced_table}",
+                              :columns   => [m.call(row[:column])], 
+                              :key       => [m.call(row[:referenced_column])], 
+                              :on_update => fk_action_map[row[:update_referential_action]], 
+                              :on_delete => fk_action_map[row[:delete_referential_action]] }
+          end
+        end
+        h.values
+      end
+
       # Use the system tables to get index information
       def indexes(table, opts={})
         m = output_identifier_meth
@@ -203,7 +245,7 @@ module Sequel
         if server_version >= 9000000
           table_name = schema_and_table(table).compact.join('.')
           self[:sys__default_constraints].
-            where{{:parent_object_id => object_id(table_name), col_name(:parent_object_id, :parent_column_id) => column_name.to_s}}.
+            where{{:parent_object_id => Sequel::SQL::Function.new(:object_id, table_name), col_name(:parent_object_id, :parent_column_id) => column_name.to_s}}.
             get(:name)
         end
       end

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

@@ -195,6 +195,7 @@ module Sequel
           opts[:null] = o == :set_column_null ? op[:null] : opts[:allow_null]
           opts[:default] = o == :set_column_default ? op[:default] : opts[:ruby_default]
           opts.delete(:default) if opts[:default] == nil
+          opts.delete(:primary_key)
           "CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(opts))}"
         when :drop_constraint
           type = case op[:type]

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

@@ -56,8 +56,8 @@ module Sequel
           sql = ps.prepared_sql
           synchronize(opts[:server]) do |conn|
             unless conn.prepared_statements[ps_name] == sql
-              conn.prepared_statements[ps_name] = sql
               _execute(conn, "PREPARE #{ps_name} FROM #{literal(sql)}", opts)
+              conn.prepared_statements[ps_name] = sql
             end
             i = 0
             _execute(conn, "SET " + args.map {|arg| "@sequel_arg_#{i+=1} = #{literal(arg)}"}.join(", "), opts) unless args.empty?

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

@@ -97,6 +97,7 @@ module Sequel
       SYSTEM_TABLE_REGEXP = /^pg|sql/.freeze
       FOREIGN_KEY_LIST_ON_DELETE_MAP = {'a'.freeze=>:no_action, 'r'.freeze=>:restrict, 'c'.freeze=>:cascade, 'n'.freeze=>:set_null, 'd'.freeze=>:set_default}.freeze
       POSTGRES_DEFAULT_RE = /\A(?:B?('.*')::[^']+|\((-?\d+(?:\.\d+)?)\))\z/
+      UNLOGGED = 'UNLOGGED '.freeze
 
       # SQL fragment for custom sequences (ones not created by serial primary key),
       # Returning the schema and literal form of the sequence name, by parsing
@@ -634,6 +635,17 @@ module Sequel
         "CREATE SCHEMA #{quote_identifier(name)}"
       end
 
+      # DDL statement for creating a table with the given name, columns, and options
+      def create_table_prefix_sql(name, options)
+        temp_or_unlogged_sql = if options[:temp]
+         raise(Error, "can't provide both :temp and :unlogged to create_table") if options[:unlogged]
+         temporary_table_sql
+       elsif options[:unlogged]
+         UNLOGGED
+       end
+        "CREATE #{temp_or_unlogged_sql}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
+      end
+
       # Use a PostgreSQL-specific create table generator
       def create_table_generator_class
         Postgres::CreateTableGenerator

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

@@ -10,6 +10,12 @@ module Sequel
       TABLES_FILTER = "type = 'table' AND NOT name = 'sqlite_sequence'".freeze
       TEMP_STORE = [:default, :file, :memory].freeze
       VIEWS_FILTER = "type = 'view'".freeze
+      TRANSACTION_MODE = {
+        :deferred => "BEGIN DEFERRED TRANSACTION".freeze,
+        :immediate => "BEGIN IMMEDIATE TRANSACTION".freeze,
+        :exclusive => "BEGIN EXCLUSIVE TRANSACTION".freeze,
+        nil => Sequel::Database::SQL_BEGIN,
+      }.freeze
 
       # Whether to use integers for booleans in the database.  SQLite recommends
       # booleans be stored as integers, but historically Sequel has used 't'/'f'.
@@ -35,6 +41,19 @@ module Sequel
         pragma_set(:case_sensitive_like, !!value ? 'on' : 'off') if sqlite_version >= 30203
       end
 
+      # A symbol signifying the value of the default transaction mode
+      def transaction_mode
+        defined?(@transaction_mode) ? @transaction_mode : (@transaction_mode = nil)
+      end
+
+      def transaction_mode=(value)
+        if TRANSACTION_MODE.include?(value)
+          @transaction_mode = value
+        else
+          raise Error, "Invalid value for transaction_mode.  Please specify one of :deferred, :immediate, :exclusive, nil"
+        end
+      end
+
       # SQLite uses the :sqlite database type.
       def database_type
         :sqlite
@@ -244,6 +263,13 @@ module Sequel
         end
       end
 
+      def begin_new_transaction(conn, opts)
+        mode = opts[:mode] || @transaction_mode
+        sql = TRANSACTION_MODE[mode] or raise Error, "transaction :mode must be one of: :deferred, :immediate, :exclusive, nil"
+        log_connection_execute(conn, sql)
+        set_transaction_isolation(conn, opts)
+      end
+
       # A name to use for the backup table
       def backup_table_name(table, opts={})
         table = table.gsub('`', '')
@@ -258,6 +284,12 @@ module Sequel
         sql << " DEFAULT (#{literal(column[:default])})" if column.include?(:default)
       end
     
+      # Add null/not null SQL fragment to column creation SQL.
+      def column_definition_null_sql(sql, column)
+        column = column.merge(:null=>false) if column[:primary_key]
+        super(sql, column)
+      end
+    
       # Array of PRAGMA SQL statements based on the Database options that should be applied to
       # new connections.
       def connection_pragmas

data/lib/sequel/adapters/sqlite.rb

@@ -117,6 +117,12 @@ module Sequel
         
         db
       end
+
+      # Disconnect given connections from the database.
+      def disconnect_connection(c)
+        c.prepared_statements.each_value{|v| v.first.close}
+        c.close
+      end
       
       # Run the given SQL with the given arguments and yield each row.
       def execute(sql, opts={}, &block)
@@ -244,15 +250,10 @@ module Sequel
         end
       end
       
-      # The main error class that SQLite3 raises
+      # SQLite3 raises ArgumentError in addition to SQLite3::Exception in
+      # some cases, such as operations on a closed database.
       def database_error_classes
-        [SQLite3::Exception]
-      end
-
-      # Disconnect given connections from the database.
-      def disconnect_connection(c)
-        c.prepared_statements.each_value{|v| v.first.close}
-        c.close
+        [SQLite3::Exception, ArgumentError]
       end
     end
     

data/lib/sequel/adapters/swift.rb

@@ -107,15 +107,10 @@ module Sequel
         :execute
       end
       
-      # Close the given database connection.
-      def disconnect_connection(c)
+      def database_error_classes
+        [::Swift::Error]
       end
-      
-      # Execute SQL on the connection
-      def log_connection_execute(conn, sql)
-        log_yield(sql){conn.execute(sql)}
-      end
-      
+
       # Set the :db entry to the same as the :database entry, since
       # Swift uses :db.
       def server_opts(o)

data/lib/sequel/adapters/tinytds.rb

@@ -108,16 +108,16 @@ module Sequel
         [TinyTds::Error]
       end
 
-      # Close the TinyTds::Client object.
-      def disconnect_connection(c)
-        c.close
-      end
-
       # Return true if the :conn argument is present and not active.
       def disconnect_error?(e, opts)
         super || (opts[:conn] && !opts[:conn].active?)
       end
 
+      # Dispose of any possible results of execution.
+      def log_connection_execute(conn, sql)
+        log_yield(sql){conn.execute(sql).each}
+      end
+
       # Return a 2 element array with the literal value and type to use
       # in the prepared statement call for the given value and connection.
       def ps_arg_type(v)

data/lib/sequel/connection_pool.rb

@@ -2,15 +2,13 @@
 # on.  This class is not instantiated directly, but subclasses should at
 # the very least implement the following API:
 #
-# initialize(Hash, &block) :: The +block+ is used as the connection proc,
-#                             which should accept a single symbol argument.
+# initialize(Database, Hash) :: Initialize using the passed Sequel::Database
+#                               object and options hash.
 # hold(Symbol, &block) :: Yield a connection object (obtained from calling
 #                         the block passed to +initialize+) to the current block. For sharded
 #                         connection pools, the Symbol passed is the shard/server to use.
-# disconnect(Symbol, &block) :: Disconnect the connection object.  If a
-#                               block is given, pass the connection option to it, otherwise use the
-#                               <tt>:disconnection_proc</tt> option in the hash passed to initialize.  For sharded
-#                               connection pools, the Symbol passed is the shard/server to use.
+# disconnect(Symbol) :: Disconnect the connection object.  For sharded
+#                       connection pools, the Symbol passed is the shard/server to use.
 # servers :: An array of shard/server symbols for all shards/servers that this
 #            connection pool recognizes.
 # size :: an integer representing the total number of connections in the pool,
@@ -39,13 +37,13 @@ class Sequel::ConnectionPool
     # option is provided is provided, use that pool class, otherwise
     # use a new instance of an appropriate pool subclass based on the
     # <tt>:single_threaded</tt> and <tt>:servers</tt> options.
-    def get_pool(opts = {}, &block)
+    def get_pool(db, opts = {})
       case v = connection_pool_class(opts)
       when Class
-        v.new(opts, &block)
+        v.new(db, opts)
       when Symbol
         Sequel.ts_require("connection_pool/#{v}")
-        connection_pool_class(opts).new(opts, &block) || raise(Sequel::Error, "No connection pool class found")
+        connection_pool_class(opts).new(db, opts) || raise(Sequel::Error, "No connection pool class found")
       end
     end
     
@@ -62,10 +60,9 @@ class Sequel::ConnectionPool
   # connection made, and is usually used to set custom per-connection settings.
   attr_accessor :after_connect
 
-  # The disconnect_proc used for the pool.  This is called with each connection
-  # that is disconnected, usually to clean up related resources.
-  attr_accessor :disconnection_proc
-  
+  # The Sequel::Database object tied to this connection pool.
+  attr_accessor :db
+
   # Instantiates a connection pool with the given options.  The block is called
   # with a single symbol (specifying the server/shard to use) every time a new
   # connection is needed.  The following options are respected for all connection
@@ -73,11 +70,8 @@ class Sequel::ConnectionPool
   # :after_connect :: The proc called after each new connection is made, with the
   #                   connection object, useful for customizations that you want to apply to all
   #                   connections.
-  # :disconnection_proc :: The proc called when removing connections from the pool,
-  #                        which is passed the connection to disconnect.
-  def initialize(opts={}, &block)
-    raise(Sequel::Error, "No connection proc specified") unless @connection_proc = block
-    @disconnection_proc = opts[:disconnection_proc]
+  def initialize(db, opts={})
+    @db = db
     @after_connect = opts[:after_connect]
   end
   
@@ -97,7 +91,7 @@ class Sequel::ConnectionPool
   # and checking for connection errors.
   def make_new(server)
     begin
-      conn = @connection_proc.call(server)
+      conn = @db.connect(server)
       @after_connect.call(conn) if @after_connect
     rescue Exception=>exception
       raise Sequel.convert_exception_class(exception, Sequel::DatabaseConnectionError)

data/lib/sequel/connection_pool/sharded_single.rb

@@ -1,18 +1,15 @@
 # A ShardedSingleConnectionPool is a single threaded connection pool that
 # works with multiple shards/servers.
 class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
-  # Initializes the instance with the supplied block as the connection_proc.
-  #
   # The single threaded pool takes the following options:
   #
   # * :servers - A hash of servers to use.  Keys should be symbols.  If not
-  #   present, will use a single :default server.  The server name symbol will
-  #   be passed to the connection_proc.
+  #   present, will use a single :default server.
   # * :servers_hash - The base hash to use for the servers.  By default,
   #   Sequel uses Hash.new(:default).  You can use a hash with a default proc
   #   that raises an error if you want to catch all cases where a nonexistent
   #   server is used.
-  def initialize(opts={}, &block)
+  def initialize(db, opts={})
     super
     @conns = {}
     @servers = opts.fetch(:servers_hash, Hash.new(:default))
@@ -41,9 +38,8 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   # #hold, the connection is reestablished. Options:
   # * :server - Should be a symbol specifing the server to disconnect from,
   #   or an array of symbols to specify multiple servers.
-  def disconnect(opts={}, &block)
-    block ||= @disconnection_proc
-    (opts[:server] ? Array(opts[:server]) : servers).each{|s| disconnect_server(s, &block)}
+  def disconnect(opts={})
+    (opts[:server] ? Array(opts[:server]) : servers).each{|s| disconnect_server(s)}
   end
   
   # Yields the connection to the supplied block for the given server.
@@ -53,7 +49,7 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
       server = pick_server(server)
       yield(@conns[server] ||= make_new(server))
     rescue Sequel::DatabaseDisconnectError
-      disconnect_server(server, &@disconnection_proc)
+      disconnect_server(server)
       raise
     end
   end
@@ -65,7 +61,7 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   def remove_servers(servers)
     raise(Sequel::Error, "cannot remove default server") if servers.include?(:default)
     servers.each do |server|
-      disconnect_server(server, &@disconnection_proc)
+      disconnect_server(server)
       @servers.delete(server)
     end
   end
@@ -80,12 +76,16 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
     @conns.length
   end
   
+  def pool_type
+    :sharded_single
+  end
+  
   private
   
   # Disconnect from the given server, if connected.
-  def disconnect_server(server, &block)
+  def disconnect_server(server)
     if conn = @conns.delete(server)
-      block.call(conn) if block
+      db.disconnect_connection(conn)
     end
   end