sequel 4.49.0 → 5.3.0

data/doc/sharding.rdoc

@@ -13,7 +13,7 @@ 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=>{})
+  DB=Sequel.connect('postgres://master_server/database', servers: {})
 
 In most cases, you are probably not going to want to use an empty hash.  Keys in the server hash are
 not restricted to type, but the general recommendation is to use a symbol
@@ -35,8 +35,8 @@ tables you are accessing, unless you really know what you are doing.
 To use a single, read-only slave that handles SELECT queries, the following
 is the simplest configuration:
 
-  DB=Sequel.connect('postgres://master_server/database', \
-    :servers=>{:read_only=>{:host=>'slave_server'}})
+  DB=Sequel.connect('postgres://master_server/database', 
+    servers: {read_only: {host: 'slave_server'}})
 
 This will use the slave_server for SELECT queries and master_server for
 other queries.
@@ -48,8 +48,8 @@ the symbol name defined in the connect options. For example:
   # Force the SELECT to run on the master
   DB[:users].server(:default).all
 
-  # Force the SELECT to run on the read-only slave
-  DB[:users].server(:read_only).all
+  # Force the DELETE to run on the read-only slave
+  DB[:users].server(:read_only).delete
 
 === Multiple Read-Only Slaves, Single Master
 
@@ -59,13 +59,13 @@ slave_server1, slave_server2, and slave_server3.
   num_read_only = 4
   read_only_host = rand(num_read_only)
   read_only_proc = proc do |db|
-    {:host=>"slave_server#{(read_only_host+=1) % num_read_only}"}
+    {host: "slave_server#{(read_only_host+=1) % num_read_only}"}
   end
-  DB=Sequel.connect('postgres://master_server/database', \
-    :servers=>{:read_only=>read_only_proc})
+  DB=Sequel.connect('postgres://master_server/database',
+    servers: {read_only: read_only_proc})
 
 This will use one of the slave servers for SELECT queries and use the
-master_server for other queries.  It's also possible to pick a random host
+master server for other queries.  It's also possible to pick a random host
 instead of using the round robin approach presented above, but that can result
 in less optimal resource usage.
 
@@ -78,15 +78,15 @@ it shows that the master database is named :default.  So for 4 masters and
   num_read_only = 4
   read_only_host = rand(num_read_only)
   read_only_proc = proc do |db|
-    {:host=>"slave_server#{(read_only_host+=1) % num_read_only}"}
+    {host: "slave_server#{(read_only_host+=1) % num_read_only}"}
   end
   num_default = 4
   default_host = rand(num_default)
   default_proc = proc do |db|
-    {:host=>"master_server#{(default_host+=1) % num_default}"}
+    {host: "master_server#{(default_host+=1) % num_default}"}
   end
-  DB=Sequel.connect('postgres://master_server/database', \
-    :servers=>{:default=>default_proc, :read_only=>read_only_proc})
+  DB=Sequel.connect('postgres://master_server/database',
+    servers: {default: default_proc, read_only: read_only_proc})
   
 == Sharding
 
@@ -100,16 +100,16 @@ of 16 shards).  First, you need to configure the database:
 
   servers = {}
   (('0'..'9').to_a + ('a'..'f').to_a).each do |hex|
-    servers[hex.to_sym] = {:host=>"hash_host_#{hex}"}
+    servers[hex.to_sym] = {host: "hash_host_#{hex}"}
   end
-  DB=Sequel.connect('postgres://hash_host/hashes', :servers=>servers)
+  DB=Sequel.connect('postgres://hash_host/hashes', servers: servers)
   
 This configures 17 servers, the 16 shard servers (/hash_host_[0-9a-f]/), and 1
 default server which will be used if no shard is specified ("hash_host").  If
 you want the default server to be one of the shard servers (e.g. hash_host_a),
 it's easiest to do:
 
-  DB=Sequel.connect('postgres://hash_host_a/hashes', :servers=>servers)
+  DB=Sequel.connect('postgres://hash_host_a/hashes', servers: servers)
 
 That will still set up a second pool of connections for the default server,
 since it considers the default server and shard servers independent.  Note that
@@ -120,7 +120,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).where(: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.
@@ -133,7 +133,7 @@ the shard to use.  This is fairly easy using a Sequel::Model:
     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)
