sequel 3.13.0 → 3.14.0

data/CHANGELOG

@@ -1,3 +1,39 @@
+=== 3.14.0 (2010-08-02)
+
+* Handle OCIInvalidHandle errors when disconnecting in the Oracle adapter (jeremyevans)
+
+* Allow calling Model.create_table, .create_table! and .create_table? with blocks containing the schema in the schema plugin (jfirebaugh)
+
+* Fix handling of a :conditions options in the rcte plugin (mluu)
+
+* Fix aggregate methods such as Dataset#sum and #avg on MSSQL on datasets with an order but no limit (mluu)
+
+* Fix rename_table on MSSQL for case sensitive collations and schemas (mluu)
+
+* Add a :single_root option to the tree plugin, for enforcing a single root value via a before_save hook (jfirebaugh)
+
+* Add a Model#root? method to the tree plugin, for checking if the current node is a root (jfirebaugh)
+
+* Add a :raise_on_failure option to Model#save to override the raise_on_save_failure setting (jfirebaugh)
+
+* Handle class discriminator column names that are existing ruby method names in the single table inheritance plugin (jeremyevans)
+
+* Fix times and datetimes when timezone support is used and you are loading a standard time when in daylight time or vice versa (gcampbell)
+
+* Handle literalization of OCI8::CLOB objects in the native oracle adapter (jeremyevans)
+
+* Raise a Sequel::Error instead of an ArgumentError if the migration current or target version does not exist (jeremyevans)
+
+* Fix Database#schema on Oracle when the same table exists in multiple schemas (djwhitt)
+
+* Fix Database#each_server when using a connection string to connect (jeremyevans)
+
+* Make Model dataset's destroy method respect the model's use_transactions setting, instead of always using a transaction (jeremyevans)
+
+* Add Database#adapter_scheme, for checking which adapter a Database uses (jeremyevans)
+
+* Allow Dataset#grep to take :all_patterns, :all_columns, and :case_insensitive options (mighub, jeremyevans)
+
 === 3.13.0 (2010-07-01)
 
 * Allow Model.find_or_create to take a block which is yielded the object to be created, if no object is found (zaius, jeremyevans)

data/doc/release_notes/3.14.0.txt

@@ -0,0 +1,118 @@
+= New Features
+
+* Dataset#grep now accepts :all_patterns, :all_columns, and
+  :case_insensitive options.  Previously, grep would use a case
+  sensitive search where it would match if any pattern matched any
+  column.  These three options give you more control over how the
+  pattern matching will work:
+  
+    dataset.grep([:a, :b], %w'%test% foo')
+    # WHERE ((a LIKE '%test%') OR (a LIKE 'foo')
+    #    OR (b LIKE '%test%') OR (b LIKE 'foo'))
+
+    dataset.grep([:a, :b], %w'%foo% %bar%', :all_patterns=>true)
+    # WHERE (((a LIKE '%foo%') OR (b LIKE '%foo%'))
+    #   AND ((a LIKE '%bar%') OR (b LIKE '%bar%')))
+
+    dataset.grep([:a, :b], %w'%foo% %bar%', :all_columns=>true)
+    # WHERE (((a LIKE '%foo%') OR (a LIKE '%bar%'))
+    #   AND ((b LIKE '%foo%') OR (b LIKE '%bar%')))
+
+    dataset.grep([:a, :b], %w'%foo% %bar%',
+                 :all_patterns=>true,:all_columns=>true)
+    # WHERE ((a LIKE '%foo%') AND (b LIKE '%foo%')
+    #   AND (a LIKE '%bar%') AND (b LIKE '%bar%'))
+    
+    dataset.grep([:a, :b], %w'%test% foo', :case_insensitive=>true)
+    # WHERE ((a ILIKE '%test%') OR (a ILIKE 'foo')
+    #    OR (b ILIKE '%test%') OR (b ILIKE 'foo')) 
+
+* When using the schema plugin, you can now provide a block to the
+  create_table methods to set the schema and create the table
+  in the same call:
+  
+    class Artist < Sequel::Model
+      create_table do
+        primary_key :id
+        String :name
+      end
+    end
+
+* The tree plugin now accepts a :single_root option, which uses a
+  before_save hook to attempt to ensure that there is only a single
+  root in the tree.  It also adds a Model.root method to get the
+  single root of the tree.
+  
+* The tree plugin now adds a Model#root? instance method to check
+  if the current node is a root of the tree.
+
+* Model#save now takes a :raise_on_failure option which will
+  override the object's raise_on_save_failure setting.  This makes
+  it easier to get the desired behavior (raise or just return false)
+  in library code without using a begin/ensure block.
+  
+* The Database#adapter_scheme instance method was added, which
+  operates the same as the class method.
+  
+* Sequel now handles the literalization of OCI8::CLOB objects in
+  the Oracle adapter.
+
+= Other Improvements
+
+* When using the timezone support, Sequel will now correctly load
+  times and datetimes in standard time when the current timezone is
+  in daylight time, or vice versa.  Previously, if you tried to
+  to load a time or datetime in December when in July in a timezone
+  that used daylight time, it would be off by an hour.
+
+* The rcte_tree plugin now works correctly when a :conditions option
+  is used.
+
+* The single_table_inheritance plugin now works correctly when the
+  class discriminator column has the same name as an existing ruby
+  method (such as type).
+
+* Database#each_server now works correctly when a connection string
+  is used to connect, instead of an options hash.
+  
+* Model#destroy now respects the object's use_transactions setting,
+  instead of always using a transaction.
+  
+* Model#exists? now uses a simpler and faster query.
+
+* Sequel now handles the aggregate methods such as count and sum
+  correctly on Microsoft SQL Server when using an ordered dataset
+  with a clause such as DISTINCT or GROUP and without a limit.
+  
+* Sequel now handles rename_table correctly on Microsoft SQL Server
+  when using a case sensitive collation, or when qualifying the
+  table with a schema.
+
+* Sequel now parses the schema correctly on Oracle when the same
+  table name is used in multiple schemas.
+
+* Sequel now handles OCIInvalidHandle errors when disconnecting
+  in the Oracle adapter.
+  
+* Sequel now raises a Sequel::Error instead of an ArgumentError
+  if the current or target migration version does not exist.
+  
+* When a mismatched number of composite keys are used in
+  associations, Sequel now uses a more detailed error message.
+
+* Significant improvements were made to the Dataset and Model
+  RDoc documentation.
+
+= Backwards Compatibility
+
+* Model#valid? now must accept an optional options hash.
+
+* The Model#save_failure private method was renamed to
+  raise_hook_failure.
+  
+* The LOCAL_DATETIME_OFFSET_SECS and LOCAL_DATETIME_OFFSET constants
+  have been removed from the Sequel module.
+  
+* Sequel now uses obj.to_json instead of JSON.generate(obj).  This
+  shouldn't affect backwards compatibility, but did fix a bug in
+  certain cases.

