sequel 5.18.0 → 5.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f181e0ec05e457e72b2517202bbd159a6a066c9dd946201de44576b64bca302
-  data.tar.gz: f554f6268798f72c667851c6d952f960564e70ebb1e2d3d1208db74bbcd98834
+  metadata.gz: 96bc5f24c2b61f558037958fedfa152895eaef5e66b50999e7da139763bf0436
+  data.tar.gz: c8376d13d1204c5c2ba969ed18d60c72fdbabd3dd9a7aa8c7729240b33678e84
 SHA512:
-  metadata.gz: 474c441a62bb901abaf12968ec62cdd239f9679ce4cb1743cd58e7ec6032cb1e26d128fd49bbe7c3edfce9a0fb63b33975aa6426ebb8ee79f1309a09967ffef5
-  data.tar.gz: 8717400fcb03235ad51ab208d35e9accca05018c6531da025bbcefb8f4b557345e1afbbfd65862f2c213ca4b05826db72c5ecc6b8abdda5920af83dcd8fe35d9
+  metadata.gz: 1f2153dde7f8e53f24ba06dcb45155ed822d3b2a25485d03dcda52df80e2fa35a0b8f42e08cb2854db838585992226a90830ce4b37ef89939c7cbbffbf308abe
+  data.tar.gz: af2107662ee35e87fa0089f1a66c8e621c5ab738ff53e1a35fbb7572c5137fae4bce53c2b716ec1b72b873a9415a4458eb96dd01e08be421a1b23f7d3fd4d111

data/CHANGELOG

@@ -1,3 +1,19 @@
+=== 5.19.0 (2019-04-02)
+
+* Use more optimized approach to merging hashes in ruby 2.5+ (jeremyevans)
+
+* Use SQLite extended result codes when using ruby-sqlite3 1.4.0+ (jeremyevans)
+
+* Recognize additional SQLite extended result codes in the shared sqlite adapter (jeremyevans)
+
+* Add Database#rename_enum_value to the pg_enum extension (AlexWayfer) (#1603)
+
+* Make Database#drop_table delete constraint validations metadata for that table if using the constraint_validations extension (jeremyevans)
+
+* Speed up row fetching in the sqlite adapter (jeremyevans)
+
+* Speed up row fetching and type conversion in the sqlanywhere adapter (jeremyevans)
+
 === 5.18.0 (2019-03-01)
 
 * Use singleton .call methods on plain objects instead of procs/methods for faster type conversion (jeremyevans)

data/doc/opening_databases.rdoc

@@ -187,9 +187,8 @@ For Derby, H2, HSQLDB, JTDS, MySQL, Postgres, SQLite3
 the adapters can use the `jdbc-*` gem, for the others you need to have the `.jar` in your CLASSPATH
 or load the Java class manually before calling Sequel.connect.
 
-
 Note that when using a JDBC adapter, the best way to use Sequel
-is via Sequel.connect, NOT Sequel.jdbc.  Use the JDBC connection
+is via Sequel.connect using a connection string, NOT Sequel.jdbc.  Use the JDBC connection
 string when connecting, which will be in a different format than
 the native connection string.  The connection string should start
 with 'jdbc:'.  For PostgreSQL, use 'jdbc:postgresql:', and for
@@ -201,6 +200,10 @@ Sequel does no preprocessing of JDBC connection strings, it passes them directly
 So if you have problems getting a connection string to work, look up the 
 documentation for the JDBC driver.
 
+The jdbc adapter does not handle common options such as +:host+,
++:user+, and +:port+.  If you must use a hash of options when connecting,
+provide the full JDBC connection string as the :uri option.
+
 Example connection strings:
 
   jdbc:sqlite::memory:

data/doc/release_notes/5.19.0.txt

@@ -0,0 +1,28 @@
+= New Features
+
+* A Database#rename_enum_value method has been added to the pg_enum
+  extension. It is supported on PostgreSQL 10+:
+
+    DB.rename_enum_value(:enum_type, 'old_name', 'new_name')
+
+= Other Improvements
+
+* The performance of row fetching and type conversion in the
+  sqlanywhere adapter has been improved.
+
+* The performance of row fetching in the sqlite adapter has been
+  improved.
+
+* Calling Database#drop_table now drops any constraint validations
+  metadata for the table if using the constraint_validations
+  extension.  However, modifying the table using Database#alter_table
+  does not affect the constraint validations metadata.
+
+* The sqlite adapter when used with ruby-sqlite3 1.4.0+ now uses
+  SQLite extended result codes for a more accurate determination of
+  specific database errors types.
+
+* Performance for typecasting to decimal and floats has been improved
+  slightly.
+
+* Performance when merging hashes has been improved slightly.

