sequel 3.37.0 → 3.38.0

data/doc/testing.rdoc

@@ -12,16 +12,16 @@ Make sure you are using Sequel 3.29.0 or above when using these examples, as old
 
   class Spec::Example::ExampleGroup
     def execute(*args, &block)
-      x = nil
-      Sequel::Model.db.transaction(:rollback=>:always){x = super(*args, &block)}
-      x
+      result = nil
+      Sequel::Model.db.transaction(:rollback=>:always){result = super(*args, &block)}
+      result
     end
   end
 
-=== RSpec 2
+=== RSpec 2, <2.8
 
   class RSpec::Core::ExampleGroup
-    # Setting an around filter globally doesn't appear to work in 2.7 (and maybe other versions),
+    # Setting an around filter globally doesn't appear to work in <2.8,
     # so set one up for each subclass.
     def self.inherited(subclass)
       super
@@ -31,21 +31,61 @@ Make sure you are using Sequel 3.29.0 or above when using these examples, as old
     end
   end
 
+=== RSpec 2, >=2.8
+
+  # Global around filters should work
+  RSpec.configure do |c|
+    c.around(:each) do |example|
+      DB.transaction(:rollback=>:always){example.run}
+    end
+  end
+
 === Test::Unit
 
   # Must use this class as the base class for your tests
   class SequelTestCase < Test::Unit::TestCase
     def run(*args, &block)
-      Sequel::Model.db.transaction(:rollback=>:always){super}
+      result = nil
+      Sequel::Model.db.transaction(:rollback=>:always){result = super}
+      result
+    end
+  end
+
+  # Or you could override the base implementation like this
+  class Test::Unit::TestCase
+    alias_method :_original_run, :run
+
+    def run(*args, &block)
+      result = nil
+      Sequel::Model.db.transaction(:rollback => :always) do
+        result = _original_run(*args, &block)
+      end
+      result
     end
   end
 
 === MiniTest::Unit
 
+  # Add a subclass
   # Must use this class as the base class for your tests
   class SequelTestCase < MiniTest::Unit::TestCase
     def run(*args, &block)
-      Sequel::Model.db.transaction(:rollback=>:always){super}
+      result = nil
+      Sequel::Model.db.transaction(:rollback=>:always){result = super}
+      result
+    end
+  end
+
+  # Or you could override the base implementation like this
+  class MiniTest::Unit::TestCase
+    alias_method :_original_run, :run
+
+    def run(*args, &block)
+      result = nil
+      Sequel::Model.db.transaction(:rollback => :always) do
+        result = _original_run(*args, &block)
+      end
+      result
     end
   end
 

data/doc/thread_safety.rdoc

@@ -4,7 +4,7 @@ Most Sequel usage (and all common Sequel usage) is thread safe by default.  Spec
 
 == Connection Pool
 
-In order to allow multiple threads to operate on the same database at the same time, Sequel uses a connection pool.  The connection pool is designed so that a thread uses a connection for the minimum amount of time, returning the connection to the pool as soon as it is done using the connection.  If a thread requests a connection and the pool is empty, the thread will block (actually busy-wait) until a connection is available or the the connection pool timeout has elapsed (in which case a PoolTimeout error will be raised).
+In order to allow multiple threads to operate on the same database at the same time, Sequel uses a connection pool.  The connection pool is designed so that a thread uses a connection for the minimum amount of time, returning the connection to the pool as soon as it is done using the connection.  If a thread requests a connection and the pool does not have an available connection, a new connection will be created.  If the maximum number of connections in the pool has already been reached, the thread will block (actually busy-wait) until a connection is available or the the connection pool timeout has elapsed (in which case a PoolTimeout error will be raised).
 
 == Exceptions
 

data/doc/transactions.rdoc

@@ -5,7 +5,7 @@ Sequel uses autocommit mode by default for all of its database adapters, so in g
 * Dataset#import to insert many records at once
 * Model#save
 * Model#destroy
-* Migrations
+* Migrations if the database supports transactional schema
 * A few model plugins
 
 Everywhere else, it is up to use to use a database transaction if you want to.

data/doc/validations.rdoc

@@ -284,7 +284,7 @@ You can mix and match the two approaches.  For example, if all albums should hav
 
 +validates_unique+ also accepts a block to scope the uniqueness constraint.  For example, if you want to ensure that all active albums have a unique name, but inactive albums can duplicate the name:
 
-  validates_unique(:name){|ds| ds.filter(:active)}
+  validates_unique(:name){|ds| ds.where(:active)}
 
 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.
 

data/doc/virtual_rows.rdoc

