sequel 3.21.0 → 3.41.0

data/doc/sharding.rdoc

@@ -8,9 +8,25 @@ that ship with Sequel.
 
 == The :servers Database option
 
-Both features use the :servers Database option.  The :servers option should
-be a hash with symbol keys and values that are either hashes or procs that
-return hashes.  Note that all servers should have the same schema for all
+Sharding and read_only support are both enabled via the :servers database
+option.  Using the :servers database option makes Sequel use a connection pool
+class that supports sharding, and the minimum required to enable sharding
+support is to use the empty hash:
+
+  DB=Sequel.connect('postgres://master_server/database', :servers=>{})
+
+In most cases, you are probably not going to want to use an empty hash,
+so you'll want to have entries in the hash.  Keys in the server hash are
+not restricted to type, but the general recommendation is to use a symbol
+unless you have special requirements. Values in the server hash should be
+either hashes or procs that return hashes. These hashes are merged into
+the Database object's default options hash to get the connection options
+for the shard, so you don't need to override all options, just the ones
+that need to be modified.  For example, if you are using the same user,
+password, and database name and just the host is changing, you only need
+a :host entry in each shard's hash.
+
+Note that all servers should have the same schema for all
 tables you are accessing, unless you really know what you are doing.
 
 == Master and Slave Database Configurations
@@ -93,7 +109,7 @@ schemas, so you should always have a default server that works.
 
 To set the shard for a given query, you use the Dataset#server method:
 
-  DB[:hashes].server(:a).filter(:hash=>/31337/)
+  DB[:hashes].server(:a).where(:hash=>/31337/)
   
 That will return all matching rows on the hash_host_a shard that have a hash
 column that contains 31337.
@@ -103,10 +119,11 @@ work, you might want to add a method to the dataset that automatically sets
 the shard to use.  This is fairly easy using a Sequel::Model:
 
   class Rainbow < Sequel::Model(:hashes)
-    def_dataset_method(:plaintext_for_hash) do |hash|
-      raise(ArgumentError, 'Invalid SHA-1 Hash') unless /\A[0-9a-f]{40}\z/.match(hash)
-      row = self.server(hash[0...1].to_sym).first(:hash=>hash)
-      row[:plaintext] if row
+    dataset_module do
+      def plaintext_for_hash(hash)
+        raise(ArgumentError, 'Invalid SHA-1 Hash') unless /\A[0-9a-f]{40}\z/.match(hash)
+        server(hash[0...1].to_sym).where(:hash=>hash).get(:plaintext)
+      end
     end
   end
   
@@ -153,3 +170,77 @@ work well with shards.  You just need to remember to set to model to use the plu
 If all of your models are sharded, you can set all models to use the plugin via:
 
   Sequel::Model.plugin :sharding
+
+=== server_block Extension
+
+By default, you must specify the server/shard you want to use for every dataset/action,
+or Sequel will use the default shard.  If you have a group of queries that should use the
+same shard, it can get a bit redundent to specify the same shard for all of them.
+
+The server_block extension adds a Database#with_server method that scopes all database
+access inside the block to the given shard by default:
+
+  DB.extension :server_block
+  DB.with_server(:a) do
+    # this SELECT query uses the "a" shard
+    if r = Rainbow.first(:hash=>/31337/)
+      r.count += 1
+      # this UPDATE query also uses the "a" shard
+      r.save
+    end
+  end
+
+The server_block extension doesn't currently integrate with the sharding plugin, as it
+ties into the Dataset#server method.  This shouldn't present a problem in practice as
+long as you just access the models inside the with_server block, since they will use
+the shard set by with_server by default.  However, you will probably have issues if
+you retrieve the models inside the block and save them outside of the block.  If you
+need to do that, call the server method explicitly on the dataset used to retrieve the
+model objects.
+
+=== arbitrary_servers Extension
+
+By default, Sequel's sharding support is designed to work with predefined shards.  It ships
+with Database#add_servers and Database#remove_servers methods to modify these predefined
+shards on the fly, but it is a bit cumbersome to work with truly arbitrary servers
+(requiring you to call add_servers before use, then remove_servers after use).
+
+The arbitrary_servers extension allows you to pass a server/shard options hash as the
+server to use, and those options will be merged directly into the database's default options:
+
+  DB.extension :arbitrary_servers
+  DB[:rainbows].server(:host=>'hash_host_a').all
+  # or
+  DB[:rainbows].server(:host=>'hash_host_b', :database=>'backup').all
+
+arbitrary_servers is designed to work well in conjunction with the server_block extension:
+
+  DB.with_server(:host=>'hash_host_b', :database=>'backup') do
+    DB.synchronize do
+      # All queries here default to the backup database on hash_host_b
+    end
+  end
+
+If you are using arbitrary_servers with server_block, you may want to
+define the following method (or something similar) so that you don't
+need to call synchronize separately:
+
+  def DB.with_server(*)
+    super{synchronize{yield}}
+  end
+
+The reason for the synchronize method is that it checks out a connection
+and makes the same connection available for the duration of the block.
+If you don't do that, Sequel will probably disconnect from the database
+and reconnect to the database on each request, since connections to
+arbitrary servers are not cached.
+
+Note that this extension only works with the sharded threaded connection
+pool.  If you are using the sharded single connection pool, you need
+to switch to the sharded threaded connection pool before using this
+extension.  If you are passing the :single_threaded option to
+the Database, just remove that option.  If you are setting:
+
+  Sequel.single_threaded = true 
+
+just remove or comment out that code.