data/doc/sharding.rdoc

@@ -268,3 +268,15 @@ the Database, just remove that option.  If you are setting:
   Sequel.single_threaded = true 
 
 just remove or comment out that code.
+
+== JDBC
+
+If you are using the jdbc adapter, note that it does not handle separate
+options such as +:host+, +:user+, and +:port+.  If you would like to use
+the +:servers+ option when connecting to a JDBC database, each hash value in
+the +servers+ option should contain a +:uri+ key with a JDBC connection string
+for that shard as the value.  Example:
+
+  DB=Sequel.connect('jdbc:postgresql://primary_server/database', 
+    servers: {read_only: {uri: 'jdbc:postgresql://replica_server/database'}})
+

data/lib/sequel/adapters/jdbc.rb

@@ -254,7 +254,9 @@ module Sequel
                 log_connection_yield(sql, conn){stmt.execute(sql)}
               when :insert
                 log_connection_yield(sql, conn){execute_statement_insert(stmt, sql)}
-                last_insert_id(conn, Hash[opts].merge!(:stmt=>stmt))
+                opts = Hash[opts]
+                opts[:stmt] = stmt
+                last_insert_id(conn, opts)
               else
                 log_connection_yield(sql, conn){stmt.executeUpdate(sql)}
               end
@@ -449,7 +451,10 @@ module Sequel
                 log_connection_yield(msg, conn, args){cps.execute}
               when :insert
                 log_connection_yield(msg, conn, args){execute_prepared_statement_insert(cps)}
-                last_insert_id(conn, Hash[opts].merge!(:prepared=>true, :stmt=>cps))
+                opts = Hash[opts]
+                opts[:prepared] = true
+                opts[:stmt] = cps
+                last_insert_id(conn, opts)
               else
                 log_connection_yield(msg, conn, args){cps.executeUpdate}
               end

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

@@ -1733,7 +1733,9 @@ module Sequel
       def _import(columns, values, opts=OPTS)
         if @opts[:returning]
           statements = multi_insert_sql(columns, values)
-          @db.transaction(Hash[opts].merge!(:server=>@opts[:server])) do
+          trans_opts = Hash[opts]
+          trans_opts[:server] = @opts[:server]
+          @db.transaction(trans_opts) do
             statements.map{|st| returning_fetch_rows(st)}
           end.first.map{|v| v.length == 1 ? v.values.first : v}
         elsif opts[:return] == :primary_key

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

@@ -323,7 +323,7 @@ module Sequel
         case sqlite_error_code(exception)
         when 1299
           NotNullConstraintViolation
-        when 2067
+        when 1555, 2067, 2579
           UniqueConstraintViolation
         when 787
           ForeignKeyConstraintViolation
@@ -331,6 +331,8 @@ module Sequel
           CheckConstraintViolation
         when 19
           ConstraintViolation
+        when 517
+          SerializationFailure
         else
           super
         end

data/lib/sequel/adapters/sqlanywhere.rb

@@ -17,21 +17,34 @@ module Sequel
       end
     end
 
-    tt = Class.new do
-      def blob(s) ::Sequel::SQL::Blob.new(s) end
-      def boolean(s) s.to_i != 0 end
-      def date(s) ::Date.strptime(s) end
-      def decimal(s) BigDecimal(s) end
-      def time(s) ::Sequel.string_to_time(s) end
-    end.new
+    boolean = Object.new
+    def boolean.call(s)
+      s.to_i != 0
+    end
+
+    date = Object.new
+    def date.call(s)
+      ::Date.strptime(s)
+    end
+
+    decimal = Object.new
+    class << decimal
+      alias call BigDecimal
+      public :call
+    end
+
+    time = Object.new
+    def time.call(s)
+      ::Sequel.string_to_time(s)
+    end
 
     SQLANYWHERE_TYPES = {}
     {
-        [0, 484] => tt.method(:decimal),
-        [384] => tt.method(:date),
-        [388] =>  tt.method(:time),
-        [500] => tt.method(:boolean),
-        [524, 528] => tt.method(:blob)
+        [0, 484] => decimal,
+        [384] => date,
+        [388] => time,
+        [500] => boolean,
+        [524, 528] => ::Sequel::SQL::Blob
     }.each do |k,v|
       k.each{|n| SQLANYWHERE_TYPES[n] = v}
     end