+        server(hash[0...1].to_sym).where(hash: hash).get(:plaintext)
       end
     end
   end
@@ -146,24 +146,24 @@ to assume the :default shard.  However, you can specify a
 different shard using the :servers_hash option when connecting
 to the database:
 
-  DB = Sequel.connect('postgres://...', :servers_hash=>Hash.new(:some_shard))
+  DB = Sequel.connect('postgres://...', servers_hash: Hash.new(:some_shard))
 
 You can also use this feature to raise an exception if an
 unconfigured shard is used:
 
-  DB = Sequel.connect('postgres://...', :servers_hash=>Hash.new{raise 'foo'})
+  DB = Sequel.connect('postgres://...', servers_hash: Hash.new{raise 'foo'})
 
 If you specify a :servers_hash option to raise an exception for non configured
 shards you should also explicitly specify a :read_only entry in your :servers option
 for the case where a shard is not specified. In most cases it is sufficient
 to make the :read_only entry the same as the :default shard:
 
-  servers = {:read_only => {}}
+  servers = {read_only: {}}
   (('0'..'9').to_a + ('a'..'f').to_a).each do |hex|
-    servers[hex.to_sym] = {:host=>"hash_host_#{hex}"}
+    servers[hex.to_sym] = {host: "hash_host_#{hex}"}
   end
-  DB=Sequel.connect('postgres://hash_host/hashes', :servers=>servers, 
-    :servers_hash=>Hash.new{raise Exception.new("Invalid Server")}) 
+  DB=Sequel.connect('postgres://hash_host/hashes', servers: servers, 
+    servers_hash: Hash.new{raise "Invalid Server"}) 
 
 === Sharding Plugin
 
@@ -176,7 +176,7 @@ work well with shards.  You just need to remember to set to model to use the plu
     plugin :sharding
   end
 
-  Rainbow.server(:a).first(:id=>1).update(:plaintext=>'VGM')
+  Rainbow.server(:a).first(id: 1).update(plaintext: 'VGM')
 
 If all of your models are sharded, you can set all models to use the plugin via:
 
@@ -186,7 +186,7 @@ If all of your models are sharded, you can set all models to use the plugin via:
 
 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.
+same shard, it can get a bit redundant 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:
@@ -194,7 +194,7 @@ 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/)
+    if r = Rainbow.first(hash: /31337/)
       r.count += 1
       # this UPDATE query also uses the "a" shard
       r.save
@@ -209,6 +209,19 @@ you retrieve the models inside the block and save them outside of the block.  If
 need to do that, call the server method explicitly on the dataset used to retrieve the
 model objects.
 
+The with_server method also supports a second argument for the default read_only server
+to use, which can be useful if you are mixing sharding and master/slave servers:
+
+  DB.extension :server_block
+  DB.with_server(:a, :a_read_only) do
+    # this SELECT query uses the "a_read_only" shard
+    if r = Rainbow.first(hash: /31337/)
+      r.count += 1
+      # this UPDATE query also uses the "a" shard
+      r.save
+    end
+  end
+
 === arbitrary_servers Extension
 
 By default, Sequel's sharding support is designed to work with predefined shards.  It ships
@@ -220,13 +233,13 @@ The arbitrary_servers extension allows you to pass a server/shard options hash a
 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
+  DB[:rainbows].server(host: 'hash_host_a').all
   # or
-  DB[:rainbows].server(:host=>'hash_host_b', :database=>'backup').all
+  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.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

data/doc/sql.rdoc

@@ -22,7 +22,7 @@ For SELECT queries, you should probably use <tt>Database#fetch</tt> with a strin
 
 You can also use named placeholders by starting the placeholder with a colon, and using a hash for the argument:
 
-  DB.fetch("SELECT * FROM albums WHERE name LIKE :pattern", :pattern=>'A%') do |row|
+  DB.fetch("SELECT * FROM albums WHERE name LIKE :pattern", pattern: 'A%') do |row|
     puts row[:name]
   end
 
@@ -121,21 +121,15 @@ As you can see, Sequel quotes identifiers by default.  Depending on your databas
 
   :column # "COLUMN" on some databases
 