data/doc/sql.rdoc

@@ -73,10 +73,14 @@ You can also use <tt>Database#<<</tt>:
 
 === Other Places
 
-Almost everywhere in Sequel, you can drop down to literal SQL by providing a literal string, which you can create with <tt>String#lit</tt>:
+Almost everywhere in Sequel, you can drop down to literal SQL by providing a literal string, which you can create with <tt>Sequel.lit</tt>:
 
   DB[:albums].select('name') # SELECT 'name' FROM albums
-  DB[:albums].select('name'.lit) # SELECT name FROM albums
+  DB[:albums].select(Sequel.lit('name')) # SELECT name FROM albums
+
+For a simpler way of creating literal strings, you can also use the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html], which adds the <tt>String#lit</tt> method, and other methods that integrate Sequel's DSL with the ruby language:
+
+  DB[:albums].select('name'.lit)
 
 So you can use Sequel's DSL everywhere you find it helpful, and fallback to literal SQL if the DSL can't do what you want or you just find literal SQL easier.
 
@@ -129,9 +133,9 @@ Also note that specifying the period inside the symbol doesn't work if you are q
 
   :"table.column" # "table.column"
 
-The other way to qualify an identifier is to use the +qualify+ method on the column symbol with the table symbol:
+The other way to qualify an identifier is to use the <tt>Sequel.qualify</tt> with the table and column symbols:
 
-  :column.qualify(:table) # "table"."column"
+  Sequel.qualify(:table, :column) # "table"."column"
 
 Another way to generate identifiers is to use Sequel's {virtual row support}[link:files/doc/virtual_rows_rdoc.html]:
 
@@ -169,37 +173,37 @@ You can combine this with implicit qualification:
 
   :table__column___alias # "table"."column" AS "alias"
 
-You can also use the +as+ method on symbols and most Sequel-specific expression objects:
+You can also use the <tt>Sequel.as</tt> method to create an alias, and the +as+ method on most Sequel-specific expression objects:
 
-  :column.as(:alias) # "column" AS "alias"
-  :column.qualify(:table).as(:alias) # "table"."column" AS "alias"
+  Sequel.as(:column, :alias) # "column" AS "alias"
+  Sequel.qualify(:table, :column).as(:alias) # "table"."column" AS "alias"
 
 === Functions
 
 The easiest way to use SQL functions is via a virtual row:
 
-  DB[:albums].select{function{}} # SELECT function() FROM "albums"
-  DB[:albums].select{function(col1, col2)} # SELECT function("col1", "col2") FROM "albums"
+  DB[:albums].select{func{}} # SELECT func() FROM "albums"
+  DB[:albums].select{func(col1, col2)} # SELECT func("col1", "col2") FROM "albums"
 
-You can also use the +sql_function+ method on the symbol that contains the function name:
+You can also use the <tt>Sequel.function</tt> method on the symbol that contains the function name:
 
