sequel 3.26.0 → 3.27.0

data/doc/testing.rdoc

@@ -0,0 +1,64 @@
+= Testing with Sequel
+
+Whether or not you use Sequel in your application, you are usually going to want to have tests that ensure that your code works.  When you are using Sequel, it's helpful to integrate it into your testing framework, and it's generally best to run each test in its own transaction if possible.  That keeps all tests isolated from each other, and it's simple as it handles all of the cleanup for you.  Sequel doesn't ship with helpers for common libraries, as the exact code you need is often application-specific, but this page offers some examples that you can either use directly or build on.
+
+== Transactional tests
+
+These run each test in its own transaction, the recommended way to test.
+
+=== RSpec 1
+
+  class Spec::Example::ExampleGroup
+    def execute(*args, &block)
+      x = nil
+      Sequel::Model.db.transaction{x = super(*args, &block); raise Sequel::Rollback}
+      x
+    end
+  end
+
+=== RSpec 2
+
+  class Spec::Example::ExampleGroup
+    around do |example|
+      Sequel::Model.db.transaction{example.call; raise Sequel::Rollback}
+    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 do
+        super
+        raise Sequel::Rollback
+      end
+    end
+  end
+
+== Nontransactional tests
+
+In some cases, it is not possible to use transactions.  For example, if you are testing a web application that is running in a separate process, you don't have access to that process's database connections, so you can't run your examples in transactions.  In that case, the best way to handle things is to cleanup after each test by deleting or truncating the database tables used in the test.
+
+The order in which you delete/truncate the tables is important if you are using referential integrity in your database (which you probably should be doing).  If you are using referential integrity, you need to make sure to delete in tables referencing other tables before the tables that are being referenced.  For example, if you have an +albums+ table with an +artist_id+ field referencing the +artists+ table, you want to delete/truncate the +albums+ table before the +artists+ table.  Note that if you have cyclic references in your database, you will probably need to write your own custom cleaning code.
+
+=== RSpec
+
+  class Spec::Example::ExampleGroup
+    after do
+      [:table1, :table2].each{|x| Sequel::Model.db.from(x).truncate}
+      # or
+      [:table1, :table2].each{|x| Sequel::Model.db.from(x).delete}
+    end
+  end
+
+=== Test::Unit
+
+  # Must use this class as the base class for your tests
+  class SequelTestCase < Test::Unit::TestCase
+    def teardown
+      [:table1, :table2].each{|x| Sequel::Model.db.from(x).truncate}
+      # or
+      [:table1, :table2].each{|x| Sequel::Model.db.from(x).delete}
+    end
+  end

data/lib/sequel/adapters/amalgalite.rb

@@ -31,6 +31,10 @@ module Sequel
       def datetime(s)
         Sequel.database_to_application_timestamp(s)
       end
+
+      def time(s)
+        Sequel.string_to_time(s)
+      end
       
       # Don't raise an error if the value is a string and the declared
       # type doesn't match a known type, just return the value.

data/lib/sequel/adapters/jdbc.rb

@@ -579,8 +579,10 @@ module Sequel
       # Convert the type.  Used for converting Java types to ruby types.
       def convert_type(v)
         case v
-        when Java::JavaSQL::Timestamp, Java::JavaSQL::Time
+        when Java::JavaSQL::Timestamp
           Sequel.database_to_application_timestamp(v.to_string)
+        when Java::JavaSQL::Time
+          Sequel.string_to_time(v.to_string)
         when Java::JavaSQL::Date
           Sequel.string_to_date(v.to_string)
         when Java::JavaIo::BufferedReader

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

@@ -151,11 +151,7 @@ module Sequel
 
         private
       
-        # H2 expects hexadecimal strings for blob values
-        def literal_blob(v)
-          literal_string v.unpack("H*").first
-        end
-        
+        # Handle H2 specific clobs as strings.
         def convert_type(v)
           case v
           when Java::OrgH2Jdbc::JdbcClob
@@ -165,6 +161,16 @@ module Sequel
           end
         end
         
