sequel 4.6.0 → 4.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4da9d52fb246c1f0e83b88184dd82d4bf7b609cd
-  data.tar.gz: 041e624b4f998ebc9835898be941fadc12fda8c4
+  metadata.gz: 4c36878b92e104f343cc1e7c92ff6e94026040c1
+  data.tar.gz: ee7e4399243acbbfa11e6f427fedb49684b2426f
 SHA512:
-  metadata.gz: d965c77370235e2ceee16aca1e1193b01d2eb259b179307a51f8218778dda40c4fb35cea667568ce7cfa4d5f95297396a2876ae744d3638d359b81dfa63a019a
-  data.tar.gz: 052c8d3db3bd66279b50cf455e6928eb9e753e49f273399f85d5d0e2fe238ecc33c97a1a95d1b56f5bca9cb670c1fedb9eeb95fdb68232ac032647eb370b7992
+  metadata.gz: faea6910ec5976db18b931961ed086cd295560a7ea54227b9af0811ecb98e75d61ba34899bf0d762c67182dea1be980daf339cce65aad1e9fe06eb7365c43f84
+  data.tar.gz: d3f3b358199a9f624387f2218074b2d01e39e9a295504dc988dbb8e792155af32e26ac17ca5bbfd95fc3c2d5b7fc084edeab90fa0123b0c673952ec048d0d574

data/CHANGELOG

