sequel 4.49.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 272cf6bec70bfd569e735839c6e7dce242527188
-  data.tar.gz: 8fac2b669b6d97264ef870f601a882a833d2abeb
+  metadata.gz: d494778be10a685dadd0181b0f35d8976ad80de5
+  data.tar.gz: 3de435547bc07c151e6511915b034c4c70909b28
 SHA512:
-  metadata.gz: 5d1fffb914a7352c99aceb0d0ae222a36a6a48c3fef47aa9b10d1ffc494ae625e53f1f0435d009aa050e13fbf8e1296b6bb15110e19e1762bce0f8f77ce4621e
-  data.tar.gz: f79ce483f64c7fbf4df674c374e2bac0009b6f1b479b8bb6e008921dd08ae2b88b16226427b26ce7bb3241c96ad0c2bbb55c6b66202efe4fa01e8813662a644e
+  metadata.gz: 71e23a94e737525c4bcf0ad0e16376a8ec933bf6962dce7c5032971ec3f8b7cb140c194ad51a41e818c4597025c3403b5f3777941ecf247595f8b7294ac9804f
+  data.tar.gz: d57c4092428f1ca13fb1fce70e9f26dae1f53e5c04f75aef5c5ad2ea5d0ac664c06443b86f7881a7abe7c499b977476fddb3155c9856290eb573b3a6d810b7a4

data/CHANGELOG