-A plain symbol is usually treated as an unqualified identifier.  However, if you are using multiple tables in a query, and you want to reference a column in one of the tables that has the same name as a column in another one of the tables, you need to qualify that reference.  There are two main ways in Sequel to do that.  The first is implicit qualification inside the symbol, using the double underscore:
-
-  :table__column # "table"."column"
-
-This works by default, but it is possible to turn off by setting <tt>Sequel.split_symbols = false</tt>.
-
-Note that you can't use a period to separate them:
+A plain symbol is usually treated as an unqualified identifier.  However, if you are using multiple tables in a query, and you want to reference a column in one of the tables that has the same name as a column in another one of the tables, you need to qualify that reference.  Note that you can't use a period to separate them: 
 
   :table.column # calls the column method on the symbol
 
 Also note that specifying the period inside the symbol doesn't work if you are quoting identifiers:
 
-  :"table.column" # "table.column"
+  :"table.column" # "table.column" instead of "table"."column"
 
-The second way is to explicitly create a qualified identifier either by using <tt>Sequel.[]</tt> to create an identifier and call <tt>[]</tt> or +qualify+ on that, or by using the <tt>Sequel.qualify</tt> method with the table and column symbols:
+There are a few different Sequel methods for creating qualified identifier objects.  The recommended way is to explicitly create a qualified identifier by using <tt>Sequel.[]</tt> to create an identifier and call <tt>[]</tt> or +qualify+ on that, or by using the <tt>Sequel.qualify</tt> method with the table and column symbols:
 
   Sequel[:table][:column]         # "table"."column"
   Sequel[:column].qualify(:table) # "table"."column"
@@ -148,6 +142,7 @@ Another way to generate identifiers is to use Sequel's {virtual row support}[rdo
 
 You can also use the symbol_aref extension for creating qualified identifiers:
 
+  Sequel.extension :symbol_aref
   :table[:column] # "table"."column"
 
 === Numbers
@@ -173,24 +168,16 @@ In general, Ruby strings map directly to SQL strings:
 
 === Aliasing
 
-Sequel allows for implicit aliasing in column symbols using the triple underscore:
-
-  :column___alias # "column" AS "alias"
-
-You can combine this with implicit qualification:
-
-  :table__column___alias # "table"."column" AS "alias"
-
-As with creating qualified identifiers via a double underscore, this works by default, but it is possible to turn off by setting <tt>Sequel.split_symbols = false</tt>.
-
-You can also use the <tt>Sequel.as</tt> method to create an alias, and the +as+ method on most Sequel-specific expression objects:
+You can use the <tt>Sequel.as</tt> method to create an alias, and the +as+ method on most Sequel-specific expression objects:
 
   Sequel.as(:column, :alias)                 # "column" AS "alias"
   Sequel[:column].as(:alias)                 # "column" AS "alias"
   Sequel[:table][:column].as(:alias)         # "table"."column" AS "alias"
+  (Sequel[:column] + 1).as(:alias)           # ("column" + 1) AS "alias"
 
 You can also use the symbol_as extension for creating aliased identifiers:
 
+  Sequel.extension :symbol_as
   :column.as(:alias) # "column" AS "alias"
 
 If you want to use a derived column list, you can provide an array of column aliases:
@@ -215,11 +202,11 @@ Aggregate functions work the same way as normal functions, since they share the
 
   Sequel.function(:sum, :column) # sum(column)
 
-To use the DISTINCT modifier to an aggregate function, call the +distinct+ method on the function:
+To use the DISTINCT modifier to an aggregate function, call the +distinct+ method on the function expression, which returns a new function expression:
 
   DB[:albums].select{sum(:column).distinct} # SELECT sum(DISTINCT column) FROM albums
 
-If you want to use the wildcard as the sole argument of the aggregate function, use the * method on the Function:
+If you want to use the wildcard as the sole argument of the aggregate function, use the * method on the function expression:
 
   Sequel.function(:count).* # count(*)
   DB[:albums].select{count.function.*} # SELECT count(*) FROM albums
@@ -228,10 +215,10 @@ Note that Sequel provides helper methods for aggregate functions such as +count+
 
 === Window Functions
 
-If the database supports window functions, Sequel can handle them by calling the +over+ method on a Function:
+If the database supports window functions, Sequel can handle them by calling the +over+ method on a function expression:
 
