sequel 5.39.0 → 5.63.0

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/release_notes/5.57.0.txt

@@ -0,0 +1,23 @@
+= New Features
+
+* An is_distinct_from extension has been added with support for the
+  SQL IS DISTINCT FROM operator.  This operator is similar to the
+  not equals operator, except in terms of NULL handling.  It returns
+  true if only one side is NULL, and false if both sides are NULL.
+  You can call is_distinct_from on Sequel itself or on Sequel objects:
+
+    Sequel.is_distinct_from(:column_a, :column_b)
+    Sequel[:column_a].is_distinct_from(:column_b)
+    # (column_a IS DISTINCT FROM column_b)
+
+  On databases not supporting IS DISTINCT FROM, support is emulated
+  using a CASE statement.
+
+* Column definitions on MySQL can use the :on_update_current_timestamp
+  option for ON UPDATE CURRENT_TIMESTAMP, which creates a column that
+  will automatically have its value set to CURRENT_TIMESTAMP on every
+  update.
+
+* Database#create_function on PostgreSQL now supports a :parallel
+  option to set the thread safety of the funciton.  The value should
+  be :safe, :unsafe, or :restricted.

data/doc/release_notes/5.58.0.txt

@@ -0,0 +1,31 @@
+= New Features
+
+* Dataset#merge and related #merge_* methods have been added for the
+  MERGE statement.  MERGE is supported on PostgreSQL 15+, Oracle,
+  Microsoft SQL Server, DB2, H2, HSQLDB, and Derby. You can use MERGE
+  to insert, update, and/or delete in a single query.  You call
+  the #merge_* methods to setup the MERGE statement, and #merge to
+  execute it on the database:
+
+    ds = DB[:m1]
+      merge_using(:m2, i1: :i2).
+      merge_insert(i1: :i2, a: Sequel[:b]+11).
+      merge_delete{a > 30}.
+      merge_update(i1: Sequel[:i1]+:i2+10, a: Sequel[:a]+:b+20)
+
+    ds.merge
+    # MERGE INTO m1 USING m2 ON (i1 = i2)
+    # WHEN NOT MATCHED THEN INSERT (i1, a) VALUES (i2, (b + 11))
+    # WHEN MATCHED AND (a > 30) THEN DELETE
+    # WHEN MATCHED THEN UPDATE SET i1 = (i1 + i2 + 10), a = (a + b + 20)
+
+  On PostgreSQL, the following additional MERGE related methods are
+  available:
+
+  * #merge_do_nothing_when_matched
+  * #merge_do_nothing_when_not_matched
+
+* A :disable_split_materialized Database option is now supported on
+  MySQL. This disables split_materialized support in the optimizer,
+  working around a bug in MariaDB 10.5+ that causes failures in
+  Sequel's association tests.

data/doc/release_notes/5.59.0.txt

@@ -0,0 +1,73 @@
+= New Features
+
+* A require_valid_schema plugin has been added, for checking that
+  model classes have schema parsed as expected.  By default, model
+  classes are not required to have valid schema, because it is
+  allowed to have model classes based on arbitrary datasets (such
+  as those using joins or set-returning functions), and it is not
+  possible to determine the schema for arbitary datasets.
+
+  Sequel swallows non-connection errors when trying to parse schema
+  for a model's dataset, but if schema parsing fails when you would
+  expect it to succeed, it results in a model where typecasting does
+  not work as expected.
+
+  The require_valid_schema plugin will raise an error when setting
+  the dataset for a model if schema parsing fails and the dataset
+  uses a simple table where you would expect schema parsing to
+  succeed.  You can also provide an argument of :warn when loading
+  the plugin, to warn instead of raising an error.
+
+  This plugin may not work correctly in all cases for all adapters,
+  especially external adapters. Adapters are not required to support
+  schema parsing.  Even if supported, adapters may not support
+  parsing schema for qualified tables, or parsing schema for views.
+  You should consider this plugin as a possible safety net.  Users
+  are encouraged to try using it and report any unexpected breakage,
+  as that may help improve schema parsing in adapters that Sequel
+  ships.
+
+* is_json and is_not_json methods have been added to the pg_json_ops
+  extension, for the IS [NOT] JSON operator supported in PostgreSQL
+  15+.
+
+* Index creation methods on PostgreSQL 15+ now support a
+  :nulls_distinct option, for NULLS [NOT] DISTINCT.  This allows you
+  to create unique indexes where NULL values are not considered
+  distinct.
+
+* View creation methods on PostgreSQL 15+ now support a
+  :security_invoker option to create a view where access is
+  determined by the permissions of the role that is accessing the
+  view, instead of the role that created the view.
+
+= Other Improvements
+
+* The :allow_eager association option is now set to false by default
+  for associations explicitly marked as :instance_specific, if the
+  :eager_loader association is not given.
+  
+* The postgres adapter now supports the sequel-postgres-pr driver.
+  The sequel-postgres-pr driver is a slimmed down fork of the
+  postgres-pr driver designed specifically for use by Sequel.
+
+* Model code that explicitly does not swallow connection errors
+  will also now not swallow disconnect errors. This can fix issues
+  where model classes are being loaded at runtime, and the query to
+  get the columns/schema for the model uses a connection that has
+  been disconnected.
+
+* Model classes created from aliased expressions and literal
+  strings no longer use the simple_table optimization, as there
+  are cases where doing so is not safe.
+
+= Backwards Compatibility
+
+* The change to not swallow disconnect errors when not swallowing
+  connection errors can result in exceptions being raised which
+  weren't raised previously.  In most cases, this will alert you
+  to issues in your application that should be fixed, but it
+  potentially it can result in regressions if you were OK with
+  the errors being swallowed.  If this does result in regressions
+  in your application, please file an issue and we can probably
+  add a setting controlling this feature.

