sequel 4.13.0 → 4.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 22556ea07ee280b6aeb118f6079e84cd50079cd4
-  data.tar.gz: 011dbf4ff522233e9bed8a1b2bab18347237345b
+  metadata.gz: 9b817d0bad633a1df7f0a331264d8ce67e0a2c40
+  data.tar.gz: e46c816ef87e537d58a982e876011f14ab42c6a3
 SHA512:
-  metadata.gz: 9dc9163ebb7f4066cd44da3bdd85b1f5f26cea75b4af812f50ef2c950742b38b992b5c0fbdf61428395b3624788b31cf9f42a9da9b7bfac4ea4976cd29c73b69
-  data.tar.gz: 0ba493e43d63d2fe3d750a621199bb5f43b39e72858424e0089ff977045a3bc6b1c472751ad4c629bbf83680de7bad227cd29c4d7f705389ee212ee638e5c77f
+  metadata.gz: d88876ee4814e172d6ed262b14a87f253e5864d03f8f3167420e10d6d3a873625a1fb797b406bc2438a28d7df846535f9af38f2dc90cc57c6167d6c333723345
+  data.tar.gz: c0a61d9260147f6fa4d458242b7ebb6139eacee710e84eb1361d9527a15dea1ecbad377893b3a0dede352af92061308c4e5fd76d4741df60cdc1cf0f3819ddc3

data/CHANGELOG

