sequel 5.51.0 → 5.56.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebee8a266be02f6ba3c1d5d340b606336dbb0fb74beb4b4333eb3c930cd59b5c
-  data.tar.gz: f657a1aaedf3e0ef8f644097ee94760dfb04381730dd0c6f0a53c57e3f2bc742
+  metadata.gz: 3505371d31fd90d388e3d889117e0dc949e73d41ebd6bee01441be9d061ea33a
+  data.tar.gz: fed52ae3813a0799065e695e90ab95e9633195477d01d1df9de6e6dbddbcaa23
 SHA512:
-  metadata.gz: 9a0aac448e73636a0c20e5e4d87d65ac648a56bb4267034c5b92fdf2cf297aeeaff408dc4e79c6fe05bdd113e22824a5d7bc7a5b236b44346cda6ed427a377c1
-  data.tar.gz: d99a2b488a0735ba9012e4dfcaae30bec76fce1e7d3c34a14be9395241432a3d00ec5fa7a22df371810adf734e0c39230d212934f10a7d39c5839e58231d6625
+  metadata.gz: 6bdd85a8fbd1ba0c0fc871e2e318836e7463d73f9677c0fbba667b6bc86fbe0cb6f0fe09026a39b9b9c79aa783c60f211ffd993b22dff6f9e0d43d3e18754351
+  data.tar.gz: 6ce33f8f9593e7cf73d1322104b7dd362deca59eb6397e7d4ea2705c8bb17d4087453903edd59389181d9829818fd31dc2b990dc77b4c3f3a714b846c8a5db3b

data/CHANGELOG