@@ -153,17 +166,20 @@ module Sequel
             else
               cps[type]
             end
-            col_infos << [i, output_identifier(name), cp]
+            col_infos << [output_identifier(name), cp]
           end
 
-          self.columns = col_infos.map{|a| a[1]}
+          self.columns = col_infos.map(&:first)
+          max = col_infos.length
 
           if rs
             while api.sqlany_fetch_next(rs) == 1
+              i = -1
               h = {}
-              col_infos.each do |i, name, cp|
-                _, v = api.sqlany_get_column(rs, i)
-                h[name] = cp && v ? cp[v] : v
+              while (i+=1) < max
+                name, cp = col_infos[i]
+                v = api.sqlany_get_column(rs, i)[1]
+                h[name] = cp && v ? cp.call(v) : v
               end
               yield h
             end

data/lib/sequel/adapters/sqlite.rb

@@ -5,7 +5,7 @@ require_relative 'shared/sqlite'
 
 module Sequel
   module SQLite
-    FALSE_VALUES = (%w'0 false f no n' + [0]).freeze
+    FALSE_VALUES = (%w'0 false f no n'.each(&:freeze) + [0]).freeze
 
     blob = Object.new
     def blob.call(s)
@@ -77,6 +77,10 @@ module Sequel
       k.each{|n| SQLITE_TYPES[n] = v}
     end
     SQLITE_TYPES.freeze
+
+    sqlite_version = SQLite3::VERSION.split('.').map(&:to_i)[0..1]
+    sqlite_version = sqlite_version[0] * 100 + sqlite_version[1]
+    USE_EXTENDED_RESULT_CODES = sqlite_version >= 104
     
     class Database < Sequel::Database
       include ::Sequel::SQLite::DatabaseMethods
@@ -109,6 +113,10 @@ module Sequel
         sqlite3_opts[:readonly] = typecast_value_boolean(opts[:readonly]) if opts.has_key?(:readonly)
         db = ::SQLite3::Database.new(opts[:database].to_s, sqlite3_opts)
         db.busy_timeout(opts.fetch(:timeout, 5000))
+
+        if USE_EXTENDED_RESULT_CODES
+          db.extended_result_codes = true
+        end
         
         connection_pragmas.each{|s| log_connection_yield(s, db){db.execute_batch(s)}}
         
@@ -279,13 +287,12 @@ module Sequel
         Dataset
       end
 
-      # Support SQLite exception codes if ruby-sqlite3 supports them.
-      # This is disabled by default because ruby-sqlite3 doesn't currently
-      # support them (returning nil), and even if it did, it doesn't support
-      # extended error codes, which would lead to worse behavior.
-      #def sqlite_error_code(exception)
-      #  exception.code if exception.respond_to?(:code)
-      #end
+      if USE_EXTENDED_RESULT_CODES
+        # Support SQLite exception codes if ruby-sqlite3 supports them.
+        def sqlite_error_code(exception)
+          exception.code if exception.respond_to?(:code)
+        end
+      end
     end
     
     class Dataset < Sequel::Dataset
@@ -318,18 +325,18 @@ module Sequel
 
       def fetch_rows(sql)
         execute(sql) do |result|
-          i = -1
           cps = db.conversion_procs
           type_procs = result.types.map{|t| cps[base_type_name(t)]}
-          cols = result.columns.map{|c| i+=1; [output_identifier(c), i, type_procs[i]]}
-          max = i+1
+          j = -1
+          cols = result.columns.map{|c| [output_identifier(c), type_procs[(j+=1)]]}
           self.columns = cols.map(&:first)
+          max = cols.length
           result.each do |values|
             row = {}
             i = -1
             while (i += 1) < max
-              name, id, type_proc = cols[i]
-              v = values[id]
+              name, type_proc = cols[i]
+              v = values[i]
               if type_proc && v
                 v = type_proc.call(v)
               end

data/lib/sequel/connection_pool.rb

@@ -90,11 +90,6 @@ class Sequel::ConnectionPool
   #                   connection object (and server argument if the callable accepts 2 arguments),
   #                   useful for customizations that you want to apply to all connections.
   # :connect_sqls :: An array of sql strings to execute on each new connection, after :after_connect runs.
