sequel 3.47.0 → 3.48.0

data/doc/association_basics.rdoc

@@ -1080,11 +1080,11 @@ Can use an array of symbols for a composite key association.
 A proc that can be used to modify the dataset used in the add/remove/remove_all
 methods.  It's separate from the association block, as that is called on a
 join of the join table and the associated table, whereas this option just
-applies to the join table.  It can be used to make sure additional columns are
-used when inserting, or that filters are used when deleting.
+applies to the join table.  It can be used to make sure that filters are used
+when deleting.
 
   Artist.many_to_many :lead_guitar_albums, :join_table_block=>proc do |ds|
-    ds.where(:instrument_id=>5).set_overrides(:instrument_id=>5)
+    ds.where(:instrument_id=>5)
   end
 
 === Callback Options
@@ -1575,7 +1575,7 @@ you also wanted to handle the Artist#remove_all_albums method:
 
 The symbol name of the reciprocal association, if it exists.  By default,
 Sequel will try to determine it by looking at the associated model's
-assocations for a association that matches the current association's key(s).
+associations for a association that matches the current association's key(s).
 Set to nil to not use a reciprocal.
 
 Reciprocals are used in Sequel to modify the matching cached associations
@@ -1704,15 +1704,6 @@ strategies are:
 :window_function :: Uses window functions if the database supports it.
                     This is used by default on databases that support window
                     functions.
-:correlated_subquery :: Uses a correlated subquery to get the information.
-                        This is never used by default as if you aren't careful,
-                        it can result in pathologically long running times.
-                        This will not work correctly for associations where
-                        the associated table has a composite primary key if
-                        the database doesn't support using IN
-                        with multiple columns.  This will also not work on MySQL
-                        because MySQL has problems using IN with a correlated
-                        subquery that contains a limit.
 :ruby :: Uses ruby array slicing to emulate database limiting (*_many
          associations only).  This is the default if the database doesn't
          support window functions.

data/doc/cheat_sheet.rdoc

@@ -2,7 +2,6 @@
 
 == Open a database
 
-  require 'rubygems'
   require 'sequel'
 
   DB = Sequel.sqlite('my_blog.db')
@@ -62,7 +61,7 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
   dataset.map(:name) # same as above
 
   dataset.inject(0){|sum, r| sum + r[:value]}
-  dataset.sum(:value) # same as above
+  dataset.sum(:value) # better
 
 == Filtering (see also {Dataset Filtering}[link:files/doc/dataset_filtering_rdoc.html])
 
