sequel 4.24.0 → 4.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ce66a463879671227d5446f7e224b1610bccd9f
-  data.tar.gz: e16b849b789b960f5c6d86dd7049a61ebe42c169
+  metadata.gz: 5bb525327915d4e6d6e8306e9edd0dc6cd32afa3
+  data.tar.gz: b64f5447c918b9d36b47622629ec697286adc0b8
 SHA512:
-  metadata.gz: 3ac3191f57bffb08c000deef706301c4b6628cb707ef9f870df162d7d55d3ed21982f931c3b9bbc3658cf4a693e7aa2b45d8a3dd1c62a0345d9d2d88dd7dc391
-  data.tar.gz: d05096b10746ea930ecd79f8cde66e295b9b5e99002c64df479369473a1bb603b36c9a69ce2462fecd33c1dc3217705bac651d590dca4c58a85edd44b1c515b3
+  metadata.gz: caa13716ae448d4a3b3c6f4886c2e529f495e843eeb5386b85a264d259bb54d0ffefca3d7cba9c82013d1c96c87bff8691e460e1e0a06806bb64cef18950e284
+  data.tar.gz: 302d93a18b52e0810e74fce6f3d4a87f497f4199fb47045834aecbe193f6796fd910453b0c1669b8d82b3d698ac5bb13346fce825311da03c7a77ab7d89d728c

data/CHANGELOG

