sequel 3.38.0 → 3.39.0

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

@@ -248,6 +248,20 @@ module Sequel
         end
       end
 
+      # Oracle treats empty strings like NULL values, and doesn't support
+      # char_length, so make char_length use length with a nonempty string.
+      # Unfortunately, as Oracle treats the empty string as NULL, there is
+      # no way to get trim to return an empty string instead of nil if
+      # the string only contains spaces.
+      def emulated_function_sql_append(sql, f)
+        case f.f
+        when :char_length
+          literal_append(sql, Sequel::SQL::Function.new(:length, Sequel.join([f.args.first, 'x'])) - 1)
+        else
+          super
+        end
+      end
+      
       # Oracle uses MINUS instead of EXCEPT, and doesn't support EXCEPT ALL
       def except(dataset, opts={})
         opts = {:all=>opts} unless opts.is_a?(Hash)

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

@@ -96,6 +96,7 @@ module Sequel
       RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session|relation "(.*)" does not exist/.freeze
       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/
 
       # SQL fragment for custom sequences (ones not created by serial primary key),
       # Returning the schema and literal form of the sequence name, by parsing
@@ -136,7 +137,7 @@ module Sequel
       SELECT_SERIAL_SEQUENCE_SQL = (<<-end_sql
         SELECT  name.nspname AS "schema", seq.relname AS "sequence"
         FROM pg_class seq, pg_attribute attr, pg_depend dep,
-          pg_namespace name, pg_constraint cons
+          pg_namespace name, pg_constraint cons, pg_class t
         WHERE seq.oid = dep.objid
           AND seq.relnamespace  = name.oid
           AND seq.relkind = 'S'
@@ -144,6 +145,7 @@ module Sequel
           AND attr.attnum = dep.refobjsubid
           AND attr.attrelid = cons.conrelid
           AND attr.attnum = cons.conkey[1]
+          AND attr.attrelid = t.oid
           AND cons.contype = 'p'
       end_sql
       ).strip.gsub(/\s+/, ' ').freeze
@@ -373,30 +375,31 @@ module Sequel
       # Return primary key for the given table.
       def primary_key(table, opts={})
         quoted_table = quote_schema_table(table)
-        @primary_keys.fetch(quoted_table) do
-          schema, table = schema_and_table(table)
-          sql = "#{SELECT_PK_SQL} AND pg_class.relname = #{literal(table)}"
-          sql << "AND pg_namespace.nspname = #{literal(schema)}" if schema
-          @primary_keys[quoted_table] = fetch(sql).single_value
-        end
+        Sequel.synchronize{return @primary_keys[quoted_table] if @primary_keys.has_key?(quoted_table)}
+        schema, table = schema_and_table(table)
+        sql = "#{SELECT_PK_SQL} AND pg_class.relname = #{literal(table)}"
+        sql << " AND pg_namespace.nspname = #{literal(schema)}" if schema
+        value = fetch(sql).single_value
+        Sequel.synchronize{@primary_keys[quoted_table] = value}
       end
 
       # Return the sequence providing the default for the primary key for the given table.
       def primary_key_sequence(table, opts={})
         quoted_table = quote_schema_table(table)
-        @primary_key_sequences.fetch(quoted_table) do
-          schema, table = schema_and_table(table)
-          table = literal(table)
-          sql = "#{SELECT_SERIAL_SEQUENCE_SQL} AND seq.relname = #{table}"
+        Sequel.synchronize{return @primary_key_sequences[quoted_table] if @primary_key_sequences.has_key?(quoted_table)}
+        schema, table = schema_and_table(table)
+        table = literal(table)
+        sql = "#{SELECT_SERIAL_SEQUENCE_SQL} AND t.relname = #{table}"
+        sql << " AND name.nspname = #{literal(schema)}" if schema
+        if pks = fetch(sql).single_record
+          value = literal(SQL::QualifiedIdentifier.new(pks[:schema], pks[:sequence]))
+          Sequel.synchronize{@primary_key_sequences[quoted_table] = value}
+        else
+          sql = "#{SELECT_CUSTOM_SEQUENCE_SQL} AND t.relname = #{table}"
           sql << " AND name.nspname = #{literal(schema)}" if schema