@@ -101,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({:x => 1, :y => 2}.sql_or & 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
@@ -126,10 +125,13 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
 == Joins
 
   DB[:items].left_outer_join(:categories, :id => :category_id).sql 
-  # SELECT * FROM items LEFT OUTER JOIN categories ON categories.id = items.category_id
+  # SELECT * FROM items
+  # LEFT OUTER JOIN categories ON categories.id = items.category_id
 
   DB[:items].join(:categories, :id => :category_id).join(:groups, :id => :items__group_id) 
-  # SELECT * FROM items INNER JOIN categories ON categories.id = items.category_id INNER JOIN groups ON groups.id = items.group_id
+  # SELECT * FROM items
+  # INNER JOIN categories ON categories.id = items.category_id
+  # INNER JOIN groups ON groups.id = items.group_id
 	
 == Aggregate functions methods
 
@@ -140,7 +142,7 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
   dataset.sum(:stock)
 
   dataset.group_and_count(:category)
-  dataset.group(:category).select(:category, Sequel.function(:AVG, :price))
+  dataset.select_group(:category).select_append{avg(:price)}
 
 == SQL Functions / Literals
 

data/doc/code_order.rdoc

@@ -0,0 +1,89 @@
+= Code Order
+
+In Sequel, the order in which code is executed is important.  This
+guide provides the recommended way to order your Sequel code.  Some
+of these guidelines are not strictly necessary, but others are, and
+this guide will be specific about which are strictly necessary.
+
+== Require Sequel
+
+This is sort of a no brainer, but you need to require the library
+first.  This is a strict requirement, none of the other code can
+be executed unless the library has been required first. Example:
+
+  require 'sequel'
+
+== Add Global Extensions
+
+Global extensions are loaded with Sequel.extension, and affect
+other parts of Sequel or the general ruby environment.  It's not
+necessary to load them first, but it is a recommended practice.
+Example:
+
+  Sequel.extension :blank
+
+== Add Extensions Applied to All Databases/Datasets
+
+If you want database or datasets extensions applied to all databases
+and datasets, you must use Sequel::Database.extension to load the
+extension before connecting to a database.  If you connect to a
+database before using Sequel::Database.extension, it will not have
+that extension loaded. Example:
+
+  Sequel::Database.extension :columns_introspection
+
+== Connect to Databases
+
+Connecting to a database is required before running any queries against
+that database, or creating any datasets or models.  You cannot create
+model classes without having a database object created first.  The
+convention for an application with a single Database instance is to
+store that instance in a constant named DB.  Example:
+
+  DB = Sequel.connect('postgres://user:pass@host/database')
+
+== Add Extensions Specific to a Database or All Datasets in that Database
+
+If you want specific databases to use specific extensions, or have all
+datasets in that database use a specific extension, you need to load that
+extension into the database after creating it using
+Sequel::Database#extension.  Example:
+
+  DB.extension :pg_array
+
+== Configure Global Model Behavior
+
+If you want to change the configuration for all model classes, you must do
+so before loading your model classes, as configuration is copied into the
+subclass when model subclasses are created.  Example:
+
+  Sequel::Model.raise_on_save_failure = false
+
+== Add Global Model Plugins
+
+If you want to load a plugin into all models classes, you must do so
+before loading your model classes, as plugin specific data may need to be
+copied into the subclass when model subclasses are created.  Example:
+
+  Sequel::Model.plugin :prepared_statements
+
+== Load Model Classes
+
+After you have established a database connection, and configured your
+global model configration and global plugins, you can load your model
+classes.  It's recommended to have a separate file for each model class,
+unless the model classes are very simple.  Example:
+
+  Dir['./models/*.rb'].each{|f| require f}
+
+== Disconnect If Using Forking Webserver with Code Preloading
+
+If you are using a forking webserver such as unicorn or passenger, with
+a feature that loads your Sequel code before forking connections (code
+preloading), then you must disconnect your database connections before
+forking.  If you don't do this, you can end up with child processes
+sharing database connections and all sorts of weird behavior.  Sequel
+will automatically reconnect on an as needed basis in the child
+processes, so you only need to do the following in the parent process:
+
+  DB.disconnect

data/doc/core_extensions.rdoc

@@ -8,7 +8,7 @@ Historically, Sequel added methods to many of the core classes, and usage of tho
     where(:column.like('A%')).              # Symbol#like
     order({1=>2}.case(0, :a))               # Hash#case
 
-While Sequel never override any methods defined by ruby, it is possible that other libraries could define the same methods that Sequel defines, which could cause problems.  Also, some rubyists do not like using libraries that add methods to the core classes.
+While Sequel never overrode any methods defined by ruby, it is possible that other libraries could define the same methods that Sequel defines, which could cause problems.  Also, some rubyists do not like using libraries that add methods to the core classes.
 
 Alternatives for the core extension methods where added to Sequel, so the query above could be written as:
 
@@ -22,7 +22,7 @@ Almost all of the core extension methods have a replacement on the Sequel module
 
 There is no recommendation on whether the core_extensions should be used or not.  It is very rare that any of the methods added by core_extensions actually causes a problem, but some of them can make it more difficult to find other problems.  For example, if you type:
 
-  do_somehting if value | other_value
+  do_something if value | other_value
 
 while meaning to type:
 
@@ -236,7 +236,7 @@ Symbol#sql_function returns an SQL function call expression object:
 
 Alternative: Sequel.function:
 
-  Sequel.function(:now, :a)
+  Sequel.function(:sum, :a)
 
 === String
 

data/doc/dataset_basics.rdoc

@@ -79,25 +79,24 @@ FROM:: from, from_self
 JOIN:: join, left_join, right_join, full_join, natural_join, natural_left_join, natural_right_join, natural_full_join, cross_join, inner_join, left_outer_join, right_outer_join, full_outer_join, join_table
 WHERE:: where, filter, exclude, exclude_where, and, or, grep, invert, unfiltered
 GROUP:: group, group_by, group_and_count, select_group, ungrouped
-HAVING:: having, filter, exclude, exclude_having, and, or, grep, invert, unfiltered
+HAVING:: having, exclude_having, invert, unfiltered
 ORDER:: order, order_by, order_append, order_prepend, order_more, reverse, reverse_order, unordered
 LIMIT:: limit, unlimited
 compounds:: union, intersect, except
 locking:: for_update, lock_style
 common table expressions:: with, with_recursive
-qualification:: qualify, qualify_to, qualify_to_first_source
-inserting:: set_defaults, set_overrides
-other:: clone, distinct, naked, server, with_sql
+other:: clone, distinct, naked, qualify, server, with_sql
 
 === Methods that execute code on the database
 
 Most other dataset methods commonly used will execute the dataset's SQL on the database:
 
-SELECT (All Records):: all, each, map, to_hash, to_hash_groups, select_map, select_order_map, select_hash, select_hash_groups, to_csv
-SELECT (First Record):: first, last, get, []
+SELECT (All Records):: all, each, map, to_hash, to_hash_groups, select_map, select_order_map, select_hash, select_hash_groups
+SELECT (First Record):: first, last, [], single_record
+SELECT (Single Value):: get, single_value
 SELECT (Aggregates):: count, avg, max, min, sum, range, interval
-INSERT:: insert, <<, import, multi_insert, insert_multiple
-UPDATE:: update, set, []=
+INSERT:: insert, <<, import, multi_insert
+UPDATE:: update
 DELETE:: delete
 other:: columns, columns!, truncate
 

data/doc/dataset_filtering.rdoc

@@ -140,11 +140,16 @@ Or against SQL functions:
 
 == String search functions
 
-You can search SQL strings using the Sequel.like method:
+You can search SQL strings in a case sensitive manner using the Sequel.like method:
 
   items.where(Sequel.like(:name, 'Acme%')).sql
   #=> "SELECT * FROM items WHERE (name LIKE 'Acme%')"
 
+You can search SQL strings in a case insensitive manner using the Sequel.ilike method:
+
+  items.where(Sequel.ilike(:name, 'Acme%')).sql
+  #=> "SELECT * FROM items WHERE (name ILIKE 'Acme%')"
+
 You can specify a Regexp as a like argument, but this will probably only work
 on PostgreSQL and MySQL:
 
@@ -163,7 +168,7 @@ You can concatenate SQL strings using Sequel.join:
   items.where(Sequel.join([:name, :comment]).like('%acme%')).sql
   #=> "SELECT * FROM items WHERE ((name || comment) LIKE 'Acme%')"
 
-Array#sql_string_join also takes a join argument:
+Sequel.join also takes a join argument:
 
   items.filter(Sequel.join([:name, :comment], ' ').like('%acme%')).sql
   #=> "SELECT * FROM items WHERE ((name || ' ' || comment) LIKE 'Acme%')"

data/doc/mass_assignment.rdoc

@@ -36,7 +36,7 @@ By default, if an invalid setter method call is attempted, Sequel raises a <tt>S
   # Instance level
   post.strict_param_setting = false
 
-These mass assignment methods have been around a long time, but starting in Sequel 3.12.0, the +set_fields+ and +update_fields+ methods were added, and these may be a better mass assignment choice for most users.
+In addition to +set_only+ and +update_only+, Sequel also has +set_fields+ and +update_fields+ methods, and these may be a better mass assignment choice for most users.
 These methods take two arguments, the attributes hash as the first argument, and a single array of valid field names as the second argument:
 
   post.set_fields(params[:post], [:title, :body])
@@ -50,7 +50,6 @@ They work great for things like HTML forms where the form fields are static.
 +set_only+ and +update_only+ are designed for cases where you are not sure what fields are going to be present in the input, but still want to make sure only certain setter methods can be called.
 They work great for flexible APIs.
 
-Starting in Sequel 3.34.0, +set_fields+ and +update_fields+ take an optional argument hash, and currently handles the :missing option.  With <tt>:missing=>:skip</tt>, +set_fields+ and +update_fields+ will just skip missing entries in the hash, allowing them to be used in flexible APIs.  With <tt>:missing=>:raise</tt>, +set_fields+ and +update_fields+ will raise an error if one of the entries in the hash is missing, instead of just assigning the value to nil or whatever the hash's default value is.  That allows stricter checks, similar to the :strict_param_checking setting for the default mass assignment methods.
++set_fields+ and +update_fields+ take an optional argument hash, and currently handles the :missing option.  With <tt>:missing=>:skip</tt>, +set_fields+ and +update_fields+ will just skip missing entries in the hash, allowing them to be used in flexible APIs.  With <tt>:missing=>:raise</tt>, +set_fields+ and +update_fields+ will raise an error if one of the entries in the hash is missing, instead of just assigning the value to nil or whatever the hash's default value is.  That allows stricter checks, similar to the :strict_param_checking setting for the default mass assignment methods.  You can use the <tt>Model.default_set_fields_options=</tt> method to set the default options to use for +set_fields+ and +update_fields+ on a global or per-model basis.
 
 In all of the mass assignment cases, methods starting with +set+ will set the attributes without saving the object, while methods starting with +update+ will set the attributes and then save the changes to the object.
-

data/doc/migration.rdoc

@@ -100,7 +100,7 @@ from Sacramento, CA, USA, but now you want to branch out and include artists in
   Sequel.migration do
     up do
       add_column :artists, :location, String
-      self[:artists].update(:location=>'Sacramento')
+      from(:artists).update(:location=>'Sacramento')
     end
 
     down do
@@ -114,10 +114,10 @@ because future artists should not be assumed to come from Sacramento.  In the +d
 just drops the +location+ column from the +artists+ table, reversing the actions of the up
 block.
 
-Note that when updating the +artists+ table in the update, a plain dataset is used, <tt>self[:artists]</tt>.
+Note that when updating the +artists+ table in the update, a plain dataset is used, <tt>from(:artists)</tt>.
 This looks a little weird, but you need to be aware that inside an up or +down+ block in a migration,
 self always refers to the <tt>Sequel::Database</tt> object that the migration is being applied to.
-Since <tt>Database#[]</tt> creates datasets, using <tt>self[:artists]</tt> inside the +up+ block creates
+Since <tt>Database#from</tt> creates datasets, using <tt>from(:artists)</tt> inside the +up+ block creates
 a dataset on the database representing all columns in the +artists+ table, and updates it to set the
 +location+ column to <tt>'Sacramento'</tt>.  You should avoid referencing the <tt>Sequel::Database</tt>
 object directly in your migration, and always use self to reference it, otherwise you may run into problems.
@@ -130,7 +130,7 @@ to create their development database.
 == The +migration+ extension
 
 The migration code is not technically part of the core of Sequel.  It's not loaded by default as it
-is only useful in specific cases.  It is one of the built-in extensions, which receive the same
+is only useful in specific cases.  It is one of the extensions that ship with Sequel, which receive the same
 level of support as Sequel's core.
 
 If you want to play with Sequel's migration tools without using the <tt>bin/sequel</tt> tool, you
@@ -240,7 +240,7 @@ the +TimestampMigrator+.  They both have plusses and minuses:
 
 * Simpler, uses migration versions starting with 1
 * Doesn't allow duplicate migrations
-* Doesn't allow missing migrations
+* Doesn't allow missing migrations by default
 * Just stores the version of the last migration run
 * Good for single developer or small teams with close
   communication
@@ -255,7 +255,7 @@ the +TimestampMigrator+.  They both have plusses and minuses:
 * Allows missing migrations (since you obviously don't have one every second)
 * Stores the file names of all applied migrations
 * Good for large teams without close communication
-* Higher risk of undected conflicting migrations
+* Higher risk of undetected conflicting migrations
 * Does not require manual merging of simultaneous migrations
 
 === Filenames
@@ -293,7 +293,7 @@ to worry about that issue until the 1000th migration:
   009_do_something.rb
   010_do_something_else.rb
 
-It should be fairly obvious, but migrations start at 1, not 0.  The migration version number 0
+Migrations start at 1, not 0.  The migration version number 0
 is important though, as it is used to mean that all migrations should be unapplied (i.e. all
 +down+ blocks run).  In Sequel, you can do that with:
 
@@ -349,7 +349,7 @@ So for unrelated migrations, the +TimestampMigrator+ works fine.  However, let's
 migrations are related, in such a way that if Bob's is run first, Alice's will fail.  In this
 case, the +TimestampMigrator+ would not raise an error when Bob merges Alice's changes, since
 Bob ran his migration first.  However, it would raise an error when Alice runs Bob's migration,
-and could leave the database in an inconsistant state if the database doesn't support transactional
+and could leave the database in an inconsistent state if the database doesn't support transactional
 schema changes.
 
 With the +TimestampMigrator+, you are trading reliability for convenience.  That's possibly a valid

data/doc/model_hooks.rdoc

@@ -17,7 +17,7 @@ Model hooks, also known as model callbacks, are used to specify actions that occ
     end
   end
 
-The one important thing to note here is the call to +super+ inside the hook.  Whenever you override one of Sequel::Model's methods, you should be calling +super+ to get the default behavior.  Many of Sequel's built in plugins work by overriding the hook methods and calling +super+.  If you use these plugins and override the hook methods but do not call +super+, it's likely the plugins will not work correctly.
+The one important thing to note here is the call to +super+ inside the hook.  Whenever you override one of Sequel::Model's methods, you should be calling +super+ to get the default behavior.  Many of the plugins that ship with Sequel work by overriding the hook methods and calling +super+.  If you use these plugins and override the hook methods but do not call +super+, it's likely the plugins will not work correctly.
 
 == Available Hooks
 
@@ -67,8 +67,6 @@ Sequel calls hooks in the following order when destroying an existing object:
 
 Note that these hooks are only called when using <tt>Model#destroy</tt>, they are not called if you use <tt>Model#delete</tt>.
 
-<tt>Sequel::Model</tt> does support a few additional hooks. One is +after_intialize+, which is called after the model object has been initalized.  It can be used to set default attribute values for new objects, since by default new <tt>Sequel::Model</tt> objects have no attributes, and the attributes are not filled in until the model object is saved.  You should be careful when you are using +after_initialize+, since it is called for every created record.  So if you run a query that returns 1000 model objects, it will be called 1000 times.  If you only want to change the behavior for new records, you can override the +initialize_set+ private method, which is called with the hash passed to +initialize+.
-
 == Special Hook-Related Instance Variables
 
 For after_save hooks, a @was_new instance variable is present that indicates whether the record was a new record that was just inserted, or an existing record that was updated.  Sequel marks a record as existing as soon as it inserts the record, so in an after_save or after_create hook, the instance is no longer considered new.  You have to check @was_new to see if the record was inserted.  This exists so that you don't have to have separate after_create and after_update hooks that are mostly the same and only differ slightly depending on whether the record was a new record.
@@ -114,7 +112,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=>: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>:
 
@@ -240,10 +238,16 @@ Likewise, let's say that upon retrieval, you associate an object with a file des
     end
   end
 
-== +hook_class_methods+
+== Hook related plugins
+
+=== +instance_hooks+
+
+Sequel also ships with an +instance_hooks+ plugin that allows you to define before and after hooks on a per instance basis.  It's very useful as it allows you to delay action on an instance until before or after saving.  This can be important if you want to modify a group of related objects together (which is how the +nested_attributes+ plugin uses +instance_hooks+).
+
+=== +hook_class_methods+
 
 While it's recommended to write your hooks as instance methods, Sequel ships with a +hook_class_methods+ plugin that allows you to define hooks via class methods. It exists mostly for legacy compatibility, but is still supported.  However, it does not implement around hooks.
 
-== +instance_hooks+
+=== +after_initialize+
 
-Sequel also ships with an +instance_hooks+ plugin that allows you to define before and after hooks on a per instance basis.  It's very useful as it allows you to delay action on an instance until before or after saving.  This can be important if you want to modify a group of related objects together (which is how the +nested_attributes+ plugin uses +instance_hooks+).
+The after_initialize plugin adds an after_initialize hook, that is called for all model instances on creation (both new instances and instances retrieved from the database).  It exists mostly for legacy compatibility, but it is still supported.

data/doc/object_model.rdoc

@@ -3,7 +3,7 @@
 Sequel's dataset layer is mostly structured as an DSL, so it often obscures
 what actual objects are being used.  For example, you don't usually create
 Sequel objects by calling #new on the object's class (other than Sequel::Model
-subclasses).  However, just as almost everything in ruby is an object, all 
+instances).  However, just as almost everything in ruby is an object, all 
 the methods you call in Sequel deal with objects behind the scenes.
 
 There are five main types of Sequel-specific objects that you deal with in