-  :function.sql_function # function()
-  :function.sql_function(:col1, :col2) # function("col1", "col2")
+  Sequel.function(:func) # func()
+  Sequel.function(:func, :col1, :col2) # func("col1", "col2")
 
 === Aggregate Functions
 
 Aggregate functions work the same way as normal functions, since they share the same syntax:
 
-  :sum.sql_function(:column) # sum(column)
+  Sequel.function(:sum, :column) # sum(column)
 
 However, if you want to use the DISTINCT modifier to an aggregate function, you either have to use literal SQL or a virtual row block:
 
-  :sum.sql_function('DISTINCT column'.lit) # sum(DISTINCT column)
+  Sequel.function(:sum, Sequel.lit('DISTINCT column')) # sum(DISTINCT column)
   DB[:albums].select{sum(:distinct, :column){}} # SELECT sum(DISTINCT column) FROM albums
 
 If you want to use the wildcard as the sole argument of the aggregate function, you again have to use literal SQL or a virtual row block:
 
-  :count.sql_function('*'.lit) # count(*)
+  Sequel.function(:count, Sequel.lit('*')) # count(*)
   DB[:albums].select{count(:*){}} # SELECT count(*) FROM albums
 
 Note that Sequel provides helper methods for aggregate functions such as +count+, +sum+, +min+, +max+, +avg+, and +group_and_count+, which handle common uses of aggregate functions.
@@ -232,28 +236,35 @@ You can also specify this as an array of two element arrays:
 
 === Not Equal Operator (!=)
 
-You can specify a not equals condition by inverting the hash or array of two element arrays using +sql_negate+ or ~:
+You can specify a not equals condition by inverting the hash or array of two element arrays using <tt>Sequel.negate</tt> or <tt>Sequel.~</tt>:
+
+  Sequel.negate(:column => 1)   # ("column" != 1)
+  Sequel.negate([[:column, 1]]) # ("column" != 1)
+  Sequel.~(:column => 1)        # ("column" != 1)
+  Sequel.~([[:column, 1]])      # ("column" != 1)
 
-  {:column => 1}.sql_negate # ("column" != 1)
-  [[:column, 1]].sql_negate # ("column" != 1)
-  ~{:column => 1} # ("column" != 1)
-  ~[[:column, 1]] # ("column" != 1)
+The difference between the two is that negate only works on hashes and arrays of element arrays, and it negates all entries in the, while ~ does a general inversion.  This is best shown by an example with multiple entries:
+
+  Sequel.negate(:column => 1, :foo => 2)   # (("column" != 1) AND (foo != 2))
+  Sequel.~(:column => 1, :foo => 2)        # (("column" != 1) OR (foo != 2))
 
 The most common need for not equals is in filters, in which case you can use the +exclude+ method:
 
   DB[:albums].exclude(:column=>1) # SELECT * FROM "albums" WHERE ("column" != 1)
 
+Note that +exclude+ does a generalized inversion, similar to <tt>Sequel.~</tt>.
+
 === Inclusion and Exclusion Operators (IN, NOT IN)
 
 Sequel also uses hashes to specify inclusion, and inversions of those hashes to specify exclusion:
 
   {:column=>[1, 2, 3]} # ("column" IN (1, 2, 3))
-  ~{:column=>[1, 2, 3]} # ("column" NOT IN (1, 2, 3))
+  Sequel.~(:column=>[1, 2, 3]) # ("column" NOT IN (1, 2, 3))
 
 As you may have guessed, Sequel switches from an = to an IN when the hash value is an array.  It also does this for datasets, which easily allows you to test for inclusion and exclusion in a subselect:
 
   {:column=>DB[:albums].select(:id)} # ("column" IN (SELECT "id" FROM "albums"))
-  ~{:column=>DB[:albums].select(:id)} # ("column" NOT IN (SELECT "id" FROM "albums"))
+  Sequel.~(:column=>DB[:albums].select(:id)) # ("column" NOT IN (SELECT "id" FROM "albums"))
 
 Sequel also supports the SQL EXISTS operator using <tt>Dataset#exists</tt>:
 
@@ -269,19 +280,19 @@ Hashes in Sequel use IS if the value is true, false, or nil:
 
 Negation works the same way as it does for equality and inclusion:
 