+        # H2 expects hexadecimal strings for blob values
+        def literal_blob(v)
+          literal_string v.unpack("H*").first
+        end
+        
+        # H2 handles fractional seconds in timestamps, but not in times
+        def literal_sqltime(v)
+          v.strftime("'%H:%M:%S'")
+        end
+
         def select_clause_methods
           SELECT_CLAUSE_METHODS
         end

data/lib/sequel/adapters/mysql.rb

@@ -5,7 +5,7 @@ rescue LoadError
 end
 raise(LoadError, "require 'mysql' did not define Mysql::CLIENT_MULTI_RESULTS!\n  You are probably using the pure ruby mysql.rb driver,\n  which Sequel does not support. You need to install\n  the C based adapter, and make sure that the mysql.so\n  file is loaded instead of the mysql.rb file.\n") unless defined?(Mysql::CLIENT_MULTI_RESULTS)
 
-Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
+Sequel.require %w'shared/mysql_prepared_statements', 'adapters'
 
 module Sequel
   # Module for holding all MySQL-related classes and modules for Sequel.
@@ -84,18 +84,13 @@ module Sequel
     # Database class for MySQL databases used with Sequel.
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
+      include Sequel::MySQL::PreparedStatements::DatabaseMethods
       
       # Mysql::Error messages that indicate the current connection should be disconnected
       MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(Commands out of sync; you can't run this command now|Can't connect to local MySQL server through socket|MySQL server has gone away|Lost connection to MySQL server during query)/
       
       set_adapter_scheme :mysql
       
-      # Support stored procedures on MySQL
-      def call_sproc(name, opts={}, &block)
-        args = opts[:args] || [] 
-        execute("CALL #{name}#{args.empty? ? '()' : literal(args)}", opts.merge(:sproc=>false), &block)
-      end
-      
       # Connect to the database.  In addition to the usual database options,
       # the following options have effect:
       #
@@ -161,10 +156,7 @@ module Sequel
 
         sqls.each{|sql| log_yield(sql){conn.query(sql)}}
 
-        class << conn
-          attr_accessor :prepared_statements
-        end
-        conn.prepared_statements = {}
+        add_prepared_statements_cache(conn)
         conn
       end
       
@@ -173,18 +165,6 @@ module Sequel
         MySQL::Dataset.new(self, opts)
       end
       
-      # Executes the given SQL using an available connection, yielding the
-      # connection if the block is given.
-      def execute(sql, opts={}, &block)
-        if opts[:sproc]
-          call_sproc(sql, opts, &block)
-        elsif sql.is_a?(Symbol)
-          execute_prepared_statement(sql, opts, &block)
-        else
-          synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
-        end
-      end
-      
       # Return the version of the MySQL server two which we are connecting.
       def server_version(server=nil)
         @server_version ||= (synchronize(server){|conn| conn.server_version if conn.respond_to?(:server_version)} || super)
@@ -268,27 +248,6 @@ module Sequel
         nil
       end
       
-      # Executes a prepared statement on an available connection.  If the
-      # prepared statement already exists for the connection and has the same
-      # SQL, reuse it, otherwise, prepare the new statement.  Because of the
-      # usual MySQL stupidity, we are forced to name arguments via separate
-      # SET queries.  Use @sequel_arg_N (for N starting at 1) for these
-      # arguments.
-      def execute_prepared_statement(ps_name, opts, &block)
-        args = opts[:arguments]
-        ps = prepared_statements[ps_name]
-        sql = ps.prepared_sql
-        synchronize(opts[:server]) do |conn|
-          unless conn.prepared_statements[ps_name] == sql
-            conn.prepared_statements[ps_name] = sql
-            _execute(conn, "PREPARE #{ps_name} FROM '#{::Mysql.quote(sql)}'", opts)
-          end
-          i = 0
-          _execute(conn, "SET " + args.map {|arg| "@sequel_arg_#{i+=1} = #{literal(arg)}"}.join(", "), opts) unless args.empty?
-          _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
-        end
-      end
-      
       # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
       def schema_column_type(db_type)
         Sequel::MySQL.convert_tinyint_to_bool && db_type == 'tinyint(1)' ? :boolean : super