@@ -1,3 +1,27 @@
+=== 4.14.0 (2014-09-01)
+
+* Raise original exception if there is an exception raised when rolling back transaction/savepoint (jeremyevans) (#875)
+
+* Allow delayed evaluation blocks to take dataset as an argument (jeremyevans)
+
+* Allow more types as filter expressions, only specifically disallow Numeric/String expressions (jeremyevans)
+
+* Remove objects from cached association array at time of nested_attributes call instead of waiting until save (jeremyevans)
+
+* Handle composite primary keys when working around validation issues for one_to_(one|many) associations in nested_attributes plugin (jeremyevans) (#870)
+
+* Recognize additional disconnect error in jdbc/jtds adapter (jeremyevans)
+
+* Have association_join work with existing model selections (jeremyevans)
+
+* Fix regression in class_table_inheritance plugin when lazily loading column in middle table (jeremyevans) (#862)
+
+* Add cache_key_prefix method to caching plugin, which can be overridden for custom handling (pete) (#861)
+
+* Add :when option to PostgreSQL create_trigger method, for adding a filter to the trigger (aschrab) (#860)
+
+* Recognize an additional serialization failure on PostgreSQL (tmtm) (#857)
+
 === 4.13.0 (2014-08-01)
 
 * Use copy constructors instead of overriding Model#dup and #clone (ged, jeremyevans) (#852)

data/doc/active_record.rdoc

@@ -327,8 +327,8 @@ ActiveRecord 2 tries to guess whether to use preloading or JOINs for eager loadi
 
 With either way of eager loading, you must call +all+ to retrieve all records at once.  You cannot use +each+, +map+, or one of the other Enumerable methods.  Just like +each+, +all+ takes a block that iterates over the records:
 
-  Artist.eager(:albums=>[:tags, :tracks]).each{|a| ...} # No cookie
-  Artist.eager(:albums=>[:tags, :tracks]).all{|a| ...} # Cookie
+  Artist.eager(:albums=>[:tags, :tracks]).each{|a| } # No cookie
+  Artist.eager(:albums=>[:tags, :tracks]).all{|a| } # Cookie
   
 Like ActiveRecord, Sequel supports cascading of eager loading for both methods of eager loading.
 
@@ -495,7 +495,7 @@ Note that +test_connection+ will return true if a connection can be made, but wi
 Sequel only uses connections for the minimum amount of time necessary, checking them out to do a query, and returning them as soon as the query finishes.  If you do want direct access to the connection object:
 
   Sequel::Model.db.synchronize do |connection|
-    ...
+    # ...
   end
 
 Note that the connection is yielded to the block, and the block ensures it is returned to the pool.  Sequel doesn't have a method that returns a connection, since that would check it out with no ability to ensure it is returned to the pool.
@@ -532,7 +532,7 @@ If you really want to destroy all rows in the table,call +destroy+ on the Model'
 
 If you want to use a specific <tt>Sequel::Database</tt> object, you can use <tt>db=</tt>:
 
-  BACKUP_DB = Sequel.connect(...)
+  BACKUP_DB = Sequel.connect('postgres://...')
   Album.db = BACKUP_DB
 
 If you want a specific dataset in that database, you can use +set_dataset+ or <tt>dataset=</tt>:

data/doc/advanced_associations.rdoc

@@ -194,7 +194,7 @@ artist or tracks method on the album will not do another database lookup.
 
 So putting everything together, the artist eager loader looks like:
 
-  :eager_loader=>(proc do |eo_opts|
+  Album.many_to_one :artist, :eager_loader=>(proc do |eo_opts|
     eo_opts[:rows].each{|album| album.associations[:artist] = nil}
     id_map = eo_opts[:id_map]
     Artist.where(:id=>id_map.keys).all do |artist|
@@ -208,7 +208,7 @@ So putting everything together, the artist eager loader looks like:
 
 and the tracks eager loader looks like:
 
-  :eager_loader=>(proc do |eo_opts|
+  Album.one_to_many :tracks, :eager_loader=>(proc do |eo_opts|
     eo_opts[:rows].each{|album| album.associations[:tracks] = []}
     id_map = eo_opts[:id_map]
     Track.where(:id=>id_map.keys).all do |tracks|

data/doc/association_basics.rdoc

@@ -697,7 +697,7 @@ and a new associated object will be created from them:
 
   @artist.add_album(:name=>'RF') # creates Album object
 
-The add_<i>association</i> method returns the now associated object:
+The add_<i>association</i> method returns the new associated object:
 
   @album = @artist.add_album(:name=>'RF')
 
@@ -817,7 +817,7 @@ artist using the artist= method, this approach may perform better.
 
 === \_add_<i>association</i> (:adder option)
 
-Continuing with the same example, here's how would you handle the same case if
+Continuing with the same example, here's how you would handle the same case if
 you also wanted to handle the Artist#add_album method:
 
   class Artist < Sequel::Model
@@ -832,7 +832,7 @@ you also wanted to handle the Artist#add_album method:
 
 === \_remove_<i>association</i> (:remover option)
 
-Continuing with the same example, here's how would you handle the same case if
+Continuing with the same example, here's how you would handle the same case if
 you also wanted to handle the Artist#remove_album method:
 
   class Artist < Sequel::Model
@@ -847,7 +847,7 @@ you also wanted to handle the Artist#remove_album method:
 
 === \_remove_all_<i>association</i> (:clearer option)
 
-Continuing with the same example, here's how would you handle the same case if
+Continuing with the same example, here's how you would handle the same case if
 you also wanted to handle the Artist#remove_all_albums method:
 
   class Artist < Sequel::Model
@@ -909,10 +909,10 @@ or a String:
 
 ==== :key
 
-For +many_to_one+ associations, is the foreign_key in current model's table
-that references associated model's primary key, as a symbol.  Defaults to
-:<i>association</i>_id.  Can use an array of symbols for a composite key
-association.
+For +many_to_one+ associations, this is the foreign_key in the current model's
+table that references the associated model's primary key as a symbol.
+Defaults to :<i>association</i>_id.  Can use an array of symbols for a
+composite key association.
 
   Album.many_to_one :artist # :key=>:artist_id
 
@@ -1583,7 +1583,7 @@ using the association setter method.
 
 ==== :adder [*_to_many associations]
 
-Continuing with the same example, here's how would you handle the same case if
+Continuing with the same example, here's how you would handle the same case if
 you also wanted to handle the Artist#add_album method:
 
   class Artist < Sequel::Model
@@ -1594,7 +1594,7 @@ you also wanted to handle the Artist#add_album method:
 
 ==== :remover [*_to_many associations]
 
-Continuing with the same example, here's how would you handle the same case if
+Continuing with the same example, here's how you would handle the same case if
 you also wanted to handle the Artist#remove_album method:
 
   class Artist < Sequel::Model
@@ -1605,7 +1605,7 @@ you also wanted to handle the Artist#remove_album method:
 
 ==== :clearer [*_to_many associations]
 
-Continuing with the same example, here's how would you handle the same case if
+Continuing with the same example, here's how you would handle the same case if
 you also wanted to handle the Artist#remove_all_albums method:
 
   class Artist < Sequel::Model

data/doc/cheat_sheet.rdoc

@@ -20,7 +20,7 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
   require 'logger'
   DB = Sequel.sqlite '', :loggers => [Logger.new($stdout)]
   # or
-  DB.loggers << Logger.new(...)
+  DB.loggers << Logger.new($stdout)
 
 == Using raw SQL
 
@@ -100,7 +100,7 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
   DB[:items].where{(x > 5) & (y > 10)}.sql 
   # SELECT * FROM items WHERE ((x > 5) AND (y > 10))
 
-  DB[:items].where(Sequel.or(:x => 1, :y => 2)) & Sequel.~(:z => 3)).sql 
+  DB[:items].where(Sequel.or(:x => 1, :y => 2) & Sequel.~(:z => 3)).sql 
   # SELECT * FROM items WHERE (((x = 1) OR (y = 2)) AND (z != 3))
 
 === Mathematical operators
@@ -150,7 +150,7 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
   dataset.update(:updated_at => Sequel.function(:NOW))
   dataset.update(:updated_at => Sequel.lit('NOW()'))
 
-  dataset.update(:updated_at => Sequel.lit("DateValue('1/1/2001')")
+  dataset.update(:updated_at => Sequel.lit("DateValue('1/1/2001')"))
   dataset.update(:updated_at => Sequel.function(:DateValue, '1/1/2001'))
 
 == Schema Manipulation
@@ -184,7 +184,7 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
 Database#transaction is re-entrant:
 
   DB.transaction do # BEGIN issued only here
-    DB.transaction
+    DB.transaction do
       dataset << {:first_name => 'Inigo', :last_name => 'Montoya'}
     end
   end # COMMIT issued only here
@@ -205,7 +205,7 @@ Savepoints can be used if the database supports it:
 
   DB.transaction do
     dataset << {:first_name => 'Farm', :last_name => 'Boy'} # Inserted
-    DB.transaction(:savepoint=>true) # This savepoint is rolled back
+    DB.transaction(:savepoint=>true) do # This savepoint is rolled back
       dataset << {:first_name => 'Inigo', :last_name => 'Montoya'} # Not inserted
       raise(Sequel::Rollback) if something_bad_happened
     end
@@ -216,5 +216,5 @@ Savepoints can be used if the database supports it:
 
   dataset.sql # "SELECT * FROM items"
   dataset.delete_sql # "DELETE FROM items"
-  dataset.columns #=> array of columns in the result set, does a SELECT
-  DB.schema(:items) => [[:id, {:type=>:integer, ...}], [:name, {:type=>:string, ...}], ...]
+  dataset.columns # => array of columns in the result set, does a SELECT
+  DB.schema(:items) # => [[:id, {:type=>:integer, ...}], [:name, {:type=>:string, ...}], ...]

data/doc/core_extensions.rdoc

@@ -275,7 +275,7 @@ Array#case and Hash#case return an SQL CASE expression, where the keys are condi
 
 Alternative: Sequel.case:
 
-  Sequel.case({:a=>[2,3]}=>1}, 0)
+  Sequel.case({{:a=>[2,3]}=>1}, 0)
 
 ==== sql_expr
 

data/doc/dataset_filtering.rdoc

@@ -110,7 +110,7 @@ This works with other hash values, such as arrays and ranges:
   items.where{Sequel.|({:category => ['ruby', 'other']}, (:price - 100 > 200))}.sql
   #=> "SELECT * FROM items WHERE ((category IN ('ruby', 'other')) OR ((price - 100) <= 200))"
 
-  items.where{Sequel.&({:price => (100..200)}, :active)).sql
+  items.where{Sequel.&({:price => (100..200)}, :active)}.sql
   #=> "SELECT * FROM items WHERE ((price >= 100 AND price <= 200) AND active)"
 
 === Negating conditions

data/doc/extensions.rdoc

@@ -79,6 +79,6 @@ The first argument is the name of the extension as a symbol, and the second is t
 
 You can also call <tt>Sequel::Dataset.register_extension</tt> with a proc:
 
-  Sequel::Dataset.register_extension(:extension_name){|ds| ...}
+  Sequel::Dataset.register_extension(:extension_name){|ds| }
 
 Note that if you use a proc, a corresponding Database extension will not be created automatically (you can still call <tt>Sequel::Database.register_extension</tt> manually in this case).

data/doc/migration.rdoc

@@ -385,14 +385,14 @@ However, the migrations you write should contain an +up+ block that does somethi
 reverses the changes made by the +up+ block:
 
   Sequel.migration do
-    up{...}
-    down{...}
+    up{}
+    down{}
   end
 
 or they should use the reversible migrations feature with a +change+ block:
 
   Sequel.migration do
-    change{...}
+    change{}
   end
 
 == What to put in your migration's +down+ block

data/doc/model_hooks.rdoc

@@ -121,7 +121,7 @@ However, skipping hooks is a bad idea in general and should be avoided.  As ment
 
 The +this+ dataset works just like any other dataset, so you can call +update+ on it to modify it:
 
-  album.this.update(:copies_sold=>album.copies_sold + 1))
+  album.this.update(:copies_sold=>album.copies_sold + 1)
 
 If you want to insert a row into the model's table without running the creation hooks, you can use <tt>Model.insert</tt> instead of <tt>Model.create</tt>:
 

data/doc/opening_databases.rdoc

@@ -381,6 +381,10 @@ The following additional options are supported:
                     to handle notice/warning messages differently.  Only respected if using the pg library).
 :sslmode :: Set to 'disable', 'allow', 'prefer', 'require' to choose how to treat SSL (only
             respected if using the pg library)
+:search_path :: Set to the schema search_path.  This can either be a single string containing the schemas
+                separated by commas (for use via a URL: <tt>postgres:///?search_path=schema1,schema2</tt>), or it
+                can be an array of strings (for use via an option:
+                <tt>Sequel.postgres(:search_path=>['schema1', 'schema2'])</tt>).
 :use_iso_date_format :: This can be set to false to not force the ISO date format.  Sequel forces
                         it by default to allow for an optimization.
 

data/doc/postgresql.rdoc

@@ -160,8 +160,8 @@ Sequel has built in support for creating and dropping PostgreSQL schemas, proced
   DB.drop_function(:set_updated_at)
   # DROP FUNCTION set_updated_at()
 
-  DB.create_trigger(:table, :trg_updated_at, :set_updated_at, :events=>[:insert, :update], :each_row=>true)
-  # CREATE TRIGGER trg_updated_at BEFORE INSERT OR UPDATE ON "table" FOR EACH ROW EXECUTE PROCEDURE set_updated_at()
+  DB.create_trigger(:table, :trg_updated_at, :set_updated_at, :events=>:update, :each_row=>true, :when => {:new__updated_at => :old__updated_at})
+  # CREATE TRIGGER trg_updated_at BEFORE UPDATE ON "table" FOR EACH ROW WHEN ("new"."updated_at" = "old"."updated_at") EXECUTE PROCEDURE set_updated_at()
   DB.drop_trigger(:table, :trg_updated_at)
   # DROP TRIGGER trg_updated_at ON "table"
 

data/doc/prepared_statements.rdoc

@@ -57,7 +57,7 @@ may itself contain placeholders:
   # Insert record with 'Jim', note that the previous filter is ignored
   ds.call(:insert, {:n=>'Jim'}, :name=>:$n)
   # Change name to 'Bob' for all records with name of 'Jim'
-  ds.call(:update, {:n=>'Jim', :new_n=>'Bob'}, :name=>$:new_n)
+  ds.call(:update, {:n=>'Jim', :new_n=>'Bob'}, :name=>:$new_n)
 
 == Prepared Statements
 

data/doc/querying.rdoc

@@ -40,7 +40,7 @@ by its primary key value:
   # Find artist with primary key (id) 1
   artist = Artist[1]
   # SELECT * FROM artists WHERE id = 1
-  => #<Artist @values={:name=>"YJM", :id=>1}>
+  # => #<Artist @values={:name=>"YJM", :id=>1}>
 
 If there is no record with the given primary key, nil will be returned. If you want
 to raise an exception if no record is found, you can use <tt>Sequel::Model.with_pk!</tt>:
@@ -54,17 +54,17 @@ If you just want the first record in the dataset,
 
   artist = Artist.first
   # SELECT * FROM artists LIMIT 1
-  => #<Artist @values={:name=>"YJM", :id=>1}>
+  # => #<Artist @values={:name=>"YJM", :id=>1}>
 
 Any options you pass to +first+ will be used as a filter:
 
   artist = Artist.first(:name => 'YJM')
   # SELECT * FROM artists WHERE (name = 'YJM') LIMIT 1
-  => #<Artist @values={:name=>"YJM", :id=>1}>
+  # => #<Artist @values={:name=>"YJM", :id=>1}>
   
   artist = Artist.first(Sequel.like(:name, 'Y%'))
   # SELECT * FROM artists WHERE (name LIKE 'Y%' ESCAPE '\') LIMIT 1
-  => #<Artist @values={:name=>"YJM", :id=>1}>
+  # => #<Artist @values={:name=>"YJM", :id=>1}>
   
 If there is no matching row, +first+ will return nil.  If you want to
 raise an exception instead, use <tt>first!</tt>.
@@ -74,7 +74,7 @@ requires an argument:
 
   DB[:artists][:name => 'YJM']
   # SELECT * FROM artists WHERE (name = 'YJM') LIMIT 1
-  => {:name=>"YJM", :id=>1}
+  # => {:name=>"YJM", :id=>1}
 
 Note that while Model.[] allows you to pass a primary key directly,
 Dataset#[] does not (unless it is a model dataset).
@@ -89,7 +89,7 @@ reverse order by the primary key field:
 
   artist = Artist.last
   # SELECT * FROM artists ORDER BY id DESC LIMIT 1
-  => #<Artist @values={:name=>"YJM", :id=>1}>
+  # => #<Artist @values={:name=>"YJM", :id=>1}>
 
 Note that what +last+ does is reverse the order of the dataset and then
 call +first+.  This is why +last+ raises a Sequel::Error if there is no
@@ -107,7 +107,7 @@ you want:
 
   artist_name = Artist.get(:name)
   # SELECT name FROM artists LIMIT 1
-  => "YJM"
+  # => "YJM"
 
 === Retrieving Multiple Objects
 
@@ -119,8 +119,8 @@ want to use:
 
   artists = Artist.all
   # SELECT * FROM artists
-  => [#<Artist @values={:name=>"YJM", :id=>1}>,
-      #<Artist @values={:name=>"AS", :id=>2}>]
+  # => [#<Artist @values={:name=>"YJM", :id=>1}>,
+  #     #<Artist @values={:name=>"AS", :id=>2}>]
 
 ==== Using an Enumerable Interface
 
@@ -138,7 +138,7 @@ such as +map+:
 
   artist_names = Artist.map{|x| x.name}
   # SELECT * FROM artists
-  => ["YJM", "AS"]
+  # => ["YJM", "AS"]
 
 ==== As an Array of Column Values
 
@@ -148,7 +148,7 @@ given column.  So the previous example can be handled more easily with:
 
   artist_names = Artist.map(:name)
   # SELECT * FROM artists
-  => ["YJM", "AS"]
+  # => ["YJM", "AS"]
 
 One difference between these two ways of returning an array of values is
 that providing +map+ with an argument is really doing:
@@ -162,21 +162,21 @@ single column and return an array of the columns values, you can use
 
   artist_names = Artist.select_map(:name)
   # SELECT name FROM artists
-  => ["YJM", "AS"]
+  # => ["YJM", "AS"]
 
 It's also common to want to order such a map, so Sequel provides a
 +select_order_map+ method as well:
 
   artist_names = Artist.select_order_map(:name)
   # SELECT name FROM artists ORDER BY name
-  => ["AS", "YJM"]
+  # => ["AS", "YJM"]
 
 In all of these cases, you can provide an array of column symbols and
 an array of arrays of values will be returned:
 
   artist_names = Artist.select_map([:id, :name])
   # SELECT id, name FROM artists
-  => [[1, "YJM"], [2, "AS"]]
+  # => [[1, "YJM"], [2, "AS"]]
 
 ==== As a Hash
 
@@ -185,7 +185,7 @@ using the +to_hash+ method:
 
   artist_names = Artist.to_hash(:id, :name)
   # SELECT * FROM artists
-  => {1=>"YJM", 2=>"AS"}
+  # => {1=>"YJM", 2=>"AS"}
 
 As you can see, the +to_hash+ method uses the first symbol as the key
 and the second symbol as the value.  So if you swap the two arguments the hash
@@ -193,7 +193,7 @@ will have its keys and values transposed:
 
   artist_names = Artist.to_hash(:name, :id)
   # SELECT * FROM artists
-  => {"YJM"=>1, "AS"=>2}
+  # => {"YJM"=>1, "AS"=>2}
 
 Now what if you have multiple values for the same key?  By default, +to_hash+
 will just have the last matching value.  If you care about all matching values,
@@ -202,20 +202,20 @@ values, in the order they were received:
 
   artist_names = Artist.to_hash_groups(:name, :id)
   # SELECT * FROM artists
-  => {"YJM"=>[1, 10, ...], "AS"=>[2, 20, ...]}
+  # => {"YJM"=>[1, 10, ...], "AS"=>[2, 20, ...]}
 
 If you only provide one argument to +to_hash+, it uses the entire hash
 or model object as the value:
 
   artist_names = DB[:artists].to_hash(:name)
   # SELECT * FROM artists
-  => {"YJM"=>{:id=>1, :name=>"YJM"}, "AS"=>{:id=>2, :name=>"AS"}}
+  # => {"YJM"=>{:id=>1, :name=>"YJM"}, "AS"=>{:id=>2, :name=>"AS"}}
 
 and +to_hash_groups+ works similarly:
 
   artist_names = DB[:artists].to_hash_groups(:name)
   # SELECT * FROM artists
-  => {"YJM"=>[{:id=>1, :name=>"YJM"}, {:id=>10, :name=>"YJM"}], ...}
+  # => {"YJM"=>[{:id=>1, :name=>"YJM"}, {:id=>10, :name=>"YJM"}], ...}
 
 Model datasets have a +to_hash+ method that can be called without any
 arguments, in which case it will use the primary key as the key and
@@ -224,8 +224,8 @@ identity map:
 
   artist_names = Artist.to_hash
   # SELECT * FROM artists
-  => {1=>#<Artist @values={:id=>1, :name=>"YGM"}>,
-      2=>#<Artist @values={:id=>2, :name=>"AS"}>}
+  # => {1=>#<Artist @values={:id=>1, :name=>"YGM"}>,
+  #     2=>#<Artist @values={:id=>2, :name=>"AS"}>}
 
 There is no equivalent handling to +to_hash_groups+, since there would
 only be one matching record, as the primary key must be unique.
@@ -237,13 +237,13 @@ columns selected and return a hash:
 
   artist_names = Artist.select_hash(:name, :id)
   # SELECT name, id FROM artists
-  => {"YJM"=>1, "AS"=>2}
+  # => {"YJM"=>1, "AS"=>2}
 
 Likewise, +select_hash_groups+ also exists:
 
   artist_names = Artist.select_hash_groups(:name, :id)
   # SELECT name, id FROM artists
-  => {"YJM"=>[1, 10, ...], "AS"=>[2, 20, ...]}
+  # => {"YJM"=>[1, 10, ...], "AS"=>[2, 20, ...]}
 
 == Modifying datasets 
 
@@ -975,15 +975,15 @@ If you just want to know whether the current dataset would return any rows, use
 
   Album.empty?
   # SELECT 1 FROM albums LIMIT 1
-  => false
+  # => false
 
   Album.where(:id=>0).empty?
   # SELECT 1 FROM albums WHERE id = 0 LIMIT 1
-  => true
+  # => true
 
   Album.where(Sequel.like(:name, 'R%')).empty?
   # SELECT 1 FROM albums WHERE name LIKE 'R%' ESCAPE '\' LIMIT 1
-  => false
+  # => false
 
 == Aggregate Calculations
 
@@ -995,23 +995,23 @@ for each of these aggregate functions.
 
   Album.count
   # SELECT count(*) AS count FROM albums LIMIT 1
-  => 2
+  # => 2
   
 The other methods take a column argument and call the aggregate function with
 the argument:
 
   Album.sum(:id)
   # SELECT sum(id) FROM albums LIMIT 1
-  => 3
+  # => 3
 
   Album.avg(:id)
   # SELECT avg(id) FROM albums LIMIT 1
-  => 1.5
+  # => 1.5
 
   Album.min(:id)
   # SELECT min(id) FROM albums LIMIT 1
-  => 1
+  # => 1
 
   Album.max(:id)
   # SELECT max(id) FROM albums LIMIT 1
-  => 2
+  # => 2