-          unless pks = fetch(sql).single_record
-            sql = "#{SELECT_CUSTOM_SEQUENCE_SQL} AND t.relname = #{table}"
-            sql << " AND name.nspname = #{literal(schema)}" if schema
-            pks = fetch(sql).single_record
-          end
-
-          @primary_key_sequences[quoted_table] = if pks
-            literal(SQL::QualifiedIdentifier.new(pks[:schema], LiteralString.new(pks[:sequence])))
+          if pks = fetch(sql).single_record
+            value = literal(SQL::QualifiedIdentifier.new(pks[:schema], LiteralString.new(pks[:sequence])))
+            Sequel.synchronize{@primary_key_sequences[quoted_table] = value}
           end
         end
       end
@@ -407,7 +410,7 @@ module Sequel
         @conversion_procs = get_conversion_procs
       end
 
-      # Reset the primary key sequence for the given table, baseing it on the
+      # Reset the primary key sequence for the given table, basing it on the
       # maximum current value of the table's primary key.
       def reset_primary_key_sequence(table)
         return unless seq = primary_key_sequence(table)
@@ -513,7 +516,7 @@ module Sequel
       end
     
       # Handle :using option for set_column_type op, and the :validate_constraint op.
-      def alter_table_sql(table, op)
+      def alter_table_op_sql(table, op)
         case op[:op]
         when :set_column_type
           s = super
@@ -524,7 +527,7 @@ module Sequel
           end
           s
         when :validate_constraint
-          "ALTER TABLE #{quote_schema_table(table)} VALIDATE CONSTRAINT #{quote_identifier(op[:name])}"
+          "VALIDATE CONSTRAINT #{quote_identifier(op[:name])}"
         else
           super
         end
@@ -549,6 +552,14 @@ module Sequel
         end
       end
       
+      # Handle PostgreSQL specific default format.
+      def column_schema_normalize_default(default, type)
+        if m = POSTGRES_DEFAULT_RE.match(default)
+          default = m[1] || m[2]
+        end
+        super(default, type)
+      end
+
       # 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={})
@@ -559,6 +570,12 @@ module Sequel
         end
       end
 
+      # PostgreSQL can't combine rename_column operations, and it can combine
+      # the custom validate_constraint operation.
+      def combinable_alter_table_op?(op)
+        (super || op[:op] == :validate_constraint) && op[:op] != :rename_column
+      end
+
       # The SQL queries to execute when starting a new connection.
       def connection_configuration_sqls
         sqls = []
@@ -739,8 +756,10 @@ module Sequel
       # changed.
       def remove_cached_schema(table)
         tab = quote_schema_table(table)
-        @primary_keys.delete(tab)
-        @primary_key_sequences.delete(tab)
+        Sequel.synchronize do
+          @primary_keys.delete(tab)
+          @primary_key_sequences.delete(tab)
+        end
         super
       end
 
@@ -756,6 +775,16 @@ module Sequel
         super && schema[:default] =~ /\Anextval/io
       end
 
+      # Recognize PostgreSQL interval type.
+      def schema_column_type(db_type)
+        case db_type
+        when /\Ainterval\z/io
+          :interval
+        else
+          super
+        end
+      end
+
       # The dataset used for parsing table schemas, using the pg_* system catalogs.
       def schema_parse_table(table_name, opts)
         m = output_identifier_meth(opts[:dataset])
@@ -813,6 +842,11 @@ module Sequel
         "(#{Array(args).map{|a| Array(a).reverse.join(' ')}.join(', ')})"
       end
 
+      # PostgreSQL can combine multiple alter table ops into a single query.
+      def supports_combining_alter_table_ops?
+        true
+      end
+
       # Handle bigserial type if :serial option is present
       def type_literal_generic_bignum(column)
         column[:serial] ? :bigserial : super