-  # :preconnect :: Automatically create the maximum number of connections, so that they don't
-  #                need to be created as needed.  This is useful when connecting takes a long time
-  #                and you want to avoid possible latency during runtime.
-  #                Set to :concurrently to create the connections in separate threads. Otherwise
-  #                they'll be created sequentially.
   def initialize(db, opts=OPTS)
     @db = db
     @after_connect = opts[:after_connect]

data/lib/sequel/database/misc.rb

@@ -106,8 +106,11 @@ module Sequel
     # :log_connection_info :: Whether connection information should be logged when logging queries.
     # :log_warn_duration :: The number of elapsed seconds after which queries should be logged at warn level.
     # :name :: A name to use for the Database object, displayed in PoolTimeout .
-    # :preconnect :: Whether to setup the maximum number of connections during initialization.
-    #                Can use a value of 'concurrently' to preconnect in separate threads.
+    # :preconnect :: Automatically create the maximum number of connections, so that they don't
+    #                need to be created as needed.  This is useful when connecting takes a long time
+    #                and you want to avoid possible latency during runtime.
+    #                Set to :concurrently to create the connections in separate threads. Otherwise
+    #                they'll be created sequentially.
     # :preconnect_extensions :: Similar to the :extensions option, but loads the extensions before the
     #                           connections are made by the :preconnect option.
     # :quote_identifiers :: Whether to quote identifiers.
@@ -115,7 +118,9 @@ module Sequel
     # :single_threaded :: Whether to use a single-threaded connection pool.
     # :sql_log_level :: Method to use to log SQL to a logger, :info by default.
     #
-    # All options given are also passed to the connection pool.
+    # All options given are also passed to the connection pool.  Additional options respected by
+    # the connection pool are :after_connect, :connect_sqls, :max_connections, :pool_timeout,
+    # :servers, and :servers_hash.  See the connection pool documentation for details.
     def initialize(opts = OPTS)
       @opts ||= opts
       @opts = connection_pool_default_options.merge(@opts)
@@ -473,9 +478,7 @@ module Sequel
     
     if RUBY_VERSION >= '2.4'
       # Typecast a string to a BigDecimal
-      def _typecast_value_string_to_decimal(value)
-        BigDecimal(value)
-      end
+      alias _typecast_value_string_to_decimal BigDecimal
     else
       # :nocov:
       def _typecast_value_string_to_decimal(value)
@@ -510,9 +513,7 @@ module Sequel
     end
 
     # Typecast the value to a Float
-    def typecast_value_float(value)
-      Float(value)
-    end
+    alias typecast_value_float Float
 
     # Typecast the value to an Integer
     def typecast_value_integer(value)

data/lib/sequel/dataset/actions.rb

@@ -18,7 +18,7 @@ module Sequel
       where_all where_each where_single_value
     METHS
 
-    # The clone options to use when retriveing columns for a dataset.
+    # The clone options to use when retrieving columns for a dataset.
     COLUMNS_CLONE_OPTIONS = {:distinct => nil, :limit => 1, :offset=>nil, :where=>nil, :having=>nil, :order=>nil, :row_proc=>nil, :graph=>nil, :eager_graph=>nil}.freeze
 
     # Inserts the given argument into the database.  Returns self so it
@@ -358,7 +358,7 @@ module Sequel
 
     # Inserts values into the associated table.  The returned value is generally
     # the value of the autoincremented primary key for the inserted row, assuming that
-    # the a single row is inserted and the table has an autoincrementing primary key.
+    # a single row is inserted and the table has an autoincrementing primary key.
     #
     # +insert+ handles a number of different argument formats:
     # no arguments or single empty hash :: Uses DEFAULT VALUES
@@ -486,7 +486,7 @@ module Sequel
       import(columns, hashes.map{|h| columns.map{|c| h[c]}}, opts)
     end
 
-    # Yields each row in the dataset, but interally uses multiple queries as needed to
+    # Yields each row in the dataset, but internally uses multiple queries as needed to
     # process the entire result set without keeping all rows in the dataset in memory,
     # even if the underlying driver buffers all query results in memory.
     #
@@ -512,7 +512,7 @@ module Sequel
     #              NULLs.  Note that some Sequel adapters have optimized implementations that will
     #              use cursors or streaming regardless of the :strategy option used.
     # :filter_values :: If the strategy: :filter option is used, this option should be a proc
-    #                   that accepts the last retreived row for the previous page and an array of
+    #                   that accepts the last retrieved row for the previous page and an array of
     #                   ORDER BY expressions, and returns an array of values relating to those
     #                   expressions for the last retrieved row.  You will need to use this option
     #                   if your ORDER BY expressions are not simple columns, if they contain
