sequel 4.10.0 → 4.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d32a56c879a430a1257dd8e5f13e7346a4fe52bc
-  data.tar.gz: 5dd875255c904b9b4a26e8b62c8beb1e31c20a59
+  metadata.gz: ced6249de982434d96b02340853663f604357771
+  data.tar.gz: 2f34bc5dff2cb2e0ffa1c613252291a52a0b5876
 SHA512:
-  metadata.gz: 1377c4ecd45ba6af86ac084cddcaa444d02055606c4296633edf333f3f67c630d4dbf3283b18eed57a054ef6c017b6aa86424cbe9c0da0de60fe56809a874ca2
-  data.tar.gz: 18257e8bbfae77001b6e94eca09f63615cfcf78169eb98d75fef94bcb8027b90948a44af43389de2e6dd2c0e17ddc70b1b0314df78f487b442bde0fc8b58ede0
+  metadata.gz: 8df573b48f64deb1af7958cdf2d09e75a5f8adb2709519e04f51cabc2b18f7b08e3da857261b0faec876e476b1a3bd961517f82d79bfb33ee9a236dfc066d899
+  data.tar.gz: becb87b9aecc164e06e48a4b5f86eb983ad9e3d09851155f50c935f0e17bccd26d57987dfdcc4635c4531d1cc07a1e753a20998b55c6fa9921e89c58310bc3dd

data/CHANGELOG

