sequel 3.21.0 → 3.39.0

data/doc/release_notes/3.31.0.txt

@@ -0,0 +1,146 @@
+= New Features
+
+* The serialization plugin can now support custom serialization
+  formats, by supplying a serializer/deserializer pair of
+  callable objects.  You can also register custom deserializers
+  via Sequel::Plugins::Serialization.register_format, so that
+  they can be referenced by name.  Example:
+  
+    Sequel::Plugins::Serialization.register_format(:reverse,
+      lambda{|v| v.reverse},
+      lambda{|v| v.reverse})
+    class User < Sequel::Model
+      serialize_attributes :reverse, :password
+    end
+
+* Dataset#import and #multi_insert now support a
+  :return=>:primary_key option.  When this option is used, the
+  methods return an array of primary key values, one for each
+  inserted row.  Usage of this option on MySQL requires that a
+  separate query be issued per row (instead of the single
+  query for all rows that MySQL would usually use).
+  
+* PostgreSQL can now use Dataset#returning in conjunction with
+  import/multi_insert to set a custom column to return.
+  
+* Microsoft SQL Server can now use Dataset#output in conjection with
+  import/multi_insert to set a custom column to return.
+  
+* Dataset#import and #multi_insert now respect a :server option to
+  set the server/shard on which to execute the queries.
+  Additionally, options given to this method are also passed to
+  Dataset#transaction.
+
+* Dataset#insert_multiple now returns an array of inserted primary
+  keys.
+
+* Model.def_column_alias has been added to make it easy to create
+  alias methods for columns.  This is useful if you have a legacy
+  database and want to create friendly method names for the
+  underlying columns.  Note that this alias only affects the setter
+  and getter methods.  This does not affect the dataset level, so you
+  still need to use the actual column names in dataset filters.
+
+* many_to_one associations can now have the same name as the related
+  foreign key column, using the :key_column option.  Use of this
+  feature is not recommended, as it is much better to either rename
+  the column or rename the association.  Here's an example of usage:
+  
+    # Example schema:
+    #  albums           artists
+    #   :id        /-->  :id
+    #   :artist --/      :name
+    #   :name
+    class Album < Sequel::Model
+      def_column_alias(:artist_id, :artist)
+      many_to_one :artist, :key_column=>:artist
+    end
+
+* The mock adapter can now mock out database types, by providing a
+  shared adapter name as the host (e.g. mock://postgres).  This
+  emulation is not perfect, but in most cases it allows you to see
+  what SQL Sequel would generate on a given database without needing
+  to install the required database driver.
+
+* Sequel now supports creating full text indexes on Microsoft SQL
+  Server.  Before using it, you must have previously setup a default
+  full text search catalog, and you need to provide a :key_index
+  option with an index name symbol.
+  
+* Dataset#group_rollup and #group_cube methods have been added for
+  GROUP BY ROLLUP and GROUP BY CUBE support.  These features are in
+  a recent SQL standard, and they are supported to various degrees on
+  Microsoft SQL Server, DB2, Oracle, MySQL, and Derby.
+
+* Dataset#full_text_search on Microsoft SQL Server now supports
+  multiple search terms.
+  
+* The jdbc adapter now supports a :login_timeout option, giving the
+  timeout in seconds.
+
+= Other Improvements
+
+* Dataset#exists can now be used with prepared statement
+  placeholders.
+
+* Dataset#full_text_search can now be used with prepared statement
+  placeholders on PostgreSQL, MySQL, and Microsoft SQL Server.
+  
+* If tables from two separate schema are detected when parsing the
+  schema for a table on PostgreSQL, an error is now raised.
+  Previously, no error was raised, which led to weird errors later,
+  such as duplicate columns in a model's primary_key.
+
+* RETURNING is now supported with UPDATE/DELETE on PostgreSQL 8.2+.
+  Previously, Sequel only supported it on 9.1+, but PostgreSQL
+  introduced support for it in 8.2.
+
+* The shared postgres adapter now correctly handles the return value
+  for Dataset#insert if you provide a separate column array and value
+  array on PostgreSQL < 8.2.
+  
+* Handle case in the PostgreSQL adapter where the server version
+  cannot be determined via a query.
+  
+* H2 clob types are now treated as string instead of as blob.
+  Treating clob as blob breaks on H2, as it doesn't automatically
+  hex-unescape the input for clobs as it does for blobs.
+  
+* Dataset#empty? now works correctly when the dataset has an offset
+  and offset support is being emulated.
+
+* The mock adapter no longer defaults to downcasing identifiers on
+  output.
+
+= Backwards Compatibility
+
+* Dataset#exists now returns a PlaceholderLiteralString instead of a
+  LiteralString, which could potentially break some code.  If you
+  would like a String returned, you can pass the returned object to
+  Dataset#literal:
+  
+    dataset.literal(dataset.exists)
+
+* Dataset#from no longer handles :a__b__c___d as "a.b.c AS d".  This
+  was not the intended behavior, and nowhere else in Sequel is a
+  symbol treated that way.  Now, Dataset#from is consistent with the
+  rest of Sequel, using "a.b__c AS d".  This should only affect
+  people in very rare cases, as most databases don't use three level
+  qualified tables.  One exception is Microsoft SQL Server, which can
+  use three level qualified tables for cross-database access.
+  
+* Previously, Dataset#insert_multiple returned an array of hashes, now
+  it returns an array of primary key values.
+
+* Dataset#EXRACT_CLOSE in the shared sqlite adapter has been renamed to
+  Dataset#EXTRACT_CLOSE.
+  
+* Dataset::StoredProcedureMethods::SQL_QUERY_TYPE and
+  Dataset::ArgumentMapper::SQL_QUERY_TYPE constants have been removed,
+  as have related sql_query_type private methods.
+
+* The serialization plugin was significantly refactored.
+  Model.serialization_map now contains a callable object instead of a
+  Symbol, and Model.serialization_format has been removed.
+  Model.define_serialized_attribute_accessors private method now takes
+  two callable objects before the columns, instead of a single symbol.

data/doc/release_notes/3.32.0.txt

@@ -0,0 +1,202 @@
+= New Features
+
+* Prepared statements now support :map and :to_hash prepared
+  statement types.  The main reason for this is that certain
+  extensions (e.g. sequel_pg) optimize map/to_hash calls, and
+  there previously was not a way to use prepared statements
+  with the map/to_hash optimizations.
+
+* Sequel.empty_array_handle_nulls has been added to change how
+  IN/NOT IN operations with an empty array are handled.  See
+  the Backwards Compatibility section for details.
+
+* 5 new association options have been added that allow you to
+  define associations where the underlying columns clash with
+  standard ruby method names:
+
+    many_to_one :primary_key_method
+    one_to_many :key_method
+    one_to_many :primary_key_column
+    many_to_many :left_primary_key_column
+    many_to_many :right_primary_key_method
+
+  Using these new options, you can now define associations
+  that work correctly when the underlying primary/foreign key
+  columns clash with existing ruby method names.  See the RDoc
+  for details.
+
+* A use_after_commit_rollback setting has been added to models.
+  This defaults to true, but can be set to false for performance
+  or to allow models to be used in prepared transactions
+  (which don't support after_commit/after_rollback).
+
+* Dataset#update_ignore has been added when connecting to MySQL,
+  enabling use of the UPDATE IGNORE syntax to skip updating a row
+  if the update would cause a unique constraint to be violated.
+
+* Database#indexes is now supported when connecting to Microsoft
+  SQL Server.
+
+* On Microsoft SQL Server, the :include option is now supported
+  when creating indexes, for storing column values in the index,
+  which can be used by the query optimizer.
+
+= Other Improvements
+
+* The filtering/excluding by associations code now uses qualified
+  identifiers instead of unqualified identifiers, which allows it
+  to avoid ambiguous column names if you are doing your own joins.
+
+* Virtual row blocks that return arrays are now handled correctly
+  in Dataset#select_map/select_order_map.
+
+* Dataset#select_map/select_order_map can now take both a block
+  argument as well as a regular argument.
+
+* Dataset#select_order_map now handles virtual row blocks that
+  return ordered expressions.
+
+* Database#table_exists? should no longer generate false negatives
+  if you only have permission to retrieve some column values but
+  not all.  Note that if you lack permission to SELECT from the
+  table itself, table_exists? can still generate false negatives.
+
+* The active_model plugin now supports ActiveModel 3.2, by adding
+  support for to_partial_path.
+
+* The serialization_modification_detection plugin now handles
+  changed_columns correctly both for new objects and after saving
+  objects.
+
+* The serialization plugin now clears the deserialized values when
+  it does the automatic refresh after saving a new object, mostly for
+  consistency.  You can use the skip_create_refresh plugin to skip
+  refreshing when creating a new model object.
+
+* Column default values are now wrapped in parentheses on SQLite,
+  which fixes some cases such as when the default is an SQL function
+  call.
+
+* Alter table emulation now works correctly on SQLite when foreign
+  keys reference the table being altered.  The emulation requires
+  a renaming/deleting the existing table and creating a new table,
+  which can break foreign key references.  Sequel now disables the
+  foreign key PRAGMA when altering tables, so SQLite won't track
+  the table renames and break the foreign key relationships.
+
+* The set_column_type table alteration method no longer modifies
+  default values and NULL/NOT NULL settings on Microsoft SQL
+  Server, H2, and SQLite.
+
+* On MySQL, Time/DateTime columns now use the timestamp type if the
+  default value is Sequel::CURRENT_TIMESTAMP, since it is currently
+  impossible for MySQL to have a non-constant default for a
+  datetime column (without using a workaround like a trigger).
+
+* Metadata methods such as tables, views, and view_exists? are now
+  handled correctly on Oracle if custom identifier input methods
+  are used.
+
+* Sequel now ignores errors that occur when attempting to get
+  information on column defaults in Oracle (which can happen if you
+  lack permission to the appropriate table).  Previously, such errors
+  would cause the schema parser to raise an error, now, the schema
+  information is just returned without default information.
+
+* Database#indexes now skips the primary key index when connecting to
+  DB2, Derby, HSQLDB, and Oracle via the jdbc adapter.
+
+* Database#indexes now works correctly on DB2.
+
+* The progress adapter has been fixed, it had been broken since the
+  dataset literalization refactoring.
+
+* Dataset#naked! now works correctly.  Previously, it just returned
+  the receiver unmodified.
+
+* Dataset#paginate! has been removed, as it was broken.
+
+* The query extension no longer breaks Dataset#clone if an argument
+  is not given.
+
+* Transaction related queries are no longer logged twice in the mock
+  adapter.
+
+= Backwards Compatibility
+
+* Sequel's default handling of NOT IN operators with an empty array
+  of values has changed, which can change which rows are returned for
+  such queries.
+ 
+  Previously, Sequel was inconsistent in that it tried to handle NULL
+  values correctly in the IN case, but not in the NOT IN case.  Now,
+  it defaults to handling NULL values correctly in both cases:
+
+    # 3.31.0
+    DB[:a].where(:b=>[])
+    # SELECT * FROM a WHERE (b != b)
+    DB[:a].exclude(:b=>[])
+    # SELECT * FROM a WHERE (1 = 1)
+
+    # 3.32.0
+    DB[:a].where(:b=>[])
+    # SELECT * FROM a WHERE (b != b)
+    DB[:a].exclude(:b=>[])
+    # SELECT * FROM a WHERE (b = b)
+
+  The important change in behavior is that in the NOT IN case, if
+  the left hand argument is NULL, the filter returns NULL instead
+  of true.  This has the potential to change query results.
+
+  "Correct" here is really an opinion and not a fact, as there are
+  valid arguments for the alternative behavior:
+
+    DB[:a].where(:b=>[])
+    # SELECT * FROM a WHERE (1 = 0)
+    DB[:a].exclude(:b=>[])
+    # SELECT * FROM a WHERE (1 = 1)
+
+  The difference is that the "correct" NULL behavior is more
+  consistent with the non-empty array cases.  For example, if b is
+  NULL:
+
+    # "Correct" NULL handling
+    #  Empty array: where(:b=>[])
+    WHERE (b != b) # NULL
+    WHERE (b = b) # NULL
+    #  Non-empty array: where(:b=>[1, 2])
+    WHERE (b IN (1, 2)) # NULL
+    WHERE (b NOT IN (1, 2)) # NULL
+
+    # Static boolean handling
+    #  Empty array: where(:b=>[])
+    WHERE (1 = 0) # false
+    WHERE (1 = 1) # true
+    #  Non-empty array: where(:b=>[1, 2])
+    WHERE (b IN (1, 2)) # NULL
+    WHERE (b NOT IN (1, 2)) # NULL
+
+  Sequel chooses to default to behavior consistent with the non-empty
+  array cases (similar to SQLAlchemy).  However, there are two
+  downsides to this handling.  The first is that some databases with
+  poor optimizers (e.g. MySQL) might do a full table scan with the
+  default syntax.  The second is that the static boolean handling may
+  be generally perferable, if you believe that IN/NOT IN with an
+  empty array should always be true or false and never NULL even if
+  the left hand argument is NULL.
+
+  As there really isn't a truly correct answer in this case, Sequel
+  defaults to the "correct" NULL handling, and allows you to switch
+  to the static boolean handling via:
+
+    Sequel.empty_array_handle_nulls = false
+
+  This is currently a global setting, it may be made Database or
+  Dataset specific later if requested.  Also, it is possible the
+  default will switch in the future, so if you care about a specific
+  handling, you should set your own default.
+
+* Database#table_exists? now only rescues Sequel::DatabaseErrors
+  instead of StandardErrors, so it's possible it will raise errors
+  instead of returning false on custom adapters that don't wrap
+  their errors correctly.

data/doc/release_notes/3.33.0.txt

@@ -0,0 +1,157 @@
+= New Features
+
+* A server_block extension has been added that makes Sequel's
+  sharding support easier to use by scoping database access inside
+  the block to a given server/shard:
+
+    Sequel.extension :server_block
+    DB.extend Sequel::ServerBlock
+    DB.with_server(:shard_1) do
+      # All of these will execute against shard_1
+      DB.tables
+      DB[:table].all
+      DB.run 'SOME SQL'
+    end
+
+* An arbitrary_servers extension has been added that extends
+  Sequel's sharding support so that you can use arbitrary
+  connection options instead of referencing an existing, predefined
+  server/shard:
+
+    Sequel.extension :arbitrary_servers
+    DB.pool.extend Sequel::ArbitraryServers
+    DB[:table].server(:host=>'foo', :database=>'bar').all
+
+  You can use this extension in conjunction with the server_block
+  extension:
+
+    DB.with_server(:host=>'foo', :database=>'bar') do
+      DB.synchronize do
+        # All of these will execute on host foo, database bar
+        DB.tables
+        DB[:table].all
+        DB.run 'SOME SQL'
+      end
+    end
+
+  The combination of these two extensions makes it pretty easy to
+  write a thread-safe Rack middleware that scopes each request
+  to an arbitrary database.
+
+* The sqlite adapter now supports an integer_booleans setting
+  for using 1/0 for true/false values, instead of the the 't'/'f'
+  values used by default.  As SQLite recommends using integers to
+  store booleans, converting your existing database and enabling
+  this setting is recommended, but for backwards compatibility it
+  is set to false.  You can convert you existing database by doing
+  the following for each table/column that has booleans:
+
+    DB[:table].update(:boolean_column=>{'t'=>1}.
+                        case(0, :boolean_column))
+
+  The integer_booleans default setting may change in a future
+  version of Sequel, so you should set it manually to false if you
+  prefer the current default.
+
+* You can now disable transaction use in migrations, in one of two
+  ways.  You generally only need to do this if you are using an
+  SQL query inside a migration that is specifically not supported
+  inside a transaction, such as CREATE INDEX CONCURRENTLY on
+  PostgreSQL.
+  
+  The first way to disable transactions is on a per-migration basis
+  by calling the no_transaction method inside the Sequel.migration
+  block:
+
+    Sequel.migration do
+      no_transaction
+      change do
+        # ...
+      end
+    end
+
+  That will make it so that a transaction is not used for that
+  particular migration.  The second way is passing the
+  :use_tranctions=>false option when calling Migrator.run (using
+  the API), which will completely disable transactions for all
+  migrations during the migrator run.
+
+* The postgres adapter now respects an :sslmode option when using
+  pg as the underlying driver, you can set the value of this option to
+  disable, allow, prefer, or require.
+
+* Database#create_schema and #drop_schema are now defined when
+  connecting to PostgreSQL.
+
+* Database#supports_savepoints_in_prepared_transactions? has been
+  added for checking if savepoints are supported inside prepared
+  transactions.  This is true if both savepoints and prepared
+  transactions are both supported, except on MySQL > 5.5.12 (due to
+  MySQL bug 64374).
+
+= Other Improvements
+
+* The mysql and mysql2 adapters now both provide an accurate number
+  of rows matched, so Sequel::Model usage on those adapters will now
+  raise a NoExistingObject exception by default if you attempt to
+  delete or update an instance that no longer exists in the database.
+
+* Foreign key creation now works correctly without specifying the
+  :key option when using MySQL with the InnoDB table engine.  InnoDB
+  requires that you list the column explicitly, even if you are
+  referencing the primary key of the table, so if the :key option is
+  not given, the database schema is introspected to find the primary
+  key for the table.  If you are attempting to create a table with
+  a self-referential foreign key, it introspects the generator to
+  get the primary key for the table.
+
+* The sqlite adapter will now return 1/0 stored in boolean columns as
+  true/false.  It will convert dates stored as Integers/Floats to
+  Date objects by assuming they represent the julian date.  It will
+  convert times stored as Integers/Floats to Sequel::SQLTime objects
+  by assuming they represent a number of seconds. It will convert
+  datetimes stored as Integers by assuming they represent a unix
+  epoch time integer, and datetimes stored as Floats by assuming the
+  represent the julian date (with fractional part representing the
+  time of day).  These changes make Sequel handle SQLite's
+  recommendations for boolean/date/time storage.
+
+* The instance_hooks plugin's (before|after)_*_hook methods now return
+  self so they can be used in a method chain.
+
+* The list plugin now automatically adds new entries to the end of the
+  list when creating the entries, if the position field is not
+  specifically set.
+
+* An identifier_output_method is now respected in the mysql2 adapter.
+
+* NaN/Infinity Float values are now quoted correctly for input on
+  PostgreSQL, and the postgres adapter correctly handles them on
+  retrieval from the database.
+
+* The :collate column option is now respected when creating tables or
+  altering columns on MySQL.
+
+* You can now force use of the TimestampMigrator when the
+  IntegerMigrator would be used by default by calling
+  TimestampMigrator.apply or .run.
+
+* Mock adapter usage with a specific SQL dialect now uses the
+  appropriate defaults for quoting identifiers.
+
+* You can now disable the use of sudo in the rake install/uninstall
+  tasks using the SUDO='' environment variable.
+
+* A very misleading error message has been fixed when attempting
+  to constantize an invalid string in the model inflector.
+
+= Backwards Compatibility
+
+* The sqlite adapter now typecasts columns that SQLite stores as
+  INTEGER/REAL.  Previously, it only typecasted columns that
+  SQLite stored as TEXT/BLOB.  For details about SQLite storage, see
+  http://www.sqlite.org/datatype3.html.
+
+  Any custom type conversion procs used with the sqlite adapter should
+  be modified to work with Integer/Float objects in addition to String
+  objects.