sequel 3.21.0 → 3.41.0

data/doc/querying.rdoc

@@ -10,7 +10,9 @@ aims to be a gentle introduction to Sequel's querying support.
 
 While you can easily use raw SQL with Sequel, a large part of the
 advantage you get from using Sequel is Sequel's ability to abstract
-SQL from you and give you a much nicer interface.
+SQL from you and give you a much nicer interface. Sequel also ships with
+a {core_extensions extension}[link:files/doc/core_extensions_rdoc.html],
+which better integrates Sequel's DSL into the ruby language.
 
 == Retrieving Objects
 
@@ -57,7 +59,7 @@ Any options you pass to +first+ will be used as a filter:
   # SELECT * FROM artists WHERE (name = 'YJM') LIMIT 1
   => #<Artist @values={:name=>"YJM", :id=>1}>
   
-  artist = Artist.first(:name.like('Y%'))
+  artist = Artist.first(Sequel.like(:name, 'Y%'))
   # SELECT * FROM artists WHERE (name LIKE 'Y%') LIMIT 1
   => #<Artist @values={:name=>"YJM", :id=>1}>
   
@@ -69,12 +71,12 @@ requires an argument:
   => {:name=>"YJM", :id=>1}
 
 Note that while Model.[] allows you to pass a primary key directly,
-Dataset#[] does not.
+Dataset#[] does not (unless it is a model dataset).
 
 ==== Using +last+
 
 If you want the last record in the dataset,
-<tt>Sequel::Dataset#last</tt> is an obvious method to use.  Note first
+<tt>Sequel::Dataset#last</tt> is an obvious method to use.  Note
 that last requires that the dataset be ordered.  Without an order, any
 object can be considered the first as well as the last.
 
@@ -162,22 +164,38 @@ It's also common to want to order such a map, so Sequel provides a
   # SELECT name FROM artists ORDER BY name
   => ["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"]]
+
 ==== As a Hash
 
 Sequel makes it easy to take an SQL query and return it as a ruby hash,
 using the +to_hash+ method:
 
-  artist_names = Artist.to_hash(:name, :id)
+  artist_names = Artist.to_hash(:id, :name)
   # SELECT * FROM artists