@@ -1011,6 +1045,11 @@ module Sequel
         true
       end
 
+      # PostgreSQL supports pattern matching via regular expressions
+      def supports_regexp?
+        true
+      end
+
       # PostgreSQL supports timezones in literal timestamps
       def supports_timestamp_timezones?
         true

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

@@ -232,10 +232,8 @@ module Sequel
             duplicate_table(table){|columns| columns.each{|s| s[:primary_key] = nil}}
           when :foreign_key
             duplicate_table(table, :no_foreign_keys=>true)
-          when :unique
-            duplicate_table(table)
           else
-            raise Error, "Unsupported :type option for drop_constraint: #{op[:type].inspect}"
+            duplicate_table(table)
           end
         when :add_constraint
           duplicate_table(table, :constraints=>[op])
@@ -413,6 +411,7 @@ module Sequel
     module DatasetMethods
       SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct columns from join where group having compounds order limit')
       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}
       EXTRACT_MAP = {:year=>"'%Y'", :month=>"'%m'", :day=>"'%d'", :hour=>"'%H'", :minute=>"'%M'", :second=>"'%f'"}
       NOT_SPACE = Dataset::NOT_SPACE
       COMMA = Dataset::COMMA
@@ -445,13 +444,11 @@ module Sequel
         end
       end
 
-      # SQLite does not support pattern matching via regular expressions.
-      # SQLite is case insensitive (depending on pragma), so use LIKE for
-      # ILIKE.
+      # SQLite is case insensitive (depending on pragma), so use LIKE for ILIKE.
+      # It also doesn't support a NOT LIKE b, you need to use NOT (a LIKE b).
+      # It doesn't support xor or the extract function natively, so those have to be emulated.
       def complex_expression_sql_append(sql, op, args)
         case op
-        when :~, :'!~', :'~*', :'!~*'
-          raise Error, "SQLite does not support pattern matching via regular expressions"
         when :ILIKE
           super(sql, :LIKE, args.map{|a| SQL::Function.new(:upper, a)})
         when :"NOT LIKE", :"NOT ILIKE"
@@ -578,7 +575,7 @@ module Sequel
           col
         end
       end
-      
+
       # SQL fragment specifying a list of identifiers
       def identifier_list(columns)
         columns.map{|i| quote_identifier(i)}.join(COMMA)

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -221,10 +221,15 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     if @connections_to_remove.include?(conn)
       remove(thread, conn, server)
     else
-      if @queue
-        available_connections(server).unshift(allocated(server).delete(thread))
+      conn = allocated(server).delete(thread)
+
+      case @connection_handling
+      when :queue
+        available_connections(server).unshift(conn)
+      when :disconnect
+        @disconnection_proc.call(conn) if @disconnection_proc
       else
-        available_connections(server) << allocated(server).delete(thread)
+        available_connections(server) << conn
       end
     end
   end

data/lib/sequel/connection_pool/threaded.rb

@@ -27,7 +27,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     @max_size = Integer(opts[:max_connections] || 4)
     raise(Sequel::Error, ':max_connections must be positive') if @max_size < 1
     @mutex = Mutex.new  
-    @queue = opts[:connection_handling] == :queue
+    @connection_handling = opts[:connection_handling]
     @available_connections = []
     @allocated = {}
     @timeout = Integer(opts[:pool_timeout] || 5)
@@ -157,10 +157,15 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   # Releases the connection assigned to the supplied thread back to the pool.
   # The calling code should already have the mutex before calling this.
   def release(thread)
-    if @queue
-      @available_connections.unshift(@allocated.delete(thread))
+    conn = @allocated.delete(thread)
+
+    case @connection_handling
+    when :queue
+      @available_connections.unshift(conn)
+    when :disconnect
+      @disconnection_proc.call(conn) if @disconnection_proc
     else