@@ -971,7 +971,8 @@ module Sequel
     # separate insert commands for each row.  Otherwise, call #multi_insert_sql
     # and execute each statement it gives separately.
     def _import(columns, values, opts)
-      trans_opts = Hash[opts].merge!(:server=>@opts[:server])
+      trans_opts = Hash[opts]
+      trans_opts[:server] = @opts[:server]
       if opts[:return] == :primary_key
         @db.transaction(trans_opts){values.map{|v| insert(columns, v)}}
       else

data/lib/sequel/dataset/graph.rb

@@ -21,7 +21,7 @@ module Sequel
         raise Error, "cannot call add_graph_aliases on a dataset that has not been called with graph or set_graph_aliases"
       end
       columns, graph_aliases = graph_alias_columns(graph_aliases)
-      select_append(*columns).clone(:graph => Hash[graph].merge!(:column_aliases=>Hash[ga].merge!(graph_aliases).freeze).freeze)
+      select_append(*columns).clone(:graph => graph.merge(:column_aliases=>ga.merge(graph_aliases).freeze).freeze)
     end
 
     # Similar to Dataset#join_table, but uses unambiguous aliases for selected
@@ -244,7 +244,7 @@ module Sequel
     def set_graph_aliases(graph_aliases)
       columns, graph_aliases = graph_alias_columns(graph_aliases)
       if graph = opts[:graph]
-        select(*columns).clone(:graph => Hash[graph].merge!(:column_aliases=>graph_aliases.freeze).freeze)
+        select(*columns).clone(:graph => graph.merge(:column_aliases=>graph_aliases.freeze).freeze)
       else
         raise Error, "cannot call #set_graph_aliases on an ungraphed dataset"
       end

data/lib/sequel/dataset/prepared_statements.rb

@@ -329,7 +329,7 @@ module Sequel
     #   # => {:id=>1}
     def bind(bind_vars=OPTS)
       bind_vars = if bv = @opts[:bind_vars]
-        Hash[bv].merge!(bind_vars).freeze
+        bv.merge(bind_vars).freeze
       else
         if bind_vars.frozen?
           bind_vars

data/lib/sequel/extensions/constraint_validations.rb

@@ -130,6 +130,10 @@
 #   readd all constraints you want to use inside the alter table block,
 #   making no other changes inside the alter_table block.
 #
+# Dropping a table will automatically delete all constraint validations for
+# that table.  However, altering a table (e.g. to drop a column) will not
+# currently make any changes to the constraint validations metadata.
+#
 # Related module: Sequel::ConstraintValidations
 
 #
@@ -264,6 +268,16 @@ module Sequel
       end
     end
 
+    # Drop all constraint validations for a table if dropping the table.
+    def drop_table(*names)
+      names.each do |name|
+        if !name.is_a?(Hash) && table_exists?(constraint_validations_table)
+          drop_constraint_validations_for(:table=>name)
+        end
+      end
+      super
+    end
+
     # Drop the constraint validations table.
     def drop_constraint_validations_table
       drop_table(constraint_validations_table)

data/lib/sequel/extensions/pg_enum.rb

@@ -17,6 +17,12 @@
 #
 #   DB.rename_enum(:enum_type_name, :enum_type_another_name)
 #
+# If you want to rename an enum value, you can use rename_enum_value:
+#
+#   DB.rename_enum_value(
+#     :enum_type_name, :enum_value_name, :enum_value_another_name
+#   )
+#
 # If you want to drop an enum type, you can use drop_enum:
 #
 #   DB.drop_enum(:enum_type_name)
@@ -86,26 +92,24 @@ module Sequel
         elsif v = opts[:after]
           sql << " AFTER #{literal(v.to_s)}"
         end
-        run sql
-        parse_enum_labels
-        nil
+        _process_enum_change_sql(sql)
       end
 
       # Run the SQL to create an enum type with the given name and values.
       def create_enum(enum, values)
-        sql = "CREATE TYPE #{quote_schema_table(enum)} AS ENUM (#{values.map{|v| literal(v.to_s)}.join(', ')})"
-        run sql
-        parse_enum_labels
-        nil
+        _process_enum_change_sql("CREATE TYPE #{quote_schema_table(enum)} AS ENUM (#{values.map{|v| literal(v.to_s)}.join(', ')})")
       end
 
       # Run the SQL to rename the enum type with the given name
       # to the another given name.
       def rename_enum(enum, new_name)