@@ -1,3 +1,61 @@
+=== 4.11.0 (2014-06-03)
+
+* Add :model_map option to class_table_inheritance plugin so class names don't need to be stored in the database (jeremyevans)
+
+* Set version when using for MySQL/SQLite emulation in the mock adapter (jeremyevans)
+
+* Add support for CUBRID/SQLAnywhere emulation to the mock adapter (jeremyevans)
+
+* Add support for the jsonb operators added in PostgreSQL 9.4 to the pg_json_ops extension (jeremyevans)
+
+* Add support for new json/jsonb functions added in PostgreSQL 9.4 to the pg_json_ops extension (jeremyevans)
+
+* Add support for the PostgreSQL 9.4+ jsonb type to the pg_json_ops extension (jeremyevans)
+
+* Add support for derived column lists to Sequel.as and SQL::AliasMethods#as (jeremyevans)
+
+* Support connecting to a DB2 catalog name in the ibmdb adapter (calh) (#821)
+
+* Fix warnings in some cases in the ibmdb adapter (calh) (#820)
+
+* Add SQL::Function#with_ordinality for creating set returning functions WITH ORDINALITY (jeremyevans)
+
+* Add SQL::Function#filter for creating filtered aggregate function calls (jeremyevans)
+
+* Add SQL::Function#within_group for creating ordered-set and hypothetical-set aggregate functions (jeremyevans)
+
+* Add SQL::Function#lateral, for creating set returning functions that will be preceded by LATERAL (jeremyevans)
+
+* Add SQL::Function#quoted and #unquoted methods, to enable/disable quoting of function names (jeremyevans)
+
+* Deprecate Dataset#{window,emulated,}_function_sql_append (jeremyevans)
+
+* Deprecate SQL::WindowFunction and SQL::EmulatedFunction classes, switch to using options on SQL::Function (jeremyevans)
+
+* Only modify changed_columns if deserialized value changes in the serialization plugin (jeremyevans) (#818)
+
+* Support PostgreSQL 9.4+ jsonb type in the pg_json extension (jeremyevans)
+
+* Allow Postgres::ArrayOp#unnest to accept arguments in the pg_array_ops extension (jeremyevans)
+
+* Add Postgres::ArrayOp#cardinality to the pg_array_ops extension (jeremyevans)
+
+* Add :check option to Database#create_view for WITH [LOCAL] CHECK OPTION support (jeremyevans)
+
+* Add :concurrently option to Database#refresh_view on PostgreSQL to support concurrent refresh of materialized views (jeremyevans)
+
+* Call the :after_connect Database option proc with both the connection and server/shard if it accepts 2 arguments (pedro, jeremyevans) (#813)
+
+* Make multiple plugins set values before validation instead of before create, works better with auto_validations (jeremyevans)
+
+* Support a default Dataset#import slice size, set to 500 on SQLite (jeremyevans) (#810)
+
+* Make :read_only transaction option be per-savepoint on PostgreSQL (jeremyevans) (#807)
+
+* Add :rank option to Dataset#full_text_search on PostgreSQL, to order by the ranking (jeremyevans) (#809)
+
+* Remove methods deprecated in 4.10.0 (jeremyevans)
+
 === 4.10.0 (2014-05-01)
 
 * Make Model.include API same as Module.include (ged) (#803)

data/doc/association_basics.rdoc

@@ -360,7 +360,7 @@ it can be further filtered, ordered, etc.:
    order(:copies_sold).
    limit(10)
   # SELECT * FROM albums
-  # WHERE ((artist_id = 20) AND (name LIKE 'A%'))
+  # WHERE ((artist_id = 20) AND (name LIKE 'A%' ESCAPE '\'))
   # ORDER BY copies_sold LIMIT 10
 
 Records retrieved using the +_dataset+ method are not cached in the

data/doc/cheat_sheet.rdoc

@@ -216,6 +216,5 @@ Savepoints can be used if the database supports it:
 
   dataset.sql # "SELECT * FROM items"
   dataset.delete_sql # "DELETE FROM items"
-  dataset.where(:name => 'sequel').exists # "EXISTS ( SELECT * FROM items WHERE name = 'sequel' )"
   dataset.columns #=> array of columns in the result set, does a SELECT
   DB.schema(:items) => [[:id, {:type=>:integer, ...}], [:name, {:type=>:string, ...}], ...]

data/doc/core_extensions.rdoc

@@ -164,7 +164,7 @@ Note the reversed order of the arguments.  For the Symbol#qualify method, the ar
 
 Symbol#like returns a case sensitive LIKE expression between the identifier and the given argument:
 
-  :a.like('b%') # SQL: a LIKE 'b%'
+  :a.like('b%') # SQL: a LIKE 'b%' ESCAPE '\'
 
 Alternative: Sequel.like:
 
@@ -174,7 +174,7 @@ Alternative: Sequel.like:
 
 Symbol#ilike returns a case insensitive LIKE expression between the identifier and the given argument:
 
-  :a.ilike('b%') # SQL: a ILIKE 'b%'
+  :a.ilike('b%') # SQL: a ILIKE 'b%' ESCAPE '\'
 
 Alternative: Sequel.ilike:
 

data/doc/dataset_filtering.rdoc

@@ -143,12 +143,12 @@ Or against SQL functions:
 You can search SQL strings in a case sensitive manner using the Sequel.like method:
 
   items.where(Sequel.like(:name, 'Acme%')).sql
-  #=> "SELECT * FROM items WHERE (name LIKE 'Acme%')"
+  #=> "SELECT * FROM items WHERE (name LIKE 'Acme%' ESCAPE '\')"
 
 You can search SQL strings in a case insensitive manner using the Sequel.ilike method:
 
   items.where(Sequel.ilike(:name, 'Acme%')).sql
-  #=> "SELECT * FROM items WHERE (name ILIKE 'Acme%')"
+  #=> "SELECT * FROM items WHERE (name ILIKE 'Acme%' ESCAPE '\')"
 
 You can specify a Regexp as a like argument, but this will probably only work
 on PostgreSQL and MySQL:
@@ -159,19 +159,19 @@ on PostgreSQL and MySQL:
 Like can also take more than one argument:
 
   items.where(Sequel.like(:name, 'Acme%', /Beta.*/)).sql
-  #=> "SELECT * FROM items WHERE ((name LIKE 'Acme%') OR (name ~ 'Beta.*'))"
+  #=> "SELECT * FROM items WHERE ((name LIKE 'Acme%' ESCAPE '\') OR (name ~ 'Beta.*'))"
 
 == String concatenation
 
 You can concatenate SQL strings using Sequel.join: 
 
   items.where(Sequel.join([:name, :comment]).like('%acme%')).sql
-  #=> "SELECT * FROM items WHERE ((name || comment) LIKE 'Acme%')"
+  #=> "SELECT * FROM items WHERE ((name || comment) LIKE 'Acme%' ESCAPE '\')"
 
 Sequel.join also takes a join argument:
 
   items.filter(Sequel.join([:name, :comment], ' ').like('%acme%')).sql
-  #=> "SELECT * FROM items WHERE ((name || ' ' || comment) LIKE 'Acme%')"
+  #=> "SELECT * FROM items WHERE ((name || ' ' || comment) LIKE 'Acme%' ESCAPE '\')"
 
 == Filtering using sub-queries
 

data/doc/model_hooks.rdoc

@@ -81,6 +81,15 @@ If you aren't using transactions when saving or destroying model objects, and th
 
 The purpose of these hooks is dealing with external systems that are interacting with the same database.  For example, let's say you have a model that stores a picture, and you have a background job library that makes thumbnails of all of the pictures.  So when a model object is created, you want to add a background job that will create the thumbnail for the picture.  If you used after_save for this and transactions are being used, you are subject to a race condition where the background job library will check the database table for the record before the transaction that saved the record commits, and it won't be able to see the record's data.  Using after_commit, you are guaranteed that the background job library will not get notified of the record until after the transaction commits and the data is viewable.
 
+Note that when using the after_commit or after_rollback hooks, you don't know whether the saved object was newly created or updated.  If you only want to run an action after commit of a newly created record, you need to use the Database's after_commit inside the model's after_create hook:
+
+  class Album < Sequel::Model
+    def after_create
+      super
+      db.after_commit{update_external_cache}
+    end
+  end
+
 == Running Hooks
 
 Sequel does not provide a simple way to turn off the running of save/create/update hooks.  If you attempt to save a model object, the save hooks are always called.  All model instance methods that modify the database call save in some manner, so you can be sure that if you define the hooks, they will be called when you save the object.

data/doc/object_model.rdoc

@@ -291,12 +291,17 @@ The following shortcuts exist for creating Sequel::SQL::QualifiedIdentifier obje
 Sequel::SQL::AliasedExpression objects represent aliased expressions in SQL.  The alias
 is treated as an identifier, but the expression can be an arbitrary Sequel expression:
 
-  Sequel::SQL::AliasedExpression.new(:column, :alias) # "column" AS "alias"
+  Sequel::SQL::AliasedExpression.new(:column, :alias)
+  # "column" AS "alias"
+
+  Sequel::SQL::AliasedExpression.new(:table, :alias, [:column_alias1, :column_alias2])
+  # "table" AS "alias"("column_alias1", "column_alias2")
 
 The following shortcuts exist for creating Sequel::SQL::AliasedExpression objects:
 
   Sequel.expr(:column___alias)
   Sequel.as(:column, :alias)
+  Sequel.as(:column, :alias, [:column_alias1, :column_alias2])
   :column.as(:alias) # core_extensions extension
   
 === Sequel::SQL::ComplexExpression
@@ -534,7 +539,7 @@ These objects are usually not instantiated manually.  See the
 
 === Sequel::SQL::Window
 
-Sequel::SQL::Window objects represent the windows used by Sequel::SQL::WindowFunction.
+Sequel::SQL::Window objects represent the windows used by Sequel::SQL::Function.
 They use a hash-based API, supporting the :frame, :order, :partition, and :window
 options:
 
@@ -544,17 +549,6 @@ options:
   Sequel::SQL::Window.new(:parition=>:a, :frame=>:all)
   # (PARTITION BY "a" ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
 
-=== Sequel::SQL::WindowFunction
-
-Sequel::SQL::WindowFunction objects represent SQL window function calls.  These
-just combine a Sequel::SQL::Function with a Sequel::SQL::Window:
-
-  function = Sequel::SQL::Function.new(:f, 1)
-  window = Sequel::SQL::Window.new(:order=>:a)
-  Sequel::SQL::WindowFunction.new(function, window) # f(1) OVER (ORDER BY "a")
-
-Virtual rows offer a shortcut for creating Sequel::SQL::Window objects.
-
 === Sequel::SQL::Wrapper
 
 Sequel::SQL::Wrapper objects wrap arbitrary objects so that they can be used

data/doc/opening_databases.rdoc

@@ -78,7 +78,9 @@ These options are shared by all adapters unless otherwise noted.
 
 The following options can be specified and are passed to the database's internal connection pool.
 
-:after_connect :: A proc called after a new connection is made, with the connection object (default: nil)
+:after_connect :: A callable object called after each new connection is made, with the
+                  connection object (and server argument if the callable accepts 2 arguments),
+                  useful for customizations that you want to apply to all connections (default: nil).
 :max_connections :: The maximum size of the connection pool (default: 4 connections on most databases)
 :pool_sleep_time :: The number of seconds to sleep before trying to acquire a connection again (default: 0.001 seconds)
 :pool_timeout :: The number of seconds to wait if a connection cannot be acquired before raising an error (default: 5 seconds)

data/doc/querying.rdoc

@@ -63,7 +63,7 @@ Any options you pass to +first+ will be used as a filter:
   => #<Artist @values={:name=>"YJM", :id=>1}>
   
   artist = Artist.first(Sequel.like(:name, 'Y%'))
-  # SELECT * FROM artists WHERE (name LIKE 'Y%') LIMIT 1
+  # SELECT * FROM artists WHERE (name LIKE 'Y%' ESCAPE '\') LIMIT 1
   => #<Artist @values={:name=>"YJM", :id=>1}>
   
 If there is no matching row, +first+ will return nil.  If you want to
@@ -273,7 +273,7 @@ Let's say we are only interested in the artists whose names
 start with "A":
 
   ds2 = ds1.where(Sequel.like(:name, 'A%'))
-  # SELECT * FROM artists WHERE name LIKE 'A%'
+  # SELECT * FROM artists WHERE name LIKE 'A%' ESCAPE '\'
 
 Here we see that +where+ returns a dataset that adds a +WHERE+
 clause to the query.  It's important to note that +where+ does
@@ -282,7 +282,7 @@ not modify the receiver:
   ds1
   # SELECT * FROM artists
   ds2
-  # SELECT * FROM artists WHERE name LIKE 'A%'
+  # SELECT * FROM artists WHERE name LIKE 'A%' ESCAPE '\'
  
 In Sequel, most dataset methods that you will be using will
 not modify the dataset itself, so you can freely use the dataset in multiple
@@ -293,7 +293,7 @@ Let's say we only want to select the id and name columns, and that
 we want to order by name:
 
   ds3 = ds.order(:name).select(:id, :name)
-  # SELECT id, name FROM artists WHERE name LIKE 'A%' ORDER BY name
+  # SELECT id, name FROM artists WHERE name LIKE 'A%' ESCAPE '\' ORDER BY name
   
 Note how you don't need to assign the returned value of order to a variable,
 and then call select on that.  Because order just returns a dataset, you can
@@ -403,7 +403,7 @@ expressions are instances of subclasses of Sequel::SQL::Expression. You've
 already seen an example earlier:
 
   Artist.where(Sequel.like(:name, 'Y%'))
-  # SELECT * FROM artists WHERE name LIKE 'Y%'
+  # SELECT * FROM artists WHERE name LIKE 'Y%' ESCAPE '\'
 
 In this case Sequel.like returns a Sequel::SQL::BooleanExpression object,
 which is used directly in the filter.
@@ -415,7 +415,7 @@ object.  In most cases, the SQL::Expression returned supports the & operator for
 +AND+, the | operator for +OR+, and the ~ operator for inversion:
 
   Artist.where(Sequel.like(:name, 'Y%') & (Sequel.expr(:b=>1) | Sequel.~(:c=>3)))
-  # SELECT * FROM artists WHERE name LIKE 'Y%' AND (b = 1 OR c != 3)
+  # SELECT * FROM artists WHERE name LIKE 'Y%' ESCAPE '\' AND (b = 1 OR c != 3)
 
 You can combine these expression operators with the virtual row support:
 
@@ -493,7 +493,7 @@ So to do a NOT IN with an array:
 Or to use the NOT LIKE operator:
 
   Artist.exclude(Sequel.like(:name, '%J%'))
-  # SELECT * FROM artists WHERE name NOT LIKE '%J%'
+  # SELECT * FROM artists WHERE name NOT LIKE '%J%' ESCAPE '\'
  
 === Removing
 
@@ -982,7 +982,7 @@ If you just want to know whether the current dataset would return any rows, use
   => true
 
   Album.where(Sequel.like(:name, 'R%')).empty?
-  # SELECT 1 FROM albums WHERE name LIKE 'R%' LIMIT 1
+  # SELECT 1 FROM albums WHERE name LIKE 'R%' ESCAPE '\' LIMIT 1
   => false
 
 == Aggregate Calculations

data/doc/release_notes/4.11.0.txt

@@ -0,0 +1,147 @@
+= New SQL Function Features
+
+* SQL::Function now supports an options hash for functions.
+  Unfortunately, since SQL::Function#initialize does not support
+  an options hash, you need to use SQL::Function.new! to create
+  a function with an options hash.  You can also call methods on
+  the SQL::Function instance, which will return a new SQL::Function
+  with the appropriate option set.
+
+* SQL::Function#quoted has been added, which will return a new
+  SQL::Function instance that will quote the function name (if
+  the database supports quoting function names).
+
+* SQL::Function#unquoted has been added, which will return a new
+  SQL::Function instance that will not quote the function name.
+
+* SQL::Function#lateral has been added, which will return a new
+  SQL::Function instance that will be preceded by LATERAL when
+  literalized, useful for set-returning functions.
+
+* SQL::Function#within_group has been added, for creating
+  ordered-set and hypothetical-set functions that use WITHIN GROUP.
+
+* SQL::Function#filter has been added, for creating filtered
+  aggregate function calls using FILTER.
+
+* SQL::Function#with_ordinality has been added, for creating set
+  returning functions that also include a row number for every
+  row in the set, using WITH ORDINALITY.
+
+= New PostgreSQL Features
+
+* The jsonb type added in 9.4 is now supported in the pg_json
+  extension.  To create a jsonb type manually, you need to call
+  Sequel.pg_jsonb.
+
+  The new json and jsonb functions and operators added in 9.4 are
+  now supported in the pg_json_ops extension.  You can use the jsonb
+  functions and operators by creating a Postgres::JSONBOp using
+  Sequel.pg_jsonb_op.
+
+* Database#full_text_search now takes a :rank option to order by the
+  ranking.
+
+* Database#refresh_view now supports a :concurrently option, to
+  refresh a materialized view concurrently, supported on 9.4+.
+
+* Postgres::ArrayOp#cardinality has been added to the pg_array_ops
+  extension, for easy use of the cardinality method added in 9.4.
+
+* Postgres::ArrayOp#unnest in the pg_array_ops extension now accepts
+  arguments.  PostgreSQL 9.4+ supports this if unnest is used in the
+  FROM clause.
+
+= Other New Features
+
+* Sequel now supports derived column lists (table aliases that include
+  column aliases) via Sequel.as and SQL::AliasedMethods#as:
+
+    Sequel.as(:table, :alias, [:c1, :c2])
+    # table AS alias(c1, c2)
+
+  Not all databases support this, but it is in SQL92 and Sequel now
+  supports it by default.  Derived column lists make it easier to
+  alias columns when using set-returning functions.
+
+  Dataset#from_self now supports derived column lists via the new
+  :column_aliases option (which requires the :alias option to take
+  effect).
+
+* Database#create_view now supports a :check option, to use
+  WITH CHECK OPTION.  You can also use :check=>:local for
+  WITH LOCAL CHECK OPTION.  These clauses make it so when you are
+  inserting into/updating the view, you can only modify rows in the
+  underlying table if the result would be returned by the view.
+
+* The :after_connect Database option proc now can accept two
+  arguments.  If the arity of the proc is 2, Sequel will pass both
+  the connection object and the shard symbol.
+
+* The class_table_inheritance plugin now supports a :model_map
+  option similar to the single_table_inheritance plugin, allowing
+  use of the plugin without storing ruby class names in the database.
+  Note that if you use this option, you must set the correct value
+  for the kind column manually when creating the row.
+
+* Support for CUBRID/SQLAnywhere emulation has been added to the
+  mock adapter.
+
+= Other Improvements
+
+* Dataset#import now supports a default slice size, which Sequel
+  sets to 500 on SQLite as that is the limit that SQLite supports in
+  a single statement.
+
+* The serialization plugin now only modifies changed_columns in the
+  setter method if the deserialized value has changed, similar to
+  how Sequel's standard column setters work.  Note that if you are
+  mutating the deserialized value (i.e. not calling the setter
+  method), you still need to use the
+  serialization_modification_detection plugin.
+
+* Plugins that set column values for new objects before creation now
+  use before_validation instead of before_create, which works better
+  when the auto_validations plugin is used.
+
+* The :read_only transaction option is now applied per-savepoint on
+  PostgreSQL.  Note that this allows you to have a READ ONLY
+  savepoint in a READ WRITE transaction, it does not allow you to
+  have a READ WRITE savepoint in a READ ONLY transaction.
+
+* In the ibm_db adapter, fix warnings when using certain column names.
+
+* Support connecting to a DB2 catalog name in the ibm_db adapter, by
+  providing a :database option without a :host or :port option.
+
+* The mock adapter now sets an emulated version when using MySQL and
+  SQLite.  Additionally, the emulated version for PostgreSQL and
+  Microsoft SQL Server has been updated.
+
+= Backwards Compatibility
+
+* External adapters that override Dataset#as_sql_append now need to
+  have the method accept two arguments.
+
+* Model.eager_loading_dataset, .apply_association_dataset_opts, and
+  .def_{add_method,association_dataset_methods,remove_methods} have
+  been removed (they were deprecated in 4.10.0).
+
+* SQL::WindowFunction and SQL::EmulatedFunction classes are now
+  deprecated, as well as Dataset methods that literalize instances of
+  these classes.  These classes are replaced by using options on
+  SQL::Function instances.
+
+* Passing a table_alias argument when creating an SQL::JoinClause
+  manually is no longer supported.  You now need to pass the table as
+  an SQL::AliasedExpression if the table needs to be aliased.
+  
+* ASTTransformer no longer transforms the table alias for
+  SQL::JoinClause.  This is for consistency with
+  SQL::AliasedExpression.
+
+* SQL standard casts are now used in Database#full_text_search, which
+  can break tests that expect specific SQL.
+
+* The to_dot extension now uses slightly different output for
+  SQL::Function and SQL::JoinClause instances.

data/doc/sql.rdoc

@@ -178,6 +178,10 @@ You can also use the <tt>Sequel.as</tt> method to create an alias, and the +as+
   Sequel.as(:column, :alias) # "column" AS "alias"
   Sequel.qualify(:table, :column).as(:alias) # "table"."column" AS "alias"
 
+If you want to use a derived column list, you can provide an array of column aliases:
+
+  Sequel.as(:table, :alias, [:c1, :c2]) # "table" AS "alias"("c1", "c2")
+
 === Functions
 
 The easiest way to use SQL functions is via a virtual row:
@@ -452,19 +456,19 @@ Just like ruby's <tt>String#join</tt>, you can provide an argument for a string
 
 For the LIKE operator, Sequel defines the +like+ and +ilike+ methods on most Sequel-specific expression objects:
 
-  Sequel.expr(:name).like('A%') # ("name" LIKE 'A%') 
-  Sequel.expr(:name).ilike('A%') # ("name" ILIKE 'A%') 
+  Sequel.expr(:name).like('A%') # ("name" LIKE 'A%' ESCAPE '\') 
+  Sequel.expr(:name).ilike('A%') # ("name" ILIKE 'A%' ESCAPE '\') 
 
 You can also use the <tt>Sequel.like</tt> and <tt>Sequel.ilike</tt> methods:
 
-  Sequel.like(:name, 'A%') # ("name" LIKE 'A%') 
-  Sequel.ilike(:name, 'A%') # ("name" ILIKE 'A%') 
+  Sequel.like(:name, 'A%') # ("name" LIKE 'A%' ESCAPE '\') 
+  Sequel.ilike(:name, 'A%') # ("name" ILIKE 'A%' ESCAPE '\') 
 
 Note the above syntax for ilike, while Sequel's default, is specific to PostgreSQL.  However, most other adapters override the behavior.  For example, on MySQL, Sequel uses LIKE BINARY for +like+, and LIKE for +ilike+.  If the database supports both case sensitive and case insensitive LIKE, then +like+ will use a case sensitive LIKE, and +ilike+ will use a case insensitive LIKE.
 
 Inverting the LIKE operator works like other inversions:
 
-  ~Sequel.like(:name, 'A%') # ("name" NOT LIKE 'A%')
+  ~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:
 
@@ -553,12 +557,12 @@ If you don't want to select from any FROM tables, just call dataset:
 Once you have your dataset object, you build queries by chaining methods, usually with one method per clause in the query:
 
   DB[:albums].select(:id, :name).where(Sequel.like(:name, 'A%')).order(:name)
-  # SELECT id, name FROM albums WHERE (name LIKE 'A%') ORDER BY name
+  # SELECT id, name FROM albums WHERE (name LIKE 'A%' ESCAPE '\') ORDER BY name
 
 Note that the order of your method chain is not usually important unless you have multiple methods that affect the same clause:
 
   DB[:albums].order(:name).where(Sequel.like(:name, 'A%')).select(:id, :name)
-  # SELECT id, name FROM albums WHERE (name LIKE 'A%') ORDER BY name
+  # SELECT id, name FROM albums WHERE (name LIKE 'A%' ESCAPE '\') ORDER BY name
 
 === Using the Same Dataset for SELECT, INSERT, UPDATE, and DELETE