data/doc/release_notes/5.60.0.txt

@@ -0,0 +1,22 @@
+= New Features
+
+* The date_arithmetic extension now supports arbitrary expressions
+  as interval values on PostgreSQL 9.4+.  Previously, only integers
+  were supported for the interval values.
+
+= Other Improvements
+
+* Most Kernel#respond_to? calls have been converted to equivalent
+  defined? calls for better performance.  defined? is a keyword
+  and is about 50% faster for the same behavior.
+
+* The is_distinct_from extension now supports the IS DISTINCT FROM
+  syntax natively on SQLite 3.39+, instead of emulating it.
+
+* HAVING without GROUP BY is now supported on SQLite 3.39+.
+
+* Coverage testing has been significantly expanded.  Previously,
+  the core, model, plugin, and extension code had 100% line/branch
+  coverage.  100% line/branch coverage has been added for the
+  core extensions, bin/sequel, and the postgres adapter with the
+  pg driver.

data/doc/release_notes/5.61.0.txt

@@ -0,0 +1,43 @@
+= Improvements
+
+* When typecasting strings to other types, Sequel::Database will now
+  by default not typecast strings that are much longer than expected
+  for the underlying type. Depending on the underlying type, there
+  is a limit of either 100 or 1000 bytes on the input string.  This
+  avoids potential performance issues when trying to convert
+  arbitrary sized user input to specific types.
+
+* The respond_to? to defined? change made in 5.60.0 was reverted in
+  5.60.1 as it broke cases on Ruby < 3 where the object had an unused
+  refinement that added the method.
+
+* When typecasting strings to integer, strings such as -0xa are now
+  treated as negative hexidecimal strings, similar to how 0xa is
+  treated as a positive hexidecimal string.
+
+* Database#foreign_key_list now returns results for partitioned
+  tables on PostgreSQL 11+.
+
+* Timestamps before the date of calendar reform are now handled
+  correctly by the pg_extended_date_support extension when using
+  Ruby 3.2 preview 2+.
+
+= Backwards Compatibility
+
+* The change to not typecast strings that are too long can break
+  backwards compatibility for applications that expect typecasting
+  for input beyond Sequel's limits.  You can disable the string
+  bytesize checking by setting:
+
+    DB.check_string_typecast_bytesize = false
+
+  or by passing the check_string_typecast_bytesize: false option when
+  creating the Database instance.
+
+* Code to workaround a bug in JRuby 9.2.0.0 has been removed from the
+  pg_extended_date_support extension.  Users of the extension should
+  upgrade to a newer JRuby version.
+
+* The is_json and is_not_json methods have been removed from the
+  pg_json_ops extension, as the underlying support was removed in
+  PostgreSQL 15 beta 4.

data/doc/release_notes/5.62.0.txt