-  {:column=>nil).sql_negate # ("column" IS NOT NULL)
-  {:column=>true).sql_negate # ("column" IS NOT TRUE)
-  {:column=>false).sql_negate # ("column" IS NOT FALSE)
+  Sequel.~(:column=>nil) # ("column" IS NOT NULL)
+  Sequel.~(:column=>true) # ("column" IS NOT TRUE)
+  Sequel.~(:column=>false) # ("column" IS NOT FALSE)
 
 === Inversion Operator (NOT)
 
 Sequel's general inversion operator is ~, which works on symbols and most Sequel-specific expression objects:
 
-  ~:column # NOT "column"
+  Sequel.~(:column) # NOT "column"
 
 Note that ~ will actually apply the inversion operation to the underlying object, which is why
   
-  ~{:column=>1}
+  Sequel.~(:column=>1)
 
 produces <tt>(column != 1)</tt> instead of <tt>NOT (column = 1)</tt>.
 
@@ -289,198 +300,229 @@ produces <tt>(column != 1)</tt> instead of <tt>NOT (column = 1)</tt>.
 
 Sequel defines the inequality operators directly on most Sequel-specific expression objects:
 
-  :column.qualify(:table) > 1 # ("table"."column" > 1)
-  :column.qualify(:table) < 1 # ("table"."column" < 1)
-  :function.sql_function >= 1 # (function() >= 1)
-  :function.sql_function(:column) <= 1 # (function("column") <= 1)
+  Sequel.qualify(:table, :column) > 1 # ("table"."column" > 1)
+  Sequel.qualify(:table, :column) < 1 # ("table"."column" < 1)
+  Sequel.function(:func) >= 1 # (func() >= 1)
+  Sequel.function(:func, :column) <= 1 # (func("column") <= 1)
 
-If you want to use them on a symbol, you should call +identifier+ on the symbol:
+If you want to use them on a symbol, you should call <tt>Sequel.expr</tt> with the symbol:
 
-  :column.identifier > 1 # ("column" > 1)
+  Sequel.expr(:column) > 1 # ("column" > 1)
 
 A common use of virtual rows is to handle inequality operators:
 
-  DB[:albums].filter{col1 > col2} # SELECT * FROM "albums" WHERE ("col1" > "col2")
+  DB[:albums].where{col1 > col2} # SELECT * FROM "albums" WHERE ("col1" > "col2")
 
 === Standard Mathematical Operators (+ - * /)
 
-The standard mathematical operates are defined on symbol and most Sequel-specific expression objects:
+The standard mathematical operates are defined on most Sequel-specific expression objects:
+
+  Sequel.expr(:column) + 1 # "column" + 1
+  Sequel.expr(:table__column) - 1 # "table"."column" - 1
+  Sequel.qualify(:table, :column) * 1 # "table"."column" * 1
+  Sequel.expr(:column) / 1 # "column" / 1
 
-  :column + 1 # "column" + 1
-  :table__column - 1 # "table"."column" - 1
-  :column.qualify(:table) * 1 # "table"."column" * 1
-  :column / 1 # "column" / 1
+You can also call the operator methods directly on the Sequel module:
+
+  Sequel.+(:column, 1) # "column" + 1
+  Sequel.-(:table__column, 1) # "table"."column" - 1
+  Sequel.*(Sequel.qualify(:table, :column), 1) # "table"."column" * 1
+  Sequel./(:column, 1) # "column" / 1
 
 Note that the following does not work:
 
-  1 + :column # raises TypeError
+  1 + Sequel.expr(:column) # raises TypeError
 
-For commutative operates such as + and *, this isn't a problem as you can just reorder, but non-commutative operators such as - and / cannot be expressed directly.  However, Sequel comes with an +sql_expr+ extension that adds an +sql_expr+ method to all objects, allowing you to do:
+For commutative operates such as + and *, this isn't a problem as you can just reorder, but non-commutative operators such as - and / cannot be expressed directly.  The solution is to use one of the methods on the Sequel module:
 
-  Sequel.extension :sql_expr
-  1.sql_expr / :column # (1 / "column")
+  Sequel.expr(1) / :column # (1 / "column")
+  Sequel./(1, :column) # (1 / "column")
 
 === Boolean Operators (AND OR)
 
-Sequel defines the & and | methods on symbols, hashes, and most Sequel-specific expression objects to handle AND and OR:
+Sequel defines the & and | methods on most Sequel-specific expression objects to handle AND and OR:
 