@@ -377,7 +377,7 @@ take arguments.  Still, it's possible they are still useful in some code:
 
   Sequel::SQL::ColumnAll.new(:table) # "table".*
 
-The following shortcut exists for creating Sequel::SQL::Cast objects:
+The following shortcut exists for creating Sequel::SQL::ColumnAll objects:
 
   Sequel.expr(:table).*
   :table.* # core_extensions extension

data/doc/opening_databases.rdoc

@@ -12,7 +12,7 @@ The connection options needed depend on the adapter being used, though most adap
 share the same basic connection options.
 
 If you are only connecting to a single database, it is recommended that you store the
-database object in a constant named DB.  This should never be required, but it is the
+database object in a constant named DB.  This is not required, but it is the
 convention that most Sequel code uses.
 
 == Using the Sequel.connect method
@@ -68,9 +68,7 @@ These options are shared by all adapters unless otherwise noted.
 
 :adapter :: The adapter to use
 :database :: The name of the database to which to connect
-:default_schema :: The database schema to use in schema_modification and introspection.
 :host :: The hostname of the database server to which to connect
-:logger :: An array of SQL loggers to log to
 :loggers :: An array of SQL loggers to log to
 :password :: The password for the user account
 :servers :: A hash with symbol keys and hash or proc values, used with master/slave/partitioned database configurations