@@ -1,6 +1,6 @@
 = Virtual Row Blocks
 
-Dataset methods filter, order, and select all take blocks that are referred to as
+Dataset methods where, order, and select all take blocks that are referred to as
 virtual row blocks.  Many other dataset methods pass the blocks
 they are given into one of those three methods, so there are actually
 many Sequel::Dataset methods that take virtual row blocks.
@@ -11,7 +11,7 @@ Virtual Rows were created to work around the issue that some parts of
 Sequel's standard DSL could not be used on ruby 1.9.  For example, the
 following Sequel code works on ruby 1.8, but not ruby 1.9:
 
-  dataset.filter(:a > :b[:c])
+  dataset.where(:a > :b[:c])
   # WHERE a > b(c)
   
 This code does not work on ruby 1.9 for two reasons.  First, Symbol#>
@@ -20,30 +20,15 @@ does not override it to return an SQL inequality expression.  Second, Symbol#[]
 is already defined on ruby 1.9, so Sequel does not override it to return an
 SQL function expression.
 
-Prior to the introduction of virtual rows, the way to handle this was
-to use the methods that work on both ruby 1.8 and ruby 1.9:
+It's possible to use Sequel's DSL to represent such expressions, but it is a
+little verbose:
 
-  dataset.filter(:a.identifier > :b.sql_function(:c))
+  dataset.where(Sequel.expr(:a) > Sequel.function(:b, :c))
   # WHERE a > b(c)
 
-However, that code is a little verbose.  The virtual row DSL makes such code
-more concise:
+The virtual row DSL makes such code more concise:
 
-  dataset.filter{a > b(c)}
-
-Another use of virtual rows is when you turn off Sequel's core extensions off
-using the SEQUEL_NO_CORE_EXTENSIONS constant or environment variable.  With
-the core extensions turned off, much of the standard Sequel DSL is not
-available.  For example, you are no longer able to do:
-
-  dataset.filter(:a & (:b | ~:c))
-  # WHERE a AND (b OR NOT c)
-  
-Because Symbol#&, Symbol#| and Symbol#~ are not defined when the core
-extensions are turned off.  However, virtual rows allow almost the same
-syntax even without the core extensions:
-
-  dataset.filter{a & (b | ~c)}
+  dataset.where{a > b(c)}
 
 == Regular Procs vs Instance Evaled Procs
 
@@ -54,11 +39,11 @@ evaluated in the context of an instance of Sequel::SQL::VirtualRow.
 
   ds = DB[:items]
   # Regular proc
-  ds.filter{|o| o.column > 1}
+  ds.where{|o| o.column > 1}
   # WHERE column > 1
   
   # Instance-evaled proc
-  ds.filter{column > 1}
+  ds.where{column > 1}
   # WHERE column > 1
   
 If you aren't familiar with the difference between regular blocks and instance
@@ -75,21 +60,21 @@ inside the proc.  If that doesn't make sense, maybe this example will help:
   b = 32
   
   # Regular proc
-  ds.filter{|o| o.c > a - b}
+  ds.where{|o| o.c > a - b}
   # WHERE c > 10
   
   # Instance-evaled proc
-  ds.filter{c > a - b}
+  ds.where{c > a - b}
   # WHERE c > (a - 32)
   
-There are two related differences here.  First is the usage of "o.c" vs "c",
-and second is the difference between the the use of "a".  In the regular proc,
-you couldn't call c without an explicit receiver in the proc, unless the self of the
-surrounding scope responded to it.  For a, note how ruby calls the method on
+There are two related differences here.  First is the usage of <tt>o.c</tt> vs +c+,
+and second is the difference between the the use of +a+.  In the regular proc,
+you couldn't call +c+ without an explicit receiver in the proc, unless the self of the
+surrounding scope responded to it.  For +a+, note how ruby calls the method on
 the receiver of the surrounding scope in the regular proc, which returns an integer,
-and does the substitution before Sequel gets access to it.  In the instance evaled
-proc, calling a without a receiver calls the a method on the VirtualRow instance.
-For b, note that it operates the same in both cases, as it is a local variable.
+and does the subtraction before Sequel gets access to it.  In the instance evaled
+proc, calling +a+ without a receiver calls the a method on the VirtualRow instance.
+For +b+, note that it operates the same in both cases, as it is a local variable.
 
 Basically, the choice for whether to use a regular proc or an instance evaled proc is
 completely up to you.  The same things can be accomplished with both.
@@ -105,7 +90,7 @@ variable, you can call it with () to differentiate the method call from the
 local variable access.  This is mostly useful in instance_evaled procs:
 
   b = 32