@@ -298,67 +257,7 @@ module Sequel
     # Dataset class for MySQL datasets accessed via the native driver.
     class Dataset < Sequel::Dataset
       include Sequel::MySQL::DatasetMethods
-      include StoredProcedures
-      
-      # Methods to add to MySQL prepared statement calls without using a
-      # real database prepared statement and bound variables.
-      module CallableStatementMethods
-        # Extend given dataset with this module so subselects inside subselects in
-        # prepared statements work.
-        def subselect_sql(ds)
-          ps = ds.to_prepared_statement(:select)
-          ps.extend(CallableStatementMethods)
-          ps = ps.bind(@opts[:bind_vars]) if @opts[:bind_vars]
-          ps.prepared_args = prepared_args
-          ps.prepared_sql
-        end
-      end
-      
-      # Methods for MySQL prepared statements using the native driver.
-      module PreparedStatementMethods
-        include Sequel::Dataset::UnnumberedArgumentMapper
-        
-        private
-        
-        # Execute the prepared statement with the bind arguments instead of
-        # the given SQL.
-        def execute(sql, opts={}, &block)
-          super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-        
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts={}, &block)
-          super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-      end
-      
-      # Methods for MySQL stored procedures using the native driver.
-      module StoredProcedureMethods
-        include Sequel::Dataset::StoredProcedureMethods
-        
-        private
-        
-        # Execute the database stored procedure with the stored arguments.
-        def execute(sql, opts={}, &block)
-          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
-        end
-        
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts={}, &block)
-          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
-        end
-      end
-      
-      # MySQL is different in that it supports prepared statements but not bound
-      # variables outside of prepared statements.  The default implementation
-      # breaks the use of subselects in prepared statements, so extend the
-      # temporary prepared statement that this creates with a module that
-      # fixes it.
-      def call(type, bind_arguments={}, *values, &block)
-        ps = to_prepared_statement(type, values)
-        ps.extend(CallableStatementMethods)
-        ps.call(bind_arguments, &block)
-      end
+      include Sequel::MySQL::PreparedStatements::DatasetMethods
       
       # Delete rows matching this dataset
       def delete
@@ -401,18 +300,6 @@ module Sequel
         execute_dui(insert_sql(*values)){|c| return c.insert_id}
       end
       
-      # Store the given type of prepared statement in the associated database
-      # with the given name.
-      def prepare(type, name=nil, *values)
-        ps = to_prepared_statement(type, values)
-        ps.extend(PreparedStatementMethods)
-        if name
-          ps.prepared_statement_name = name
-          db.prepared_statements[name] = ps
-        end
-        ps
-      end
-      
       # Replace (update or insert) the matching row.
       def replace(*args)
         execute_dui(replace_sql(*args)){|c| return c.insert_id}
@@ -456,11 +343,6 @@ module Sequel
         "'#{::Mysql.quote(v)}'"
       end
       
-      # Extend the dataset with the MySQL stored procedure methods.
-      def prepare_extend_sproc(ds)
-        ds.extend(StoredProcedureMethods)
-      end
-      
       # Yield each row of the given result set r with columns cols
       # as a hash with symbol keys
       def yield_rows(r, cols)

data/lib/sequel/adapters/mysql2.rb

@@ -1,6 +1,5 @@
 require 'mysql2' unless defined? Mysql2
-
-Sequel.require %w'shared/mysql', 'adapters'
+Sequel.require %w'shared/mysql_prepared_statements', 'adapters'
 
 module Sequel
   # Module for holding all Mysql2-related classes and modules for Sequel.
@@ -8,6 +7,7 @@ module Sequel
     # Database class for MySQL databases used with Sequel.
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
+      include Sequel::MySQL::PreparedStatements::DatabaseMethods
 
       # Mysql::Error messages that indicate the current connection should be disconnected
       MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(Commands out of sync; you can't run this command now|Can't connect to local MySQL server through socket|MySQL server has gone away)/
@@ -21,7 +21,6 @@ module Sequel
       #   a filter for an autoincrement column equals NULL to return the last
       #   inserted row.
       # * :charset - Same as :encoding (:encoding takes precendence)