-  DB[:albums].select{function.function.over}
-  # SELECT function() OVER () FROM albums
+  DB[:albums].select{row_number.function.over}
+  # SELECT row_number() OVER () FROM albums
 
   DB[:albums].select{count.function.*.over}
   # SELECT count(*) OVER () FROM albums
@@ -244,12 +231,12 @@ If the database supports window functions, Sequel can handle them by calling the
 
 === Schema Qualified Functions
 
-If the database supports schema qualified functions, Sequel can handle them by calling the +function+ method on a QuailfiedIdentifier:
+If the database supports schema qualified functions, Sequel can handle them by calling the +function+ method on a qualified identifier:
 
   DB[:albums].select{schema[:function].function}
   # SELECT schema.function() FROM albums
   
-  DB[:albums].select{schema[:function].function(col, 2, "a")}
+  DB[:albums].select{schema[:function].function(:col, 2, "a")}
   # SELECT schema.function(col, 2, 'a') FROM albums
 
 === Portable/Emulated Functions
@@ -265,7 +252,7 @@ Some examples are:
 
 Sequel uses hashes to specify equality:
 
-  {:column=>1} # ("column" = 1)
+  {column: 1} # ("column" = 1)
 
 You can also specify this as an array of two element arrays:
 
@@ -279,27 +266,27 @@ For expression objects, you can also use the =~ method:
 
 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.negate([[:column, 1]]) # ("column" != 1)
-  Sequel.~(:column => 1)        # ("column" != 1)
+  Sequel.~(column: 1)           # ("column" != 1)
   Sequel.~([[: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 hash or array, 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))
+  Sequel.negate(column: 1, foo: 2)   # (("column" != 1) AND (foo != 2))
+  Sequel.~(column: 1, foo: 2)        # (("column" != 1) OR (foo != 2))
 
 You can also use the ~ method on an equality expression:
 
   where{~(column =~ 1)} # ("column" != 1)
 
-On Ruby 1.9+, you can use the !~ method:
+Or you can use the !~ method:
 
   where{column !~ 1} # ("column" != 1)
 
 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)
+  DB[:albums].exclude(column: 1) # SELECT * FROM "albums" WHERE ("column" != 1)
 
 Note that +exclude+ does a generalized inversion, similar to <tt>Sequel.~</tt>.
 
@@ -307,19 +294,19 @@ Note that +exclude+ does a generalized inversion, similar to <tt>Sequel.~</tt>.
 
 Sequel also uses hashes to specify inclusion, and inversions of those hashes to specify exclusion:
 
-  {:column=>[1, 2, 3]} # ("column" IN (1, 2, 3))
-  Sequel.~(:column=>[1, 2, 3]) # ("column" NOT IN (1, 2, 3))
+  {column: [1, 2, 3]} # ("column" 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"))
-  Sequel.~(:column=>DB[:albums].select(:id)) # ("column" NOT IN (SELECT "id" FROM "albums"))
+  {column: DB[:albums].select(:id)} # ("column" IN (SELECT "id" FROM "albums"))
+  Sequel.~(column: DB[:albums].select(:id)) # ("column" NOT IN (SELECT "id" FROM "albums"))
 
 Similar to =, you can also use =~ with expressions for inclusion:
 
   where{column =~ [1, 2, 3]} # ("column" IN (1, 2, 3))
 
-and on Ruby 1.9, !~ for exclusion:
+and !~ for exclusion:
 
   where{column !~ [1, 2, 3]} # ("column" NOT IN (1, 2, 3))
 
@@ -331,17 +318,17 @@ Sequel also supports the SQL EXISTS operator using <tt>Dataset#exists</tt>:
 
 Hashes in Sequel use IS if the value is +true+, +false+, or +nil+:
 
-  {:column=>nil} # ("column" IS NULL)
-  {:column=>true} # ("column" IS TRUE)
-  {:column=>false} # ("column" IS FALSE)
+  {column: nil}   # ("column" IS NULL)
+  {column: true}  # ("column" IS TRUE)
+  {column: false} # ("column" IS FALSE)
 
 Negation works the same way as it does for equality and inclusion:
 
