sequel 4.42.1 → 4.43.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d84f8a9b0d5ee524d044add19f1c9adca2c642a
-  data.tar.gz: 5139deab1c3ddfc8e6a9482f8f711d86f35ab261
+  metadata.gz: f5f04eb2ea922da521a4e67f1cf8fd4346d034df
+  data.tar.gz: 39ea6ce91593a98832c7e53c03c4ec1ea5607fb8
 SHA512:
-  metadata.gz: 12202167088c4caef4db81fc6fa6ed35d2104dc993f1be93d45984b887ba9b698395e576be6537457f2cf8123abed75c85175fa1193e5ef7d3c313584908be06
-  data.tar.gz: 9a4d6933538023d4d7b0ea38c18b317557e01a1c2df0391e9a06a8732ac1d9a1f7525e82fe338ff57052c93973a8f979c757c2bcc1730df9f22ad3f28abad665
+  metadata.gz: e449fabbb5ec97c98df590e9afcd6378e392513509dfcb95fbc503cf668029bf31a3e120adf906af3040c695e7998f8ab24d7883409965379ef242498b988b3f
+  data.tar.gz: 2829985707e14c79044a296d34fa62300053e1a279f232da1aa08cd93217eb001ccb78117c049a287b6c370091b8dfb1b5e3a7424d18fdff5ff289081fa2ec58

data/CHANGELOG

@@ -1,7 +1,41 @@
-=== 4.42.1 (2017-01-12)
+=== 4.43.0 (2017-02-01)
+
+* Make jdbc/postgresql adapter work if pg_hstore extension is loaded first (jeremyevans) (#1296)
+
+* Make prepared_statements_associations plugin work correctly on some instance specific associations (jeremyevans)
+
+* Make prepared_statements plugin not use prepared statements in cases where it is probably slower (jeremyevans)
+
+* Optimize Model#refresh similar to Model.with_pk (jeremyevans)
+
+* Make Database#extension not attempt to load the same extension more than once (jeremyevans)
+
+* Implement Database#freeze such that it can be used in production (jeremyevans)
+
+* Freeze enum_labels in the pg_enum extension (jeremyevans)
+
+* Handle Database#type_supported? thread-safely on PostgreSQL (jeremyevans)
+
+* Handle primary_key_sequences thread-safely on Oracle (jeremyevans)
+
+* Handle sharding better when using mysql2 native prepared statements (jeremyevans)
+
+* Use thread-safe incrementor for mock adapter autoid handling (jeremyevans)
+
+* Make Model#freeze not freeze associations hash until after validating the model instance (jeremyevans)
+
+* Make prepared_statements_associations plugin work correctly when model object explicitly specifies server to use when also using sharding plugin (jeremyevans)
+
+* Make prepared_statements_with_pk plugin work correctly when dataset explicitly specifies server to use (jeremyevans)
+
+* Make prepared_statements plugin work correctly when model object explicitly specifies server to use (jeremyevans)
 
 * Make dataset_module inherited to subclasses when using the single_table_inheritance plugin (jeremyevans) (#1284)
 
+* Support use of SQLite result codes in the jdbc-sqlite adapter, if the jdbc sqlite driver supports them (flash-gordon, jeremyevans) (#1283)
+
+* Make timestamp migrator handle key length limitations when using MySQL with InnoDB engine and utf8mb4 charset default (jeremyevans) (#1282)
+
 === 4.42.0 (2017-01-01)
 
 * Handle eager load callbacks correctly for one_to_one associations with orders or offsets when window functions are not supported (jeremyevans)

data/MIT-LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2007-2008 Sharon Rosner
-Copyright (c) 2008-2016 Jeremy Evans
+Copyright (c) 2008-2017 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README.rdoc

@@ -175,7 +175,7 @@ You can retrieve all records by using the +all+ method:
   posts.all
   # SELECT * FROM posts
 
-The all method returns an array of hashes, where each hash corresponds to a record.
+The +all+ method returns an array of hashes, where each hash corresponds to a record.
 
 You can also iterate through records one at a time using +each+:
 
@@ -318,7 +318,7 @@ You can also specify descending order:
 
 === Core Extensions
 
-Note the use of <tt>Sequel.desc(:stamp)</tt> in the above example.  Much of Sequel's DSL uses this style, calling methods on the Sequel module that return SQL expression objects.  Sequel also ships with a {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc]) that integrates Sequel's DSL better into the ruby language, allowing you to write:
+Note the use of <tt>Sequel.desc(:stamp)</tt> in the above example.  Much of Sequel's DSL uses this style, calling methods on the Sequel module that return SQL expression objects.  Sequel also ships with a {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc] that integrates Sequel's DSL better into the Ruby language, allowing you to write:
 
   :stamp.desc
 
@@ -749,7 +749,7 @@ Associations can be eagerly loaded via +eager+ and the <tt>:eager</tt> associati
 
 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.
 
-You can dynamically customize the eagerly loaded dataset by using using a proc.  This proc is passed the dataset used for eager loading, and should return a modified copy of that dataset:
+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
@@ -765,7 +765,7 @@ You can dynamically customize eager loads for both +eager+ and +eager_graph+ whi
 
 === Joining with Associations
 
-You can use the association_join method to add a join to the model's dataset based on the assocation:
+You can use the +association_join+ method to add a join to the model's dataset based on the assocation:
 
   Post.association_join(:author)
   # SELECT * FROM posts

data/doc/release_notes/4.43.0.txt

@@ -0,0 +1,87 @@
+= New Features
+
+* Database#freeze has now been implemented.  It is now recommended
+  to use it in production and during testing, after loading
+  extensions and making other changes to Database state.  Once frozen,
+  the Database settings cannot be modified, but the Database can
+  execute queries and return results.  By freezing the Database, you
+  gain greater thread-safety assurance and will be alerted via an
+  exception if runtime code attempts to modify Database state.
+
+= Other Improvements
+
+* Model#refresh now uses the same optimization that Model.with_pk
+  uses, resulting in faster refreshing for most models.
+
+* The prepared_statements plugin no longer automatically uses
+  prepared statements in cases where it is likely to be slower.
+  Now, prepared statements are only used by default for INSERT
+  and UPDATE statements (and DELETE on Oracle and DB2).  This
+  change was made after benchmarking showed that using prepared
+  statements for primary key lookups, refreshes, and deletes is
+  significantly slower than non-prepared statements across almost
+  all adapters.
+
+* Database#extension no longer attempts to load the same extension
+  more than once.
+
+* The timestamp migrator now handles key length limitations when
+  using MySQL with InnoDB engine and utf8mb4 charset default.
+
+* The jdbc/sqlite adapter will now use SQLite result codes for
+  more accurate exception types, if the jdbc-sqlite driver
+  supports them.
+
+* dataset_module is now inherited correctly if using the
+  single_table_inheritance plugin.  This was broken in 4.42.0,
+  and fixed in 4.42.1.
+
+* The prepared_statements plugin now respects a server specified
+  for the model instance, instead of always using the default
+  server.
+
+* The prepared_statements_associations plugin now respects a
+  server specified for the model instance if using the sharding
+  plugin, instead of always using the default server.
+
+* The prepared_statements_associations plugin now works correctly
+  when using some instance-specific associations, such as
+  many_to_one associations using a nil :key option.
+
+* The prepared_statements_with_pk plugin now respects a server
+  specified for the dataset, instead of always using the default
+  server.
+
+* Model#freeze now freezes the associations hash after validating
+  the model instance, instead of before, fixing cases where
+  validation calls association methods.
+
+* Sequel no longer continually tries to determine the server
+  version on HSQLDB, if the first attempt fails.
+
+* The mock adapter now uses a thread-safe incrementor for autoid.
+
+* Mysql2 native prepared statement support now better handles
+  sharding where connection options differ per shard.
+
+* On Oracle, Database#sequence_for_table is now thread-safe.
+
+* On PostgreSQL, Database#type_supported? is now thread-safe.
+
+* On MySQL, Database#supports_timestamp_usecs? now correctly
+  memoizes false values.
+
+* The jdbc/postgresql adapter now works correctly if the
+  pg_hstore extension is loaded first.
+
+= Backwards Compatibility
+
+* Maintainers of external adapters and Database extensions
+  should update their code to support Database#freeze.
+
+* Code that relies on Database extensions being loaded multiple
+  times if called multiple times needs to be updated, because
+  now the extension only gets loaded the first time
+  Database#extension is called.
+
+* @enum_labels in the pg_enum extension is now frozen by default.

data/doc/sql.rdoc

@@ -14,7 +14,7 @@ For SELECT queries, you should probably use <tt>Database#fetch</tt> with a strin
     puts row[:name]
   end
 
-<tt>Database#fetch</tt> will take the query you give it, execute it on the database, and yield a hash with column symbol keys for each row returned.  If you want to use some placeholder variables, you can set the placeholders with ? and add the arguments to fetch:
+<tt>Database#fetch</tt> will take the query you give it, execute it on the database, and yield a hash with column symbol keys for each row returned.  If you want to use some placeholder variables, you can set the placeholders with ? and add the corresponding arguments to +fetch+:
 
   DB.fetch("SELECT * FROM albums WHERE name LIKE ?", 'A%') do |row|
     puts row[:name]
@@ -26,9 +26,9 @@ You can also use named placeholders by starting the placeholder with a colon, an
     puts row[:name]
   end
 
-This can be helpful for long queries where it is difficult to match the ? with the arguments.
+This can be helpful for long queries where it is difficult to match the question marks in the query with the arguments.
 
-What Sequel actually does internally is two separate things.  It first creates a dataset representing the query, and then it executes the dataset's SQL code to retrieve the objects.  Often, you want to define a dataset at some point, but not execute it till later.  You can do this by leaving off the block, and storing the dataset in a variable:
+What Sequel actually does internally is two separate things.  It first creates a dataset representing the query, and then it executes the dataset's SQL code to retrieve the objects.  Often, you want to define a dataset at some point, but not execute it until later.  You can do this by leaving off the block, and storing the dataset in a variable:
 
   ds = DB.fetch("SELECT * FROM albums")
 
@@ -41,7 +41,7 @@ You should note that <tt>Database#[]</tt> calls <tt>Database#fetch</tt> if a str
   ds = DB["SELECT * FROM albums"]
   ds.each{|r| puts r[:name]}
 
-However, note that <tt>Database#[]</tt> cannot take a block directly, you have to call +each+ on the returned dataset.  There are plenty of other methods besides +each+, one is +all+ which returns all records as an array:
+However, note that <tt>Database#[]</tt> cannot take a block directly, you have to call +each+ on the returned dataset.  There are plenty of other methods besides +each+. For example, the +all+ method returns all records in the dataset as an array:
 
   DB["SELECT * FROM albums"].all # [{:id=>1, :name=>'RF', ...}, ...]
 
@@ -78,7 +78,7 @@ Almost everywhere in Sequel, you can drop down to literal SQL by providing a lit
   DB[:albums].select('name') # SELECT 'name' FROM albums
   DB[:albums].select(Sequel.lit('name')) # SELECT name FROM albums
 
-For a simpler way of creating literal strings, you can also use the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc], which adds the <tt>String#lit</tt> method, and other methods that integrate Sequel's DSL with the ruby language:
+For a simpler way of creating literal strings, you can also use the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc], which adds the <tt>String#lit</tt> method, and other methods that integrate Sequel's DSL with the Ruby language:
 
   DB[:albums].select('name'.lit)
 
@@ -113,7 +113,7 @@ Now that you know how to see what SQL is being used, let's jump in and see how t
 
 === Identifiers
 
-In Sequel, SQL identifiers are usually specified as ruby symbols:
+In Sequel, SQL identifiers are usually specified as Ruby symbols:
 
   :column # "column"
 
@@ -121,7 +121,7 @@ As you can see, Sequel quotes identifiers by default.  Depending on your databas
 
   :column # "COLUMN" on some databases
 
-A plain symbol is usually treated as an unqualified identifier.  However, if you are using multiple tables in a query, and you want to reference a column in one of the tables that has the same name as a column in another one of the tables, you need to qualify that reference.  There's two main ways in Sequel to do that.  The first is implicit qualification inside the symbol, using the double underscore:
+A plain symbol is usually treated as an unqualified identifier.  However, if you are using multiple tables in a query, and you want to reference a column in one of the tables that has the same name as a column in another one of the tables, you need to qualify that reference.  There are two main ways in Sequel to do that.  The first is implicit qualification inside the symbol, using the double underscore:
 
   :table__column # "table"."column"
 
@@ -135,8 +135,7 @@ Also note that specifying the period inside the symbol doesn't work if you are q
 
   :"table.column" # "table.column"
 
-A couple other ways two create a qualified identifier are to use <tt>Sequel.[]</tt> to create an identifier,
-and call <tt>[]</tt> or +qualify+ on that, or to use the <tt>Sequel.qualify</tt> with the table and column symbols:
+The second way is to explicitly create a qualified identifier either by using <tt>Sequel.[]</tt> to create an identifier and call <tt>[]</tt> or +qualify+ on that, or by using the <tt>Sequel.qualify</tt> method with the table and column symbols:
 
   Sequel[:table][:column]         # "table"."column"
   Sequel[:column].qualify(:table) # "table"."column"
@@ -153,7 +152,7 @@ You can also use the symbol_aref extension for creating qualified identifiers:
 
 === Numbers
 
-In general, ruby numbers map directly to SQL numbers:
+In general, Ruby numbers map directly to SQL numbers:
 
   # Integers
   1 # 1
@@ -167,7 +166,7 @@ In general, ruby numbers map directly to SQL numbers:
 
 === Strings
 
-In general, ruby strings map directly to SQL strings:
+In general, Ruby strings map directly to SQL strings:
 
   'name' # 'name'
   "name" # 'name'
@@ -182,7 +181,7 @@ You can combine this with implicit qualification:
 
   :table__column___alias # "table"."column" AS "alias"
 
-As with creating qualified identifiers via a double underscore, This works by default, but it is possible to turn off by setting <tt>Sequel.split_symbols = false</tt>.
+As with creating qualified identifiers via a double underscore, this works by default, but it is possible to turn off by setting <tt>Sequel.split_symbols = false</tt>.
 
 You can also use the <tt>Sequel.as</tt> method to create an alias, and the +as+ method on most Sequel-specific expression objects:
 
@@ -216,7 +215,7 @@ Aggregate functions work the same way as normal functions, since they share the
 
   Sequel.function(:sum, :column) # sum(column)
 
-To use the DISTINCT modifier to an aggregate function, call the distinct method on the function:
+To use the DISTINCT modifier to an aggregate function, call the +distinct+ method on the function:
 
   DB[:albums].select{sum(:column).distinct} # SELECT sum(DISTINCT column) FROM albums
 
@@ -229,7 +228,7 @@ Note that Sequel provides helper methods for aggregate functions such as +count+
 
 === Window Functions
 
-If the database supports window functions, Sequel can handle them by calling the over method on a Function:
+If the database supports window functions, Sequel can handle them by calling the +over+ method on a Function:
 
   DB[:albums].select{function.function.over}
   # SELECT function() OVER () FROM albums
@@ -245,7 +244,7 @@ If the database supports window functions, Sequel can handle them by calling the
 
 === Schema Qualified Functions
 
-If the database supports schema qualified functions, Sequel can handle them by calling the function method on a QuailfiedIdentifier:
+If the database supports schema qualified functions, Sequel can handle them by calling the +function+ method on a QuailfiedIdentifier:
 
   DB[:albums].select{schema[:function].function}
   # SELECT schema.function() FROM albums
@@ -285,7 +284,7 @@ You can specify a not equals condition by inverting the hash or array of two ele
   Sequel.~(:column => 1)        # ("column" != 1)
   Sequel.~([[:column, 1]])      # ("column" != 1)
 
-The difference between the two is that negate only works on hashes and arrays of element arrays, and it negates all entries in the hash or array, while ~ does a general inversion.  This is best shown by an example with multiple entries:
+The difference between the two is that +negate+ only works on hashes and arrays of element arrays, and it negates all entries in the hash or array, while ~ does a general inversion.  This is best shown by an example with multiple entries:
 
   Sequel.negate(:column => 1, :foo => 2)   # (("column" != 1) AND (foo != 2))
   Sequel.~(:column => 1, :foo => 2)        # (("column" != 1) OR (foo != 2))
@@ -330,7 +329,7 @@ Sequel also supports the SQL EXISTS operator using <tt>Dataset#exists</tt>:
 
 === Identity Operators (IS, IS NOT)
 
-Hashes in Sequel use IS if the value is true, false, or nil:
+Hashes in Sequel use IS if the value is +true+, +false+, or +nil+:
 
   {:column=>nil} # ("column" IS NULL)
   {:column=>true} # ("column" IS TRUE)
@@ -394,7 +393,7 @@ You can also call the operator methods directly on the Sequel module:
   Sequel./(:column, 1) # "column" / 1
   Sequel.**(:column, 1) # power("column", 1)
 
-Note that since Sequel implements support for ruby's coercion protocol, the following also works:
+Note that since Sequel implements support for Ruby's coercion protocol, the following also works:
 
   1 + Sequel[:column]
   1 - Sequel[:table][:column]
@@ -416,7 +415,7 @@ is parsed as:
 
   Sequel.function(:func) > (1 & :column3)
 
-You and also use the <tt>Sequel.&</tt> and <tt>Sequel.|</tt> methods:
+You can also use the <tt>Sequel.&</tt> and <tt>Sequel.|</tt> methods:
 
   Sequel.&(:column1, :column2) # ("column1" AND "column2")
   Sequel.|({:column1=>1}, {:column2=>2}) # (("column1" = 1) OR ("column2" = 2))
@@ -482,7 +481,7 @@ Sequel allows the use of the string concatenation operator on Sequel::SQL::Strin
 
   Sequel[:name].sql_string + ' - Name' # ("name" || ' - Name')
 
-Just like for the bitwise operators, Sequel allows you do do the cast and conversion at the same time via +cast_string+:
+Just like for the bitwise operators, Sequel allows you to do the cast and conversion at the same time via +cast_string+:
 
   Sequel[:number].cast_string + ' - Number' # (CAST(number AS varchar(255)) || ' - Number')
 
@@ -498,7 +497,7 @@ The <tt>Sequel.join</tt> method concatenates all of the elements in the array:
 
   Sequel.join(['Name', :name]) # ('Name' || "name")
 
-Just like ruby's <tt>String#join</tt>, you can provide an argument for a string used to join each element:
+Just like Ruby's <tt>String#join</tt>, you can provide an argument for a string used to join each element:
 
   Sequel.join(['Name', :name], ' - ') # ('Name' || ' - ' || "name")
 
@@ -512,13 +511,13 @@ You can also use the <tt>Sequel.like</tt> and <tt>Sequel.ilike</tt> methods:
   Sequel.like(:name, 'A%') # ("name" LIKE 'A%' ESCAPE '\') 
   Sequel.ilike(:name, 'A%') # ("name" ILIKE 'A%' ESCAPE '\') 
 
-Note the above syntax for ilike, while Sequel's default, is specific to PostgreSQL.  However, most other adapters override the behavior.  For example, on MySQL, Sequel uses LIKE BINARY for +like+, and LIKE for +ilike+.  If the database supports both case sensitive and case insensitive LIKE, then +like+ will use a case sensitive LIKE, and +ilike+ will use a case insensitive LIKE.
+Note the above syntax for +ilike+, while Sequel's default, is specific to PostgreSQL.  However, most other adapters override the behavior.  For example, on MySQL, Sequel uses LIKE BINARY for +like+, and LIKE for +ilike+.  If the database supports both case sensitive and case insensitive LIKE, then +like+ will use a case sensitive LIKE, and +ilike+ will use a case insensitive LIKE.
 
 Inverting the LIKE operator works like other inversions:
 
   ~Sequel.like(:name, 'A%') # ("name" NOT LIKE 'A%' ESCAPE '\')
 
-Sequel also supports SQL regular expressions on MySQL and PostgreSQL.  You can use these by passing a ruby regular expression to +like+ or +ilike+, or by making the regular expression a hash value:
+Sequel also supports SQL regular expressions on MySQL and PostgreSQL.  You can use these by passing a Ruby regular expression to +like+ or +ilike+, or by making the regular expression a hash value:
 
   Sequel.like(:name, /^A/) # ("name" ~ '^A')
   ~Sequel.ilike(:name, /^A/) # ("name" !~* '^A')
@@ -552,7 +551,7 @@ To select all columns in a table, Sequel supports the * method on identifiers wi
 
 === CASE statements
 
-Sequel allows the easy production of SQL CASE statements using the <tt>Sequel.case</tt> method.  The first argument is a hash or array of two element arrays representing the conditions, the second argument is the default value (ELSE).   The keys of the hash (or first element in each array) is the WHEN condition, and the values of the hash (or second element in each array) is the THEN result.  Here are some examples:
+Sequel allows the easy production of SQL CASE statements using the <tt>Sequel.case</tt> method.  The first argument is a hash or array of two element arrays representing the conditions, the second argument is the default value (ELSE).  The keys of the hash (or first element in each array) is the WHEN condition, and the values of the hash (or second element in each array) is the THEN result.  Here are some examples:
 
   Sequel.case({:column=>1}, 0) # (CASE WHEN "column" THEN 1 ELSE 0 END)
   Sequel.case([[column, 1]], 0) # (CASE WHEN "column" THEN 1 ELSE 0 END)
@@ -588,7 +587,7 @@ In Sequel, the SQL queries are build with method chaining.
 
 === Creating Datasets
 
-You generally start by creating a dataset by calling <tt>Dataset#[]</tt> with a symbol specifying the table name:
+You generally start creating a dataset by calling <tt>Dataset#[]</tt> with a symbol specifying the table name:
 
   DB[:albums] # SELECT * FROM albums
 
@@ -596,7 +595,7 @@ If you want to select from multiple FROM tables, use multiple arguments:
 
   DB[:albums, :artists] # SELECT * FROM albums, artists
 
-If you don't want to select from any FROM tables, just call dataset:
+If you don't want to select from any FROM tables, just call +dataset+:
 
   DB.dataset # SELECT *
 
@@ -630,7 +629,7 @@ In general, the +insert+, +update+, and +delete+ methods use the appropriate cla
   ds.update(:name=>'RF') # UPDATE albums SET name = 'RF' WHERE (id = 1)
   ds.delete # DELETE FROM albums WHERE (id = 1)
 
-Note how +update+ and +delete+ used the +where+ argument, but that +insert+ did not, because INSERT doesn't use a WHERE clause.
+Note how +update+ and +delete+ used the +where+ argument, but +insert+ did not, because INSERT doesn't use a WHERE clause.
 
 === Methods Used for Each SQL Clause
 

data/doc/testing.rdoc

@@ -157,6 +157,8 @@ SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when runni
 SEQUEL_DUPLICATE_COLUMNS_HANDLER :: Use the duplicate columns handler extension with value given when running the specs
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
 SEQUEL_FREEZE_DATASETS :: Use the freeze_datasets extension when running the specs
+SEQUEL_FREEZE_DATABASE :: Freeze the database before running the integration specs
+SEQUEL_MODEL_PREPARED_STATEMENTS :: Use the prepared_statements and prepared_statements_associations plugins when running the specs
 SEQUEL_NO_AUTO_LITERAL_STRINGS :: Use the no_auto_string_literals extension when running the specs
 SEQUEL_NO_CACHE_ASSOCIATIONS :: Don't cache association metadata when running the specs
 SEQUEL_NO_CHECK_SQLS :: Don't check for specific SQL syntax when running the specs

data/doc/validations.rdoc

@@ -153,7 +153,7 @@ You can call simple methods such as:
     end
   end
 
-Other than +validates_unique+, which has it's own API, the methods defined by
+Other than +validates_unique+, which has its own API, the methods defined by
 +validation_helpers+ have one of the following two APIs:
 
 <tt>(atts, opts={})</tt>:: For methods such as +validates_presence+, which do not

data/lib/sequel/adapters/ado.rb

@@ -127,6 +127,11 @@ module Sequel
         nil
       end
 
+      def freeze
+        @conversion_procs.freeze
+        super
+      end
+
       # Just execute so it doesn't attempt to return the number of rows modified.
       def execute_ddl(sql, opts=OPTS)
         execute(sql, opts)

data/lib/sequel/adapters/cubrid.rb

@@ -89,6 +89,11 @@ module Sequel
         execute(sql, opts.merge(:type=>:insert))
       end
 
+      def freeze
+        server_version
+        super
+      end
+
       private
 
       def begin_transaction(conn, opts=OPTS)

data/lib/sequel/adapters/ibmdb.rb

@@ -264,6 +264,11 @@ module Sequel
         end
       end
 
+      def freeze
+        @conversion_procs.freeze
+        super
+      end
+
       private
 
       # Execute the given SQL on the database.