-      # * :compress - Set to false to not compress results from the server
       # * :config_default_group - The default group to read from the in
       #   the MySQL config file.
       # * :config_local_infile - If provided, sets the Mysql::OPT_LOCAL_INFILE
@@ -57,6 +56,7 @@ module Sequel
 
         sqls.each{|sql| log_yield(sql){conn.query(sql)}}
 
+        add_prepared_statements_cache(conn)
         conn
       end
 
@@ -65,16 +65,6 @@ module Sequel
         Mysql2::Dataset.new(self, opts)
       end
 
-      # Executes the given SQL using an available connection, yielding the
-      # connection if the block is given.
-      def execute(sql, opts={}, &block)
-        if opts[:sproc]
-          call_sproc(sql, opts, &block)
-        else
-          synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
-        end
-      end
-
       # Return the version of the MySQL server two which we are connecting.
       def server_version(server=nil)
         @server_version ||= (synchronize(server){|conn| conn.server_info[:id]} || super)
@@ -132,6 +122,7 @@ module Sequel
     # Dataset class for MySQL datasets accessed via the native driver.
     class Dataset < Sequel::Dataset
       include Sequel::MySQL::DatasetMethods
+      include Sequel::MySQL::PreparedStatements::DatasetMethods
 
       # Delete rows matching this dataset
       def delete

data/lib/sequel/adapters/odbc.rb

@@ -19,6 +19,9 @@ module Sequel
         when 'progress'
           Sequel.ts_require 'adapters/shared/progress'
           extend Sequel::Progress::DatabaseMethods
+        when 'db2'
+          Sequel.ts_require 'adapters/odbc/db2'
+          extend Sequel::ODBC::DB2::DatabaseMethods
         end
       end
 
@@ -126,7 +129,7 @@ module Sequel
           Sequel.database_to_application_timestamp([v.year, v.month, v.day, v.hour, v.minute, v.second])
         when ::ODBC::Time
           now = ::Time.now
-          Sequel.database_to_application_timestamp([now.year, now.month, now.day, v.hour, v.minute, v.second])
+          Sequel::SQLTime.local(now.year, now.month, now.day, v.hour, v.minute, v.second)
         when ::ODBC::Date
           Date.new(v.year, v.month, v.day)
         else

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

@@ -0,0 +1,21 @@
+module Sequel
+  module ODBC
+    # Database and Dataset instance methods for DB2 specific
+    # support via ODBC.
+    module DB2
+      module DatabaseMethods
+        def dataset(opts=nil)
+          Sequel::ODBC::DB2::Dataset.new(self, opts)
+        end
+      end
+      
+      class Dataset < ODBC::Dataset
+        def select_limit_sql(sql)
+          if l = @opts[:limit]
+            sql << " FETCH FIRST #{l == 1 ? 'ROW' : "#{literal(l)} ROWS"} ONLY"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -154,6 +154,18 @@ module Sequel
           "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(opts))}"
         when :drop_index
           "#{drop_index_sql(table, op)} ON #{quote_schema_table(table)}"
+        when :drop_constraint
+          type = case op[:type]
+          when :primary_key
+            return "ALTER TABLE #{quote_schema_table(table)} DROP PRIMARY KEY"
+          when :foreign_key
+            'FOREIGN KEY'
+          when :unique
+            'INDEX'
+          else
+            raise(Error, "must specify constraint type via :type=>(:foreign_key|:primary_key|:unique) when dropping constraints on MySQL")
+          end
+          "ALTER TABLE #{quote_schema_table(table)} DROP #{type} #{quote_identifier(op[:name])}"
         else
           super(table, op)
         end

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