-  Sequel.~(:column=>nil) # ("column" IS NOT NULL)
-  Sequel.~(:column=>true) # ("column" IS NOT TRUE)
-  Sequel.~(:column=>false) # ("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)
 
-Likewise, =~ works for identity (and Ruby 1.9, !~ for negative identity):
+Likewise, =~ works for identity and !~ for negative identity on expressions:
 
   where{column =~ nil} # ("column" IS NULL)
   where{column !~ nil} # ("column" IS NOT NULL)
@@ -354,7 +341,7 @@ Sequel's general inversion operator is ~, which works on symbols and most Sequel
 
 Note that ~ will actually apply the inversion operation to the underlying object, which is why
   
-  Sequel.~(:column=>1)
+  Sequel.~(column: 1)
 
 produces <tt>(column != 1)</tt> instead of <tt>NOT (column = 1)</tt>.
 
@@ -367,7 +354,7 @@ Sequel defines the inequality operators directly on most Sequel-specific express
   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 <tt>Sequel.[]</tt> with the symbol:
+If you want to use them on a symbol, you should call <tt>Sequel.[]</tt> with the symbol to get an expression object:
 
   Sequel[:column] > 1 # ("column" > 1)
 
@@ -403,7 +390,7 @@ Note that since Sequel implements support for Ruby's coercion protocol, the foll
 Sequel defines the & and | methods on most Sequel-specific expression objects to handle AND and OR:
 
   Sequel[:column1] & :column2 # ("column1" AND "column2")
-  Sequel[:column1=>1] | {:column2=>2} # (("column1" = 1) OR ("column2" = 2))
+  Sequel[{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.
@@ -418,28 +405,28 @@ is parsed as:
 You can 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))
+  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))
   [[:column1, 1], [:column2, 2]] # (("column1" = 1) AND ("column2" = 2))
 
 As you can see, these literalize with ANDs by default.  You can use the <tt>Sequel.or</tt> method to use OR instead:
 
-  Sequel.or(:column1=>1, :column2=>2) # (("column1" = 1) OR ("column2" = 2))
+  Sequel.or(column1: 1, column2: 2) # (("column1" = 1) OR ("column2" = 2))
 
 You've already seen the <tt>Sequel.negate</tt> method, which will use ANDs if multiple entries are used:
 
-  Sequel.negate(:column1=>1, :column2=>2) # (("column1" != 1) AND ("column2" != 2))
+  Sequel.negate(column1: 1, column2: 2) # (("column1" != 1) AND ("column2" != 2))
  
 To negate while using ORs, the <tt>Sequel.~</tt> operator can be used:
 
-  Sequel.~(:column1=>1, :column2=>2) # (("column1" != 1) OR ("column2" != 2))
+  Sequel.~(column1: 1, column2: 2) # (("column1" != 1) OR ("column2" != 2))
 
 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))
+  DB[:albums].exclude(column1: 1, column2: 2) # SELECT * FROM "albums" WHERE (("column" != 1) OR ("column2" != 2))
 
 === Casts
 
@@ -521,8 +508,8 @@ Sequel also supports SQL regular expressions on MySQL and PostgreSQL.  You can u
 
   Sequel.like(:name, /^A/) # ("name" ~ '^A')
   ~Sequel.ilike(:name, /^A/) # ("name" !~* '^A')
-  {:name=>/^A/i} # ("name" ~* '^A')
-  Sequel.~(:name=>/^A/) # ("name" !~ '^A')
+  {name: /^A/i} # ("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.
 
@@ -545,21 +532,22 @@ On some databases, you can specify null ordering:
 
 === All Columns (.*)
 
-To select all columns in a table, Sequel supports the * method on identifiers without an argument:
+To select all columns in a table, Sequel supports the * method on identifiers and qualified without an argument:
 
-  Sequel[:table].* # "table".*
+  Sequel[:table].*          # "table".*
+  Sequel[:schema][:table].* # "schema"."table".*
 
 === CASE statements
 
-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:
+Sequel supports 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:
 
-  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)
+  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:
 
-  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)
   Sequel.case([[:c, 1], [:d, 2]], 0) # (CASE WHEN "c" THEN 1 WHEN "d" THEN 2 ELSE 0 END)
 
 If you provide a 3rd argument to <tt>Sequel.case</tt>, it goes between CASE and WHEN:

data/doc/testing.rdoc

@@ -156,13 +156,12 @@ SEQUEL_COLUMNS_INTROSPECTION :: Use the columns_introspection extension when run
 SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when running the specs
 SEQUEL_DUPLICATE_COLUMNS_HANDLER :: Use the duplicate columns handler extension with value given when running the specs
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
-SEQUEL_FREEZE_DATASETS :: Use the freeze_datasets extension when running the specs
 SEQUEL_FREEZE_DATABASE :: Freeze the database before running the integration specs
 SEQUEL_IDENTIFIER_MANGLING :: Use the identifier_mangling extension when running the specs
-SEQUEL_MODEL_PREPARED_STATEMENTS :: Use the prepared_statements and prepared_statements_associations plugins when running the specs
-SEQUEL_NO_AUTO_LITERAL_STRINGS :: Use the no_auto_string_literals extension when running the specs
+SEQUEL_MODEL_PREPARED_STATEMENTS :: Use the prepared_statements plugin when running the specs
 SEQUEL_NO_CACHE_ASSOCIATIONS :: Don't cache association metadata when running the specs
 SEQUEL_NO_CHECK_SQLS :: Don't check for specific SQL syntax when running the specs
+SEQUEL_CHECK_PENDING :: Try running all specs (note, can cause lockups for some adapters), and raise errors for skipped specs that don't fail
 SEQUEL_NO_PENDING :: Don't skip any specs, try running all specs (note, can cause lockups for some adapters)
-SEQUEL_NO_SPLIT_SYMBOLS :: Turn off symbol splitting when running the specs
-SKIPPED_TEST_WARN :: Warn when skipping any tests because libraries aren't available
+SEQUEL_SPLIT_SYMBOLS :: Turn on symbol splitting when running the adapter and integration specs
+SEQUEL_SYNCHRONIZE_SQL :: Use the synchronize_sql extension when running the specs

data/doc/thread_safety.rdoc

@@ -1,10 +1,10 @@
 = Thread Safety
 
-Most Sequel usage (and all common Sequel usage) is thread safe by default.  Specifically, multiple threads can operate on Database instances, Dataset instances, and Model classes concurrently without problems.  In general, Database instance and Model classes are not modified after application startup, and modifying Dataset instances returns modified copies of the dataset instead of mutating it.
+Most Sequel usage (and all common Sequel usage) is thread safe by default.  Specifically, multiple threads can operate on Database instances, Dataset instances, and Model classes concurrently without problems.  In general, Database instance and Model classes are not modified after application startup, and Dataset instances are always frozen.
 
 == Connection Pool
 
-In order to allow multiple threads to operate on the same database at the same time, Sequel uses a connection pool.  The connection pool is designed so that a thread uses a connection for the minimum amount of time, returning the connection to the pool as soon as it is done using the connection.  If a thread requests a connection and the pool does not have an available connection, a new connection will be created.  If the maximum number of connections in the pool has already been reached, the thread will block until a connection is available or the connection pool timeout has elapsed (in which case a PoolTimeout error will be raised).
+In order to allow multiple threads to operate on the same database at the same time, Sequel uses a connection pool.  The connection pool is designed so that a thread uses a connection for the minimum amount of time, returning the connection to the pool as soon as it is done using the connection.  If a thread requests a connection and the pool does not have an available connection, a new connection will be created.  If the maximum number of connections in the pool has already been reached, the thread will block until a connection is available or the connection pool timeout has elapsed (in which case a Sequel::PoolTimeout error will be raised).
 
 == Exceptions
 
@@ -13,5 +13,3 @@ This is a small list of things that are specifically non thread-safe.  This is n
 1) Model instances: Model instances are not thread-safe unless they are frozen first.  Multiple threads should not operate on an unfrozen model instance concurrently.
 
 2) Model class modifications: Model class modifications, such as adding associations and loading plugins, are not designed to be thread safe.  You should not modify a class in one thread if any other thread can concurrently access it.  Model subclassing is designed to be thread-safe, so you create a model subclass in a thread and modify it safely.
-
-3) Dataset mutation methods: Dataset mutation methods are not thread safe, you should not call them on datasets that could be accessed by other threads.  It is safe to clone the dataset first inside a thread and call mutation methods on the cloned dataset.