-  => {"YJM"=>1, "AS"=>2}
+  => {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
 will have its keys and values transposed:
 
-  artist_names = Artist.to_hash(:id, :name)
+  artist_names = Artist.to_hash(:name, :id)
   # SELECT * FROM artists
-  => {1=>"YJM", 2=>"AS"}
+  => {"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,
+use +to_hash_groups+, which makes the values of the array an array of matching
+values, in the order they were received:
+
+  artist_names = Artist.to_hash_groups(:name, :id)
+  # SELECT * FROM artists
+  => {"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:
@@ -186,6 +204,12 @@ or model object as the value:
   # SELECT * FROM artists
   => {"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"}], ...}
+
 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
 the model object as the value.  This can be used to easily create an
@@ -196,6 +220,9 @@ identity map:
   => {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.
+
 Note that +to_hash+ never modifies the columns selected.  However, just
 like Sequel has a +select_map+ method to modify the columns selected and
 return an array, Sequel also has a +select_hash+ method to modify the
@@ -205,6 +232,12 @@ columns selected and return a hash:
   # SELECT name, id FROM artists
   => {"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, ...]}
+
 == Modifying datasets 
 
 Note that the retrieval methods discussed above just return
@@ -232,7 +265,7 @@ table +artists+:
 Let's say we are only interested in the artists whose names
 start with "A":
 
-  ds2 = ds1.where(:name.like('A%'))
+  ds2 = ds1.where(Sequel.like(:name, 'A%'))
   # SELECT * FROM artists WHERE name LIKE 'A%'
 
 Here we see that +where+ returns a dataset that adds a +WHERE+
@@ -282,47 +315,47 @@ of condition is used depends on the values in the hash.
 Unless Sequel has special support for the value's class, it uses a simple
 equality statement:
 
-  Artist.filter(:id=>1)
+  Artist.where(:id=>1)
   # SELECT * FROM artists WHERE id = 1
 
-  Artist.filter(:name=>'YJM')
+  Artist.where(:name=>'YJM')
   # SELECT * FROM artists WHERE name = 'YJM'
 
 For arrays, Sequel uses the IN operator.
 
-  Artist.filter(:id=>[1, 2])
+  Artist.where(:id=>[1, 2])
   # SELECT * FROM artists WHERE id IN (1, 2)
 
 For datasets, Sequel uses the IN operator with a subselect:
 
-  Artist.filter(:id=>Album.select(:artist_id))
+  Artist.where(:id=>Album.select(:artist_id))
   # SELECT * FROM artists WHERE id IN (
   #   SELECT artist_id FROM albums)
 
 For boolean values such as nil, true, and false, Sequel uses the IS operator:
 
-  Artist.filter(:id=>nil)
+  Artist.where(:id=>nil)
   # SELECT * FROM artists WHERE id IS NULL
 
 For ranges, Sequel uses a pair of inequality statements:
 
-  Artist.filter(:id=>1..5)
+  Artist.where(:id=>1..5)
   # SELECT * FROM artists WHERE id >= 1 AND id <= 5
 
 Finally, for regexps, Sequel uses an SQL regular expression.  Note that this
 is probably only supported on PostgreSQL and MySQL.
 
-  Artist.filter(:name=>/JM$/)
+  Artist.where(:name=>/JM$/)
   # SELECT * FROM artists WHERE name ~ 'JM$'
 
 If there are multiple arguments in the hash, the filters are ANDed together:
 
-  Artist.filter(:id=>1, :name=>/JM$/)
+  Artist.where(:id=>1, :name=>/JM$/)
   # SELECT * FROM artists WHERE id = 1 AND name ~ 'JM$'
 
-This works the same as if you used two separate filter calls:
+This works the same as if you used two separate +where+ calls:
 
-  Artist.filter(:id=>1).filter(:name=>/JM$/)
+  Artist.where(:id=>1).where(:name=>/JM$/)
   # SELECT * FROM artists WHERE id = 1 AND name ~ 'JM$'
 
 === Array of Two Element Arrays
@@ -331,14 +364,14 @@ If you use an array of two element arrays, it is treated as a hash.  The only
 advantage to using an array of two element arrays is that it allows you to
 duplicate keys, so you can do:
 
-  Artist.filter([[:name, /JM$/], [:name, /^YJ/]])
+  Artist.where([[:name, /JM$/], [:name, /^YJ/]])
   # SELECT * FROM artists WHERE name ~ 'JM$' AND name ~ '^YJ'
 
 === Virtual Row Blocks
 
-If a block is passed to filter, it is treated as a virtual row block:
+If a block is passed to a filter, it is treated as a virtual row block:
 
-  Artist.filter{id > 5}
+  Artist.where{id > 5}
   # SELECT * FROM artists WHERE id > 5
 
 You can learn more about virtual row blocks in the {"Virtual Rows" guide}[link:files/doc/virtual_rows_rdoc.html].
@@ -346,7 +379,7 @@ You can learn more about virtual row blocks in the {"Virtual Rows" guide}[link:f
 You can provide both regular arguments and a block, in which case the results
 will be ANDed together:
 
-  Artist.filter(:name=>'A'...'M'){id > 5}
+  Artist.where(:name=>'A'...'M'){id > 5}
   # SELECT * FROM artists WHERE name >= 'A' AND name < 'M' AND id > 5
 
 === Symbols
@@ -363,28 +396,30 @@ Sequel has a DSL that allows easily creating SQL expressions.  These SQL
 expressions are instances of subclasses of Sequel::SQL::Expression. You've
 already seen an example earlier:
 
-  Artist.filter(:name.like('Y%'))
+  Artist.where(Sequel.like(:name, 'Y%'))
   # SELECT * FROM artists WHERE name LIKE 'Y%'
 
-In this case Symbol#like returns a Sequel::SQL::BooleanExpression object,
+In this case Sequel.like returns a Sequel::SQL::BooleanExpression object,
 which is used directly in the filter.
 
 You can use the DSL to create arbitrarily complex expressions.  SQL::Expression
-objects support the & operator for +AND+, the | operator for +OR+, and the ~ operator
-for inversion:
+objects can be created via singleton methods on the Sequel module.  The most common
+method is Sequel.expr, which takes any object and wraps it in a SQL::Expression
+object.  In most cases, the SQL::Expression returned supports the & operator for
++AND+, the | operator for +OR+, and the ~ operator for inversion:
 
-  Artist.filter(:name.like('Y%') & ({:b=>1} | ~{:c=>3}))
+  Artist.where(Sequel.like(:name, 'Y%') & (Sequel.expr(:b=>1) | Sequel.~(:c=>3)))
   # SELECT * FROM artists WHERE name LIKE 'Y%' AND (b = 1 OR c != 3)
 
 You can combine these expression operators with the virtual row support:
 
-  Artist.filter{(a > 1) & ~((b(c) < 1) | d)}
+  Artist.where{(a > 1) & ~((b(c) < 1) | d)}
   # SELECT * FROM artists WHERE a > 1 AND b(c) >= 1 AND NOT d
 
 Note the use of parentheses when using the & and | operators, as they have lower
 precedence than other operators.  The following will not work:
 
-  Artist.filter{a > 1 & ~(b(c) < 1 | d)}
+  Artist.where{a > 1 & ~(b(c) < 1 | d)}
   # Raises a TypeError, as it calls Integer#| with a Sequel::SQL::Identifier
 
 === Strings with Placeholders
@@ -392,24 +427,24 @@ precedence than other operators.  The following will not work:
 Assuming you want to get your hands dirty and write some SQL, Sequel allows you
 to use strings using placeholders for the values:
 
-  Artist.filter("name LIKE ?", 'Y%')
+  Artist.where("name LIKE ?", 'Y%')
   # SELECT * FROM artists WHERE name LIKE 'Y%'
 
 This is the most common type of placeholder, where each question mark is substituted
 with the next argument:
 
-  Artist.filter("name LIKE ? AND id = ?", 'Y%', 5)
+  Artist.where("name LIKE ? AND id = ?", 'Y%', 5)
   # SELECT * FROM artists WHERE name LIKE 'Y%' AND id = 5
 
 You can also use named placeholders with a hash, where the named placeholders use
 colons before the placeholder names:
 
-  Artist.filter("name LIKE :name AND id = :id", :name=>'Y%', :id=>5)
+  Artist.where("name LIKE :name AND id = :id", :name=>'Y%', :id=>5)
   # SELECT * FROM artists WHERE name LIKE 'Y%' AND id = 5
 
 You don't have to provide any placeholders if you don't want to:
 
-  Artist.filter("id = 2")
+  Artist.where("id = 2")
   # SELECT * FROM artists WHERE id = 2
 
 However, if you are using any untrusted input, you should definitely be using placeholders.
@@ -417,9 +452,9 @@ In general, unless you are hardcoding values in the strings, you should use plac
 You should never pass a string that has been built using interpolation, unless you are
 sure of what you are doing.
 
-  Artist.filter("id = #{params[:id]}") # Don't do this!
-  Artist.filter("id = ?", params[:id]) # Do this instead
-  Artist.filter(:id=>params[:id]) # Even better
+  Artist.where("id = #{params[:id]}") # Don't do this!
+  Artist.where("id = ?", params[:id]) # Do this instead
+  Artist.where(:id=>params[:id]) # Even better
 
 === Inverting
 
@@ -427,12 +462,12 @@ You may be wondering how to specify a not equals condition in Sequel, or the NOT
 operator.  Sequel has generic support for inverting conditions, so to write a not
 equals condition, you write an equals condition, and invert it:
 
-  Artist.filter(:id=>5).invert
+  Artist.where(:id=>5).invert
   # SELECT * FROM artists WHERE id != 5
 
 Note that +invert+ inverts the entire filter:
 
-  Artist.filter(:id=>5).filter{name > 'A'}.invert
+  Artist.where(:id=>5).where{name > 'A'}.invert
   # SELECT * FROM artists WHERE id != 5 OR name <= 'A'
 
 In general, +invert+ is used rarely, since +exclude+ allows you to invert only specific
@@ -441,7 +476,7 @@ filters:
   Artist.exclude(:id=>5)
   # SELECT * FROM artists WHERE id != 5
   
-  Artist.filter(:id=>5).exclude{name > 'A'}
+  Artist.where(:id=>5).exclude{name > 'A'}
   # SELECT * FROM artists WHERE id = 5 OR name <= 'A'
 
 So to do a NOT IN with an array:
@@ -451,14 +486,14 @@ So to do a NOT IN with an array:
 
 Or to use the NOT LIKE operator:
 
-  Artist.exclude(:name.like('%J%'))
+  Artist.exclude(Sequel.like(:name, '%J%'))
   # SELECT * FROM artists WHERE name NOT LIKE '%J%'
  
 === Removing
 
 To remove all existing filters, use +unfiltered+:
 
-  Artist.filter(:id=>1).unfiltered
+  Artist.where(:id=>1).unfiltered
   # SELECT * FROM artists
 
 == Ordering
@@ -474,7 +509,7 @@ You can specify multiple arguments to order by more than one column:
   Album.order(:artist_id, :id)
   # SELECT * FROM album ORDER BY artist_id, id
 
-Note that unlike +filter+, +order+ replaces an existing order, it does not
+Note that unlike +where+, +order+ replaces an existing order, it does not
 append to an existing order:
 
   Artist.order(:id).order(:name)
@@ -499,15 +534,15 @@ order, using +reverse+:
   # SELECT FROM artists ORDER BY id DESC
 
 As you might expect, +reverse+ is not used all that much.  In general,
-<tt>Symbol#desc</tt> is used more commonly to specify a descending order
+<tt>Sequel.desc</tt> is used more commonly to specify a descending order
 for columns:
 
-  Artist.order(:id.desc)
+  Artist.order(Sequel.desc(:id))
   # SELECT FROM artists ORDER BY id DESC
 
 This allows you to easily use both ascending and descending orders:
 
-  Artist.order(:name, :id.desc)
+  Artist.order(:name, Sequel.desc(:id))
   # SELECT FROM artists ORDER BY name, id DESC
 
 === Removing
@@ -559,6 +594,12 @@ columns, use +select_all+:
   Artist.select(:id).select_all
   # SELECT * FROM artists
 
+To select all columns from a given table, provide an argument to
++select_all+:
+
+  Artist.select_all(:artists)
+  # SELECT artists.* FROM artists
+
 === Distinct
 
 To treat duplicate rows as a single row when retrieving the records,
@@ -613,6 +654,17 @@ and Sequel provides a +group_and_count+ method to make this easier:
 
 This will return the number of albums for each artist_id.
 
+If you want to select and group on the same columns, you can use +select_group+:
+
+  Album.select_group(:artist_id)
+  # SELECT artist_id FROM albums GROUP BY artist_id
+
+Usually you would add a +select_append+ call after that, to add some sort of
+aggregation:
+
+  Album.select_group(:artist_id).select_append{sum(num_tracks).as(tracks)}
+  # SELECT artist_id, sum(num_tracks) AS tracks FROM albums GROUP BY artist_id
+
 == Having
 
 The SQL HAVING clause is similar to the WHERE clause, except that
@@ -632,12 +684,9 @@ will add to the HAVING clause instead of the WHERE clause:
   # SELECT artist_id, COUNT(*) AS count FROM albums
   # GROUP BY artist_id HAVING count >= 10 AND count < 15
 
-Unlike +filter+, +where+ always affects the WHERE clause:
-
-  Album.group_and_count(:artist_id).
-   having{count >= 10}.where(:name.like('A%'))
-  # SELECT artist_id, COUNT(*) AS count FROM albums
-  # WHERE name LIKE 'A%' GROUP BY artist_id HAVING count >= 10
+This can be confusing, so it is recommended that you always use
+either +having+ or +where+ instead of +filter+, indicating which
+clause that would want affected.
 
 Both the WHERE clause and the HAVING clause are removed by +unfiltered+:
 
@@ -678,7 +727,7 @@ can also provide a model class:
 
 Or a dataset, in which case a subselect is used:
 
-  Album.join(Artist.filter{name < 'A'}, :id=>:artist_id)
+  Album.join(Artist.where{name < 'A'}, :id=>:artist_id)
   # SELECT * FROM albums
   # INNER JOIN (SELECT * FROM artists WHERE (name < 'A')) AS t1
   #  ON (t1.id = albums.artist_id)
@@ -746,6 +795,19 @@ as a hash, but allows for duplicate keys:
 And just like in the hash case, unqualified symbol elements in the
 array are implicitly qualified.
 
+By default, Sequel only qualifies unqualified symbols in the conditions.  However,
+You can provide an options hash with a <tt>:qualify=>:deep</tt> option to do a deep
+qualification, which can qualify subexpressions.  For example, let's say you are doing
+a JOIN using case insensitive string comparison:
+
+  Album.join(:artists, {Sequel.function(:lower, :name) =>
+                        Sequel.function(:lower, :artist_name)},
+             :qualify => :deep)
+  # SELECT * FROM albums INNER JOIN artists
+  #  ON (lower(artists.name) = lower(albums.artist_name))
+
+Note how the arguments to lower were qualified correctly in both cases.
+
 ==== USING Joins
 
 The most common type of join conditions is a JOIN ON, as displayed
@@ -788,7 +850,7 @@ and artists tables, but only want albums where the artist's name
 comes before the album's name.
 
   Album.join(:artists, :id=>:artist_id) do |j, lj, js|
-    :name.qualify(j) < :name.qualify(lj)
+    Sequel.qualify(j, :name) < Sequel.qualify(lj, :name)
   end
   # SELECT * FROM albums INNER JOIN artists
   # ON artists.id = albums.artist_id
@@ -888,6 +950,25 @@ With either of these methods, you can use placeholders:
   DB[:albums].with_sql("SELECT * FROM artists WHERE id = :id", :id=>5)
   # SELECT * FROM artists WHERE id = 5
 
+Note that if you specify the dataset using custom SQL, you can still call the dataset
+modification methods, but in many cases they will appear to have no affect:
+
+  DB["SELECT * FROM artists"].select(:name).order(:id)
+  # SELECT * FROM artists
+
+If you must drop down to using custom SQL, it's recommended that you only do so for
+specific parts of a query.  For example, if the reason you are using custom SQL is
+to use a custom operator in the database in the SELECT clause:
+
+  DB["SELECT name, (foo !@# ?) AS baz FROM artists", 'bar']
+
+it's better to use Sequel's DSL, and use a literal string for the custom operator:
+
+  DB[:artists].select(:name, Sequel.lit("(foo !@# ?)", 'bar').as(:baz))
+
+That way Sequel's method chaining still works, and it increases Sequel's ability to
+introspect the code.
+
 == Checking for Records
 
 If you just want to know whether the current dataset would return any rows, use <tt>empty?</tt>:
@@ -896,11 +977,11 @@ If you just want to know whether the current dataset would return any rows, use
   # SELECT 1 FROM albums LIMIT 1
   => false
 
-  Album.filter(:id=>0).empty?
+  Album.where(:id=>0).empty?
   # SELECT 1 FROM albums WHERE id = 0 LIMIT 1
   => true
 
-  Album.filter(:name.like('R%')).empty?
+  Album.where(Sequel.like(:name, 'R%')).empty?
   # SELECT 1 FROM albums WHERE name LIKE 'R%' LIMIT 1
   => false
 

data/doc/reflection.rdoc

@@ -4,9 +4,9 @@ Sequel supports reflection information in multiple ways.
 
 == Adapter in Use
 
-You can get the adapter in use using Database.adapter_scheme.  As this is a class method, you generally need to do DB.class.adapter_scheme:
+You can get the adapter in use using Database#adapter_scheme:
 
-  DB.class.adapter_scheme # e.g. :postgres, :jdbc, :odbc
+  DB.adapter_scheme # e.g. :postgres, :jdbc, :odbc
 
 == Database Connected To
 
@@ -16,28 +16,54 @@ In some cases, the adapter scheme will be the same as the database to which you
 
 == Tables in the Database
 
-On many database types/adapters, Database#tables exists and gives an array of table name symbols:
+Database#tables gives an array of table name symbols:
 
   DB.tables # [:table1, :table2, :table3, ...]
 
+== Views in the Database
+
+Database#views and gives an array of view name symbols:
+
+  DB.views # [:view1, :view2, :view3, ...]
+
 == Indexes on a table
 
-On a few database types/adapters, Database#indexes takes a table name gives a hash of index information.  Keys are index names, values are subhashes with the keys :columns and :unique :
+Database#indexes takes a table name gives a hash of index information.  Keys are index names, values are subhashes with the keys :columns and :unique :
 
   DB.indexes(:table1) # {:index1=>{:columns=>[:column1], :unique=>false}, :index2=>{:columns=>[:column2, :column3], :unique=>true}}
 
 Index information generally does not include partial indexes, functional indexes, or indexes on the primary key of the table.
 
+== Foreign Key Information for a Table
+
+Database#foreign_key_list takes a table name and gives an array of hashes of foreign key information:
+
+  DB.foreign_key_list(:table1) # [{:columns=>[:column1], :table=>:referenced_table, :key=>[:referenced_column1]}]
+
+At least the following entries will be present in the hash:
+
+:columns :: An array of columns in the given table
+:table :: The table referenced by the columns
+:key :: An array of columns referenced (in the table specified by :table), but can be nil on certain adapters
+        if the primary key is referenced.
+
+The hash may also contain entries for:
+
+:deferrable :: Whether the constraint is deferrable
+:name :: The name of the constraint
+:on_delete :: The action to take ON DELETE
+:on_update :: The action to take ON UPDATE
+
 == Column Information for a Table
 
 Database#schema takes a table symbol and returns column information in an array with each element being an array with two elements.  The first elements of the subarray is a column symbol, and the second element is a hash of information about that column.  The hash should include the following keys:
 
-* :allow_null - Whether NULL/nil is an allowed value for this column. Used by the Sequel::Model typecasting code.
-* :db_type - The type of column the database provided, as a string.  Used by the schema_dumper plugin for a more specific type translation.
-* :default - The default value of the column, as either a string or nil.  Uses a database specific format. Used by the schema_dumper plugin for converting to a ruby value.
-* :primary_key - Whether this column is one of the primary key columns for the table.  Used by the Sequel::Model code to determine primary key columns.
-* :ruby_default - The default value of the column as a ruby object, or nil if there is no default or the default could not be successfully parsed into a ruby object.
-* :type - The type of column, as a symbol (e.g. :string).  Used by the Sequel::Model typecasting code.
+:allow_null :: Whether NULL/nil is an allowed value for this column. Used by the Sequel::Model typecasting code.
+:db_type :: The type of column the database provided, as a string.  Used by the schema_dumper plugin for a more specific type translation.
+:default :: The default value of the column, as either a string or nil.  Uses a database specific format. Used by the schema_dumper plugin for converting to a ruby value.
+:primary_key :: Whether this column is one of the primary key columns for the table.  Used by the Sequel::Model code to determine primary key columns.
+:ruby_default :: The default value of the column as a ruby object, or nil if there is no default or the default could not be successfully parsed into a ruby object.
+:type :: The type of column, as a symbol (e.g. :string).  Used by the Sequel::Model typecasting code.
 
 Example:
 

data/doc/release_notes/3.22.0.txt

@@ -0,0 +1,39 @@
+= New Features
+
+* Support COLLATE in column definitions.  At least MySQL and Microsoft
+  SQL Server support them, and PostgreSQL 9.1 should as well.
+
+* When connecting to Microsoft SQL Server, you can use the
+  mssql_unicode_strings accessor to turn of the default usage
+  of unicode strings (N'') and use regular strings (''). This
+  can improve performance, but changes the behavior.  It's
+  set to true by default for backwards compatibility.  You can
+  change it at both the dataset and database level:
+
+    DB.mssql_unicode_strings = false # default for datasets
+    dataset.mssql_unicode_strings = false # just this dataset
+
+* In the oracle adapter, if Sequel.application_timezone is :utc, set
+  the timezone for the connection to use the 00:00 timezone.
+
+= Other Improvements
+
+* In the single_table_inheritance plugin, correctly handle a
+  multi-level class hierarchy so that loading instances from a
+  middle level of the hierarchy can return instances of subclasses.
+
+* Don't use a schema when creating a temporary table, even if
+  default_schema is set.
+
+* Fix the migrator when a default_schema is used.
+
+* In the ado adapter, assume a connection to SQL Server if the
+  :conn_string is given and doesn't indicate Access/Jet.
+
+* Fix fetching rows in the tinytds adapter when the
+  identifier_output_method is nil.
+
+* The tinytds adapter now checks for disconnect errors, but it might
+  not be reliable until the next release of tiny_tds.
+
+* The odbc adapter now handles ODBC::Time instances correctly.