@@ -0,0 +1,132 @@
+= New Features
+
+* The pg_auto_parameterize extension for automatically using bound
+  variables when using postgres adapter with the pg driver has been
+  added back to Sequel.  This extension was originally added in Sequel
+  3.34.0, but was removed in 4.0.0 due to the many corner cases it
+  had.  Almost all of the corner cases have now been fixed, and
+  the extension is now recommended for production use.  Compared
+  to the original version in Sequel 3, the reintroduced version
+  of the extension includes the following changes:
+
+  * Handles integers used in LIMIT/ORDER
+  * Respects explicit CASTs
+  * Tries to convert column IN (int, ...) into column = ANY($) with an
+    array parameter
+  * Uses the same parameter for the same object used more than once in
+    a query
+  * Uses parameters when inserting multiple rows via Dataset#import
+  * Supports automatically parameterizing all of the
+    PostgreSQL-specific types that Sequel ships support for in pg_*
+    extensions (though some values of those types may not support
+    automatic parameterization).
+  * Supports skipping auto parameterization for specific values.
+
+  Automatic parameterization is generally slower than Sequel's default
+  behavior, since some optimizations Sequel uses by default do not
+  currently support automatic parameterization.
+
+  Applications may need changes to work correctly with the
+  pg_auto_parameterize extension, such as the addition of explicit
+  casts.  Please read the extension documentation for more details.
+
+* Integer column schema entries now include :min_value and :max_value
+  entries on most databases, indicating the minimum and maximum values
+  supported for the column.
+
+  The validation_helpers plugin now has validates_max_value and
+  validates_min_value for testing the column value is not greater
+  than the given maximum value and not less than the given minimum
+  value, respectively.
+
+  The auto_validations plugin now automatically uses the :min_value
+  and :max_value column schema entries with the new validation_helpers
+  methods to validate that the column values for integer columns are
+  in the allowed range.
+
+* A primary_key_lookup_check_values plugin has been added for
+  automatically typecasting and checking the primary key values are
+  in the allowed range (given by :min_value and :max_value column
+  schema entries) during lookup. If typecasting fails or the value
+  is outside the allowed range, the primary key lookup will return
+  nil without issuing a query (or will raise a NoMatchingRow error
+  if using with_pk!).
+
+  Note that this can change behavior in some cases if you are
+  passing filter conditions during lookup instead of passing primary
+  key values. The plugin tries to support most common filter
+  conditions, but there are still cases that will break.
+
+* Sequel now supports shard-specific :after_connect and :connect_sqls
+  Database options, allowing you to customize behavior for specific
+  shards:
+
+    DB = Sequel.connect('url', servers: {
+        :shard1 => {host: '...', after_connect: proc{|conn|}},
+        :shard2 => {host: '...', connect_sqls: ['...']},
+      })
+
+  Note that these shard-specific options will not be respected if you
+  are calling after_connect= or connect_sqls= on the Database's
+  connection pool.
+
+= Other Improvements
+
+* A Sequel::Postgres::IntegerOutsideBigintRange exception will now be
+  raised if trying to literalize an integer outside PostgreSQL bigint
+  range, to avoid PostgreSQL treating the integer as a numeric type
+  and not respecting indexes on the related column.
+
+  A pg_extended_integer_support extension has been added for
+  customizing the behavior when literalizing an integer outside
+  PostgreSQL bigint range, either quoting it or getting the
+  historical behavior of using it directly in the query.
+
+* Dataset#import and #multi_insert no longer use transactions when
+  they only run a single query.
+
+* Fractional seconds in timestamps are now respected in the
+  named_timezones extension.
+
+* Using hstore[] types as bound variables now works on PostgreSQL.
+
+* Using BC dates and timestamps in bound variables now works on
+  PostgreSQL.
+
+* A corner case has been fixed in eager loading where the window
+  function eager limit strategy would be used without removing the
+  row_number entries from the result.
+
+* The shared postgres adapter now caches reflection datasets, speeding
+  up Database#indexes and similar methods.
+
+* The mock postgres adapter now assumes PostgreSQL 15 instead of
+  PostgreSQL 14 by default.
+
+= Backwards Compatibility
+
+* If you are using Ruby integers outside PostgreSQL bigint range when
+  dealing with PostgreSQL numeric column values, this version may
+  not be compatible.  It is recommended you explicitly convert the
+  Ruby integers to BigDecimal objects if you are using them for
+  numeric column values.  You can also use the
+  pg_extended_integer_support extension introduced in this version.
+
+= Workaround for Older Versions
+
+* If you cannot upgrade to Sequel 5.62.0, but still want to avoid the
+  problems that come from using literal large integers on PostgreSQL,
+  you can use the following code, where DB is your Sequel::Database
+  object:
+
+    DB.extend_datasets do
+      def literal_integer(v)
+        if v > 9223372036854775807 || v < -9223372036854775808
+          raise Sequel::InvalidValue, "PostgreSQL int too large: #{v}"
+        end
+        super
+      end
+    end
+
+  This workaround should work all the way back to Sequel 3.29.0,
+  released in November 2011.

data/doc/release_notes/5.63.0.txt