data/lib/sequel/adapters/oracle.rb

@@ -34,9 +34,9 @@ module Sequel
       def schema_parse_table(table, opts={})
         ds = dataset
         ds.identifier_output_method = :downcase
-        schema, table = schema_and_table(table)
+        schema_and_table = "#{"#{quote_identifier(opts[:schema])}." if opts[:schema]}#{quote_identifier(table)}"
         table_schema = []
-        metadata = transaction(opts){|conn| conn.describe_table(table.to_s)}
+        metadata = transaction(opts){|conn| conn.describe_table(schema_and_table)}
         metadata.columns.each do |column|
           table_schema << [
             column.name.downcase.to_sym,
@@ -85,6 +85,8 @@ module Sequel
 
       def disconnect_connection(c)
         c.logoff
+      rescue OCIInvalidHandle
+        nil
       end
       
       def remove_transaction(conn)
@@ -122,6 +124,9 @@ module Sequel
         case v
         when OraDate
           literal(Sequel.database_to_application_timestamp(v))
+        when OCI8::CLOB
+          v.rewind
+          literal(v.read)
         else
           super
         end

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

@@ -67,7 +67,7 @@ module Sequel
         when :add_column
           "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
         when :rename_column
-          "SP_RENAME #{literal("#{quote_schema_table(table)}.#{quote_identifier(op[:name])}")}, #{literal(op[:new_name].to_s)}, 'COLUMN'"
+          "sp_rename #{literal("#{quote_schema_table(table)}.#{quote_identifier(op[:name])}")}, #{literal(op[:new_name].to_s)}, 'COLUMN'"
         when :set_column_type
           "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}"
         when :set_column_null
@@ -124,9 +124,9 @@ module Sequel
         ds
       end
       
-      # Use SP_RENAME to rename the table
+      # Use sp_rename to rename the table
       def rename_table_sql(name, new_name)
-        "SP_RENAME #{quote_schema_table(name)}, #{quote_schema_table(new_name)}"
+        "sp_rename #{literal(quote_schema_table(name))}, #{quote_identifier(schema_and_table(new_name).pop)}"
       end
       
       # SQL to rollback to a savepoint
@@ -373,6 +373,12 @@ module Sequel
       def supports_window_functions?
         true
       end
+      
+      protected
+      # MSSQL does not allow ordering in sub-clauses unless 'top' (limit) is specified
+      def aggregate_dataset
+        (options_overlap(Sequel::Dataset::COUNT_FROM_SELF_OPTS) && !options_overlap([:limit])) ? unordered.from_self : super
+      end
 
       private
 

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -56,7 +56,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     @allocated[server].length + @available_connections[server].length
   end
   
-  # Removes all connection currently available on all servers, optionally
+  # Removes all connections currently available on all servers, optionally
   # yielding each connection to the given block. This method has the effect of 
   # disconnecting from the database, assuming that no connections are currently
   # being used.  If connections are being used, they are scheduled to be

data/lib/sequel/connection_pool/threaded.rb

@@ -1,4 +1,5 @@
 # A connection pool allowing multi-threaded access to a pool of connections.
+# This is the default connection pool used by Sequel.
 class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   # The maximum number of connections this pool will create (per shard/server
   # if sharding).
@@ -35,11 +36,10 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
     @allocated.length + @available_connections.length
   end
   
-  # Removes all connection currently available on all servers, optionally
+  # Removes all connections currently available on all servers, optionally
   # yielding each connection to the given block. This method has the effect of 
   # disconnecting from the database, assuming that no connections are currently
-  # being used.  If connections are being used, they are scheduled to be
-  # disconnected as soon as they are returned to the pool.
+  # being used.
   # 
   # Once a connection is requested using #hold, the connection pool
   # creates new connections to the database.

data/lib/sequel/database/connecting.rb

@@ -27,13 +27,13 @@ module Sequel
         
         # make sure we actually loaded the adapter
         unless klass = ADAPTER_MAP[scheme]
-          raise AdapterNotFound, "Could not load #{scheme} adapter"
+          raise AdapterNotFound, "Could not load #{scheme} adapter: adapter class not registered in ADAPTER_MAP"
         end
       end
       klass
     end
         
-    # Returns the scheme for the Database class.
+    # Returns the scheme symbol for the Database class.
     def self.adapter_scheme
       @scheme
     end
@@ -54,6 +54,7 @@ module Sequel
           uri.query.split('&').collect{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?
           uri_options.entries.each{|k,v| uri_options[k] = URI.unescape(v) if v.is_a?(String)}
           opts = uri_options.merge(opts)
+          opts[:adapter] = scheme
         end
       when Hash
         opts = conn_string.merge(opts)
@@ -62,7 +63,7 @@ module Sequel
         raise Error, "Sequel::Database.connect takes either a Hash or a String, given: #{conn_string.inspect}"
       end
       # process opts a bit
-      opts = opts.inject({}) do |m, kv| k, v = *kv
+      opts = opts.inject({}) do |m, (k,v)|
         k = :user if k.to_s == 'username'
         m[k.to_sym] = v
         m
@@ -104,9 +105,20 @@ module Sequel
     end
     private_class_method :set_adapter_scheme
     
-    # The connection pool for this database
+    # The connection pool for this Database instance.  All Database instances have
+    # their own connection pools.
     attr_reader :pool
 
+    # Returns the scheme symbol for this instance's class, which reflects which
+    # adapter is being used.  In some cases, this can be the same as the
+    # +database_type+ (for native adapters), in others (i.e. adapters with
+    # subadapters), it will be different.
+    #
+    #   Sequel.connect('jdbc:postgres://...').adapter_scheme # => :jdbc
+    def adapter_scheme
+      self.class.adapter_scheme
+    end
+
     # Dynamically add new servers or modify server options at runtime. Also adds new
     # servers to the connection pool. Intended for use with master/slave or shard
     # configurations where it is useful to add new server hosts at runtime.
@@ -115,7 +127,7 @@ module Sequel
     # proc values.  If a servers key is already in use, it's value is overridden
     # with the value provided.
     #
-    #  DB.add_servers(:f=>{:host=>"hash_host_f"})
+    #   DB.add_servers(:f=>{:host=>"hash_host_f"})
     def add_servers(servers)
       @opts[:servers] = @opts[:servers] ? @opts[:servers].merge(servers) : servers
       @pool.add_servers(servers.keys)
@@ -133,19 +145,27 @@ module Sequel
     # type.  Even better, you can tell that two Database objects that are using
     # the same adapter are connecting to different database types (think JDBC or
     # DataObjects).
+    #
+    #   Sequel.connect('jdbc:postgres://...').database_type # => :postgres
     def database_type
-      self.class.adapter_scheme
+      adapter_scheme
     end
     
     # Disconnects all available connections from the connection pool.  Any
     # connections currently in use will not be disconnected. Options:
     # * :servers - Should be a symbol specifing the server to disconnect from,
     #   or an array of symbols to specify multiple servers.
+    #
+    # Example:
+    #
+    #   DB.disconnect # All servers
+    #   DB.disconnect(:servers=>:server1) # Single server
+    #   DB.disconnect(:servers=>[:server1, :server2]) # Multiple servers
     def disconnect(opts = {})
       pool.disconnect(opts)
     end
 
-    # Yield a new database object for every server in the connection pool.
+    # Yield a new Database instance for every server in the connection pool.
     # Intended for use in sharded environments where there is a need to make schema
     # modifications (DDL queries) on each shard.
     #
@@ -175,6 +195,9 @@ module Sequel
     end
     
     # An array of servers/shards for this Database object.
+    #
+    #   DB.servers # Unsharded: => [:default]
+    #   DB.servers # Sharded:   => [:default, :server1, :server2]
     def servers
       pool.servers
     end
@@ -184,13 +207,27 @@ module Sequel
       @single_threaded
     end
     
-    # Acquires a database connection, yielding it to the passed block.
+    # Acquires a database connection, yielding it to the passed block. This is
+    # useful if you want to make sure the same connection is used for all
+    # database queries in the block.  It is also useful if you want to gain
+    # direct access to the underlying connection object if you need to do
+    # something Sequel does not natively support.
+    #
+    # If a server option is given, acquires a connection for that specific
+    # server, instead of the :default server.
+    #
+    #
+    #   DB.synchronize do |conn|
+    #     ...
+    #   end
     def synchronize(server=nil, &block)
       @pool.hold(server || :default, &block)
     end
     
     # Attempts to acquire a database connection.  Returns true if successful.
-    # Will probably raise an error if unsuccessful.
+    # Will probably raise an Error if unsuccessful.  If a server argument
+    # is given, attempts to acquire a database connection to the given
+    # server/shard.
     def test_connection(server=nil)
       synchronize(server){|conn|}
       true
@@ -207,7 +244,7 @@ module Sequel
     # options for all server with the specific options for the given
     # server specified in the :servers option.
     def server_opts(server)
-      opts = if @opts[:servers] && server_options = @opts[:servers][server]
+      opts = if @opts[:servers] and server_options = @opts[:servers][server]
         case server_options
         when Hash
           @opts.merge(server_options)
@@ -222,6 +259,5 @@ module Sequel
       opts.delete(:servers)
       opts
     end
-    
   end
 end

data/lib/sequel/database/dataset.rb

@@ -5,10 +5,11 @@ module Sequel
     # These methods all return instances of this database's dataset class.
     # ---------------------
 
-    # Returns a dataset from the database. If the first argument is a string,
+    # Returns a dataset for the database. If the first argument is a string,
     # the method acts as an alias for Database#fetch, returning a dataset for
-    # arbitrary SQL:
+    # arbitrary SQL, with or without placeholders:
     #
+    #   DB['SELECT * FROM items'].all
     #   DB['SELECT * FROM items WHERE name = ?', my_name].all
     #
     # Otherwise, acts as an alias for Database#from, setting the primary
@@ -19,7 +20,10 @@ module Sequel
       (String === args.first) ? fetch(*args) : from(*args)
     end
     
-    # Returns a blank dataset for this database
+    # Returns a blank dataset for this database.
+    #
+    #   DB.dataset # SELECT *
+    #   DB.dataset.from(:items) # SELECT * FROM items
     def dataset
       ds = Sequel::Dataset.new(self)
     end
@@ -29,11 +33,11 @@ module Sequel
     #
     #   DB.fetch('SELECT * FROM items'){|r| p r}
     #
-    # The method returns a dataset instance:
+    # The +fetch+ method returns a dataset instance:
     #
     #   DB.fetch('SELECT * FROM items').all
     #
-    # Fetch can also perform parameterized queries for protection against SQL
+    # +fetch+ can also perform parameterized queries for protection against SQL
     # injection:
     #
     #   DB.fetch('SELECT * FROM items WHERE name = ?', my_name).all
@@ -43,14 +47,21 @@ module Sequel
       ds
     end
     
-    # Returns a new dataset with the from method invoked. If a block is given,
+    # Returns a new dataset with the +from+ method invoked. If a block is given,
     # it is used as a filter on the dataset.
+    #
+    #   DB.from(:items) # SELECT * FROM items
+    #   DB.from(:items){id > 2} # SELECT * FROM items WHERE (id > 2)
     def from(*args, &block)
       ds = dataset.from(*args)
       block ? ds.filter(&block) : ds
     end
     
     # Returns a new dataset with the select method invoked.
+    #
+    #   DB.select(1) # SELECT 1
+    #   DB.select{server_version{}} # SELECT server_version()
+    #   DB.select(:id).from(:items) # SELECT id FROM items
     def select(*args, &block)
       dataset.select(*args, &block)
     end