-  ds.filter{b() > b}
+  ds.where{b() > b}
   # WHERE b > 32
 
 == VirtualRow Methods
@@ -120,8 +105,8 @@ not qualified by any table. You get an SQL::Identifier if the method is called
 without a block or arguments, and doesn't have a double underscore in the method
 name:
 
-  ds.filter{|o| o.column > 1}
-  ds.filter{column > 1}
+  ds.where{|o| o.column > 1}
+  ds.where{column > 1}
   # WHERE column > 1
   
 == SQL::QualifiedIdentifiers - Qualified columns
@@ -131,8 +116,8 @@ are qualified to a specific table.  You get an SQL::QualifiedIdentifier if
 the method is called without a block or arguments, and has a double underscore
 in the method name:
 
-  ds.filter{|o| o.table__column > 1}
-  ds.filter{table__column > 1}
+  ds.where{|o| o.table__column > 1}
+  ds.where{table__column > 1}
   # WHERE table.column > 1
 
 Using the double underscore for SQL::QualifiedIdentifiers was done to make
@@ -144,15 +129,15 @@ into a qualified column.
 SQL::Functions can be thought of as function calls in SQL.  You get a simple
 function call if you call a method with arguments and without a block:
 
-  ds.filter{|o| o.function(1) > 1}
-  ds.filter{function(1) > 1}
+  ds.where{|o| o.function(1) > 1}
+  ds.where{function(1) > 1}
   # WHERE function(1) > 1
   
 To call a SQL function with multiple arguments, just use those arguments in
 your function call:
   
-  ds.filter{|o| o.function(1, o.a) > 1}
-  ds.filter{function(1, a) > 1}
+  ds.where{|o| o.function(1, o.a) > 1}
+  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
@@ -191,7 +176,8 @@ the method call:
 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: Here are some examples of use:
+call, with an optional hash as the second argument, and provide an empty block
+to the method. Here are some examples of use:
 
   ds.select{|o| o.rank(:over){}}
   ds.select{rank(:over){}}

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

@@ -15,10 +15,7 @@ module Sequel
         # Add the primary_keys and primary_key_sequences instance variables,
         # so we can get the correct return values for inserted rows.
         def self.extended(db)
-          db.instance_eval do
-            @primary_keys = {}
-            @primary_key_sequences = {}
-          end
+          db.send(:initialize_postgres_adapter)
         end
         
         private

data/lib/sequel/adapters/jdbc.rb

@@ -66,7 +66,7 @@ module Sequel
       end,
       :jtds=>proc do |db|
         Sequel.ts_require 'adapters/jdbc/jtds'
-        db.extend(Sequel::JDBC::MSSQL::DatabaseMethods)
+        db.extend(Sequel::JDBC::JTDS::DatabaseMethods)
         db.dataset_class = Sequel::JDBC::JTDS::Dataset
         db.send(:set_mssql_unicode_strings)
         JDBC.load_gem('jtds')
@@ -431,7 +431,8 @@ module Sequel
       # Support fractional seconds for Time objects used in bound variables
       def java_sql_timestamp(time)
         ts = java.sql.Timestamp.new(time.to_i * 1000)
-        ts.setNanos(RUBY_VERSION >= '1.9.0' ? time.nsec : time.usec * 1000)
+        # Work around jruby 1.6 ruby 1.9 mode bug
+        ts.setNanos((RUBY_VERSION >= '1.9.0' && time.nsec != 0) ? time.nsec : time.usec * 1000)
         ts
       end 
       
@@ -477,7 +478,7 @@ module Sequel
         when TrueClass, FalseClass
           cps.setBoolean(i, arg)
         when NilClass
-          cps.setString(i, nil)
+          set_ps_arg_nil(cps, i)
         when DateTime
           cps.setTimestamp(i, java_sql_datetime(arg))
         when Date
@@ -492,6 +493,11 @@ module Sequel
           cps.setObject(i, arg)
         end
       end
+
+      # Use setString with a nil value by default, but this doesn't work on all subadapters.
+      def set_ps_arg_nil(cps, i)
+        cps.setString(i, nil)
+      end
       
       # Return the connection.  Used to do configuration on the
       # connection object before adding it to the connection pool.
@@ -636,6 +642,7 @@ module Sequel
       JAVA_BUFFERED_READER  = Java::JavaIo::BufferedReader
       JAVA_BIG_DECIMAL      = Java::JavaMath::BigDecimal
       JAVA_BYTE_ARRAY       = Java::byte[]
+      JAVA_UUID             = Java::JavaUtil::UUID
 
       # Handle type conversions for common Java types.
       class TYPE_TRANSLATOR