-  :column1 & :column2 # ("column1" AND "column2")
-  {:column1=>1} | {:column2=>2} # (("column1" = 1) OR ("column2" = 2))
-  (:function.sql_function > 1) & :column3 # ((function() > 1) AND "column3")
+  Sequel.expr(:column1) & :column2 # ("column1" AND "column2")
+  Sequel.expr(:column1=>1) | {:column2=>2} # (("column1" = 1) OR ("column2" = 2))
+  (Sequel.function(:func) > 1) & :column3 # ((func() > 1) AND "column3")
 
 Note the use of parentheses in the last statement.  If you omit them, you won't get what you expect:
 
-  :function.sql_function > 1 & :column3 # (function() > 1)
+  Sequel.function(:func) > 1 & :column3 # (func() > 1)
 
 This is because & has higher precedence than >, so it is parsed as:
 
-  :function.sql_function > (1 & :column3)
+  Sequel.function(:func) > (1 & :column3)
 
 In this case, <tt>:column3.to_int</tt> returns an odd integer, so:
 
   1 & :column3 # => 1
 
+You and also use the <tt>Sequel.&</tt> and <tt>Sequel.|</tt> methods:
+
+  Sequel.&(:column1, :column2) # ("column1" AND "column2")
+  Sequel.|({:column1=>1}, {:column2=>2}) # (("column1" = 1) OR ("column2" = 2))
+
 You can use hashes and arrays of two element arrays to specify AND and OR with equality conditions:
 
   {:column1=>1, :column2=>2} # (("column1" = 1) AND ("column2" = 2))
   [[:column1, 1], [:column2, 2]] # (("column1" = 1) AND ("column2" = 2))
 
-As you can see, these literalize with ANDs by default.  You can use the +sql_or+ method to use OR instead:
+As you can see, these literalize with ANDs by default.  You can use the <tt>Sequel.or</tt> method to use OR instead:
 
-  {:column1=>1, :column2=>2}.sql_or # (("column1" = 1) OR ("column2" = 2))
+  Sequel.or(:column1=>1, :column2=>2) # (("column1" = 1) OR ("column2" = 2))
 
-You've already seen the +sql_negate+ method, which will use ANDs if multiple entries are used:
+You've already seen the <tt>Sequel.negate</tt> method, which will use ANDs if multiple entries are used:
 
-  {:column1=>1, :column2=>2}.sql_negate # (("column1" != 1) AND ("column2" != 2))
+  Sequel.negate(:column1=>1, :column2=>2) # (("column1" != 1) AND ("column2" != 2))
  
-To negate while using ORs, the ~ operator can be used:
+To negate while using ORs, the <tt>Sequel.~</tt> operator can be used:
 
-  ~{:column1=>1, :column2=>2} # (("column1" != 1) OR ("column2" != 2))
+  Sequel.~(:column1=>1, :column2=>2) # (("column1" != 1) OR ("column2" != 2))
 
-Note that <tt>Dataset#exclude</tt> uses ~, not +sql_negate+:
+Note again that <tt>Dataset#exclude</tt> uses ~, not +negate+:
 
   DB[:albums].exclude(:column1=>1, :column2=>2) # SELECT * FROM "albums" WHERE (("column" != 1) OR ("column2" != 2))
 
 === Casts
 
-Casting in Sequel is done with the +cast+ method, which is available on strings, symbols, and most of the Sequel-specific expression objects:
+Casting in Sequel is done with the +cast+ method, which is available on most of the Sequel-specific expression objects:
 
-  :name.cast(:text) # CAST("name" AS text)
-  '1'.cast(:integer) # CAST('1' AS integer)
-  :column.qualify(:table).cast(:date) # CAST("table"."column" AS date)
+  Sequel.expr(:name).cast(:text) # CAST("name" AS text)
+  Sequel.expr('1').cast(:integer) # CAST('1' AS integer)
+  Sequel.qualify(:table, :column).cast(:date) # CAST("table"."column" AS date)
 
-=== Bitwise Mathematical Operators (& | ^ << >> ~)
+You can also use the <tt>Sequel.cast</tt> method:
 
-Sequel allows the use of bitwise mathematical operators on Sequel::SQL::NumericExpression objects:
+  Sequel.cast(:name, :text) # CAST("name" AS text)
 