-        sql = "ALTER TYPE #{quote_schema_table(enum)} RENAME TO #{quote_schema_table(new_name)}"
-        run sql
-        parse_enum_labels
-        nil
+        _process_enum_change_sql("ALTER TYPE #{quote_schema_table(enum)} RENAME TO #{quote_schema_table(new_name)}")
+      end
+
+      # Run the SQL to rename the enum value with the given name
+      # to the another given name.
+      def rename_enum_value(enum, old_name, new_name)
+        _process_enum_change_sql("ALTER TYPE #{quote_schema_table(enum)} RENAME VALUE #{literal(old_name.to_s)} TO #{literal(new_name.to_s)}")
       end
 
       # Run the SQL to drop the enum type with the given name.
@@ -113,14 +117,18 @@ module Sequel
       # :if_exists :: Do not raise an error if the enum type does not exist
       # :cascade :: Also drop other objects that depend on the enum type
       def drop_enum(enum, opts=OPTS)
-        sql = "DROP TYPE#{' IF EXISTS' if opts[:if_exists]} #{quote_schema_table(enum)}#{' CASCADE' if opts[:cascade]}"
-        run sql
-        parse_enum_labels
-        nil
+        _process_enum_change_sql("DROP TYPE#{' IF EXISTS' if opts[:if_exists]} #{quote_schema_table(enum)}#{' CASCADE' if opts[:cascade]}")
       end
 
       private
 
+      # Run the SQL on the database, reparsing the enum labels after it is run.
+      def _process_enum_change_sql(sql)
+        run(sql)
+        parse_enum_labels
+        nil
+      end
+
       # Parse the pg_enum table to get enum values, and
       # the pg_type table to get names and array oids for
       # enums.

data/lib/sequel/model/associations.rb

@@ -2129,7 +2129,7 @@ module Sequel
           graph_cks = opts[:graph_keys]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(graph_cks) + conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(graph_cks) + conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
           end
       
           return if opts[:read_only]