@@ -656,6 +663,7 @@ module Sequel
           end
           lines
         end
+        def uuid(v) v.to_string end
       end
       TYPE_TRANSLATOR_INSTANCE = tt = TYPE_TRANSLATOR.new
 
@@ -668,6 +676,7 @@ module Sequel
       BYTE_ARRAY_METHOD = tt.method(:byte_array)
       BLOB_METHOD = tt.method(:blob)
       CLOB_METHOD = tt.method(:clob)
+      UUID_METHOD = tt.method(:uuid)
 
       # Convert the given Java timestamp to an instance of Sequel.datetime_class.
       def convert_type_timestamp(v)
@@ -695,6 +704,8 @@ module Sequel
           BLOB_METHOD
         when JAVA_SQL_CLOB
           CLOB_METHOD
+        when JAVA_UUID
+          UUID_METHOD
         else
           false
         end

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

@@ -27,6 +27,15 @@ module Sequel
         end
 
         private
+
+        def set_ps_arg(cps, arg, i)
+          case arg
+          when Sequel::SQL::Blob
+            cps.setString(i, arg)
+          else
+            super
+          end
+        end
         
         def last_insert_id(conn, opts={})
           statement(conn) do |stmt|

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

@@ -114,6 +114,11 @@ module Sequel
           end
         end
 
+        # Handle nil values by using setNull with the correct parameter type.
+        def set_ps_arg_nil(cps, i)
+          cps.setNull(i, cps.getParameterMetaData.getParameterType(i))
+        end
+      
         # Derby uses RENAME TABLE syntax to rename tables.
         def rename_table_sql(name, new_name)
           "RENAME TABLE #{quote_schema_table(name)} TO #{quote_schema_table(new_name)}"
@@ -124,6 +129,11 @@ module Sequel
           PRIMARY_KEY_INDEX_RE
         end
 
+        # Treat clob as string instead of blob
+        def schema_column_type(db_type)
+          db_type.downcase == 'clob' ? :string : super
+        end
+        
         # If an :identity option is present in the column, add the necessary IDENTITY SQL.
         def type_literal(column)
           if column[:identity]
@@ -156,8 +166,10 @@ module Sequel
         ROWS = " ROWS".freeze
         FETCH_FIRST = " FETCH FIRST ".freeze
         ROWS_ONLY = " ROWS ONLY".freeze
-        BOOL_TRUE = '(1 = 1)'.freeze
-        BOOL_FALSE = '(1 = 0)'.freeze
+        BOOL_TRUE_OLD = '(1 = 1)'.freeze
+        BOOL_FALSE_OLD = '(1 = 0)'.freeze
+        BOOL_TRUE = 'TRUE'.freeze
+        BOOL_FALSE = 'FALSE'.freeze
         SELECT_CLAUSE_METHODS = clause_methods(:select, %w'select distinct columns from join where group having compounds order limit lock')
 
         # Derby doesn't support an expression between CASE and WHEN,
@@ -226,6 +238,23 @@ module Sequel
 
         private
 
+        JAVA_SQL_CLOB         = Java::JavaSQL::Clob
+
+        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
+          def derby_clob(v) v.getSubString(1, v.length) end
+        end
+
+        DERBY_CLOB_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:derby_clob)
+      
+        # Handle clobs on Derby as strings.
+        def convert_type_proc(v)
+          if v.is_a?(JAVA_SQL_CLOB)
+            DERBY_CLOB_METHOD
+          else
+            super
+          end
+        end
+        
         # Derby needs a hex string casted to BLOB for blobs.
         def literal_blob_append(sql, v)
           sql << BLOB_OPEN << v.unpack(HSTAR).first << BLOB_CLOSE
@@ -240,7 +269,11 @@ module Sequel
         # Derby uses an expression yielding false for false values.
         # Newer versions can use the FALSE literal, but the latest gem version cannot.
         def literal_false
-          BOOL_FALSE
+          if db.svn_version >= 1040133
+            BOOL_FALSE
+          else
+            BOOL_FALSE_OLD
+          end
         end
 
         # Derby handles fractional seconds in timestamps, but not in times
@@ -251,7 +284,11 @@ module Sequel
         # Derby uses an expression yielding true for true values.
         # Newer versions can use the TRUE literal, but the latest gem version cannot.
         def literal_true
-          BOOL_TRUE
+          if db.svn_version >= 1040133
+            BOOL_TRUE
+          else
+            BOOL_TRUE_OLD
+          end
         end
 
         # Derby doesn't support common table expressions.