@@ -1,3 +1,43 @@
+=== 4.25.0 (2015-08-01)
+
+* Add Dataset#insert_conflict on PostgreSQL 9.5+, for upsert/insert ignore support using INSERT ON CONFLICT (jeremyevans)
+
+* Support Dataset#group_rollup and #group_cube on PostgreSQL 9.5+ (jeremyevans)
+
+* Automatically REORG tables when altering when using jdbc/db2 (karlhe) (#1054)
+
+* Recognize constraint violation exceptions on swift/sqlite (jeremyevans)
+
+* Recognize another check constraint violation exception message on SQLite (jeremyevans)
+
+* Allow =~ and !~ to be used on ComplexExpressions (janko-m) (#1050)
+
+* Support case sensitive SQL Server 2012 in MSSQL metadata queries (knut2) (#1049)
+
+* Add Dataset#group_append, for appending to the existing GROUP BY clause (YorickPeterse) (#1047)
+
+* Add inverted_subsets plugin, for creating an inverted subset method for each subset (celsworth) (#1042)
+
+* Make Dataset#for_update not use the :read_only database when the dataset is executed (jeremyevans) (#1041)
+
+* Add singular_table_names plugin, for changing Sequel to not pluralize table names by default (jeremyevans)
+
+* PreparedStatement#prepare now raises an Error (jeremyevans)
+
+* Clear delayed association pks when refreshing an object (jeremyevans)
+
+* Add empty_array_consider_nulls extension to make Sequel consider NULL values when using IN/NOT IN with an empty array (jeremyevans)
+
+* Make Sequel default to ignoring NULL values when using IN/NOT IN with an empty array (jeremyevans)
+
+* Remove the deprecated firebird and informix adapters (jeremyevans)
+
+* Make :collate option when creating columns literalize non-String values on PostgreSQL (jeremyevans) (#1040)
+
+* Make dirty plugin notice when serialized column is changed (celsworth) (#1039)
+
+* Allow prepared statements to use RETURNING (jeremyevans) (#1036)
+
 === 4.24.0 (2015-07-01)
 
 * Allow class_table_inheritance plugin to support subclasses that don't add additional columns (QuinnHarris, jeremyevans) (#1030)

data/doc/association_basics.rdoc

@@ -754,11 +754,8 @@ all associated objects to NULL in a single query.  For +many_to_many+
 associations, this deletes all matching rows in the join table.
 Unlike the add_<i>association</i> and remove_<i>association</i> method, the
 plural form of the association name is used in this method.
-The remove_all_<i>association</i> method returns the number of rows updated
-for +one_to_many+ associations and the number of rows deleted for
-+many_to_many+ associations:
-
-  @rows_modified = @artist.remove_all_albums
+The remove_all_<i>association</i> method returns the previously cached associated
+records, or nil if there were no cached associated records.
 
 === <i>association</i>_dataset (e.g. albums_dataset)
 

data/doc/dataset_basics.rdoc

@@ -78,7 +78,7 @@ SELECT:: select, select_all, select_append, select_group, select_more
 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
+GROUP:: group, group_by, group_and_count, group_append, select_group, ungrouped
 HAVING:: having, exclude_having, invert, unfiltered
 ORDER:: order, order_by, order_append, order_prepend, order_more, reverse, reverse_order, unordered
 LIMIT/OFFSET:: limit, offset, unlimited

data/doc/postgresql.rdoc

@@ -185,6 +185,53 @@ When returning is used, instead of returning the number of rows affected (for up
 or the serial primary key value (for insert), it will return an array of hashes with the
 returned results.
 
+=== INSERT ON CONFLICT Support
+
+Starting with PostgreSQL 9.5, you can do an upsert or ignore unique or exclusion constraint
+violations when inserting using <tt>Dataset#insert_conflict</tt>:
+
+  DB[:table].insert_conflict.insert(:a=>1, :b=>2)
+  # INSERT INTO TABLE (a, b) VALUES (1, 2)
+  # ON CONFLICT DO NOTHING
+
+For compatibility with Sequel's MySQL support, you can also use +insert_ignore+:
+
+  DB[:table].insert_ignore.insert(:a=>1, :b=>2)
+  # INSERT INTO TABLE (a, b) VALUES (1, 2)
+  # ON CONFLICT DO NOTHING
+ 
+You can pass a specific constraint name using +:constraint+, to only ignore a specific
+constraint violation:
+
+  DB[:table].insert_conflict(:constraint=>:table_a_uidx).insert(:a=>1, :b=>2)
+  # INSERT INTO TABLE (a, b) VALUES (1, 2)
+  # ON CONFLICT ON CONSTRAINT table_a_uidx DO NOTHING
+ 
+If the unique or exclusion constraint covers the whole table (e.g. it isn't a partial unique
+index), then you can just specify the column using the +:target+ option:
+
+  DB[:table].insert_conflict(:target=>:a).insert(:a=>1, :b=>2)
+  # INSERT INTO TABLE (a, b) VALUES (1, 2)
+  # ON CONFLICT (a) DO NOTHING
+ 
+If you want to update the existing row instead of ignoring the constraint violation, you
+can pass an +:update+ option with a hash of values to update.  You must pass either the
++:target+ or +:constraint+ options when passing the +:update+ option:
+
+  DB[:table].insert_conflict(:target=>:a, :update=>{:b=>:excluded__b}).insert(:a=>1, :b=>2)
+  # INSERT INTO TABLE (a, b) VALUES (1, 2)
+  # ON CONFLICT (a) DO UPDATE SET b = excluded.b
+ 
+Additionally, if you only want to do the update in certain cases, you can specify an
++:update_where+ option, which will be used as a filter.  If the row doesn't match the
+conditions, the constraint violation will be ignored, but the row will not be updated:
+
+  DB[:table].insert_conflict(:constraint=>:table_a_uidx,
+    :update=>{:b=>:excluded__b}, :update_where=>{:table__status_id=>1}).insert(:a=>1, :b=>2)
+  # INSERT INTO TABLE (a, b) VALUES (1, 2)
+  # ON CONFLICT ON CONSTRAINT table_a_uidx
+  # DO UPDATE SET b = excluded.b WHERE (table.status_id = 1)
+
 === Distinct On Specific Columns
 
 Sequel allows passing columns to <tt>Dataset#distinct</tt>, which will make the dataset return

data/doc/querying.rdoc

@@ -677,6 +677,11 @@ You can remove an existing grouping using +ungrouped+:
 
   Album.group(:artist_id).ungrouped
   # SELECT * FROM albums
+
+If you want to add a column to the end of the existing grouping columns:
+
+  Album.group(:artist_id).group_append(:name)
+  # SELECT * FROM albums GROUP BY artist_id, name
  
 A common use of grouping is to count based on the number of grouped rows,
 and Sequel provides a +group_and_count+ method to make this easier:

data/doc/release_notes/4.25.0.txt

@@ -0,0 +1,181 @@
+= New Features
+
+* The =~ and !~ methods are now defined on ComplexExpressions in
+  addition to GenericExpressions, allowing the following code to
+  work:
+
+    DB[:table].where{(column1 + column2) =~ column3}
+
+* Dataset#group_append has been added for appending to an existing
+  GROUP BY clause:
+
+    ds = DB[:table].group(:column1)
+    # SELECT * FROM table GROUP BY column1
+
+    ds = ds.group_append(:column2)
+    # SELECT * FROM table GROUP BY column1, column2
+
+* An inverted_subsets plugin has been added, for automatic creation of
+  methods for the inversion of the subset criteria.  For example:
+
+    Album.plugin :inverted_subsets
+    Album.subset :published, :published=>true
+
+    Album.published
+    # SELECT * FROM albums WHERE published IS TRUE
+
+    Album.not_published
+    # SELECT * FROM albums WHERE published IS NOT TRUE
+
+  By default, the subset method name is prefixed with "not_".  You can
+  pass a block to override the default behavior:
+
+    Album.plugin(:inverted_subsets){|name| "exclude_#{name}"}
+    Album.subset :published, :published=>true
+
+    Album.exclude_published
+    # SELECT * FROM albums WHERE published IS NOT TRUE
+
+* A singular_table_names plugin has been added, which changes Sequel
+  to not pluralize table names by default.
+
+    Sequel::Model.plugin :singular_table_names
+    class FooBar < Sequel::Model; end
+    FooBar.table_name # => foo_bar
+
+* Dataset#insert_conflict and #insert_ignore have been added on
+  PostgreSQL.  When using PostgreSQL 9.5+, they allow you to ignore
+  unique or exclusion constraint violations on inserting, or to do
+  an update instead:
+
+    DB[:table].insert_conflict.insert(:a=>1, :b=>2)
+    # INSERT INTO TABLE (a, b) VALUES (1, 2)
+    # ON CONFLICT DO NOTHING
+
+  You can pass a specific constraint name using :constraint, to only
+  ignore a specific constraint violation:
+
+    DB[:table].insert_conflict(:constraint=>:table_a_uidx).
+      insert(:a=>1, :b=>2)
+    # INSERT INTO TABLE (a, b) VALUES (1, 2)
+    # ON CONFLICT ON CONSTRAINT table_a_uidx DO NOTHING
+   
+  If the unique or exclusion constraint covers the whole table (e.g.
+  it isn't a partial unique index), then you can just specify the
+  column using the :target option:
+
+    DB[:table].insert_conflict(:target=>:a).insert(:a=>1, :b=>2)
+    # INSERT INTO TABLE (a, b) VALUES (1, 2)
+    # ON CONFLICT (a) DO NOTHING
+   
+  If you want to update the existing row instead of ignoring the
+  constraint violation, you can pass an :update option with a hash of
+  values to update.  You must pass either the :target or :constraint
+  options when passing the :update option:
+
+    DB[:table].insert_conflict(:target=>:a,
+                               :update=>{:b=>:excluded__b}).
+      insert(:a=>1, :b=>2)
+    # INSERT INTO TABLE (a, b) VALUES (1, 2)
+    # ON CONFLICT (a) DO UPDATE SET b = excluded.b
+   
+  Additionally, if you only want to do the update in certain cases,
+  you can specify an :update_where option, which will be used as a
+  filter.  If the row doesn't match the conditions, the constraint
+  violation will be ignored, but the row will not be updated:
+
+    DB[:table].insert_conflict(:constraint=>:table_a_uidx,
+                               :update=>{:b=>:excluded__b},
+                               :update_where=>{:table__status_id=>1}).
+      insert(:a=>1, :b=>2)
+    # INSERT INTO TABLE (a, b) VALUES (1, 2)
+    # ON CONFLICT ON CONSTRAINT table_a_uidx
+    # DO UPDATE SET b = excluded.b WHERE (table.status_id = 1)
+
+* Dataset#group_rollup and #group_cube are now supported when using
+  PostgreSQL 9.5+.
+
+* Sequel now supports Dataset#returning when using prepared statements
+  and bound variables:
+
+    DB[:table].returning.prepare(:insert, :i, :col=>:$col).
+      call(:col=>42)
+    # => [{:col=>42}]
+
+= Other Improvements
+
+* The serialization plugin now integrates with the dirty plugin, so
+  that column changes are detected correctly.  However, column values
+  that are changed and then changed back to the original value are
+  still detected as changed.
+
+* Dataset#for_update and similar locking methods now cause Sequel not
+  to use the :read_only shard if sharding is used.  
+
+* The association_pks plugin now clears cached delayed associated pks
+  when the object is refreshed.
+
+* The :collate column option when adding columns now literalizes
+  non-String values on PostgreSQL. Previously, the :collate option
+  value was used verbatim. This is because PostgreSQL's collations
+  generally require quoting as they are uppercase or mixed-case.
+
+* Sequel's metadata parsing methods now support Microsoft SQL Server
+  2012+ when used in case sensitive mode.
+
+* Sequel now recognizes an addition check constraint violation
+  exception on SQLite.
+
+* Sequel now recognizes constraint violations when using the
+  swift/sqlite adapter.
+
+* Sequel now automatically REORGs tables when altering them in the
+  jdbc/db2 adapter.
+
+= Backwards Compatibility
+
+* Sequel now defaults to ignoring NULL values when using IN/NOT IN
+  with an empty array.  Previously, code such as:
+
+    DB[:table].where(:column=>[])
+
+  would be literalized as:
+
+    SELECT * FROM table WHERE (column != column)
+
+  This yields a NULL value when column is NULL, similarly to how most
+  other SQL operators work.  Unfortunately, most databases do not
+  optimize this, and such a query can require a sequential scan of the
+  table.
+
+  Sequel previously shipped with a empty_array_ignore_nulls extension
+  that literalized the query to:
+
+    SELECT * FROM table WHERE (1 = 0)
+
+  which databases will generally optimize to a constant false value,
+  resulting in much faster queries.  This behavior is now the default.
+
+  Users that desire the previous behavior can use the new
+  empty_array_consider_nulls extension.
+
+* The deprecated firebird and informix adapters have been removed.
+
+* Calling prepare on a prepared statement now raises an exception.
+  It was supported accidently before, as prepared statements are
+  dataset instances.
+
+* Model::DatasetModule#subset now calls Model.subset instead of
+  the other way around.  This makes it possible to modify the
+  behavior of subset in a plugin.
+
+* The :collate column option change on PostgreSQL can break code
+  that used already quoted values in symbols.  For example:
+
+    String :column_name, collate=>:'"C"'
+
+  would need to change to:
+
+    String :column_name, collate=>:C
+    # or
+    String :column_name, collate=>'"C"'

data/lib/sequel/adapters/ibmdb.rb

@@ -185,15 +185,6 @@ module Sequel
 
       # Hash of connection procs for converting
       attr_reader :conversion_procs
-
-      # REORG the related table whenever it is altered.  This is not always
-      # required, but it is necessary for compatibilty with other Sequel
-      # code in many cases.
-      def alter_table(name, generator=nil)
-        res = super
-        reorg(name)
-        res
-      end
     
       # Create a new connection object for the given server.
       def connect(server)
@@ -271,25 +262,6 @@ module Sequel
         end
       end
 
-      # On DB2, a table might need to be REORGed if you are testing existence
-      # of it.  This REORGs automatically if the database raises a specific
-      # error that indicates it should be REORGed.
-      def table_exists?(name)
-        v ||= false # only retry once
-        sch, table_name = schema_and_table(name)
-        name = SQL::QualifiedIdentifier.new(sch, table_name) if sch
-        from(name).first
-        true
-      rescue DatabaseError => e
-        if e.to_s =~ /Operation not allowed for reason code "7" on table/ && v == false
-          # table probably needs reorg
-          reorg(name)
-          v = true
-          retry 
-        end
-        false
-      end
-
       private
 
       # Execute the given SQL on the database.

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

@@ -83,6 +83,25 @@ module Sequel
         true
       end
 
+      # On DB2, a table might need to be REORGed if you are testing existence
+      # of it.  This REORGs automatically if the database raises a specific
+      # error that indicates it should be REORGed.
+      def table_exists?(name)
+        v ||= false # only retry once
+        sch, table_name = schema_and_table(name)
+        name = SQL::QualifiedIdentifier.new(sch, table_name) if sch
+        from(name).first
+        true
+      rescue DatabaseError => e
+        if e.to_s =~ /Operation not allowed for reason code "7" on table/ && v == false
+          # table probably needs reorg
+          reorg(name)
+          v = true
+          retry 
+        end
+        false
+      end
+
       private
 
       # Handle DB2 specific alter table operations.
@@ -119,6 +138,16 @@ module Sequel
         end
       end
 
+      # REORG the related table whenever it is altered.  This is not always
+      # required, but it is necessary for compatibilty with other Sequel
+      # code in many cases.
+      def apply_alter_table(name, ops)
+        alter_table_sql_list(name, ops).each do |sql|
+          execute_ddl(sql)
+          reorg(name)
+        end
+      end
+
       # DB2 uses an identity column for autoincrement.
       def auto_increment_sql
         AUTOINCREMENT
@@ -190,12 +219,12 @@ module Sequel
       # Run the REORG TABLE command for the table, necessary when
       # the table has been altered.
       def reorg(table)
-        synchronize(opts[:server]){|c| c.execute(reorg_sql(table))}
+        execute_ddl(reorg_sql(table))
       end
 
       # The SQL to use for REORGing a table.
       def reorg_sql(table)
-        "CALL ADMIN_CMD(#{literal("REORG TABLE #{table}")})"
+        "CALL SYSPROC.ADMIN_CMD(#{literal("REORG TABLE #{quote_schema_table(table)}")})"
       end
 
       # Treat clob as blob if use_clob_as_blob is true

data/lib/sequel/adapters/shared/mssql.rb

@@ -131,10 +131,10 @@ module Sequel
         schema, table = schema_and_table(table)
         current_schema = m.call(get(Sequel.function('schema_name')))
         fk_action_map = FOREIGN_KEY_ACTION_MAP
-        ds = metadata_dataset.from(:sys__foreign_keys___fk).
-          join(:sys__foreign_key_columns___fkc, :constraint_object_id => :object_id).
-          join(:sys__all_columns___pc, :object_id => :fkc__parent_object_id,     :column_id => :fkc__parent_column_id).
-          join(:sys__all_columns___rc, :object_id => :fkc__referenced_object_id, :column_id => :fkc__referenced_column_id).
+        ds = metadata_dataset.from(Sequel.lit('[sys].[foreign_keys]').as(:fk)).
+          join(Sequel.lit('[sys].[foreign_key_columns]').as(:fkc), :constraint_object_id => :object_id).
+          join(Sequel.lit('[sys].[all_columns]').as(:pc), :object_id => :fkc__parent_object_id,     :column_id => :fkc__parent_column_id).
+          join(Sequel.lit('[sys].[all_columns]').as(:rc), :object_id => :fkc__referenced_object_id, :column_id => :fkc__referenced_column_id).
           where{{object_schema_name(:fk__parent_object_id) => im.call(schema || current_schema)}}.
           where{{object_name(:fk__parent_object_id) => im.call(table)}}.
           select{[:fk__name, 
@@ -169,10 +169,10 @@ module Sequel
         m = output_identifier_meth
         im = input_identifier_meth
         indexes = {}
-        ds = metadata_dataset.from(:sys__tables___t).
-         join(:sys__indexes___i, :object_id=>:object_id).
-         join(:sys__index_columns___ic, :object_id=>:object_id, :index_id=>:index_id).
-         join(:sys__columns___c, :object_id=>:object_id, :column_id=>:column_id).
+        ds = metadata_dataset.from(Sequel.lit('[sys].[tables]').as(:t)).
+         join(Sequel.lit('[sys].[indexes]').as(:i), :object_id=>:object_id).
+         join(Sequel.lit('[sys].[index_columns]').as(:ic), :object_id=>:object_id, :index_id=>:index_id).
+         join(Sequel.lit('[sys].[columns]').as(:c), :object_id=>:object_id, :column_id=>:column_id).
          select(:i__name, :i__is_unique, :c__name___column).
          where{{t__name=>im.call(table)}}.
          where(:i__is_primary_key=>0, :i__is_disabled=>0).
@@ -433,15 +433,15 @@ module Sequel
         inf_sch_qual = lambda{|s| info_sch_sch ? Sequel.qualify(info_sch_sch, s) : Sequel.expr(s)}
         sys_qual = lambda{|s| info_sch_sch ? Sequel.qualify(info_sch_sch, Sequel.qualify(Sequel.lit(''), s)) : Sequel.expr(s)}
 
-        identity_cols = metadata_dataset.from(:sys__columns).
+        identity_cols = metadata_dataset.from(Sequel.lit('[sys].[columns]')).
           where(:object_id=>table_id, :is_identity=>true).
           select_map(:name)
 
-        pk_index_id = metadata_dataset.from(sys_qual.call(:sysindexes)).
+        pk_index_id = metadata_dataset.from(sys_qual.call(Sequel.lit('sysindexes'))).
           where(:id=>table_id, :indid=>1..254){{(status & 2048)=>2048}}.
           get(:indid)
-        pk_cols = metadata_dataset.from(sys_qual.call(:sysindexkeys).as(:sik)).
-          join(sys_qual.call(:syscolumns).as(:sc), :id=>:id, :colid=>:colid).
+        pk_cols = metadata_dataset.from(sys_qual.call(Sequel.lit('sysindexkeys')).as(:sik)).
+          join(sys_qual.call(Sequel.lit('syscolumns')).as(:sc), :id=>:id, :colid=>:colid).
           where(:sik__id=>table_id, :sik__indid=>pk_index_id).
           select_order_map(:sc__name)