@@ -0,0 +1,143 @@
+Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
+
+module Sequel
+  module MySQL
+    # This module is used by the mysql and mysql2 adapters to support
+    # prepared statements and stored procedures.
+    module PreparedStatements
+      module DatabaseMethods
+        # Support stored procedures on MySQL
+        def call_sproc(name, opts={}, &block)
+          args = opts[:args] || [] 
+          execute("CALL #{name}#{args.empty? ? '()' : literal(args)}", opts.merge(:sproc=>false), &block)
+        end
+        
+        # Executes the given SQL using an available connection, yielding the
+        # connection if the block is given.
+        def execute(sql, opts={}, &block)
+          if opts[:sproc]
+            call_sproc(sql, opts, &block)
+          elsif sql.is_a?(Symbol)
+            execute_prepared_statement(sql, opts, &block)
+          else
+            synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
+          end
+        end
+        
+        private
+
+        def add_prepared_statements_cache(conn)
+          class << conn
+            attr_accessor :prepared_statements
+          end
+          conn.prepared_statements = {}
+        end
+
+        # Executes a prepared statement on an available connection.  If the
+        # prepared statement already exists for the connection and has the same
+        # SQL, reuse it, otherwise, prepare the new statement.  Because of the
+        # usual MySQL stupidity, we are forced to name arguments via separate
+        # SET queries.  Use @sequel_arg_N (for N starting at 1) for these
+        # arguments.
+        def execute_prepared_statement(ps_name, opts, &block)
+          args = opts[:arguments]
+          ps = prepared_statements[ps_name]
+          sql = ps.prepared_sql
+          synchronize(opts[:server]) do |conn|
+            unless conn.prepared_statements[ps_name] == sql
+              conn.prepared_statements[ps_name] = sql
+              _execute(conn, "PREPARE #{ps_name} FROM #{literal(sql)}", opts)
+            end
+            i = 0
+            _execute(conn, "SET " + args.map {|arg| "@sequel_arg_#{i+=1} = #{literal(arg)}"}.join(", "), opts) unless args.empty?
+            _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
+          end
+        end
+        
+      end
+      module DatasetMethods
+        include Sequel::Dataset::StoredProcedures
+       
+        # Methods to add to MySQL prepared statement calls without using a
+        # real database prepared statement and bound variables.
+        module CallableStatementMethods
+          # Extend given dataset with this module so subselects inside subselects in
+          # prepared statements work.
+          def subselect_sql(ds)
+            ps = ds.to_prepared_statement(:select)
+            ps.extend(CallableStatementMethods)
+            ps = ps.bind(@opts[:bind_vars]) if @opts[:bind_vars]
+            ps.prepared_args = prepared_args
+            ps.prepared_sql
+          end
+        end
+        
+        # Methods for MySQL prepared statements using the native driver.
+        module PreparedStatementMethods
+          include Sequel::Dataset::UnnumberedArgumentMapper
+          
+          private
+          
+          # Execute the prepared statement with the bind arguments instead of
+          # the given SQL.
+          def execute(sql, opts={}, &block)
+            super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
+          end
+          
+          # Same as execute, explicit due to intricacies of alias and super.
+          def execute_dui(sql, opts={}, &block)
+            super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
+          end
+        end
+        
+        # Methods for MySQL stored procedures using the native driver.
+        module StoredProcedureMethods
+          include Sequel::Dataset::StoredProcedureMethods
+          
+          private
+          
+          # Execute the database stored procedure with the stored arguments.
+          def execute(sql, opts={}, &block)
+            super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
+          end
+          
+          # Same as execute, explicit due to intricacies of alias and super.
+          def execute_dui(sql, opts={}, &block)
+            super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
+          end
+        end
+        
+        # MySQL is different in that it supports prepared statements but not bound
+        # variables outside of prepared statements.  The default implementation
+        # breaks the use of subselects in prepared statements, so extend the
+        # temporary prepared statement that this creates with a module that
+        # fixes it.
+        def call(type, bind_arguments={}, *values, &block)
+          ps = to_prepared_statement(type, values)
+          ps.extend(CallableStatementMethods)
+          ps.call(bind_arguments, &block)
+        end
+        
+        # Store the given type of prepared statement in the associated database
+        # with the given name.
+        def prepare(type, name=nil, *values)
+          ps = to_prepared_statement(type, values)
+          ps.extend(PreparedStatementMethods)
+          if name
+            ps.prepared_statement_name = name
+            db.prepared_statements[name] = ps
+          end
+          ps
+        end
+        
+        private
+
+        # Extend the dataset with the MySQL stored procedure methods.
+        def prepare_extend_sproc(ds)
+          ds.extend(StoredProcedureMethods)
+        end
+        
+      end
+    end
+  end
+end