@@ -1,3 +1,35 @@
+=== 4.7.0 (2014-02-01)
+
+* Don't swallow underlying exception if there is an exception closing the cursor on PostgreSQL (jeremyevans) (#761)
+
+* Recognize primary key unique constraint violations on MSSQL and SQLAnywhere (jeremyevans)
+
+* Recognize composite unique constraint violations on SQLite (timcraft) (#758)
+
+* Make #* method without arguments on SQL::Function return a Function with * prepended to the arguments (jeremyevans)
+
+* Add #function to SQL::Identifier and SQL::QualifiedIdentifier, allowing for easy use of schema qualified functions or functions names that need quoting (jeremyevans)
+
+* Add SQL::Function#distinct for easier creation of aggregate functions using DISTINCT (jeremyevans)
+
+* Add SQL::Function#over for easier creation of window functions (jeremyevans)
+
+* Don't clear validation instance_hooks until after a successful save (jeremyevans)
+
+* Support :raise_on_save_failure option for one_to_many, pg_array_to_many, and many_to_pg_array associations (jeremyevans)
+
+* Make SQLTime#to_s return a string in HH:MM:SS format, since it shouldn't include date information (jeremyevans)
+
+* Support the Database#tables :schema option in the jdbc adapter (robbiegill, jeremyevans) (#755)
+
+* Automatically rollback transactions in killed threads in ruby 2.0+ (chanks) (#752)
+
+* Add update_or_create plugin, for updating an object if it exists, or creating such an object if it does not (jeremyevans)
+
+* Make auto_validations uniqueness validations work correctly for STI subclasses (jeremyevans)
+
+* Support :dataset option to validates_unique vaildation (jeremyevans)
+
 === 4.6.0 (2014-01-02)
 
 * Add Database#call_mssql_sproc on MSSQL for calling stored procedures and handling output parameters (jrgns, jeremyevans) (#748)

data/doc/association_basics.rdoc

@@ -689,6 +689,14 @@ The add_<i>association</i> method returns the now associated object:
 
   @album = @artist.add_album(:name=>'RF')
 
+Note that the add_* methods for +one_to_many+ persist the changes by
+saving the passed in (or newly created) object.  However, to avoid
+silent failures of these methods, they explicitly raise exceptions
+even when raise_on_save_failure is false for the associated model.
+You can disable this behavior (i.e. return nil instead of raising
+exceptions on a save failure) by setting the <tt>:raise_on_save_failure=>false</tt>
+option for the association.
+
 === remove_<i>association</i>(object_to_disassociate) (e.g. remove_album) [+one_to_many+ and +many_to_many+]
 
 The remove_<i>association</i> method disassociates the passed object from
@@ -1645,6 +1653,16 @@ add_<i>association</i> method, Sequel will automatically save the object.
 If you don't want to validate objects when these implicit saves are done,
 the validate option should be set to false.
 
+==== :raise_on_save_failure [+one_to_many+ associations]
+
+Set to false to not raise an exception when validation or a before hook
+fails when implicitly saving an associated object in the add_* or remove_*
+methods.  This mirrors the raise_on_save_failure model setting, which these
+methods do not respect (by design, since the setting is dangerous).
+
+If you use this option, you must explicitly check all add_* and remove_* return
+values to see if they were successful.
+
 ==== :allow_eager
 
 If set to false, you cannot load the association eagerly via eager or

data/doc/migration.rdoc

@@ -482,6 +482,36 @@ depend on which migrations that have been applied.  Applied migrations greater
 than that version will be migrated down, while unapplied migrations less than
 or equal to that version will be migrated up.
 
+== Running migrations from a Rake task
+
+You can also incorporate migrations into a Rakefile. Here's an example
+using integer migration versions.
+
+  namespace :db do
+    desc "Run migrations"
+    task :migrate, [:version] do |t, args|
+      require "sequel"
+      Sequel.extension :migration
+      db = Sequel.connect(ENV.fetch("DATABASE_URL"))
+      if args[:version]
+        puts "Migrating to version #{args[:version]}"
+        Sequel::Migrator.run(db, "db/migrations", target: args[:version].to_i)
+      else
+        puts "Migrating to latest"
+        Sequel::Migrator.run(db, "db/migrations")
+      end
+    end
+  end
+
+To migrate to the latest version, run:
+
+  rake db:migrate
+
+This Rake task takes an optional argument specifying the target
+version. To migrate to version 42, run:
+
+  rake db:migrate[42]
+
 == Verbose migrations
 
 By default, <tt>sequel -m</tt> operates as a well behaved command line utility

data/doc/release_notes/4.7.0.txt

@@ -0,0 +1,103 @@
+= New Features
+
+* Alternatives for the more complex virtual row method calls have
+  been added:
+
+    # Window Functions using SQL::Function#over
+    # before: select{sum(:over, :args=>:col1, :partition=>:col2){}}
+    select{sum(:col1).over(:partition=>:col2)}
+
+    # count(*) using SQL::Function#*
+    # before: select{count(:*){}}
+    select{count{}.*}
+
+    # count(distinct col) using SQL::Function#distinct
+    # before: select{count(:distinct, :col){}}
+    select{count(:col).distinct}
+
+  Additionally, schema qualified functions are now supported via
+  SQL::QualifiedIdentifier#function, and quoted functions are now
+  supported via SQL::Identifier#function on some databases:
+
+    # "func"("col")
+    select{func.function(:col)}
+
+    # "schema"."func"("col1")
+    select{schema__func.function(:col1)}
+
+  If the database does not support quoting function names, then
+  Sequel will not quote them.
+
+* An update_or_create plugin has been added, for updating a matching
+  object if one exists, or creating an object if it does not. For
+  example, the following code will update the number of copies sold
+  for album with the name 'Hello', or it will create an album with
+  the name 'Hello' and 1000 number of copies sold:
+
+    Album.plugin :update_or_create
+    Album.update_or_create(:name=>'Hello') do |album|
+      album.num_copies_sold = 1000
+    end
+
+  You can also use a shorter form of this, with two hashes:
+    
+    Album.update_or_create({:name=>'Hello'}, {:num_copies_sold=>1000})
+
+  This plugin also adds a method named find_or_new, which does the
+  same thing as update_or_create, except it doesn't persist any
+  changes.
+
+* A :raise_on_save_failure option has been added for one_to_many,
+  pg_array_to_many, and many_to_pg_array associations.  This mirrors
+  the Model.raise_on_save_failure setting, and if set to false, it
+  will make the add/remove methods return nil instead of raising
+  an error if there is a validation/hook error when saving the
+  associated record.
+
+* The validates_unique validation in validation_helpers now supports a
+  :dataset option to provide the base dataset to use to check
+  uniqueness.  This is useful when the model itself uses a filtered
+  dataset, but the unique index in the database is on an unfiltered
+  dataset.
+
+  The auto_validations plugin uses this option to ensure that unique
+  validations are setup correctly in subclasses using single table
+  inheritance.
+
+= Other Improvements
+
+* Sequel now automatically rolls back transactions in killed threads
+  on ruby 2.0+.  It is still impossible to do so on ruby 1.9.
+
+* In the instance_hooks plugin, validation instance hooks are now
+  not cleared until after a successful save.
+
+* Composite unique key constraint violations are now recognized
+  and raised as Sequel::UniqueConstraintViolation on SQLite.
+
+* Primary key unique constraint violations are now recognized and
+  and raised as Sequel::UniqueConstraintViolation on Microsoft
+  SQL Server and SQLAnywhere.
+
+* If an exception occurs when using a cursor in the postgres adapter,
+  and an exception also occurs when closing the cursor when cleaning
+  up, the initial exception is now raised.
+
+* You can now get tables in a specific schema in the jdbc adapter
+  using the :schema option to Database#tables.  This was already
+  supported in most jdbc subadapters because they implement #tables
+  using database specific code instead of looking at the JDBC
+  metadata, but it should now work for all jdbc subadapters.
+
+* Sequel::SQLTime#to_s is now defined and returns a string in
+  HH:MM:SS format (leaving off the date).
+
+= Backwards Compatibility
+
+* The odbc adapter's :driver option is no longer deprecated, as reports
+  were received that it still works.
+
+* If you were re-adding instance validation hooks using instance_hooks
+  after a save failure, and then retrying the save, you may now end up
+  with duplicate validations.  You no longer need to re-add validation
+  hooks unless the object was saved successfully.

data/doc/security.rdoc

@@ -175,6 +175,11 @@ be specified by the user, it allows you to use a ruby string, and that
 string is used verbatim as the SQL type.  You should not use user input
 for type strings.
 
+==== SQL Function Names
+
+In most cases, Sequel does not quote SQL function names.  You should not use
+user input for function names.
+
 === SQL Identifier Injections
 
 Usually, Sequel treats ruby symbols as SQL identifiers, and ruby

data/doc/sql.rdoc

@@ -182,7 +182,7 @@ You can also use the <tt>Sequel.as</tt> method to create an alias, and the +as+
 
 The easiest way to use SQL functions is via a virtual row:
 
-  DB[:albums].select{func{}} # SELECT func() FROM "albums"
+  DB[:albums].select{func.function} # SELECT func() FROM "albums"
   DB[:albums].select{func(col1, col2)} # SELECT func("col1", "col2") FROM "albums"
 
 You can also use the <tt>Sequel.function</tt> method on the symbol that contains the function name:
@@ -196,34 +196,43 @@ Aggregate functions work the same way as normal functions, since they share the
 
   Sequel.function(:sum, :column) # sum(column)
 
-However, if you want to use the DISTINCT modifier to an aggregate function, you either have to use literal SQL or a virtual row block:
+To use the DISTINCT modifier to an aggregate function, call the distinct method on the function:
 
-  Sequel.function(:sum, Sequel.lit('DISTINCT column')) # sum(DISTINCT column)
-  DB[:albums].select{sum(:distinct, :column){}} # SELECT sum(DISTINCT column) FROM albums
+  DB[:albums].select{sum(:column).distinct} # SELECT sum(DISTINCT column) FROM albums
 
-If you want to use the wildcard as the sole argument of the aggregate function, you again have to use literal SQL or a virtual row block:
+If you want to use the wildcard as the sole argument of the aggregate function, use the * method on the Function:
 
-  Sequel.function(:count, Sequel.lit('*')) # count(*)
-  DB[:albums].select{count(:*){}} # SELECT count(*) FROM albums
+  Sequel.function(:count).* # count(*)
+  DB[:albums].select{count.function.*} # SELECT count(*) FROM albums
 
 Note that Sequel provides helper methods for aggregate functions such as +count+, +sum+, +min+, +max+, +avg+, and +group_and_count+, which handle common uses of aggregate functions.
 
 === Window Functions
 
-If the database supports window functions, Sequel can handle them using a virtual row block:
+If the database supports window functions, Sequel can handle them by calling the over method on a Function:
 
-  DB[:albums].select{function(:over){}}
+  DB[:albums].select{function.function.over}
   # SELECT function() OVER () FROM albums
 
-  DB[:albums].select{count(:over, :*=>true){}}
+  DB[:albums].select{count.function.*.over}
   # SELECT count(*) OVER () FROM albums
 
-  DB[:albums].select{function(:over, :args=>col1, :partition=>col2, :order=>col3){}}
+  DB[:albums].select{function(:col1).over(:partition=>col2, :order=>col3)}
   # SELECT function(col1) OVER (PARTITION BY col2 ORDER BY col3) FROM albums
 
-  DB[:albums].select{function(:over, :args=>[c1, c2], :partition=>[c3, c4], :order=>[c5, c6]){}}
+  DB[:albums].select{function(c1, c2).over(:partition=>[c3, c4], :order=>[c5, c6])}
   # SELECT function(c1, c2) OVER (PARTITION BY c3, c4 ORDER BY c5, c6) FROM albums
 
+=== Schema Qualified Functions
+
+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
+  
+  DB[:albums].select{schema__function.function(col, 2, "a")}
+  # SELECT schema.function(col, 2, 'a') FROM albums
+
 === Equality Operator (=)
 
 Sequel uses hashes to specify equality:

data/doc/validations.rdoc

@@ -245,7 +245,7 @@ These methods check that the specified attributes can be valid integers or valid
 
 === +validates_schema_types+
 
-+validates_schema_types+ uses the database metadata for the model's table to determine which ruby type(s) should be used for the given database type, and calls +validates_type+ with that ruby type.  It's designed to be used with the <tt>raise_on_typecast_failure = false</tt> setting (the default starting in Sequel 4).  <tt>raise_on_typecast_failure = false</tt, Sequel attempts to typecast values, but silently ignores any errors raised:
++validates_schema_types+ uses the database metadata for the model's table to determine which ruby type(s) should be used for the given database type, and calls +validates_type+ with that ruby type.  It's designed to be used with the <tt>raise_on_typecast_failure = false</tt> setting (the default starting in Sequel 4).  <tt>raise_on_typecast_failure = false</tt>, Sequel attempts to typecast values, but silently ignores any errors raised:
 
   Album.raise_on_typecast_failure = false
   album = Album.new
@@ -294,10 +294,18 @@ You can mix and match the two approaches.  For example, if all albums should hav
 
 If you provide a block, it is called with the dataset to use for the uniqueness check, which you can then filter to scope the uniqueness validation to a subset of the model's dataset.
 
-Additionally, you can also include an optional options hash as the last argument.  Unlike the other validations, the options hash for +validates_unique+ only checks for two options:
+You can also include an options hash as the last argument.  Unlike the other validations, the options hash for +validates_unique+ only recognizes for these options:
 
+:dataset :: The base dataset to use for the unique query, defaults to the model's dataset
 :message :: The message to use
 :only_if_modified :: Only check the uniqueness if the object is new or one of the columns has been modified.
+:where :: A callable object where call takes three arguments, a dataset,
+          the current object, and an array of columns, and should return
+          a modified dataset that is filtered to include only rows with
+          the same values as the current object for each column in the array.
+          This is useful any time the unique constraints are derived from
+          the columns and not the columns themselves (such as unique constraints
+          on lower(column)).
 
 +validates_unique+ is the only method in +validation_helpers+ that checks with the database.  Attempting to validate uniqueness outside of the database suffers from a race condition, so any time you want to add a uniqueness validation, you should make sure to add a uniqueness constraint or unique index on the underlying database table.  See the {"Migrations and Schema Modification" guide}[rdoc-ref:doc/migration.rdoc] for details on how to do that.  
 

data/doc/virtual_rows.rdoc

@@ -140,55 +140,48 @@ your function call:
   ds.where{function(1, a) > 1}
   # WHERE function(1, a) > 1
 
-If the SQL function does not accept any arguments, you need to provide an empty
-block to the method to distinguish it from a call that will produce an
-SQL::Identifier:
+If the SQL function does not accept any arguments, create an identifier, then
+call the function method on it to produce a function:
 
-  ds.select{|o| o.version{}}
-  ds.select{version{}}
+  ds.select{|o| o.version.function}
+  ds.select{version.function}
   # SELECT version()
   
-To use the SQL wildcard (*) as the sole argument in a function call (most often
-used with the count function), you should provide :* as the sole argument to
-the method, and provide an empty block to the method:
+To use the SQL wildcard (*) as the sole argument in a function call, create a
+function without arguments, then call the * method on the function:
   
-  ds.select{|o| o.count(:*){}}
-  ds.select{count(:*){}}
+  ds.select{|o| o.count.function.*}
+  ds.select{count.function.*}
   # SELECT count(*)
 
-To append the DISTINCT keyword before the method arguments, you need to make
-:distinct the first argument of the method call, and provide an empty block to
-the method:
+To append the DISTINCT keyword before the method arguments, just call the
+distinct method on the returned Function:
 
-  ds.select{|o| o.count(:distinct, o.col1){}}
-  ds.select{count(:distinct, col1){}}
+  ds.select{|o| o.count(o.col1).distinct)}
+  ds.select{count(col1).distinct}
   # SELECT count(DISTINCT col1)
   
-To use multiple columns with the DISTINCT keyword, use multiple arguments in
-the method call:
-
-  ds.select{|o| o.count(:distinct, o.col1, o.col2){}}
-  ds.select{count(:distinct, col1, col2){}}
+  ds.select{|o| o.count(o.col1, o.col2).distinct}
+  ds.select{count(col1, col2).distinct}
   # SELECT count(DISTINCT col1, col2)
   
 == SQL::WindowFunctions - SQL window function calls
 
 SQL::WindowFunctions can be thought of as calls to SQL window functions.  Not
 all databases support them, but they are very helpful for certain types of
-queries.  To use them, you need to make :over the first argument of the method
-call, with an optional hash as the second argument, and provide an empty block
-to the method. Here are some examples of use:
+queries.  To use them, you should just call the over method on the Function
+object returned, with the options for the window:
 
-  ds.select{|o| o.rank(:over){}}
-  ds.select{rank(:over){}}
+  ds.select{|o| o.rank.function.over}
+  ds.select{rank.function.over}
   # SELECT rank() OVER ()
   
-  ds.select{|o| o.count(:over, :*=>true){}}
-  ds.select{count(:over, :*=>true){}}
+  ds.select{|o| o.count.function.*.over}
+  ds.select{count.function.*.over}
   # SELECT count(*) OVER ()
   
-  ds.select{|o| o.sum(:over, :args=>o.col1, :partition=>o.col2, :order=>o.col3){}}
-  ds.select{sum(:over, :args=>col1, :partition=>col2, :order=>col3){}}
+  ds.select{|o| o.sum(o.col1).over(:partition=>o.col2, :order=>o.col3)}
+  ds.select{sum(col1).over(:partition=>col2, :order=>col3)}
   # SELECT sum(col1) OVER (PARTITION BY col2 ORDER BY col3)
 
 == Operators

data/lib/sequel/adapters/jdbc.rb

@@ -497,7 +497,10 @@ module Sequel
       def get_tables(type, opts)
         ts = []
         m = output_identifier_meth
-        metadata(:getTables, nil, nil, nil, [type].to_java(:string)){|h| ts << m.call(h[:table_name])}
+        if schema = opts[:schema]
+          schema = schema.to_s
+        end
+        metadata(:getTables, nil, schema, nil, [type].to_java(:string)){|h| ts << m.call(h[:table_name])}
         ts
       end
 

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

@@ -223,6 +223,11 @@ module Sequel
         def select_clause_methods
           SELECT_CLAUSE_METHODS
         end
+
+        # H2 supports quoted function names.
+        def supports_quoted_function_names?
+          true
+        end
       end
     end
   end

data/lib/sequel/adapters/odbc.rb

@@ -14,7 +14,6 @@ module Sequel
         conn = if opts.include?(:drvconnect)
           ::ODBC::Database.new.drvconnect(opts[:drvconnect])
         elsif opts.include?(:driver)
-          Deprecation.deprecate("The odbc driver's handling of the :driver option is thought to be broken and will probably be removed in the future. If you are successfully using it, please contact the developers.")
           drv = ::ODBC::Driver.new
           drv.name = 'Sequel ODBC Driver130'
           opts.each do |param, value|

data/lib/sequel/adapters/postgres.rb

@@ -780,8 +780,15 @@ module Sequel
                 return if res.ntuples < rows_per_fetch
               end
             end
+          rescue Exception => e
+            raise
           ensure
-            execute_ddl("CLOSE #{cursor_name}", server_opts)
+            begin
+              execute_ddl("CLOSE #{cursor_name}", server_opts)
+            rescue
+              raise e if e
+              raise
+            end
           end
         end
       end