-      @available_connections << @allocated.delete(thread)
+      @available_connections << conn
     end
   end
 

data/lib/sequel/database/query.rb

@@ -21,10 +21,10 @@ module Sequel
       :repeatable=>'REPEATABLE READ'.freeze,
       :serializable=>'SERIALIZABLE'.freeze}
     
-    POSTGRES_DEFAULT_RE = /\A(?:B?('.*')::[^']+|\((-?\d+(?:\.\d+)?)\))\z/
-    MSSQL_DEFAULT_RE = /\A(?:\(N?('.*')\)|\(\((-?\d+(?:\.\d+)?)\)\))\z/
-    MYSQL_TIMESTAMP_RE = /\ACURRENT_(?:DATE|TIMESTAMP)?\z/
     STRING_DEFAULT_RE = /\A'(.*)'\z/
+    CURRENT_TIMESTAMP_RE = /now|CURRENT|getdate/io
+    COLUMN_SCHEMA_DATETIME_TYPES = [:date, :datetime]
+    COLUMN_SCHEMA_STRING_TYPES = [:string, :blob, :date, :datetime, :time, :enum, :set, :interval]
 
     # The prepared statement object hash for this database, keyed by name symbol
     attr_reader :prepared_statements
@@ -390,56 +390,70 @@ module Sequel
       SQL_BEGIN
     end
 
+    # Whether the type should be treated as a string type when parsing the
+    # column schema default value.
+    def column_schema_default_string_type?(type)
+      COLUMN_SCHEMA_STRING_TYPES.include?(type)
+    end
+
+    # Transform the given normalized default string into a ruby object for the
+    # given type.
+    def column_schema_default_to_ruby_value(default, type)
+      case type
+      when :boolean
+        case default 
+        when /[f0]/i
+          false
+        when /[t1]/i
+          true
+        end
+      when :string, :enum, :set, :interval
+        default
+      when :blob
+        Sequel::SQL::Blob.new(default)
+      when :integer
+        Integer(default)
+      when :float
+        Float(default)
+      when :date
+        Sequel.string_to_date(default)
+      when :datetime
+        DateTime.parse(default)
+      when :time
+        Sequel.string_to_time(default)
+      when :decimal
+        BigDecimal.new(default)
+      end
+    end
+   
+    # Normalize the default value string for the given type
+    # and return the normalized value.
+    def column_schema_normalize_default(default, type)
+      if column_schema_default_string_type?(type)
+        return unless m = STRING_DEFAULT_RE.match(default)
+        m[1].gsub("''", "'")
+      else
+        default
+      end
+    end
+
     # Convert the given default, which should be a database specific string, into
     # a ruby object.
     def column_schema_to_ruby_default(default, type)
       return if default.nil?
-      orig_default = default
-      if database_type == :postgres and m = POSTGRES_DEFAULT_RE.match(default)
-        default = m[1] || m[2]
-      end
-      if database_type == :mssql and m = MSSQL_DEFAULT_RE.match(default)
-        default = m[1] || m[2]
-      end
-      if [:string, :blob, :date, :datetime, :time, :enum].include?(type)
-        if database_type == :mysql
-          return if [:date, :datetime, :time].include?(type) && MYSQL_TIMESTAMP_RE.match(default)
-          orig_default = default = "'#{default.gsub("'", "''").gsub('\\', '\\\\')}'"
-        end
-        return unless m = STRING_DEFAULT_RE.match(default)
-        default = m[1].gsub("''", "'")
-      end
-      res = begin
-        case type
-        when :boolean
-          case default 
-          when /[f0]/i
-            false
-          when /[t1]/i
-            true
+      if COLUMN_SCHEMA_DATETIME_TYPES.include?(type)
+        if CURRENT_TIMESTAMP_RE.match(default)
+          if type == :date
+            return Sequel::CURRENT_DATE
+          else
+            return Sequel::CURRENT_TIMESTAMP
           end
-        when :string, :enum
-          default
-        when :blob
-          Sequel::SQL::Blob.new(default)
-        when :integer
-          Integer(default)
-        when :float
-          Float(default)
-        when :date
-          Sequel.string_to_date(default)
-        when :datetime
-          DateTime.parse(default)
-        when :time
-          Sequel.string_to_time(default)
-        when :decimal
-          BigDecimal.new(default)
         end
-      rescue
-        nil
       end
+      default = column_schema_normalize_default(default, type)
+      column_schema_default_to_ruby_value(default, type) rescue nil
     end
-   
+
     if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or RUBY_ENGINE == 'rbx') and RUBY_VERSION < '1.9'
       # Whether to commit the current transaction. On ruby 1.8 and rubinius,
       # Thread.current.status is checked because Thread#kill skips rescue
@@ -568,15 +582,13 @@ module Sequel
     # such as :integer or :string.
     def schema_column_type(db_type)
       case db_type
-      when /\Ainterval\z/io
-        :interval
       when /\A(character( varying)?|n?(var)?char|n?text)/io
         :string
       when /\A(int(eger)?|(big|small|tiny)int)/io
         :integer
       when /\Adate\z/io
         :date
-      when /\A((small)?datetime|timestamp( with(out)? time zone)?)\z/io
+      when /\A((small)?datetime|timestamp( with(out)? time zone)?)(\(\d+\))?\z/io
         :datetime
       when /\Atime( with(out)? time zone)?\z/io
         :time

data/lib/sequel/database/schema_generator.rb

@@ -13,7 +13,7 @@ module Sequel
     # the column method, which makes for a nicer DSL.
     #
     # For more information on Sequel's support for schema modification, see
-    # the {"Migrations and Schema Modification" guide}[link:files/doc/migration_rdoc.html].
+    # the {"Schema Modification" guide}[link:files/doc/schema_modification_rdoc.html].
     class CreateTableGenerator
       # Classes specifying generic types that Sequel will convert to database-specific types.
       GENERIC_TYPES=[String, Integer, Fixnum, Bignum, Float, Numeric, BigDecimal,
@@ -270,7 +270,7 @@ module Sequel
     # alter a table's description.
     #
     # For more information on Sequel's support for schema modification, see
-    # the {"Migrations and Schema Modification" guide}[link:files/doc/migration_rdoc.html].
+    # the {"Schema Modification" guide}[link:files/doc/schema_modification_rdoc.html].
     class AlterTableGenerator
       # An array of DDL operations to perform
       attr_reader :operations
@@ -294,7 +294,7 @@ module Sequel
       # Add a constraint with the given name and args to the DDL for the table.
       # See CreateTableGenerator#constraint.
       #
-      #   add_constraint(:valid_name, :name.like('A%'))
+      #   add_constraint(:valid_name, Sequel.like(:name, 'A%'))
       #   # ADD CONSTRAINT valid_name CHECK (name LIKE 'A%')
       def add_constraint(name, *args, &block)
         @operations << {:op => :add_constraint, :name => name, :type => :check, :check => block || args}
@@ -430,13 +430,20 @@ module Sequel
         @operations << {:op => :set_column_type, :name => name, :type => type}.merge(opts)
       end
       
-      # Modify a column's NOT NULL constraint.
+      # Set a given column as allowing NULL values.
       #
-      #   set_column_allow_null(:artist_name, false) # ALTER COLUMN artist_name SET NOT NULL
-      def set_column_allow_null(name, allow_null)
+      #   set_column_allow_null(:artist_name) # ALTER COLUMN artist_name DROP NOT NULL
+      def set_column_allow_null(name, allow_null=true)
         @operations << {:op => :set_column_null, :name => name, :null => allow_null}
       end
 
+      # Set a given column as not allowing NULL values.
+      #
+      #   set_column_not_null(:artist_name) # ALTER COLUMN artist_name SET NOT NULL
+      def set_column_not_null(name)
+        set_column_allow_null(name, false)
+      end
+
       private
 
       # Add a composite primary key constraint