-  :number + 1 # => #<Sequel::SQL::NumericExpression ...>
-  (:number + 1) & 5 # (("number" + 1) & 5)
+=== Bitwise Mathematical Operators (& | ^ << >> ~)
 
-As you can see, when you use the + operator on a symbol, you get a NumericExpression.  You can turn a symbol into a NumericExpression using +sql_number+:
+Sequel allows the use of bitwise mathematical operators on Sequel::SQL::NumericExpression objects:
 
-  :number.sql_number | 5 # ("number" | 5)
+  Sequel.expr(:number) + 1 # => #<Sequel::SQL::NumericExpression ...>
+  (Sequel.expr(:number) + 1) & 5 # (("number" + 1) & 5)
 
-+sql_number+ also works on the many other Sequel-specific expression objects:
+As you can see, when you use the + operator on a symbol, you get a NumericExpression.  You can turn an expression a NumericExpression using +sql_number+:
 
-  :function.sql_function.sql_number << 7 # (function() << 7)
-  :name.cast(:integer).sql_number >> 8 # (CAST("name" AS integer) >> 8)
+  Sequel.expr(:number).sql_number | 5 # ("number" | 5)
+  Sequel.function(:func).sql_number << 7 # (func() << 7)
+  Sequel.cast(:name, :integer).sql_number >> 8 # (CAST("name" AS integer) >> 8)
 
 Sequel allows you to do the cast and conversion at the same time via +cast_numeric+:
 
-  :name.cast_numeric ^ 9 # (CAST("name" AS integer) ^ 9)
+  Sequel.expr(:name).cast_numeric ^ 9 # (CAST("name" AS integer) ^ 9)
 
-Note that &, |, and ~ are already defined to do AND, OR, and NOT on most objects, so if you want to use the bitwise operators, you need to make sure that they are converted first:
+Note that &, |, and ~ are already defined to do AND, OR, and NOT on most expressions, so if you want to use the bitwise operators, you need to make sure that they are converted first:
 
-  ~:name # NOT "name"
-  ~:name.sql_number # ~"name"
+  ~Sequel.expr(:name) # NOT "name"
+  ~Sequel.expr(:name).sql_number # ~"name"
 
 === String Operators (||, LIKE, Regexp)
 
-Sequel allows the use of the string concatenation operator on Sequel::SQL::StringExpression objects, which can be created using the +sql_string+ method:
+Sequel allows the use of the string concatenation operator on Sequel::SQL::StringExpression objects, which can be created using the +sql_string+ method on an expression:
 
-  :name.sql_string + ' - Name' # ("name" || ' - Name')
+  Sequel.expr(:name).sql_string + ' - Name' # ("name" || ' - Name')
 
 Just like for the bitwise operators, Sequel allows you do do the cast and conversion at the same time via +cast_string+:
 
-  :number.cast_string + ' - Number' # (CAST(number AS varchar(255)) || ' - Number')
+  Sequel.expr(:number).cast_string + ' - Number' # (CAST(number AS varchar(255)) || ' - Number')
 
 Note that similar to the mathematical operators, you cannot switch the order the expression and have it work:
 
-  'Name - ' + :name.sql_string # raises TypeError
+  'Name - ' + Sequel.expr(:name).sql_string # raises TypeError
 
-Just like for the mathematical operators, you can use the +sql_expr+ extension to work around this:
+Just like for the mathematical operators, you can use <tt>Sequel.expr</tt> to wrap the object:
 
-  Sequel.extension :sql_expr
-  'Name - '.sql_expr + :name # ('Name - ' || "name")
+  Sequel.expr('Name - ') + :name # ('Name - ' || "name")
   
-Sequel also adds an <tt>Array#sql_string_join</tt> method, which concatenates all of the elements in the array:
+The <tt>Sequel.join</tt> method concatenates all of the elements in the array:
 
-  ['Name', :name].sql_string_join # ('Name' || "name")
+  Sequel.join(['Name', :name]) # ('Name' || "name")
 
 Just like ruby's <tt>String#join</tt>, you can provide an argument for a string used to join each element:
 
-  ['Name', :name].sql_string_join(' - ') # ('Name' || ' - ' || "name")
+  Sequel.join(['Name', :name], ' - ') # ('Name' || ' - ' || "name")
+
+For the LIKE operator, Sequel defines the +like+ and +ilike+ methods on most Sequel-specific expression objects:
 