@@ -1,3 +1,73 @@
+=== 5.0.0 (2017-09-01)
+
+* Make bin/sequel -M option always use base 10 (jeremyevans)
+
+* Don't use savepoints when creating indexes inside a transaction on databases that don't support transactional schema modifications (jeremyevans) (#1407)
+
+* Support :if_not_exists option when creating indexes on PostgreSQL 9.5+ (DyegoCosta) (#1405)
+
+* Make threaded connection pools not block while connections are being made (jeremyevans)
+
+* SQL::Expression#clone and #dup now return self, since all expressions should be frozen value objects (jeremyevans)
+
+* Don't create empty arrays for unused association callbacks (jeremyevans)
+
+* Cache association method name symbols instead of recomputing them everytime (jeremyevans)
+
+* Raise an exception if attempting to create a prepared statement using a dataset with a delayed evaluation (jeremyevans)
+
+* Make ConnectionPool#size thread safe by using the pool mutex (jeremyevans)
+
+* Use instance_exec instead of instance_eval when passing a block, to work with lambdas that accept no arguments (jeremyevans)
+
+* Freeze SQL::StringAgg instances in string_agg extension (jeremyevans)
+
+* Freeze SQL::DateAdd instances in date_arithmetic extension (jeremyevans)
+
+* Freeze SQL::Expression.comparison_attrs (jeremyevans)
+
+* Rename SQL::Subscript#f to #expression, keeping #f as an alias (jeremyevans)
+
+* Require the :pool_class Database option be a class to use a custom connection pool (jeremyevans)
+
+* Make the class_table_inheritance plugin raise an Error during update if any UPDATE query does not affect a single row (jeremyevans)
+
+* Change most send calls to public_send unless calling private methods is expected (jeremyevans)
+
+* Database schema and schema generator methods now return nil (jeremyevans)
+
+* Model#validates_unique in the validation helpers plugin now defaults to only checking on new or modified values (jeremyevans)
+
+* Deprecate Model#_before_validation (private_method), use Model#before_validation now (jeremyevans)
+
+* Always run before/after/around validation hooks when saving, even when not validating the object (jeremyevans)
+
+* Deprecate Model use_after_commit_rollback class and instance accessors (jeremyevans)
+
+* Deprecate Model.allowed_columns reader (jeremyevans)
+
+* Freeze internal constants that shouldn't be modified at runtime (jeremyevans)
+
+* Attempt to connect to the database immediately when creating the Database instance (jeremyevans)
+
+* Make association_pks plugin delay the setting of associated objects until the current object is saved by default (jeremyevans)
+
+* Joined datasets used as model datasets are now automatically wrapped in a subquery (jeremyevans)
+
+* Setting an invalid dataset for a model class now raises an exception by default (jeremyevans)
+
+* Getting all values for newly created models now happens before calling after_create, instead of after (jeremyevans)
+
+* Remove use of @was_new/@columns_updated instance variables when saving model objects (jeremyevans)
+
+* Disable symbol splitting by default (jeremyevans)
+
+* Make datasets frozen by default (jeremyevans)
+
+* Drop support for ruby 1.8.7, minimum now is 1.9.2 (jeremyevans) 
+
+* Remove deprecated adapters, extensions, plugins, constants, and features (jeremyevans)
+
 === 4.49.0 (2017-08-01)
 
 * Make dataset_associations plugin automatically alias tables when using many_through_many associations that join the same table multiple times (jeremyevans)

data/README.rdoc

@@ -8,9 +8,9 @@ toolkit for Ruby.
 * Sequel includes a comprehensive ORM layer for mapping
   records to Ruby objects and handling associated records.
 * Sequel supports advanced database features such as prepared
-  statements, bound variables, stored procedures, savepoints,
-  two-phase commit, transaction isolation, master/slave
-  configurations, and database sharding.
+  statements, bound variables, savepoints, two-phase commit,
+  transaction isolation, master/slave configurations, and
+  database sharding.
 * Sequel currently has adapters for ADO, Amalgalite, 
   IBM_DB, JDBC, MySQL, Mysql2, ODBC, Oracle,
   PostgreSQL, SQLAnywhere, SQLite3, and TinyTDS.
@@ -71,7 +71,7 @@ Sequel includes an IRB console for quick access to databases (usually referred t
 
   sequel sqlite://test.db # test.db in current directory
 
-You get an IRB session with the database object stored in DB.
+You get an IRB session with the Sequel::Database object stored in DB.
 
 In addition to providing an IRB shell (the default behavior), bin/sequel also has support for migrating databases, dumping schema migrations, and copying databases.  See the {bin/sequel guide}[rdoc-ref:doc/bin_sequel.rdoc] for more details.
 
@@ -89,18 +89,19 @@ Which is equivalent to:
 
   SELECT avg(GDP) FROM countries WHERE region = 'Middle East'
 
-Since datasets retrieve records only when needed, they can be stored and later reused. Records are fetched as hashes (or custom model objects), and are accessed using an +Enumerable+ interface:
+Since datasets retrieve records only when needed, they can be stored and later reused. Records are fetched as hashes, and are accessed using an +Enumerable+ interface:
 
   middle_east = DB[:countries].where(:region => 'Middle East')
   middle_east.order(:name).each{|r| puts r[:name]}
   
 Sequel also offers convenience methods for extracting data from Datasets, such as an extended +map+ method:
 
-  middle_east.map(:name) #=> ['Egypt', 'Turkey', 'Israel', ...]
+  middle_east.map(:name) # => ['Egypt', 'Turkey', 'Israel', ...]
+  middle_east.map([:id, :name]) # => [[1, 'Egypt'], [3, 'Turkey'], [2, 'Israel'], ...]
   
-Or getting results as a hash via +to_hash+, with one column as key and another as value:
+Or getting results as a hash via +as_hash+, with one column as key and another as value:
 
-  middle_east.to_hash(:name, :area) #=> {'Israel' => 20000, 'Turkey' => 120000, ...}
+  middle_east.as_hash(:name, :area) # => {'Israel' => 20000, 'Turkey' => 120000, ...}
 
 == Getting Started
 
@@ -118,7 +119,12 @@ The connection URL can also include such stuff as the user name, password, and p
 You can also specify optional parameters, such as the connection pool size, or loggers for logging SQL queries:
 
   DB = Sequel.connect("postgres://user:password@host:port/database_name",
-    :max_connections => 10, :logger => Logger.new('log/db.log'))
+    max_connections: 10, logger: Logger.new('log/db.log'))
+
+It is also possible to use a hash instead of a connection URL, but make sure to include the :adapter option in this case:
+
+  DB = Sequel.connect(adapter: :postgres, user: 'user', password: 'password', host: 'host', port: port,
+    database: 'database_name", max_connections: 10, logger: Logger.new('log/db.log'))
 
 You can specify a block to connect, which will disconnect from the database after it completes:
 
@@ -166,7 +172,7 @@ Datasets are the primary way records are retrieved and manipulated.  They are ge
   posts = DB.from(:posts)
   posts = DB[:posts] # same
 
-Datasets will only fetch records when you tell them to. They can be manipulated to filter records, change ordering, join tables, etc..
+Datasets will only fetch records when you tell them to. They can be manipulated to filter records, change ordering, join tables, etc..  Datasets are always frozen, and they safe to use by multiple threads concurrently.
 
 === Retrieving Records
 
@@ -188,68 +194,92 @@ Or perform more advanced stuff:
   
 You can also retrieve the first record in a dataset:
 
-  posts.first
-  # SELECT * FROM posts LIMIT 1
+  posts.order(:id).first
+  # SELECT * FROM posts ORDER BY id LIMIT 1
   
-Or retrieve a single record with a specific value:
+Note that you can get the first record in a dataset even if it isn't ordered:
 
-  posts[:id => 1]
-  # SELECT * FROM posts WHERE id = 1 LIMIT 1
+  posts.first
+  # SELECT * FROM posts LIMIT 1
   
 If the dataset is ordered, you can also ask for the last record:
 
   posts.order(:stamp).last
   # SELECT * FROM posts ORDER BY stamp DESC LIMIT 1
   
+You can also provide a filter when asking for a single record:
+
+  posts.first(:id => 1)
+  # SELECT * FROM posts WHERE id = 1 LIMIT 1
+  
+Or retrieve a single value for a specific record:
+
+  posts.where(:id => 1).get(:name)
+  # SELECT name FROM posts WHERE id = 1 LIMIT 1
+  
 === Filtering Records
 
-An easy way to filter records is to provide a hash of values to match to +where+:
+The most common way to filter records is to provide a hash of values to match to +where+:
 
-  my_posts = posts.where(:category => 'ruby', :author => 'david')
-  # WHERE category = 'ruby' AND author = 'david'
+  my_posts = posts.where(category: 'ruby', author: 'david')
+  # WHERE ((category = 'ruby') AND (author = 'david'))
   
 You can also specify ranges:
 
-  my_posts = posts.where(:stamp => (Date.today - 14)..(Date.today - 7))
-  # WHERE stamp >= '2010-06-30' AND stamp <= '2010-07-07'
+  my_posts = posts.where(stamp: (Date.today - 14)..(Date.today - 7))
+  # WHERE ((stamp >= '2010-06-30') AND (stamp <= '2010-07-07'))
   
 Or arrays of values:
 
-  my_posts = posts.where(:category => ['ruby', 'postgres', 'linux'])
-  # WHERE category IN ('ruby', 'postgres', 'linux')
+  my_posts = posts.where(category: ['ruby', 'postgres', 'linux'])
+  # WHERE (category IN ('ruby', 'postgres', 'linux'))
   
-Sequel also accepts expressions:
+By passing a block to where, you can use expressions (this is fairly "magical"):
   
   my_posts = posts.where{stamp > Date.today << 1}
-  # WHERE stamp > '2010-06-14'
+  # WHERE (stamp > '2010-06-14')
   my_posts = posts.where{stamp =~ Date.today}
-  # WHERE stamp = '2010-07-14'
+  # WHERE (stamp = '2010-07-14')
+  
+If you want to wrap the objects yourself, you can use expressions without the "magic":
+  
+  my_posts = posts.where(Sequel[:stamp] > Date.today << 1)
+  # WHERE (stamp > '2010-06-14')
+  my_posts = posts.where(Sequel[:stamp] =~ Date.today)
+  # WHERE (stamp = '2010-07-14')
   
-Some adapters will also let you specify Regexps:
+Some databases such as PostgreSQL and MySQL also support filtering via Regexps:
 
-  my_posts = posts.where(:category => /ruby/i)
-  # WHERE category ~* 'ruby'
+  my_posts = posts.where(category: /ruby/i)
+  # WHERE (category ~* 'ruby')
   
 You can also use an inverse filter via +exclude+:
 
-  my_posts = posts.exclude(:category => ['ruby', 'postgres', 'linux'])
-  # WHERE category NOT IN ('ruby', 'postgres', 'linux')
+  my_posts = posts.exclude(category: ['ruby', 'postgres', 'linux'])
+  # WHERE (category NOT IN ('ruby', 'postgres', 'linux'))
 
-You can also specify a custom WHERE clause using a string:
+But note that this does a full inversion of the filter:
 
-  posts.where('stamp IS NOT NULL')
-  # WHERE stamp IS NOT NULL
+  my_posts = posts.exclude(category: ['ruby', 'postgres', 'linux'], id: 1)
+  # WHERE ((category NOT IN ('ruby', 'postgres', 'linux')) OR (id != 1))
 
-You can use parameters in your string, as well:
+If at any point you want to use a custom SQL fragment for part of a query,
+you can do so via +Sequel.lit+:
+
+  posts.where(Sequel.lit('stamp IS NOT NULL'))
+  # WHERE (stamp IS NOT NULL)
+
+You can safely interpolate parameters into the custom SQL fragment by
+providing them as additional arguments:
 
   author_name = 'JKR'
-  posts.where('(stamp < ?) AND (author != ?)', Date.today - 3, author_name)
-  # WHERE (stamp < '2010-07-11') AND (author != 'JKR')
+  posts.where(Sequel.lit('(stamp < ?) AND (author != ?)', Date.today - 3, author_name))
+  # WHERE ((stamp < '2010-07-11') AND (author != 'JKR'))
 
 Datasets can also be used as subqueries:
 
-  DB[:items].where('price > ?', DB[:items].select{avg(price) + 100})
-  # WHERE price > (SELECT avg(price) + 100 FROM items)
+  DB[:items].where(Sequel[:price] > DB[:items].select{avg(price) + 100})
+  # WHERE (price > (SELECT avg(price) + 100 FROM items))
 
 After filtering, you can retrieve the matching records by using any of the retrieval methods:
 
@@ -268,7 +298,7 @@ issues that you should be aware of when using Sequel.
 Counting records is easy using +count+:
 
   posts.where(Sequel.like(:category, '%ruby%')).count
-  # SELECT COUNT(*) FROM posts WHERE category LIKE '%ruby%'
+  # SELECT COUNT(*) FROM posts WHERE (category LIKE '%ruby%' ESCAPE '\')
 
 And you can also query maximum/minimum values via +max+ and +min+:
 
@@ -294,18 +324,15 @@ Ordering datasets is simple using +order+:
   posts.order(:stamp, :name)
   # ORDER BY stamp, name
 
-Chaining +order+ doesn't work the same as +where+:
++order+ always overrides the existing order:
 
   posts.order(:stamp).order(:name)
   # ORDER BY name
 
-The +order_append+ method chains this way, though:
+If you would like to add to the existing order, use +order_append+ or +order_prepend+:
 
   posts.order(:stamp).order_append(:name)
   # ORDER BY stamp, name
-  
-The +order_prepend+ method can be used as well:
-
   posts.order(:stamp).order_prepend(:name)
   # ORDER BY name, stamp
   
@@ -335,7 +362,7 @@ Selecting specific columns to be returned is also simple using +select+:
   posts.select(:stamp, :name)
   # SELECT stamp, name FROM posts
 
-Chaining +select+ works like +order+, not +where+:
+Like +order+, +select+ overrides an existing selection:
 
   posts.select(:stamp).select(:name)
   # SELECT name FROM posts
@@ -349,52 +376,56 @@ As you might expect, there is an +order_append+ equivalent for +select+ called +
 
 Deleting records from the table is done with +delete+:
 
-  posts.where('stamp < ?', Date.today - 3).delete
-  # DELETE FROM posts WHERE stamp < '2010-07-11'
+  posts.where(Sequel[:stamp] < Date.today - 3).delete
+  # DELETE FROM posts WHERE (stamp < '2010-07-11')
   
 Be very careful when deleting, as +delete+ affects all rows in the dataset.
 Call +where+ first and +delete+ second:
 
   # DO THIS:
-  posts.where('stamp < ?', Date.today - 7).delete
+  posts.where(Sequel[:stamp] < Date.today - 7).delete
   # NOT THIS:
-  posts.delete.where('stamp < ?', Date.today - 7)
+  posts.delete.where(Sequel[:stamp] < Date.today - 7)
 
 === Inserting Records
 
 Inserting records into the table is done with +insert+:
 
-  posts.insert(:category => 'ruby', :author => 'david')
+  posts.insert(category: 'ruby', author: 'david')
   # INSERT INTO posts (category, author) VALUES ('ruby', 'david')
   
 === Updating Records
 
 Updating records in the table is done with +update+:
 
-  posts.where('stamp < ?', Date.today - 7).update(:state => 'archived')
-  # UPDATE posts SET state = 'archived' WHERE stamp < '2010-07-07'
+  posts.where(Sequel[:stamp] < Date.today - 7).update(state: 'archived')
+  # UPDATE posts SET state = 'archived' WHERE (stamp < '2010-07-07')
 
-You can reference table columns when choosing what values to set:
+You can provide arbitrary expressions when choosing what values to set:
 
-  posts.where{|o| o.stamp < Date.today - 7}.update(:backup_number => Sequel.+(:backup_number, 1))
-  # UPDATE posts SET backup_number = backup_number + 1 WHERE stamp < '2010-07-07'
+  posts.where(Sequel[:stamp] < Date.today - 7).update(backup_number: Sequel[:backup_number] + 1)
+  # UPDATE posts SET backup_number = (backup_number + 1) WHERE (stamp < '2010-07-07'))))
 
 As with +delete+, +update+ affects all rows in the dataset, so +where+ first,
 +update+ second:
 
   # DO THIS:
-  posts.where('stamp < ?', Date.today - 7).update(:state => 'archived')
+  posts.where(Sequel[:stamp] < Date.today - 7).update(:state => 'archived')
   # NOT THIS:
-  posts.update(:state => 'archived').where('stamp < ?', Date.today - 7)
+  posts.update(:state => 'archived').where(Sequel[:stamp] < Date.today - 7)
 
 === Transactions
 
-You can wrap some code in a database transaction using the <tt>Database#transaction</tt> method:
+You can wrap a block of code in a database transaction using the <tt>Database#transaction</tt> method:
 
   DB.transaction do
-    posts.insert(:category => 'ruby', :author => 'david')
-    posts.where('stamp < ?', Date.today - 7).update(:state => 'archived')
+    # BEGIN
+    posts.insert(category: 'ruby', author: 'david')
+    # INSERT
+    posts.where(Sequel[:stamp] < Date.today - 7).update(:state => 'archived')
+    # UPDATE 
   end
+  # COMMIT
 
 If the block does not raise an exception, the transaction will be committed.
 If the block does raise an exception, the transaction will be rolled back,
@@ -403,21 +434,24 @@ and not raise an exception outside the block, you can raise the
 <tt>Sequel::Rollback</tt> exception inside the block:
 
   DB.transaction do
+    # BEGIN
     posts.insert(:category => 'ruby', :author => 'david')
+    # INSERT
     if posts.where('stamp < ?', Date.today - 7).update(:state => 'archived') == 0
+    # UPDATE 
       raise Sequel::Rollback
     end
   end
+  # ROLLBACK
 
 === Joining Tables
 
 Sequel makes it easy to join tables:
 
-  order_items = DB[:items].join(:order_items, :item_id => :id).
-    where(:order_id => 1234)
-  # SELECT * FROM items INNER JOIN order_items
-  # ON order_items.item_id = items.id 
-  # WHERE order_id = 1234
+  order_items = DB[:items].join(:order_items, item_id: :id).where(order_id: 1234)
+  # SELECT * FROM items
+  # INNER JOIN order_items ON (order_items.item_id = items.id)
+  # WHERE (order_id = 1234)
 
 The important thing to note here is that item_id is automatically qualified with
 the table being joined, and id is automatically qualified with the last table
@@ -426,9 +460,9 @@ joined.
 You can then do anything you like with the dataset:
 
   order_total = order_items.sum(:price)
-  # SELECT sum(price) FROM items INNER JOIN order_items
-  # ON order_items.item_id = items.id
-  # WHERE order_items.order_id = 1234
+  # SELECT sum(price) FROM items
+  # INNER JOIN order_items ON (order_items.item_id = items.id)
+  # WHERE (order_id = 1234)
   
 Note that the default selection in Sequel is <tt>*</tt>, which includes all columns
 in all joined tables.  Because Sequel returns results as a hash keyed by column name
@@ -440,57 +474,52 @@ selection using +select+, +select_all+, and/or +select_append+.
 
 Sequel expects column names to be specified using symbols. In addition, returned hashes always use symbols as their keys. This allows you to freely mix literal values and column references in many cases. For example, the two following lines produce equivalent SQL:
 
-  items.where(:x => 1)
+  items.where(x: 1)
   # SELECT * FROM items WHERE (x = 1)
   items.where(1 => :x)
   # SELECT * FROM items WHERE (1 = x)"
 
 Ruby strings are generally treated as SQL strings:
 
-  items.where(:x => 'x')
+  items.where(x: 'x')
   # SELECT * FROM items WHERE (x = 'x')
 
 === Qualifying identifiers (column/table names)
 
 An identifier in SQL is a name that represents a column, table, or schema.
-By default, identifiers can be qualified by using the double underscore special notation <tt>:table__column</tt>:
-
-  items.literal(:items__price)
-  # items.price
+The recommended way to qualify columns is to use <tt>Sequel[][]</tt> or +Sequel.qualify+
 
-Another way to qualify columns is to use the <tt>Sequel[][]</tt> method:
+  Sequel[:table][:column]
+  Sequel.qualify(:table, :column)
+  # table.column
 
-  items.literal(Sequel[:items][:price])
-  # items.price
+You can also qualify tables with schemas:
 
-While it is more common to qualify column identifiers with table identifiers, you can also qualify table identifiers with schema identifiers
-to select from a qualified table:
+  Sequel[:schema][:table]
+  # schema.table
 
-  posts = DB[:some_schema__posts]
-  # SELECT * FROM some_schema.posts
+or use multi-level qualification:
 
-=== Identifier aliases
+  Sequel[:schema][:table][:column]
+  # schema.table.column
 
-By default, you can also alias identifiers by using the triple underscore special notation <tt>:column___alias</tt> or <tt>:table__column___alias</tt>:
+=== Expression aliases
 
-  items.literal(:price___p)
-  # price AS p
-  items.literal(:items__price___p)
-  # items.price AS p
+You can alias identifiers using  <tt>Sequel[].as</tt> or +Sequel.as+:
 
-Another way to alias columns is to use the <tt>Sequel.as</tt> method:
-
-  items.literal(Sequel.as(:price, :p))
-  # price AS p
+  Sequel[:column].as(:alias)
+  Sequel.as(:column, :alias)
+  # column AS alias
 
 You can use the <tt>Sequel.as</tt> method to alias arbitrary expressions, not just identifiers:
 
-  items.literal(Sequel.as(DB[:posts].select{max(id)}, :p))
+  Sequel.as(DB[:posts].select{max(id)}, :p)
   # (SELECT max(id) FROM posts) AS p
 
-You can turn off the splitting of symbols containing double and triple underscores, and treat all symbols as regular identifiers, by using:
+And most Sequel expression objects support an +as+ method for aliasing:
 
-  Sequel.split_symbols = false
+  (Sequel[:column] + 2).as(:c_plus_2)
+  # (column + 2) AS c_plus_2
 
 == Sequel Models
 
@@ -508,7 +537,7 @@ implements the active record pattern).
 
 Sequel model classes assume that the table name is an underscored plural of the class name:
 
-  Post.table_name #=> :posts
+  Post.table_name # => :posts
 
 You can explicitly set the table name or even the dataset used:
 
@@ -518,27 +547,27 @@ You can explicitly set the table name or even the dataset used:
 
 If you pass a symbol to the <tt>Sequel::Model</tt> method, it assumes you are referring to the table with the same name.  You can also call it with a dataset, which will set the defaults for all retrievals for that model:
 
-  class Post < Sequel::Model(DB[:my_posts].where(:category => 'ruby')); end
+  class Post < Sequel::Model(DB[:my_posts].where(category: 'ruby')); end
   class Post < Sequel::Model(DB[:my_posts].select(:id, :name).order(:date)); end
 
 === Model instances
 
-Model instances are identified by a primary key.  In most cases, Sequel can query the database to determine the primary key, but if not, it defaults to using <tt>:id</tt>. The <tt>Model.[]</tt> method can be used to fetch records by their primary key:
+Model instances are identified by a primary key.  Sequel queries the database to determine the primary key for each model. The <tt>Model.[]</tt> method can be used to fetch records by their primary key:
 
   post = Post[123]
 
 The +pk+ method is used to retrieve the record's primary key value:
 
-  post.pk #=> 123
+  post.pk # => 123
 
-Sequel models allow you to use any column as a primary key, and even composite keys made from multiple columns:
+If you want to override which column(s) to use as the primary key, you can use +set_primary_key+:
 
   class Post < Sequel::Model
     set_primary_key [:category, :title]
   end
 
   post = Post['ruby', 'hello world']
-  post.pk #=> ['ruby', 'hello world']
+  post.pk # => ['ruby', 'hello world']
 
 You can also define a model class that does not have a primary key via +no_primary_key+, but then you lose the ability to easily update and delete records:
 
@@ -546,39 +575,43 @@ You can also define a model class that does not have a primary key via +no_prima
 
 A single model instance can also be fetched by specifying a condition:
 
-  post = Post[:title => 'hello world']
+  post = Post.first(title: 'hello world')
   post = Post.first{num_comments < 10}
 
+The dataset for a model class returns rows a model instances instead of plain hashes:
+
+  DB[:posts].first.class # => Hash
+  Post.first.class # => Post
+
 === Acts like a dataset
 
 A model class forwards many methods to the underlying dataset. This means that you can use most of the +Dataset+ API to create customized queries that return model instances, e.g.:
 
-  Post.where(:category => 'ruby').each{|post| p post}
+  Post.where(category: 'ruby').each{|post| p post}
 
 You can also manipulate the records in the dataset:
 
   Post.where{num_comments < 7}.delete
-  Post.where(Sequel.like(:title, /ruby/)).update(:category => 'ruby')
+  Post.where(Sequel.like(:title, /ruby/)).update(category: 'ruby')
 
 === Accessing record values
 
 A model instance stores its values as a hash with column symbol keys, which you can access directly via the +values+ method:
 
-  post.values #=> {:id => 123, :category => 'ruby', :title => 'hello world'}
+  post.values # => {:id => 123, :category => 'ruby', :title => 'hello world'}
 
 You can read the record values as object attributes, assuming the attribute names are valid columns in the model's dataset:
 
-  post.id #=> 123
-  post.title #=> 'hello world'
+  post.id # => 123
+  post.title # => 'hello world'
   
 If the record's attributes names are not valid columns in the model's dataset (maybe because you used +select_append+ to add a computed value column), you can use <tt>Model#[]</tt> to access the values:
 
-  post[:id] #=> 123
-  post[:title] #=> 'hello world'
+  post[:id] # => 123
+  post[:title] # => 'hello world'
 
 You can also modify record values using attribute setters or the <tt>[]=</tt> method.
 
-
   post.title = 'hey there'
   post[:title] = 'hey there'
 
@@ -590,24 +623,26 @@ That will just change the value for the object, it will not update the row in th
 
 You can also set the values for multiple columns in a single method call, using one of the mass-assignment methods.  See the {mass assignment guide}[rdoc-ref:doc/mass_assignment.rdoc] for details.  For example +set+ updates the model's column values without saving:
 
-  post.set(:title=>'hey there', :updated_by=>'foo')
+  post.set(title: 'hey there', updated_by: 'foo')
 
 and +update+ updates the model's column values and then saves the changes to the database:
 
-  post.update(:title => 'hey there', :updated_by=>'foo')
+  post.update(title: 'hey there', updated_by: 'foo')
 
 === Creating new records
 
-New records can be created by calling <tt>Model.create</tt>:
+New model instances can be created by calling <tt>Model.new</tt>, which returns a new model instance without updating the database:
 
-  post = Post.create(:title => 'hello world')
+  post = Post.new(title: 'hello world')
 
-Another way is to construct a new instance and save it later:
+You can save the record to the database later by calling +save+ on the model instance:
 
-  post = Post.new
-  post.title = 'hello world'
   post.save
 
+If you want to create a new record and save it to the database at the same time, you can use <tt>Model.create</tt>:
+
+  post = Post.create(title: 'hello world')
+
 You can also supply a block to <tt>Model.new</tt> and <tt>Model.create</tt>:
 
   post = Post.new do |p|
@@ -634,7 +669,7 @@ You can execute custom code when creating, updating, or deleting records by defi
 
 Note the use of +super+ if you define your own hook methods.  Almost all <tt>Sequel::Model</tt> class and instance methods (not just hook methods) can be overridden safely, but you have to make sure to call +super+ when doing so, otherwise you risk breaking things.
 
-For the example above, you should probably use a database trigger if you can.  Hooks can be used for data integrity, but they will only enforce that integrity when you are modifying the database through model instances, and even then they are often subject to race conditions.  It's best to use database triggers and constraints to enforce data integrity.
+For the example above, you should probably use a database trigger if you can.  Hooks can be used for data integrity, but they will only enforce that integrity when you are modifying the database through model instances, and even then they are often subject to race conditions.  It's best to use database triggers and database constraints to enforce data integrity.
 
 === Deleting records
 
@@ -666,21 +701,21 @@ Associations are used in order to specify relationships between model classes th
 
 +many_to_one+ and +one_to_one+ create a getter and setter for each model object:
 
-  post = Post.create(:name => 'hi!')
-  post.author = Author[:name => 'Sharon']
+  post = Post.create(name: 'hi!')
+  post.author = Author.first(name: 'Sharon')
   post.author
 
 +one_to_many+ and +many_to_many+ create a getter method, a method for adding an object to the association, a method for removing an object from the association, and a method for removing all associated objects from the association:
 
-  post = Post.create(:name => 'hi!')
+  post = Post.create(name: 'hi!')
   post.comments
 
-  comment = Comment.create(:text=>'hi')
+  comment = Comment.create(text: 'hi')
   post.add_comment(comment)
   post.remove_comment(comment)
   post.remove_all_comments
 
-  tag = Tag.create(:tag=>'interesting')
+  tag = Tag.create(tag: 'interesting')
   post.add_tag(tag)
   post.remove_tag(tag)
   post.remove_all_tags
@@ -693,7 +728,7 @@ All associations add a dataset method that can be used to further filter or reor
   post.comments_dataset.destroy
 
   # Return all tags related to this post with no subscribers, ordered by the tag's name
-  post.tags_dataset.where(:subscribers=>0).order(:name).all
+  post.tags_dataset.where(subscribers: 0).order(:name).all
 
 === Eager Loading
 
@@ -735,32 +770,32 @@ Associations can be eagerly loaded via +eager+ and the <tt>:eager</tt> associati
   Post.eager(:person).eager(:tags).all
   
   # Cascading via .eager
-  Tag.eager(:posts=>:replies).all
+  Tag.eager(posts: :replies).all
   
   # Will also grab all associated posts' tags (because of :eager)
-  Reply.eager(:person=>:posts).all
+  Reply.eager(person: :posts).all
   
   # No depth limit (other than memory/stack), and will also grab posts' tags
   # Loads all people, their posts, their posts' tags, replies to those posts,
   # the person for each reply, the tag for each reply, and all posts and
   # replies that have that tag.  Uses a total of 8 queries.
-  Person.eager(:posts=>{:replies=>[:person, {:tags=>[:posts, :replies]}]}).all
+  Person.eager(posts: {replies: [:person, {tags: [:posts, :replies]}]}).all
 
-In addition to using +eager+, you can also use +eager_graph+, which will use a single query to get the object and all associated objects.  This may be necessary if you want to filter or order the result set based on columns in associated tables.  It works with cascading as well, the API is very similar.  Note that using +eager_graph+ to eagerly load multiple <tt>*_to_many</tt> associations will cause the result set to be a cartesian product, so you should be very careful with your filters when using it in that case.
+In addition to using +eager+, you can also use +eager_graph+, which will use a single query to get the object and all associated objects.  This may be necessary if you want to filter or order the result set based on columns in associated tables.  It works with cascading as well, the API is similar.  Note that using +eager_graph+ to eagerly load multiple <tt>*_to_many</tt> associations will cause the result set to be a cartesian product, so you should be very careful with your filters when using it in that case.
 
 You can dynamically customize the eagerly loaded dataset by using a proc.  This proc is passed the dataset used for eager loading, and should return a modified copy of that dataset:
 
   # Eagerly load only replies containing 'foo'
-  Post.eager(:replies=>proc{|ds| ds.where(Sequel.like(text, '%foo%'))}).all
+  Post.eager(replies: proc{|ds| ds.where(Sequel.like(text, '%foo%'))}).all
 
 This also works when using +eager_graph+, in which case the proc is called with dataset to graph into the current dataset:
 
-  Post.eager_graph(:replies=>proc{|ds| ds.where(Sequel.like(text, '%foo%'))}).all
+  Post.eager_graph(replies: proc{|ds| ds.where(Sequel.like(text, '%foo%'))}).all
 
 You can dynamically customize eager loads for both +eager+ and +eager_graph+ while also cascading, by making the value a single entry hash with the proc as a key, and the cascaded associations as the value:
 
   # Eagerly load only replies containing 'foo', and the person and tags for those replies
-  Post.eager(:replies=>{proc{|ds| ds.where(Sequel.like(text, '%foo%'))}=>[:person, :tags]}).all
+  Post.eager(replies: {proc{|ds| ds.where(Sequel.like(text, '%foo%'))} => [:person, :tags]}).all
 
 === Joining with Associations
 
@@ -778,7 +813,7 @@ This comes with variants for different join types:
 
 Similar to the eager loading methods, you can use multiple associations and nested associations:
 
-  Post.association_join(:author, :replies=>:person).all
+  Post.association_join(:author, replies: :person).all
   # SELECT * FROM posts
   # INNER JOIN authors AS author ON (author.id = posts.author_id)
   # INNER JOIN replies ON (replies.post_id = posts.id)
@@ -802,16 +837,16 @@ The recommended way to implement table-wide logic by defining methods on the dat
 
 This allows you to have access to your model API from filtered datasets as well:
 
-  Post.where(:category => 'ruby').clean_boring
+  Post.where(category: 'ruby').clean_boring
   # DELETE FROM posts WHERE ((category = 'ruby') AND (num_comments < 30))
 
 Inside +dataset_module+ blocks, there are numerous methods that support easy creation of dataset methods.
 Most of these methods are named after the dataset methods themselves, such as +select+, +order+, and
-+group+, and there is also a method named +subset+ which uses a filter:
++group+:
 
   class Post < Sequel::Model
     dataset_module do
-      subset(:with_few_comments){num_comments < 30}
+      where(:with_few_comments, Sequel[:num_comments] < 30)
       select :with_title_and_date, :id, :title, :post_date
       order :by_post_date, :post_date
       limit :top10, 10
@@ -824,6 +859,10 @@ Most of these methods are named after the dataset methods themselves, such as +s
   # ORDER BY post_date
   # LIMIT 10
 
+One advantage of using these methods inside dataset_module blocks, instead of
+defining methods manually, is that the created methods will generally cache
+the resulting values and result in better performance.
+
 === Model Validations
 
 You can define a +validate+ method for your model, which +save+
@@ -831,8 +870,7 @@ will check before attempting to save the model in the database.
 If an attribute of the model isn't valid, you should add an error
 message for that attribute to the model object's +errors+. If an
 object has any errors added by the validate method, +save+ will
-raise an error or return false depending on how it is configured
-(the +raise_on_save_failure+ flag).
+raise an error by default:
 
   class Post < Sequel::Model
     def validate
@@ -841,3 +879,24 @@ raise an error or return false depending on how it is configured
       errors.add(:written_on, "should be in the past") if written_on >= Time.now
     end
   end
+
+== Sequel Release Policy
+
+New major versions of Sequel do not have a defined release policy, but historically have
+occurred once ever few years.
+
+New minor versions of Sequel are released around once a month near the start of the month.
+
+New tiny versions of Sequel are only released to address security issues or regressions
+in the most current release.
+
+== Ruby Support Policy
+
+Sequel fully supports the currently supported versions of Ruby (MRI) and JRuby.  It may
+support unsupported versions of Ruby or JRuby, but such support may be dropped in any
+minor version of keeping it becomes a support issue.  The minimum Ruby version
+required to run the current version of Sequel is 1.9.2.
+
+== Maintainer
+
+Jeremy Evans <code@jeremyevans.net>