@@ -1,3 +1,65 @@
+=== 5.56.0 (2022-05-01)
+
+* Make alter_table add_column/add_foreign_key methods support :index option to create an index on the column (jeremyevans)
+
+* Support creation of STRICT tables on SQLite 3.37.0+ via create_table :strict option (jeremyevans)
+
+* Add sqlite_json_ops extension for DSL support for JSON functions and operators added in SQLite 3.38.0 (jeremyevans)
+
+* Recognize "INTEGER" type same as "integer" type in the schema dumper, helpful on SQLite 3.37.0+ (jeremyevans)
+
+=== 5.55.0 (2022-04-01)
+
+* Support :setup_regexp_function Database option in the sqlite adapter to allow the use of regexps when querying (jeremyevans)
+
+* Add auto_restrict_eager_graph plugin for automatically disallow eager_graph with associations needing but lacking graph options (jeremyevans)
+
+* Fix placeholder literalizer optimization for dataset aggregate methods on a model dataset (belousovAV) (#1847, #1848)
+
+=== 5.54.0 (2022-03-01)
+
+* Add enum plugin for treating columns as enums in a model (jeremyevans) (#1839)
+
+=== 5.53.0 (2022-02-01)
+
+* Make Dataset#_sql_comment private when using the Database sql_comments extension (jeremyevans)
+
+* Fix prepared statements in the mysql2 adapter to reuse native prepared statements (jeremyevans) (#1832)
+
+* Support H2 version 2+ in the jdbc/h2 adapter (jeremyevans) (#1817)
+
+* Work around active_support breaking subclasses plugin on Ruby <3.1 (jeremyevans) (#1816)
+
+* Fix error handling if trying to setup column_encryption plugin without keys (jeremyevans) (#1815)
+
+=== 5.52.0 (2022-01-01)
+
+* Use Class#subclasses if available in the subclasses plugin, instead of a custom Model.subclasses accessor (jeremyevans)
+
+* Add Model.descendants and .freeze_descendants to subclasses plugin (jeremyevans)
+
+* Avoid use of deprecated Refinement#include on Ruby 3.1+ (jeremyevans)
+
+* Add date_parse_input_handler extension for custom handling of input to date parsing methods (jeremyevans)
+
+* Make postgres adapter respect Database#default_string_column_size (jeremyevans)
+
+* Make pg_interval extension work with ActiveSupport 7.0 (jeremyevans)
+
+* Make :ruby_default schema entry for type: :datetime respect Sequel.datetime_class (jeremyevans)
+
+* Make alter_table drop_constraint have an effect on MySQL 8.0.19+ (jeremyevans)
+
+* Make mysql adapter support ruby-mysql 3 API (jeremyevans) (#1795)
+
+* Make mysql adapter no longer use connection's server_version, since it isn't accurate when using the ruby-mysql driver (jeremyevans)
+
+* Add sql_comments plugin for automatically including comments on queries generated by model class, instance, and dataset methods (jeremyevans)
+
+* Make sql_comments Database extension support Database#with_comments, for automatically including comments for queries executed inside the block (jeremyevans)
+
+* Fix sql_comments extension to not modify cached SQL for a dataset (jeremyevans)
+
 === 5.51.0 (2021-12-01)
 
 * Make eager loading via tactical_eager_loading no longer modify objects who already have a cached value for the association (jeremyevans)

data/MIT-LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2007-2008 Sharon Rosner
-Copyright (c) 2008-2021 Jeremy Evans
+Copyright (c) 2008-2022 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README.rdoc

@@ -880,6 +880,11 @@ raise an error by default:
     end
   end
 
+== Testing Sequel
+
+Please see the {testing guide}[rdoc-ref:doc/testing.rdoc] for recommendations on testing
+applications that use Sequel, as well as the how to run the tests for Sequel itself.
+
 == Sequel Release Policy
 
 New major versions of Sequel do not have a defined release policy, but historically have

data/doc/opening_databases.rdoc

@@ -249,7 +249,7 @@ jdbc-mysql :: Depending on the configuration of the MySQL server, jdbc-mysql ver
 
 Requires: mysql
 
-The MySQL adapter does not support the pure-ruby mysql.rb driver, it requires the C-extension driver.
+This should work with the mysql gem (C extension) and the ruby-mysql gem (pure ruby).
 
 The following additional options are supported:
 
@@ -383,6 +383,9 @@ The following additional options are supported:
 
 :readonly :: open database in read-only mode
 :timeout :: the busy timeout to use in milliseconds (default: 5000).
+:setup_regexp_function :: Whether to setup a REGEXP function in the underlying SQLite3::Database object. Doing so
+                          allows you to use regexp support in dataset expressions.  Note that this creates a new
+                          Regexp object per call to the function, so it is not an efficient implementation.
 
 Note that SQLite memory databases are restricted to a single connection by
 default.  This is because SQLite does not allow multiple connections to

data/doc/querying.rdoc

@@ -357,7 +357,9 @@ For ranges, Sequel uses a pair of inequality statements:
   # SELECT * FROM artists WHERE ((id >= 1) AND (id < 5))
 
 Finally, for regexps, Sequel uses an SQL regular expression.  Note that this
-is probably only supported on PostgreSQL and MySQL.
+is only supported by default on PostgreSQL and MySQL.  It can also be supported
+on SQLite when using the sqlite adapter with the :setup_regexp_function
+Database option.
 
   Artist.where(name: /JM$/)
   # SELECT * FROM artists WHERE (name ~ 'JM$')

data/doc/release_notes/5.52.0.txt

@@ -0,0 +1,87 @@
+= New Features
+
+* When the sql_comments Database extension is used,
+  Database#with_comments is now added, which can be used for including
+  comments for all queries executed inside a given block.  This can
+  be useful if you want to analyze database query logs, and want to
+  group all related queries:
+
+     DB.with_comments(model: Album, action: :all) do
+       DB[:albums].all
+       # SELECT * FROM albums -- model:Album,action:all
+    end
+
+* An sql_comments plugin has been added, which will automatically
+  add SQL comments for all queries generated by model class, instance
+  and dataset methods:
+
+    Album.plugin :sql_comments
+
+    album = Album[1]
+    # SELECT * FROM albums WHERE (id = 1) LIMIT 1
+    # -- model:Album,method_type:class,method:[]
+
+    album.update(:name=>'A')
+    # UPDATE albums SET name = 'baz' WHERE (id = 1)
+    # -- model:Album,method_type:instance,method:update
+
+    Album.where(id: 1).delete
+    # DELETE FROM albums WHERE (id = 1)
+    # -- model:Album,method_type:dataset,method:delete
+
+  This plugin requires you have loaded the sql_comments Database
+  extension into the related Database before use.
+
+* A date_parse_input_handler extension has been added to support
+  custom handling of input to date parsing methods.  Among other
+  things, you can use this to limit the length of strings that
+  will be parsed, which can prevent ArgumentErrors in newer Ruby
+  versions:
+
+    Sequel.extension :date_parse_input_handler
+    Sequel.date_parse_input_handler do |string|
+      string.b[0, 128]
+    end
+
+= Other Improvements
+
+* On Ruby 3.1, the core_refinements extension now avoids the
+  deprecated Refinement#include, switching to
+  Refinement#import_methods.
+
+* On Ruby 3.1, the subclasses plugin will use Ruby's native support
+  for Class#subclasses.
+
+* The subclasses plugin has renamed descendents to descendants and
+  freeze_descendents to freeze_descendants.  The previous method
+  names are still available as aliases.
+
+* The :ruby_default schema entry for datetime/timestamp columns now
+  respects Sequel.datetime_class.  Previously, the value for the
+  :ruby_default schema entry would always be a DateTime value for
+  such columns.
+
+* The pg_interval extension now works with ActiveSupport 7.0.
+
+* The shared postgres adapter now respects
+  Database#default_string_column_size for setting the size of string
+  columns that don't use text as the database type.
+
+* Database#supports_check_constraints? now returns true on MySQL
+  8.0.19+. This fixes drop_constraint in certain cases when combining
+  the constraint dropping with other changes in the same alter_table
+  block.
+
+* The mysql adapter now supports the ruby-mysql 3 API (ruby-mysql
+  is a pure-ruby MySQL driver).
+
+* The mysql adapter no longer uses the connection's server_version
+  method if it is defined, as the method does not return the
+  correct value when using the ruby-mysql driver with MariaDB.
+
+* Comments added by the sql_comments extension no longer modify
+  cached SQL for a dataset.
+
+= Other
+
+* This is Sequel's 250th release!

data/doc/release_notes/5.53.0.txt

@@ -0,0 +1,23 @@
+= Improvements
+
+* The jdbc/h2 subadapter now supports H2 version 2.0.  It continues to
+  support H2 versions 1.3 and 1.4.
+
+* The mysql2 adapter's prepared statement support now reuses existing
+  native prepared statements, instead of only binding variables on
+  newly prepared statements.  This was the intended behavior
+  previously, and should result in increased performance in cases
+  where preparing a query takes significant time.
+
+* The subclasses plugin now ignores an existing Class#subclasses
+  method if it is defined in Ruby.  This fixes cases where usage of
+  ActiveSupport would break the subclasses plugin.
+
+* Database#call_sproc in the jdbc adapter will now always close the
+  prepared call it creates.  Before, if there was an exception raised
+  when setting the arguments for the prepared call, the prepared call
+  would not be closed.
+
+* A more appropriate error is now issued if you try to use the
+  column_encryption plugin to encrypt a column without setting up an
+  encryption key.

data/doc/release_notes/5.54.0.txt

@@ -0,0 +1,27 @@
+= New Feature
+
+* An enum plugin has been added.  This plugin allows you to create
+  model-level enums, giving names to underlying values of a column.
+  For example:
+
+    Album.plugin :enum
+    Album.enum :status_id, good: 1, bad: 2
+
+  Adds Album#good! and Album#bad! for changing the status_id to 1 or 
+  2 respectively.  It adds Album#good? and Album#bad? for checking
+  whether the status_id is 1 or 2 respectively.  It overrides
+  Album#status_id to return :good or :bad instead of 1 or 2,
+  respectively, and overrides Album#status_id= to accept :good or
+  :bad instead of 1 or 2 respectively.
+
+  Additionally, it adds good and bad dataset methods for filtering
+  the model's dataset to records where status_id is 1 or 2
+  respectively. It also adds not_good and not_bad dataset methods
+  for filtering the model's dataset to records where status_id is not
+  1 or not 2 respectively.
+
+  You can use :prefix and :suffix options when calling enum to
+  add a prefix or suffix to the method names created.  You can
+  set the :override_accessors option to false to not override
+  the accessor methods for the column, and set the :dataset_methods
+  option to false to not add dataset methods.

data/doc/release_notes/5.55.0.txt

@@ -0,0 +1,21 @@
+= New Features
+
+* An auto_restrict_eager_graph plugin has been added for automatically
+  disallowing the use of eager_graph with associations using blocks but
+  lacking graph_* options.  This can prevent potentionally invalid usage,
+  as the restrictions added by the block are not used by eager_graph.
+
+* The sqlite adapter now supports the :setup_regexp_function
+  Database option. This option will define a REGEXP function in the
+  database that will allow regexp support in queries, such as:
+
+    DB[:table].where(column: /(some|pattern)/)
+
+  Note that this creates a Ruby Regexp object per column value tested,
+  so it isn't the most optimal approach. 
+
+= Other Improvements
+
+* Calling dataset aggregate methods such as #max on a model dataset now
+  works correctly. Previously, it could fail if called enough times to
+  optimize using a placeholder literalizer.

data/doc/release_notes/5.56.0.txt

@@ -0,0 +1,51 @@
+= New Features
+
+* On SQLite, Database#create_table now supports a :strict option to
+  use the STRICT keyword when creating the table.  When this option
+  is used, SQLite will enforce the types for each column. When using
+  this option, you are limited to using the following column types:
+  int, integer, real, text, blob, and any (any allows for dynamic
+  types).
+
+* An sqlite_json_ops extension has been added, providing DSL support
+  for JSON functions and operators supported in SQLite 3.38.0. Usage
+  is similar to the pg_json_ops extension.  First, you create an
+  appropriate object:
+
+    j = Sequel.sqlite_json_op(:json_column)
+    # or:
+    j = Sequel[:json_column].sqlite_json_op
+
+  Then, you call methods on that object to create expressions for the
+  JSON functions and operators:
+
+    j[1]                 # (json_column ->> 1)
+    j.get_text(1)        # (json_column -> 1)
+    j.extract('$.a')     # json_extract(json_column, '$.a')
+ 
+    j.array_length       # json_array_length(json_column)
+    j.type               # json_type(json_column)
+    j.valid              # json_valid(json_column)
+    j.json               # json(json_column)
+ 
+    j.insert('$.a', 1)   # json_insert(json_column, '$.a', 1)
+    j.set('$.a', 1)      # json_set(json_column, '$.a', 1)
+    j.replace('$.a', 1)  # json_replace(json_column, '$.a', 1)
+    j.remove('$.a')      # json_remove(json_column, '$.a')
+    j.patch('{"a":2}')   # json_patch(json_column, '{"a":2}')
+ 
+    j.each               # json_each(json_column)
+    j.tree               # json_tree(json_column)
+
+= Other Improvements
+
+* The alter_table add_column and add_foreign_key methods now support
+  the :index option to create an index on the added column, for
+  compatibility with the :index option on the create_table column and
+  foreign_key methods.
+
+* The schema_dumper extension now treats the "INTEGER" type the same
+  as the "integer" type.  This fixes some behavior when using SQLite
+  3.37.0+.
+
+* Sequel's website has a much improved visual design.

data/doc/sql.rdoc

@@ -528,7 +528,7 @@ Inverting the LIKE operator works like other inversions:
 
   ~Sequel.like(:name, 'A%') # ("name" NOT LIKE 'A%' ESCAPE '\')
 
-Sequel also supports SQL regular expressions on MySQL and PostgreSQL.  You can use these by passing a Ruby regular expression to +like+ or +ilike+, or by making the regular expression a hash value:
+Sequel also supports SQL regular expressions on MySQL and PostgreSQL (and SQLite when using the sqlite adapter with the :setup_regexp_function Database option).  You can use these by passing a Ruby regular expression to +like+ or +ilike+, or by making the regular expression a hash value:
 
   Sequel.like(:name, /^A/) # ("name" ~ '^A')
   ~Sequel.ilike(:name, /^A/) # ("name" !~* '^A')

data/doc/testing.rdoc

@@ -113,7 +113,7 @@ The order in which you delete/truncate the tables is important if you are using
 
 = Testing Sequel Itself
 
-Sequel has multiple separate test suites.  All test suites use minitest/spec, with the minitest-hooks and minitest-shared_description extensions.
+Sequel has multiple separate test suites.  All test suites use minitest/spec, with the minitest-hooks, minitest-global_expectations, and minitest-shared_description extensions.  To install the dependencies necessary to test Sequel, run <tt>gem install --development sequel</tt>.
 
 == rake
 
@@ -145,6 +145,8 @@ The <tt>spec_<i>adapter</i></tt> specs run against a real database connection wi
 
 These specs are broken down into two parts.  For each database, there are specific specs that only apply to that database, and these are called the adapter specs.  There are also shared specs that apply to all (or almost all) databases, these are called the integration specs. For database types that don't have specific adapter tests, you can use <tt>rake spec_integration</tt> to just run the shared integration tests.
 
+Each adapter needs a specific gem installed in order to run.  Please see the {connecting to a database guide}[rdoc-ref:doc/opening_databases.rdoc] for which gem you need to install for the adapter you are testing.
+
 == Environment variables
 
 Sequel uses environment variables when testing to specify either the database to be tested or specify how testing should be done.  You can also specify the databases to test by copying <tt>spec/spec_config.rb.example</tt> to <tt>spec/spec_config.rb</tt> and modifying it.  See that file for details.  It may be necessary to use +spec_config.rb+ as opposed to an environment variable if your database connection cannot be specified by a connection string.

data/lib/sequel/adapters/amalgalite.rb

@@ -118,11 +118,9 @@ module Sequel
       # Yield an available connection.  Rescue
       # any Amalgalite::Errors and turn them into DatabaseErrors.
       def _execute(sql, opts)
-        begin
-          synchronize(opts[:server]){|conn| yield conn}
-        rescue ::Amalgalite::Error, ::Amalgalite::SQLite3::Error => e
-          raise_error(e)
-        end
+        synchronize(opts[:server]){|conn| yield conn}
+      rescue ::Amalgalite::Error, ::Amalgalite::SQLite3::Error => e
+        raise_error(e)
       end
       
       # The Amagalite adapter does not need the pool to convert exceptions.

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

@@ -24,6 +24,7 @@ module Sequel
 
         def freeze
           h2_version
+          version2?
           super
         end
 
@@ -140,13 +141,36 @@ module Sequel
           DATABASE_ERROR_REGEXPS
         end
 
-        # Use IDENTITY() to get the last inserted id.
+        def execute_statement_insert(stmt, sql)
+          stmt.executeUpdate(sql, JavaSQL::Statement::RETURN_GENERATED_KEYS)
+        end
+
+        def prepare_jdbc_statement(conn, sql, opts)
+          opts[:type] == :insert ? conn.prepareStatement(sql, JavaSQL::Statement::RETURN_GENERATED_KEYS) : super
+        end
+
+        # Get the last inserted id using getGeneratedKeys, scope_identity, or identity.
         def last_insert_id(conn, opts=OPTS)
-          statement(conn) do |stmt|
-            sql = 'SELECT IDENTITY();'
-            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
-            rs.next
-            rs.getLong(1)
+          if stmt = opts[:stmt]
+            rs = stmt.getGeneratedKeys
+            begin
+              if rs.next
+                begin
+                  rs.getLong(1)
+                rescue
+                  rs.getObject(1) rescue nil
+                end
+              end
+            ensure
+              rs.close
+            end
+          elsif !version2?
+            statement(conn) do |stmt|
+              sql = 'SELECT IDENTITY()'
+              rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
+              rs.next
+              rs.getLong(1)
+            end
           end
         end
         
@@ -161,7 +185,12 @@ module Sequel
 
         # Use BIGINT IDENTITY for identity columns that use :Bignum type
         def type_literal_generic_bignum_symbol(column)
-          column[:identity] ? 'BIGINT IDENTITY' : super
+          column[:identity] ? 'BIGINT AUTO_INCREMENT' : super
+        end
+
+        def version2?
+          return @version2 if defined?(@version2)
+          @version2 = h2_version.to_i >= 2
         end
       end
       
@@ -209,9 +238,21 @@ module Sequel
 
         # H2 expects hexadecimal strings for blob values
         def literal_blob_append(sql, v)
-          sql << "'" << v.unpack("H*").first << "'"
+          if db.send(:version2?)
+            super
+          else
+            sql << "'" << v.unpack("H*").first << "'"
+          end
+        end
+
+        def literal_false
+          'FALSE'
         end
         
+        def literal_true
+          'TRUE'
+        end
+
         # H2 handles fractional seconds in timestamps, but not in times
         def literal_sqltime(v)
           v.strftime("'%H:%M:%S'")
@@ -223,8 +264,12 @@ module Sequel
         end
 
         def select_only_offset_sql(sql)
-          sql << " LIMIT -1 OFFSET "
-          literal_append(sql, @opts[:offset])
+          if db.send(:version2?)
+            super
+          else
+            sql << " LIMIT -1 OFFSET "
+            literal_append(sql, @opts[:offset])
+          end
         end
 
         # H2 supports quoted function names.

data/lib/sequel/adapters/jdbc.rb

@@ -32,15 +32,13 @@ module Sequel
 
     # Allow loading the necessary JDBC support via a gem.
     def self.load_gem(name)
-      begin
-        require "jdbc/#{name.to_s.downcase}"
-      rescue LoadError
-        # jdbc gem not used, hopefully the user has the .jar in their CLASSPATH
-      else
-        if defined?(::Jdbc) && ( ::Jdbc.const_defined?(name) rescue nil )
-          jdbc_module = ::Jdbc.const_get(name) # e.g. Jdbc::SQLite3
-          jdbc_module.load_driver if jdbc_module.respond_to?(:load_driver)
-        end
+      require "jdbc/#{name.to_s.downcase}"
+    rescue LoadError
+      # jdbc gem not used, hopefully the user has the .jar in their CLASSPATH
+    else
+      if defined?(::Jdbc) && ( ::Jdbc.const_defined?(name) rescue nil )
+        jdbc_module = ::Jdbc.const_get(name) # e.g. Jdbc::SQLite3
+        jdbc_module.load_driver if jdbc_module.respond_to?(:load_driver)
       end
     end
 
@@ -190,12 +188,12 @@ module Sequel
         args = opts[:args] || []
         sql = "{call #{name}(#{args.map{'?'}.join(',')})}"
         synchronize(opts[:server]) do |conn|
-          cps = conn.prepareCall(sql)
+          begin
+            cps = conn.prepareCall(sql)
 
-          i = 0
-          args.each{|arg| set_ps_arg(cps, arg, i+=1)}
+            i = 0
+            args.each{|arg| set_ps_arg(cps, arg, i+=1)}
 
-          begin
             if defined?(yield)
               yield log_connection_yield(sql, conn){cps.executeQuery}
             else
@@ -207,7 +205,7 @@ module Sequel
           rescue *DATABASE_ERROR_CLASSES => e
             raise_error(e)
           ensure
-            cps.close
+            cps.close if cps
           end
         end
       end