@@ -2189,7 +2189,7 @@ module Sequel
           graph_block = opts[:graph_block]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(opts.apply_eager_graph_limit_strategy(eo[:limit_strategy], eager_graph_dataset(opts, eo)), use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds = ds.graph(opts.apply_eager_graph_limit_strategy(eo[:limit_strategy], eager_graph_dataset(opts, eo)), use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
             # We only load reciprocals for one_to_many associations, as other reciprocals don't make sense
             ds.opts[:eager_graph][:reciprocals][eo[:table_alias]] = opts.reciprocal
             ds
@@ -2908,7 +2908,7 @@ module Sequel
         def eager(*associations)
           opts = @opts[:eager]
           association_opts = eager_options_for_associations(associations)
-          opts = opts ? Hash[opts].merge!(association_opts) : association_opts
+          opts = opts ? opts.merge(association_opts) : association_opts
           clone(:eager=>opts.freeze)
         end
 

data/lib/sequel/model/base.rb

@@ -1517,7 +1517,7 @@ module Sequel
       #   # Sequel::Error raised
       def set_fields(hash, fields, opts=nil)
         opts = if opts
-          Hash[model.default_set_fields_options].merge!(opts)
+          model.default_set_fields_options.merge(opts)
         else
           model.default_set_fields_options
         end

data/lib/sequel/plugins/json_serializer.rb

@@ -279,7 +279,7 @@ module Sequel
         #   obj.json_serializer_opts(only: :name)
         #   [obj].to_json # => '[{"name":"..."}]'
         def json_serializer_opts(opts=OPTS)
-          @json_serializer_opts = Hash[@json_serializer_opts||OPTS].merge!(opts)
+          @json_serializer_opts = (@json_serializer_opts||OPTS).merge(opts)
         end
 
         # Return a string in JSON format.  Accepts the following
@@ -301,9 +301,9 @@ module Sequel
         #          use an underscored version of the model's name.
         def to_json(*a)
           opts = model.json_serializer_opts
-          opts = Hash[opts].merge!(@json_serializer_opts) if @json_serializer_opts
+          opts = opts.merge(@json_serializer_opts) if @json_serializer_opts
           if (arg_opts = a.first).is_a?(Hash)
-            opts = Hash[opts].merge!(arg_opts)
+            opts = opts.merge(arg_opts)
             a = []
           end
 

data/lib/sequel/plugins/nested_attributes.rb

@@ -155,7 +155,7 @@ module Sequel
         def set_nested_attributes(assoc, obj, opts=OPTS)
           raise(Error, "no association named #{assoc} for #{model.inspect}") unless ref = model.association_reflection(assoc)
           raise(Error, "nested attributes are not enabled for association #{assoc} for #{model.inspect}") unless meta = ref[:nested_attributes]
-          meta = Hash[meta].merge!(opts)
+          meta = meta.merge(opts)
           meta[:reflection] = ref
           if ref.returns_array?
             nested_attributes_list_setter(meta, obj)

data/lib/sequel/plugins/pg_array_associations.rb

@@ -337,8 +337,10 @@ module Sequel
           end
           opts[:eager_loader] ||= proc do |eo|
             id_map = eo[:id_map]
+            eo = Hash[eo]
+            eo[:loader] = false
 
-            eager_load_results(opts, Hash[eo].merge!(:loader=>false)) do |assoc_record|
+            eager_load_results(opts, eo) do |assoc_record|
               if pks ||= assoc_record.get_column_value(key)
                 pks.each do |pkv|
                   next unless objects = id_map[pkv]
@@ -374,7 +376,7 @@ module Sequel
 
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
             ds
           end
 
@@ -433,7 +435,9 @@ module Sequel
               end
             end
 
-            eager_load_results(opts, Hash[eo].merge!(:id_map=>id_map)) do |assoc_record|
+            eo = Hash[eo]
+            eo[:id_map] = id_map
+            eager_load_results(opts, eo) do |assoc_record|
               if objects = id_map[assoc_record.get_column_value(pkm)]
                 objects.each do |object| 
                   object.associations[name].push(assoc_record)
@@ -466,7 +470,7 @@ module Sequel
 
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
             ds
           end
 

data/lib/sequel/plugins/prepared_statements.rb

@@ -149,7 +149,7 @@ module Sequel
         # Use a prepared statement to update this model's columns in the database.
         def _update_without_checking(columns)
           if use_prepared_statements_for?(:update)
-            _set_prepared_statement_server(model.send(:prepared_update, columns.keys)).call(Hash[columns].merge!(pk_hash))
+            _set_prepared_statement_server(model.send(:prepared_update, columns.keys)).call(columns.merge(pk_hash))
           else
             super
           end

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -67,7 +67,7 @@ module Sequel
         # of free columns.
         def before_create
           if v = model.prepared_statements_column_defaults
-            @values = Hash[v].merge!(values)
+            @values = v.merge(values)
           end
           super
         end

data/lib/sequel/plugins/validation_helpers.rb

@@ -244,7 +244,7 @@ module Sequel
         def validates_unique(*atts)
           opts = default_validation_helpers_options(:unique)
           if atts.last.is_a?(Hash)
-            opts = Hash[opts].merge!(atts.pop)
+            opts = opts.merge(atts.pop)
           end
           message = validation_error_message(opts[:message])
           from_values = opts[:from] == :values
@@ -302,7 +302,7 @@ module Sequel
         # Merge the given options with the default options for the given type
         # and call validatable_attributes with the merged options.
         def validatable_attributes_for_type(type, atts, opts, &block)
-          validatable_attributes(atts, Hash[default_validation_helpers_options(type)].merge!(opts), &block)
+          validatable_attributes(atts, default_validation_helpers_options(type).merge(opts), &block)
         end
         
         # The validation error message to use, as a string.  If message

data/lib/sequel/sql.rb

@@ -1472,7 +1472,7 @@ module Sequel
 
       # Return a new function call with the given opts merged into the current opts.
       def with_opts(opts)
-        self.class.new!(name, args, Hash[@opts].merge!(opts))
+        self.class.new!(name, args, @opts.merge(opts))
       end
     end
 

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 18
+  MINOR = 19
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

data/spec/adapters/postgres_spec.rb

@@ -3930,6 +3930,14 @@ describe 'PostgreSQL enum types' do
     @db.schema(:test_enumt, :reload=>true).first.last[:enum_values].must_equal @initial_enum_values
     @db.rename_enum(:new_enum, :test_enum)
   end
+
+  it "should rename enum values" do
+    @db.rename_enum_value(:test_enum, :b, :x)
+    new_enum_values = @initial_enum_values
+    new_enum_values[new_enum_values.index('b')] = 'x'
+    @db.schema(:test_enumt, :reload=>true).first.last[:enum_values].must_equal new_enum_values
+    @db.rename_enum_value(:test_enum, :x, :b)
+  end if DB.server_version >= 100000
 end
 
 describe "PostgreSQL stored procedures for datasets" do

data/spec/core/schema_spec.rb

@@ -1679,7 +1679,7 @@ describe "Schema Parser" do
     sch = @db.schema(:x)
     sch.must_equal [[:a, {:db_type=>"x", :ruby_default=>nil}], [:b, {:db_type=>"x", :ruby_default=>nil}]]
     sch[0][1][:db_type].must_be_same_as(sch[1][1][:db_type])
-  end if RUBY_VERSION >= '2.5' && !defined?(JRUBY_VERSION)
+  end if RUBY_VERSION >= '2.5'
 
   it "should set :auto_increment to true by default if unset and a single integer primary key is used" do
     @db.define_singleton_method(:schema_parse_table){|*| [[:a, {:primary_key=>true, :db_type=>'integer'}]]}

data/spec/extensions/constraint_validations_spec.rb

@@ -20,6 +20,7 @@ describe "constraint_validations extension" do
   before do
     @db = Sequel.mock
     @db.extend(Module.new{attr_writer :schema; def schema(table, *) execute("parse schema for #{table}"); @schema; end})
+    def @db.table_exists?(_) true; end
     @db.extension(:constraint_validations)
   end
 
@@ -36,13 +37,13 @@ describe "constraint_validations extension" do
 
   it "should allow dropping the sequel_constraint_validations table" do
     @db.drop_constraint_validations_table
-    @db.sqls.must_equal ["DROP TABLE sequel_constraint_validations"]
+    @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE (table = 'sequel_constraint_validations')", "DROP TABLE sequel_constraint_validations"]
   end
 
   it "should allow dropping the sequel_constraint_validations table with a non-default table name" do
     @db.constraint_validations_table = :foo
     @db.drop_constraint_validations_table
-    @db.sqls.must_equal ["DROP TABLE foo"]
+    @db.sqls.must_equal ["DELETE FROM foo WHERE (table = 'foo')", "DROP TABLE foo"]
   end
 
   it "should allow dropping validations for a given table" do
@@ -50,6 +51,23 @@ describe "constraint_validations extension" do
     @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE (table = 'foo')"]
   end
 
+  it "should drop validations for a given table when dropping the table" do
+    @db.drop_table(:foo)
+    @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE (table = 'foo')", "DROP TABLE foo"]
+
+    @db.drop_table(:foo, :if_exists => true)
+    @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE (table = 'foo')", "DROP TABLE IF EXISTS foo"]
+
+    @db.drop_table?(:foo)
+    @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE (table = 'foo')", "DROP TABLE foo"]
+  end
+
+  it "should not drop validations for a given table if the constraint validations table does not exist" do
+    def @db.table_exists?(_) false; end
+    @db.drop_table(:foo)
+    @db.sqls.must_equal ["DROP TABLE foo"]
+  end
+
   it "should allow dropping validations for a given table and column" do
     @db.drop_constraint_validations_for(:table=>:foo, :column=>:bar)
     @db.sqls.must_equal ["DELETE FROM sequel_constraint_validations WHERE ((table = 'foo') AND (column = 'bar'))"]

data/spec/extensions/pg_enum_spec.rb

@@ -49,6 +49,11 @@ describe "pg_enum extension" do
     @db.sqls.first.must_equal "ALTER TYPE sch.foo RENAME TO sch.bar"
   end
 
+  it "should support #rename_enum_value method for renameing an enum value" do
+    @db.rename_enum_value(:foo, :b, :x)
+    @db.sqls.first.must_equal "ALTER TYPE foo RENAME VALUE 'b' TO 'x'"
+  end
+
   it "should support #drop_enum method for dropping an enum" do
     @db.drop_enum(:foo)
     @db.sqls.first.must_equal "DROP TYPE foo"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.18.0
+  version: 5.19.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-01 00:00:00.000000000 Z
+date: 2019-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -202,6 +202,7 @@ extra_rdoc_files:
 - doc/release_notes/5.16.0.txt
 - doc/release_notes/5.17.0.txt
 - doc/release_notes/5.18.0.txt
+- doc/release_notes/5.19.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -290,6 +291,7 @@ files:
 - doc/release_notes/5.16.0.txt
 - doc/release_notes/5.17.0.txt
 - doc/release_notes/5.18.0.txt
+- doc/release_notes/5.19.0.txt
 - doc/release_notes/5.2.0.txt
 - doc/release_notes/5.3.0.txt
 - doc/release_notes/5.4.0.txt
@@ -845,7 +847,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: The Database Toolkit for Ruby