-For the LIKE operator, Sequel defines the +like+ and +ilike+ methods on symbol and most Sequel-specific expression objects:
+  Sequel.expr(:name).like('A%') # ("name" LIKE 'A%') 
+  Sequel.expr(:name).ilike('A%') # ("name" ILIKE 'A%') 
 
-  :name.like('A%') # ("name" LIKE 'A%') 
-  :name.qualify.ilike('A%') # ("name" ILIKE 'A%') 
+You can also use the <tt>Sequel.like</tt> and <tt>Sequel.ilike</tt> methods:
 
-Note the above syntax, 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.  Some databases only support case insensitive behavior, in which case +like+ and +ilike+ will act identically.
+  Sequel.like(:name, 'A%') # ("name" LIKE 'A%') 
+  Sequel.ilike(:name, 'A%') # ("name" ILIKE 'A%') 
+
+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:
 
-  ~:name.like('A%') # ("name" NOT LIKE 'A%')
+  ~Sequel.like(:name, 'A%') # ("name" NOT LIKE 'A%')
 
-Sequel also supports SQL regular expressions on MySQL and PostgreSQL.  You can use these by passing a ruby regular expression to the +like+ or +ilike+ method, or by making the regular expression a hash value:
+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:
 
-  :name.like(/^A/) # ("name" ~ '^A')
-  ~:name.ilike(/^A/) # ("name" !~* '^A')
+  Sequel.like(:name, /^A/) # ("name" ~ '^A')
+  ~Sequel.ilike(:name, /^A/) # ("name" !~* '^A')
   {:name=>/^A/i} # ("name" ~* '^A')
-  ~{:name=>/^A/} # ("name" !~ '^A')
+  Sequel.~(:name=>/^A/) # ("name" !~ '^A')
 
 Note that using +ilike+ with a regular expression will always make the regexp case insensitive.  If you use +like+ or the hash with regexp value, it will only be case insensitive if the Regexp itself is case insensitive.
 
 === Order Specifications (ASC, DESC)
 
-Sequel supports specifying ascending or descending order using the +asc+ and +desc+ method on symbols and most Sequel-specific expression objects:
+Sequel supports specifying ascending or descending order using the asc+ and +desc+ method on most Sequel-specific expression objects:
+
+  Sequel.expr(:column).asc # "column" ASC
+  Sequel.expr(:column).qualify(:table).desc # "table"."column" DESC
 
-  :column.asc # "column" ASC
-  :column.qualify(:table).desc # "table"."column" DESC
+You can also use the <tt>Sequel.asc</tt> and <tt>Sequel.desc</tt> methods:
+
+  Sequel.asc(:column) # "column" ASC
+  Sequel.desc(Sequel.expr(:column).qualify(:table)) # "table"."column" DESC
+
+On some databases, you can specify null ordering:
+
+  Sequel.asc(:column, :nulls=>:first) # "column" ASC NULLS FIRST
+  Sequel.desc(Sequel.expr(:column).qualify(:table), :nulls=>:last) # "table"."column" DESC NULLS LAST
 
 === All Columns (.*)
 
-To select all columns in a table, Sequel supports the * method on symbols without an argument:
+To select all columns in a table, Sequel supports the * method on identifiers without an argument:
 
-  :table.* # "table".*
+  Sequel.expr(:table).* # "table".*
 
 === CASE statements
 
-Sequel allows the easy production of SQL CASE statements using the +case+ method of hashes and arrays of two element arrays.  The argument to +case+ is the default value, the keys of the hash (or first element in each array) is the WHEN condition, and the values of the hash (or second element in each array) is the THEN result.  Here are some examples:
+Sequel allows the easy production of SQL CASE statements using the <tt>Sequel.case</tt> method.  The first argument is a hash or array of two element arrays representing the conditions, the second argument is the default value (ELSE).   The keys of the hash (or first element in each array) is the WHEN condition, and the values of the hash (or second element in each array) is the THEN result.  Here are some examples:
 