@@ -0,0 +1,33 @@
+= New Features
+
+* On Ruby 3.2, the pool_class: :timed_queue Database option can now
+  be used to use an alternative connection pool that stores
+  connections in a queue, and uses the new Queue#pop :timeout option
+  in Ruby 3.2 to implement the pool timeout.  This new connection
+  pool is simpler than the default connection pool.  It is not yet
+  the default connection pool on Ruby 3.2, but it may become the
+  default in a later version.  Users of Ruby 3.2 are encouraged to
+  try out the pool_class: :timed_queue Database option and provide
+  feedback on how it works in their application.
+
+= Other Improvements
+
+* The tactical_eager_loading plugin now works in combination with the
+  single_table_inheritance and class_table_inheritance plugins, when
+  loading an association only defined in a specific subclass.
+  Previously, eager loading would be skipped in such a case.  Now,
+  an eager load will be attempted for all instances supporting the
+  association.
+
+* The validate_associated plugin now avoids database type errors for
+  non-integer association keys.  In cases where the associated object
+  doesn't have a value for the associated key, and the current object
+  does not have a key value that can be set in the associated object,
+  validation errors in the associated object related to the associated
+  key will be ignored.
+
+* Thread-keyed connection pool hashes now use compare_by_identity for
+  better performance.
+
+* The JRuby workaround in the named_timezones extension is no longer
+  used on JRuby 9.3.9.0+, as JRuby fixed the related bug.

data/doc/schema_modification.rdoc

@@ -377,7 +377,7 @@ Sequel will not add a column, but will add a composite primary key constraint:
 It is possible to specify a name for the primary key constraint: via the :name option:
 
   alter_table(:albums_artists) do
-    add_primary_key [:album_id, :artist_id], :name=>:albums_artists_pkey
+    add_primary_key [:album_id, :artist_id], name: :albums_artists_pkey
   end
 
 If you just want to take an existing single column and make it a primary key, call

data/doc/security.rdoc

@@ -127,8 +127,8 @@ a ruby string as raw SQL.  For example:
   DB.literal(Date.today) # "'2013-03-22'"
   DB.literal('a') # "'a'"
   DB.literal(Sequel.lit('a')) # "a"
-  DB.literal(:a => 'a') # "(\"a\" = 'a')"
-  DB.literal(:a => Sequel.lit('a')) # "(\"a\" = a)"
+  DB.literal(a: 'a') # "(\"a\" = 'a')"
+  DB.literal(a: Sequel.lit('a')) # "(\"a\" = a)"
 
 ==== SQL Filter Fragments
 
@@ -178,7 +178,7 @@ user input for function names.
 For backwards compatibility, Sequel supports regular strings in the
 window function :frame option, which will be treated as a literal string:
 
-  DB[:table].select{fun(arg).over(:frame=>'SQL Here')}
+  DB[:table].select{fun(arg).over(frame: 'SQL Here')}
 
 You should make sure the frame argument is not derived from user input,
 or switch to using a hash as the :frame option value.
@@ -237,7 +237,7 @@ or:
 
 Instead, you should do:
 
-  DB[:table].update(:column => params[:value].to_s) # Safe
+  DB[:table].update(column: params[:value].to_s) # Safe
 
 Because using the auto_literal_strings extension makes SQL injection
 so much eaiser, it is recommended to not use it, and instead
@@ -402,29 +402,29 @@ This issue isn't necessarily specific to Sequel, but it is a good general practi
 If you are using values derived from user input, it is best to be explicit about
 their type.  For example:
 
-  Album.where(:id=>params[:id])
+  Album.where(id: params[:id])
 
 is probably a bad idea.  Assuming you are using a web framework, <tt>params[:id]</tt> could
 be a string, an array, a hash, nil, or potentially something else.
 
 Assuming that +id+ is an integer field, you probably want to do:
 
-  Album.where(:id=>params[:id].to_i)
+  Album.where(id: params[:id].to_i)
 
 If you are looking something up by name, you should try to enforce the value to be
 a string:
 
-  Album.where(:name=>params[:name].to_s)
+  Album.where(name: params[:name].to_s)
 
 If you are trying to use an IN clause with a list of id values based on input provided
 on a web form:
 
-  Album.where(:id=>params[:ids].to_a.map(&:to_i))
+  Album.where(id: params[:ids].to_a.map(&:to_i))
 
 Basically, be as explicit as possible. While there aren't any known security issues
 in Sequel when you do:
 
-  Album.where(:id=>params[:id])
+  Album.where(id: params[:id])
 
 It allows the attacker to choose to do any of the following queries: