sequel 3.31.0 → 3.32.0

data/CHANGELOG

@@ -1,3 +1,57 @@
+=== 3.32.0 (2012-02-01)
+
+* Make serialization_modification_detection plugin work correctly with new objects and after saving existing objects (jeremyevans) (#432)
+
+* Make refreshes after model creation clear the deserialized values in the serialization plugin (jeremyevans)
+
+* Add Dataset#update_ignore on MySQL, for using UPDATE IGNORE in queries (danielb2) (#429)
+
+* Allow select_map/select_order_map to take both a column argument and a block (jeremyevans)
+
+* Fix virtual row block handling in select_map/select_order_map if block returns an array (jeremyevans) (#428)
+
+* Add Sequel.empty_array_handle_nulls setting, can be set to false for possible better performance on some databases (jeremyevans)
+
+* Change exclude(:b=>[]) to not return rows where b is NULL (jeremyevans) (#427)
+
+* Support ActiveModel 3.2 in the active_model plugin, by adding support for to_partial_path (jeremyevans)
+
+* Fix metadata methods (e.g. tables) on Oracle when custom identifier input methods are used (jeremyevans)
+
+* Fix Database#indexes on DB2 (jeremyevans)
+
+* Make DateTime/Time columns with Sequel::CURRENT_TIMESTAMP default values use timestamp column on MySQL (jeremyevans)
+
+* Wrap column default values in extra parens on SQLite, fixes some cases (jeremyevans)
+
+* Make Database#indexes not include primary key indexes on Derby, HSQLDB, Oracle, and DB2 using the jdbc adapter (jeremyevans)
+
+* Support Database#indexes in shared MSSQL adapter (jeremyevans)
+
+* Support :include option when creating indexes on MSSQL, for storing column values in the index (crawlik) (#426)
+
+* Make set_column_type not modify defaults and NULL/NOT NULL setting on MSSQL, H2, and SQLite (jeremyevans)
+
+* Qualify identifiers when filtering/excluding by associations (jeremyevans)
+
+* Make table_exists? better handle tables where you don't have permissions for all columns (jeremyevans) (#422)
+
+* Using new association options, support associations based on columns that clash with ruby method names (jeremyevans) (#417)
+
+* Add use_after_commit_rollback setting to models, can be turned off to allow model usage with prepared transactions (jeremyevans)
+
+* Fix alter table emulation on SQLite when foreign keys reference the table being altered (jeremyevans)
+
+* Fix progress shared adapter, broken since the dataset literalization refactoring (jeremyevans) (#414)
+
+* Support :map and :to_hash prepared statement types (jeremyevans)
+
+* Make Dataset#naked! work correctly (jeremyevans)
+
+* Remove Dataset#paginate!, as it was broken (jeremyevans)
+
+* Fix query extension to not break usage of #clone without arguments (jeremyevans) (#413)
+
 === 3.31.0 (2012-01-03)
 
 * Dataset#from no longer handles :a__b__c___d as a.b.c AS d (jeremyevans)

data/MIT-LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2007-2008 Sharon Rosner
-Copyright (c) 2008-2011 Jeremy Evans
+Copyright (c) 2008-2012 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/doc/advanced_associations.rdoc

@@ -237,6 +237,23 @@ Sequel::Model:
 
   class Invoice < Sequel::Model
     many_to_one :client
+
+    # has_one :through equivalent 1
+    # eager load with :eager=>:firm option on :client association, and eager loading :client
+    def firm
+      client.firm if client
+    end
+
+    # has_one :through equivalent 2
+    # eager load the usual way
+    many_to_many :firms, :join_table=>:clients, :left_key=>:id, :left_primary_key=>:client_id, :right_key=>:firm_id
+    def firm
+      firms.first
+    end
+
+    # has_one :through equivalent 3
+    # eager loading requires custom :eager_loader proc
+    many_to_one :firm, :dataset=>proc{Firm.join(:clients, :firm_id=>:id, :id=>client_id).select_all(:firms)}
   end
 
   Firm.first.invoices

data/doc/association_basics.rdoc

@@ -1430,6 +1430,78 @@ by the foreign/primary keys.  This option causes the
 you want to replace the default foreign/primary key conditions that Sequel
 would use when eagerly graphing.
 
+=== Column Naming Conflict Options
+
+Sequel's association support historically called methods on model objects
+to get primary key or foreign key values instead of accessing the column
+values directly, in order to allow advanced features such as associations
+based on virtual column keys.  Unfortunately, that causes issues if columns
+are used with names that clash with existing method names, which can happen
+if you want to name the association the same name as an existing column, or
+if the column has the same name as an already defined method such as
+<tt>object_id</tt>.
+
+Sequel has added the following options that allow you to work around the
+issue by either specifying the column name symbol or the method name symbol
+to use.  In most cases, these methods are designed to be used with column
+aliases defined with <tt>Model.def_column_alias</tt>:
+
+  # Example schema:
+  #  albums           artists
+  #   :id        /-->  :id
+  #   :artist --/      :name
+  #   :name
+  class Album < Sequel::Model
+    def_column_alias(:artist_id, :artist)
+    many_to_one :artist, :key=>:artist_id, :key_column=>:artist
+  end
+  
+  # Example schema:
+  #  things              objs
+  #   :id           /-->  :id
+  #   :object_id --/      :name
+  #   :name
+  class Thing < Sequel::Model
+    def_column_alias(:obj_id, :object_id)
+  end
+  class Obj < Sequel::Model
+    many_to_one :things, :key=>:object_id, :key_method=>:obj_id
+  end
+
+Note that for eager loading purposes, you generally need to set the
+<tt>:eager_loader_key</tt> option as well, specifying the underlying
+column(s) to use.
+
+==== :key_column [+many_to_one+]
+
+Like the :key option, but :key references the method name, while
+:key_column references the underlying column.
+
+==== :primary_key_method [+many_to_one+]
+
+Like the :primary_key option, but :primary_key references the column
+name, while :primary_key_method references the method name.
+
+==== :primary_key_column [+one_to_many+, +one_to_one+]
+
+Like the :primary_key option, but :primary_key references the method name, while
+:primary_key_column references the underlying column.
+
+==== :key_method [+one_to_many+, +one_to_one+]
+
+Like the :key option, but :key references the column
+name, while :key_method references the method name.
+
+==== :left_primary_key_column [+many_to_many+]
+
+Like the :left_primary_key option, but :left_primary_key references the method name, while
+:left_primary_key_column references the underlying column.
+
+==== :right_primary_key_method [+many_to_many+]
+
+Like the :right_primary_key option, but :right_primary_key references the column
+name, while :right_primary_key_method references the method name.
+
 === Advanced Options
 
 ==== :reciprocal
@@ -1483,34 +1555,6 @@ If the default modification methods would not do what you want, and you
 don't plan on overriding the internal modification methods to do what you
 want, it may be best to set this option to true.
 
-==== :key_column [+many_to_one+]
-
-This option exists to make it possible to create a +many_to_one+ association
-with the same name as the foreign key it uses.  Before this option was
-introduced, this was problematic, since the :key option was used to refer
-both to the model methods and the underlying database columns (which are
-usually the same).
-
-If you have a legacy database with a foreign key that is the same as the name
-of the association you would like to use, you should create a column alias
-for the foreign key and use this option:
-
-  # 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
-
-Note that if you have control over the database, it's better to just rename
-the foreign key column than use this option.  Similarly, if you can think
-of another association name that will work, it's wiser to rename the
-association than use this option.  Think of this option as a last resort.
-
 ==== :validate
 
 Set to false to not validate when implicitly saving any associated object.
@@ -1595,8 +1639,8 @@ strategies are:
                     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 association where
+                        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

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/schema_modification.rdoc

@@ -515,7 +515,7 @@ mess up the migration.
 <tt>create_table?</tt> with a question mark only creates the table if it does
 not already exist, so:
 
-  create_table!(:artists)
+  create_table?(:artists)
     primary_key :id
   end
 

data/lib/sequel/adapters/jdbc/db2.rb

@@ -16,6 +16,8 @@ module Sequel
     module DB2
       # Database instance methods for DB2 databases accessed via JDBC.
       module DatabaseMethods
+        PRIMARY_KEY_INDEX_RE = /\Asql\d+\z/i.freeze
+
         include Sequel::DB2::DatabaseMethods
         include Sequel::JDBC::Transactions
         IDENTITY_VAL_LOCAL = "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1".freeze
@@ -34,6 +36,11 @@ module Sequel
             rs.getInt(1)
           end
         end
+        
+        # Primary key indexes appear to be named sqlNNNN on DB2
+        def primary_key_index_re
+          PRIMARY_KEY_INDEX_RE
+        end
       end
       
       # Dataset class for DB2 datasets accessed via JDBC.