@@ -98,7 +96,7 @@ Requires: win32ole
 
 The ADO adapter provides connectivity to ADO databases in Windows. It relies
 on WIN32OLE library, so it isn't usable on other operating systems (except
-possibly through WINE, but that's fairly unlikely).
+possibly through WINE, but that's unlikely).
 
 The following options are supported:
 
@@ -239,7 +237,7 @@ Requires: java
 Houses Sequel's JDBC support when running on JRuby.
 Support for individual database types is done using sub adapters.
 There are currently subadapters for PostgreSQL, MySQL, SQLite, H2, HSQLDB, Derby,
-Oracle, MSSQL, JTDS, AS400, Progress, Firebird, Informix, and DB2.  For PostgreSQL, MySQL, SQLite, H2, Derby,
+Oracle, MSSQL, JTDS, AS400, Progress, Firebird, Informix, and DB2.  For PostgreSQL, MySQL, SQLite, H2, HSQLDB, Derby,
 and JTDS, this can use the jdbc-* gem, for the others you need to have the .jar in your CLASSPATH
 or load the Java class manually before calling Sequel.connect.
 
@@ -396,7 +394,7 @@ The following additional options are supported:
 
 === swift
 
-swift is a ruby 1.9 only library, so you'll need to be running ruby 1.9.  It
+swift is a ruby 1.9+ library, so you'll need to be running ruby 1.9+.  It
 can connect to SQLite, MySQL, and PostgreSQL, and you must specify which
 database using the db_type option.
 
@@ -416,8 +414,7 @@ Examples:
 
 Requires: tiny_tds
 
-Because the underscore is not a valid character in a URI schema, the adapter
-is named tinytds instead of tiny_tds.  The connection options are passed directly
+The connection options are passed directly
 to tiny_tds, except that the tiny_tds :username option is set to
 the Sequel :user option.  If you want to use an entry in the freetds.conf file, you
 should specify the :dataserver option with that name as the value.  Some other
@@ -432,11 +429,5 @@ Other Sequel specific options:
              text or blob values via tinytds, you should use this option or modify
              your freetds.conf file.
 
-For highest performance, you should disable any identifier output method when
-using the tinytds adapter, which probably means disabling any identifier input method
-as well.  The default for Microsoft SQL Server is to :downcase identifiers on output
-and :upcase them on input, so the highest performance will require changing the setting
-from the default.
-
 The Sequel tinytds adapter requires tiny_tds >= 0.4.5, and if you are using FreeTDS
 0.91, you must at least be using 0.91rc2 (0.91rc1 does not work).