sequel 3.41.0 → 3.42.0

data/CHANGELOG

@@ -1,3 +1,31 @@
+=== 3.42.0 (2012-12-03)
+
+* If an exception occurs while committing a transaction, attempt to rollback (jeremyevans)
+
+* Support setting default string column sizes on a per-Database basis via default_string_column_size (jeremyevans)
+
+* Reset Model.instance_dataset when extending the model's dataset (jeremyevans)
+
+* Make the force_encoding plugin work with frozen strings (jeremyevans)
+
+* Add Database#do on PostgreSQL for using the DO anonymous code block execution statement (jeremyevans)
+
+* Remove Model.dataset_methods (jeremyevans)
+
+* Allow subset to be called inside a dataset_module block (jeremyevans)
+
+* Make Dataset#avg, #interval, #min, #max, #range, and #sum accept virtual row blocks (jeremyevans)
+
+* Make Dataset#count use a subselect when the dataset has an offset without a limit (jeremyevans) (#587)
+
+* Dump deferrable status of unique indexes on PostgreSQL (radford) (#583)
+
+* Extend deferrable constraint support to all types of constraints, not just foreign keys (radford, jeremyevans) (#583)
+
+* Support Database#copy_table and #copy_into on jdbc/postgres (bdon) (#580)
+
+* Make Dataset#update not use a limit (TOP) on Microsoft SQL Server 2000 (jeremyevans) (#578)
+
 === 3.41.0 (2012-11-01)
 
 * Add bin/sequel usage guide (jeremyevans)

data/README.rdoc

@@ -395,10 +395,10 @@ and not raise an exception outside the block, you can raise the
 Sequel makes it easy to join tables:
 
   order_items = DB[:items].join(:order_items, :item_id => :id).
-    where(:order_items__order_id => 1234)
+    where(:order_id => 1234)
   # SELECT * FROM items INNER JOIN order_items
   # ON order_items.item_id = items.id 
-  # WHERE order_items.order_id = 1234
+  # WHERE order_id = 1234
 
 The important thing to note here is that item_id is automatically qualified with
 the table being joined, and id is automatically qualified with the last table
@@ -437,9 +437,10 @@ Ruby strings are generally treated as SQL strings:
   items.where(:x => 'x')
   # SELECT * FROM items WHERE (x = 'x')
 
-=== Qualifying column names
+=== Qualifying identifiers (column/table names)
 
-Column references can be qualified by using the double underscore special notation <tt>:table__column</tt>:
+An identifier in SQL is a name that represents a column, table, or schema.
+Identifiers can be qualified by using the double underscore special notation <tt>:table__column</tt>:
 
   items.literal(:items__price)
   # items.price
@@ -449,9 +450,15 @@ Another way to qualify columns is to use the <tt>Sequel.qualify</tt> method:
   items.literal(Sequel.qualify(:items, :price))
   # items.price
 
-=== Column aliases
+While it is more common to qualify column identifiers with table identifiers, you can also qualify table identifiers with schema identifiers
+to select from a qualified table:
+
+  posts = DB[:some_schema__posts]
+  # SELECT * FROM some_schema.posts
+
+=== Identifier aliases
 
-You can also alias columns by using the triple undersecore special notation <tt>:column___alias</tt> or <tt>:table__column___alias</tt>:
+You can also alias identifiers by using the triple undersecore special notation <tt>:column___alias</tt> or <tt>:table__column___alias</tt>:
 
   items.literal(:price___p)
   # price AS p
@@ -463,6 +470,11 @@ Another way to alias columns is to use the <tt>Sequel.as</tt> method:
   items.literal(Sequel.as(:price, :p))
   # price AS p
 
+You can use the <tt>Sequel.as</tt> method to alias arbitrary expressions, not just identifiers:
+
+  items.literal(Sequel.as(DB[:posts].select{max(id)}, :p))
+  # (SELECT max(id) FROM posts) AS p
+
 == Sequel Models
 
 A model class wraps a dataset, and an instance of that class wraps a single record in the dataset.

data/Rakefile

@@ -32,6 +32,18 @@ task :release=>[:package] do
   sh %{gem push ./#{NAME}-#{VERS.call}.gem}
 end
 
+### Website
+
+desc "Make local version of website"
+task :website do
+  sh %{#{FileUtils::RUBY} www/make_www.rb}
+end
+
+desc "Update Non-RDoc section of sequel.rubyforge.org"
+task :website_rf_base=>[:website] do
+  sh %{rsync -rt www/public/*.html rubyforge.org:/var/www/gforge-projects/sequel/}
+end
+
 ### RDoc
 
 RDOC_DEFAULT_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', 'Sequel: The Database Toolkit for Ruby']
@@ -41,54 +53,47 @@ rdoc_task_class = begin
   RDOC_DEFAULT_OPTS.concat(['-f', 'hanna'])
   RDoc::Task
 rescue LoadError
-  require "rake/rdoctask"
-  Rake::RDocTask
+  begin
+    require "rake/rdoctask"
+    Rake::RDocTask
+  rescue LoadError
+  end
 end
 
-RDOC_OPTS = RDOC_DEFAULT_OPTS + ['--main', 'README.rdoc']
+if rdoc_task_class
+  RDOC_OPTS = RDOC_DEFAULT_OPTS + ['--main', 'README.rdoc']
 
-rdoc_task_class.new do |rdoc|
-  rdoc.rdoc_dir = "rdoc"
-  rdoc.options += RDOC_OPTS
-  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG MIT-LICENSE lib/**/*.rb doc/*.rdoc doc/release_notes/*.txt"
-end
+  rdoc_task_class.new do |rdoc|
+    rdoc.rdoc_dir = "rdoc"
+    rdoc.options += RDOC_OPTS
+    rdoc.rdoc_files.add %w"README.rdoc CHANGELOG MIT-LICENSE lib/**/*.rb doc/*.rdoc doc/release_notes/*.txt"
+  end if rdoc_task_class
 
-### Website
+  desc "Make rdoc for website"
+  task :website_rdoc=>[:website_rdoc_main, :website_rdoc_adapters, :website_rdoc_plugins]
 
-desc "Make local version of website"
-task :website do
-  sh %{#{FileUtils::RUBY} www/make_www.rb}
-end
-
-desc "Make rdoc for website"
-task :website_rdoc=>[:website_rdoc_main, :website_rdoc_adapters, :website_rdoc_plugins]
-
-rdoc_task_class.new(:website_rdoc_main) do |rdoc|
-  rdoc.rdoc_dir = "www/public/rdoc"
-  rdoc.options += RDOC_OPTS
-  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG MIT-LICENSE lib/*.rb lib/sequel/*.rb lib/sequel/{connection_pool,dataset,database,model}/*.rb doc/*.rdoc doc/release_notes/*.txt lib/sequel/extensions/migration.rb"
-end
-
-rdoc_task_class.new(:website_rdoc_adapters) do |rdoc|
-  rdoc.rdoc_dir = "www/public/rdoc-adapters"
-  rdoc.options += RDOC_DEFAULT_OPTS + %w'--main Sequel'
-  rdoc.rdoc_files.add %w"lib/sequel/adapters/**/*.rb"
-end
+  rdoc_task_class.new(:website_rdoc_main) do |rdoc|
+    rdoc.rdoc_dir = "www/public/rdoc"
+    rdoc.options += RDOC_OPTS
+    rdoc.rdoc_files.add %w"README.rdoc CHANGELOG MIT-LICENSE lib/*.rb lib/sequel/*.rb lib/sequel/{connection_pool,dataset,database,model}/*.rb doc/*.rdoc doc/release_notes/*.txt lib/sequel/extensions/migration.rb"
+  end
 
-rdoc_task_class.new(:website_rdoc_plugins) do |rdoc|
-  rdoc.rdoc_dir = "www/public/rdoc-plugins"
-  rdoc.options += RDOC_DEFAULT_OPTS + %w'--main Sequel'
-  rdoc.rdoc_files.add %w"lib/sequel/{extensions,plugins}/**/*.rb"
-end
+  rdoc_task_class.new(:website_rdoc_adapters) do |rdoc|
+    rdoc.rdoc_dir = "www/public/rdoc-adapters"
+    rdoc.options += RDOC_DEFAULT_OPTS + %w'--main Sequel'
+    rdoc.rdoc_files.add %w"lib/sequel/adapters/**/*.rb"
+  end
 
-desc "Update Non-RDoc section of sequel.rubyforge.org"
-task :website_rf_base=>[:website] do
-  sh %{rsync -rt www/public/*.html rubyforge.org:/var/www/gforge-projects/sequel/}
-end
+  rdoc_task_class.new(:website_rdoc_plugins) do |rdoc|
+    rdoc.rdoc_dir = "www/public/rdoc-plugins"
+    rdoc.options += RDOC_DEFAULT_OPTS + %w'--main Sequel'
+    rdoc.rdoc_files.add %w"lib/sequel/{extensions,plugins}/**/*.rb"
+  end
 
-desc "Update sequel.rubyforge.org"
-task :website_rf=>[:website, :website_rdoc] do
-  sh %{rsync -rvt www/public/* rubyforge.org:/var/www/gforge-projects/sequel/}
+  desc "Update sequel.rubyforge.org"
+  task :website_rf=>[:website, :website_rdoc] do
+    sh %{rsync -rvt www/public/* rubyforge.org:/var/www/gforge-projects/sequel/}
+  end
 end
 
 ### Specs

data/doc/release_notes/3.42.0.txt

@@ -0,0 +1,74 @@
+= New Features
+
+* Dataset#avg, #interval, #min, #max, #range, and #sum now
+  accept virtual row blocks, allowing you to more easily get
+  aggregate values of expressions based on the table:
+
+    DB[:table].sum{some_function(column1, column2)} # => 134
+    # SELECT sum(some_function(column1, column2)) FROM table
+
+* Database#do has been added on PostgreSQL for using the DO
+  anonymous code block execution statement.
+
+* Model.dataset_module now uses a Module subclass, which allows
+  you to call subset inside a dataset_module block, making
+  it easier to consolidate dataset method code:
+
+    class Album < Sequel::Model
+      dataset_module do
+        subset(:gold){copies_sold > 500000}
+      end
+    end
+
+* Database#copy_table and #copy_into are now supported on
+  jdbc/postgres.
+
+* Sequel now supports deferred constraints on constraint types other
+  than foreign keys.  The only databases that appear to implement
+  this are Oracle and PostgreSQL.
+
+* Sequel now supports INITIALLY IMMEDIATE deferred constraints via
+  the :deferrable=>:immediate constraint/column option.
+
+* Sequel now supports setting the default size of string columns,
+  via the default_string_column_size option or accessor.  In some
+  cases, Sequel's default string column size of 255 is too large
+  (e.g. MySQL with utf8mb4 character set), and this allows you to
+  change it.
+
+= Other Improvements
+
+* Dataset#count and other methods now use a subselect in the case
+  where the dataset has an offset but no limit.
+
+* If an error occurs while attempting to commit a transaction, Sequel
+  now attempts to rollback the transaction.  Some databases do this
+  automatically, but not all.  Among other things, this fixes issues
+  with deferred foreign key constraint violations on SQLite.
+
+* When extending a model's dataset, the model's instance_dataset is
+  reset, insuring that it will also be extended with the module.
+
+* When passing an invalid argument to Dataset#filter, the exception
+  message now includes the argument.
+
+* The force_encoding plugin now works with frozen string values.
+
+* Public methods added to a model dataset_module now have model
+  class methods created for them even if the method was added outside
+  of a dataset_module block.
+
+* On PostgreSQL, Database#indexes now includes a :deferrable entry
+  for each index hash, which will be true for unique indexes where
+  the underlying constraint is deferrable.
+
+* On Microsoft SQL Server 2000, Dataset#update no longer includes a
+  limit (TOP), allowing it to work correctly. 
+
+= Backwards Compatibility
+
+* Model.dataset_methods has been removed.  This was used to store
+  blocks for methods created via def_dataset_method and subset.
+  The internals have been changed so that a dataset_module is
+  always used in these cases, therefore there was no longer a reason
+  for this method.

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

@@ -17,7 +17,62 @@ module Sequel
         def self.extended(db)
           db.send(:initialize_postgres_adapter)
         end
+
+        # See Sequel::Postgres::Adapter#copy_into
+        def copy_into(table, opts={})
+          data = opts[:data]
+          data = Array(data) if data.is_a?(String)
+
+          if block_given? && data
+            raise Error, "Cannot provide both a :data option and a block to copy_into"
+          elsif !block_given? && !data
+            raise Error, "Must provide either a :data option or a block to copy_into"
+          end
+
+          transaction(opts) do |conn|
+            begin
+              copy_manager = org.postgresql.copy.CopyManager.new(conn)
+              copier = copy_manager.copy_in(copy_into_sql(table, opts))
+              if block_given?
+                while buf = yield
+                  copier.writeToCopy(buf.to_java_bytes, 0, buf.length)
+                end
+              else
+                data.each { |d| copier.writeToCopy(d.to_java_bytes, 0, d.length) }
+              end
+            rescue Exception => e
+              copier.endCopy
+              raise
+            ensure
+              copier.endCopy unless e
+            end
+          end
+        end
         
+        # See Sequel::Postgres::Adapter#copy_table
+        def copy_table(table, opts={})
+          synchronize(opts[:server]) do |conn|
+            copy_manager = org.postgresql.copy.CopyManager.new(conn)
+            copier = copy_manager.copy_out(copy_table_sql(table, opts))
+            begin
+              if block_given?
+                while buf = copier.readFromCopy
+                  yield(String.from_java_bytes(buf))
+                end
+                nil
+              else
+                b = ''
+                while buf = copier.readFromCopy
+                  b << String.from_java_bytes(buf)
+                end
+                b
+              end
+            ensure
+              raise DatabaseDisconnectError, "disconnecting as a partial COPY may leave the connection in an unusable state" if buf
+            end
+          end
+        end
+
         private
         
         # Use setNull for nil arguments as the default behavior of setString

data/lib/sequel/adapters/postgres.rb

@@ -268,24 +268,8 @@ module Sequel
         # per row.  If a block is not provided, a single string is returned with all
         # of the data.
         def copy_table(table, opts={})
-          sql = if table.is_a?(String)
-            sql = table
-          else
-            if opts[:options] || opts[:format]
-              options = " ("
-              options << "FORMAT #{opts[:format]}" if opts[:format]
-              options << "#{', ' if opts[:format]}#{opts[:options]}" if opts[:options]
-              options << ')'
-            end
-            table = if table.is_a?(::Sequel::Dataset)
-              "(#{table.sql})"
-            else
-              literal(table)
-            end
-           sql = "COPY #{table} TO STDOUT#{options}"
-          end
-          synchronize(opts[:server]) do |conn| 
-            conn.execute(sql)
+          synchronize(opts[:server]) do |conn|
+            conn.execute(copy_table_sql(table, opts))
             begin
               if block_given?
                 while buf = conn.get_copy_data
@@ -323,18 +307,6 @@ module Sequel
         # If a block is provided and :data option is not, this will yield to the block repeatedly.
         # The block should return a string, or nil to signal that it is finished.
         def copy_into(table, opts={})
-          sql = "COPY #{literal(table)}"
-          if cols = opts[:columns]
-            sql << literal(Array(cols))
-          end
-          sql << " FROM STDIN"
-          if opts[:options] || opts[:format]
-            sql << " ("
-            sql << "FORMAT #{opts[:format]}" if opts[:format]
-            sql << "#{', ' if opts[:format]}#{opts[:options]}" if opts[:options]
-            sql << ')'
-          end
-          
           data = opts[:data]
           data = Array(data) if data.is_a?(String)
 
@@ -344,8 +316,8 @@ module Sequel
             raise Error, "Must provide either a :data option or a block to copy_into"
           end
 
-          synchronize(opts[:server]) do |conn| 
-            conn.execute(sql)
+          synchronize(opts[:server]) do |conn|
+            conn.execute(copy_into_sql(table, opts))
             begin
               if block_given?
                 while buf = yield

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

@@ -380,6 +380,7 @@ module Sequel
       INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'with insert into columns output values')
       SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with select distinct limit columns into from lock join where group having order compounds')
       UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'with update limit table set output from where')
+      UPDATE_CLAUSE_METHODS_2000 = Dataset.clause_methods(:update, %w'update table set output from where')
       NOLOCK = ' WITH (NOLOCK)'.freeze
       UPDLOCK = ' WITH (UPDLOCK)'.freeze
       WILDCARD = LiteralString.new('*').freeze
@@ -801,10 +802,15 @@ module Sequel
       alias delete_output_sql output_sql
       alias update_output_sql output_sql
 
-      # MSSQL supports the OUTPUT clause for UPDATE statements.
-      # It also allows prepending a WITH clause.
+      # MSSQL supports the OUTPUT and TOP clause for UPDATE statements.
+      # It also allows prepending a WITH clause.  For MSSQL 2000
+      # and below, exclude WITH and TOP.
       def update_clause_methods
-        UPDATE_CLAUSE_METHODS
+        if is_2005_or_later?
+          UPDATE_CLAUSE_METHODS
+        else
+          UPDATE_CLAUSE_METHODS_2000
+        end
       end
 
       # Only include the primary table in the main update clause

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

@@ -49,6 +49,11 @@ module Sequel
         metadata_dataset.from(:tab).filter(:tname =>m.call(name), :tabtype => 'VIEW').count > 0 
       end 
 
+      # Oracle supports deferrable constraints.
+      def supports_deferrable_constraints?
+        true
+      end
+
       private
 
       # Handle Oracle specific ALTER TABLE SQL

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

@@ -224,6 +224,16 @@ module Sequel
         :postgres
       end
 
+      # Use PostgreSQL's DO syntax to execute an anonymous code block.  The code should
+      # be the literal code string to use in the underlying procedural language.  Options:
+      #
+      # :language :: The procedural language the code is written in.  The PostgreSQL
+      #              default is plpgsql.  Can be specified as a string or a symbol.
+      def do(code, opts={})
+        language = opts[:language]
+        run "DO #{"LANGUAGE #{literal(language.to_s)} " if language}#{literal(code)}"
+      end
+
       # Drops the function from the database. Arguments:
       # * name : name of the function to drop
       # * opts : options hash:
@@ -343,16 +353,17 @@ module Sequel
           join(:pg_index___ind, :indrelid=>:oid, im.call(table)=>:relname).
           join(:pg_class___indc, :oid=>:indexrelid).
           join(:pg_attribute___att, :attrelid=>:tab__oid, :attnum=>attnums).
+          left_join(:pg_constraint___con, :conname=>:indc__relname).
           filter(:indc__relkind=>'i', :ind__indisprimary=>false, :indexprs=>nil, :indpred=>nil, :indisvalid=>true).
           order(:indc__relname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:ind__indkey, [x]), x]}, 32, :att__attnum)).
-          select(:indc__relname___name, :ind__indisunique___unique, :att__attname___column)
+          select(:indc__relname___name, :ind__indisunique___unique, :att__attname___column, :con__condeferrable___deferrable)
 
         ds.join!(:pg_namespace___nsp, :oid=>:tab__relnamespace, :nspname=>schema.to_s) if schema
         ds.filter!(:indisready=>true, :indcheckxmin=>false) if server_version >= 80300
 
         indexes = {}
         ds.each do |r|
-          i = indexes[m.call(r[:name])] ||= {:columns=>[], :unique=>r[:unique]}
+          i = indexes[m.call(r[:name])] ||= {:columns=>[], :unique=>r[:unique], :deferrable=>r[:deferrable]}
           i[:columns] << m.call(r[:column])
         end
         indexes
@@ -455,6 +466,16 @@ module Sequel
         server_version >= 90100
       end
 
+      # PostgreSQL 9.0+ supports some types of deferrable constraints beyond foreign key constraints.
+      def supports_deferrable_constraints?
+        server_version >= 90000
+      end
+
+      # PostgreSQL supports deferrable foreign key constraints.
+      def supports_deferrable_foreign_key_constraints?
+        true
+      end
+
       # PostgreSQL supports DROP TABLE IF EXISTS
       def supports_drop_table_if_exists?
         true
@@ -604,6 +625,42 @@ module Sequel
         end
       end
 
+      # SQL for doing fast table insert from stdin.
+      def copy_into_sql(table, opts)
+        sql = "COPY #{literal(table)}"
+        if cols = opts[:columns]
+          sql << literal(Array(cols))
+        end
+        sql << " FROM STDIN"
+        if opts[:options] || opts[:format]
+          sql << " ("
+          sql << "FORMAT #{opts[:format]}" if opts[:format]
+          sql << "#{', ' if opts[:format]}#{opts[:options]}" if opts[:options]
+          sql << ')'
+        end
+        sql
+      end
+
+      # SQL for doing fast table output to stdout.
+      def copy_table_sql(table, opts)
+         if table.is_a?(String)
+           return table
+         else
+           if opts[:options] || opts[:format]
+             options = " ("
+             options << "FORMAT #{opts[:format]}" if opts[:format]
+             options << "#{', ' if opts[:format]}#{opts[:options]}" if opts[:options]
+             options << ')'
+           end
+           table = if table.is_a?(::Sequel::Dataset)
+             "(#{table.sql})"
+           else
+             literal(table)
+           end
+          return "COPY #{table} TO STDOUT#{options}"
+         end
+       end
+
       # SQL statement to create database function.
       def create_function_sql(name, definition, opts={})
         args = opts[:args]