-  {:column=>1}.case(0) # (CASE WHEN "column" THEN 1 ELSE 0 END)
-  [[column, 1]].case(0) # (CASE WHEN "column" THEN 1 ELSE 0 END)
-  {{:column=>nil}=>1}.case(0) # (CASE WHEN (column IS NULL) THEN 1 ELSE 0 END)
+  Sequel.case({:column=>1, 0) # (CASE WHEN "column" THEN 1 ELSE 0 END)
+  Sequel.case([[column, 1]], 0) # (CASE WHEN "column" THEN 1 ELSE 0 END)
+  Sequel.case({{:column=>nil}=>1}, 0) # (CASE WHEN (column IS NULL) THEN 1 ELSE 0 END)
 
 If the hash or array has multiple arguments, multiple WHEN clauses are used:
 
-  {:c=>1, :d=>2}.case(0) # (CASE WHEN "c" THEN 1 WHEN "d" THEN 2 ELSE 0 END)
-  [[:c, 1], [:d, 2]].case(0) # (CASE WHEN "c" THEN 1 WHEN "d" THEN 2 ELSE 0 END)
+  Sequel.case({:c=>1, :d=>2}, 0) # (CASE WHEN "c" THEN 1 WHEN "d" THEN 2 ELSE 0 END)
+  Sequel.case([[:c, 1], [:d, 2]], 0) # (CASE WHEN "c" THEN 1 WHEN "d" THEN 2 ELSE 0 END)
 
 If you provide a 2nd argument to CASE, it goes between CASE and WHEN:
 
-  {2=>1, 3=>5}.case(0, :column) # (CASE column WHEN 2 THEN 1 WHEN 3 THEN 5 ELSE 0 END)
+  Sequel.case({2=>1, 3=>5}, 0, :column) # (CASE column WHEN 2 THEN 1 WHEN 3 THEN 5 ELSE 0 END)
 
 === Subscripts/Array Access ([])
 
-Sequel supports SQL subscripts using the +sql_subscript+ method on symbols and most Sequel-specific expression objects:
+Sequel supports SQL subscripts using the +sql_subscript+ method on most Sequel-specific expression objects:
+
+  Sequel.expr(:column).sql_subscript(3) # column[3]
+  Sequel.expr(:column).qualify(:table).sql_subscript(3) # table.column[3]
+
+You can also use the <tt>Sequel.subscript</tt> method:
 
-  :column.sql_subscript(3) # column[3]
-  :column.qualify(:table).sql_subscript(3) # table.column[3]
+  Sequel.subscript(:column, 3) # column[3]
 
 Just like in SQL, you can use any expression as a subscript:
 
-  :column.sql_subscript(:function.sql_function) # column[function()]
+  Sequel.subscript(:column, Sequel.function(:func)) # column[func()]
 
 == Building Queries in Sequel
 
@@ -504,12 +546,12 @@ If you don't want to select from any FROM tables, use no arguments:
 
 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(:name.like('A%')).order(:name)
+  DB[:albums].select(:id, :name).where(Sequel.like(:name, 'A%')).order(:name)
   # SELECT id, name FROM albums WHERE (name LIKE 'A%') 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(:name.like('A%')).select(:id, :name)
+  DB[:albums].order(:name).where(Sequel.like(:name, 'A%')).select(:id, :name)
   # SELECT id, name FROM albums WHERE (name LIKE 'A%') ORDER BY name
 
 === Using the Same Dataset for SELECT, INSERT, UPDATE, and DELETE
@@ -524,13 +566,13 @@ Also note that while the SELECT clause is displayed when you look at a dataset,
 
 In general, the +insert+, +update+, and +delete+ methods use the appropriate clauses you defined on the dataset:
 
-  ds = DB[:albums].filter(:id=>1)
+  ds = DB[:albums].where(:id=>1)
   ds.all # SELECT * FROM albums WHERE (id = 1)
   ds.insert(:name=>'RF') # INSERT INTO albums (name) VALUES ('RF')
   ds.update(:name=>'RF') # UPDATE albums SET name = 'RF' WHERE (id = 1)
   ds.delete # DELETE FROM albums WHERE (id = 1)
 
-Note how +update+ and +delete+ used the +filter+ argument, but that +insert+ did not, because INSERT doesn't use a WHERE clause.
+Note how +update+ and +delete+ used the +where+ argument, but that +insert+ did not, because INSERT doesn't use a WHERE clause.
 
 === Methods Used for Each SQL Clause