sequel 3.15.0 → 3.16.0

data/CHANGELOG

@@ -1,3 +1,17 @@
+=== 3.16.0 (2010-10-01)
+
+* Support composite foreign keys for associations in the identity_map plugin (harukizaemon, jeremyevans) (#310)
+
+* Handle INTERSECT and EXCEPT on Microsoft SQL Server 2005+ (jfirebaugh)
+
+* Add :replace option to Database#create_language in the postgresql adapter (jeremyevans)
+
+* Make rcte_tree plugin work when not all columns are selected (jeremyevans)
+
+* Add swift adapter (jeremyevans)
+
+* Fix literalization of DateTime objects on 1.9 for databases that support fractional seconds (jeremyevans)
+
 === 3.15.0 (2010-09-01)
 
 * Make emulated alter_table tasks on SQLite correctly preserve foreign keys (DirtYiCE, jeremyevans)

data/README.rdoc

@@ -13,7 +13,7 @@ toolkit for Ruby.
   configurations, and database sharding.
 * Sequel currently has adapters for ADO, Amalgalite, DataObjects,
   DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase,
-  Oracle, PostgreSQL and SQLite3.
+  Oracle, PostgreSQL, SQLite3, and Swift.
 
 == Resources
 

data/Rakefile

@@ -12,7 +12,7 @@ VERS = lambda do
   require File.expand_path("../lib/sequel/version", __FILE__)
   Sequel.version
 end
-CLEAN.include ["**/.*.sw?", "sequel-*.gem", ".config", "rdoc", "coverage", "www/public/*.html", "www/public/rdoc*"]
+CLEAN.include ["**/.*.sw?", "sequel-*.gem", ".config", "rdoc", "coverage", "www/public/*.html", "www/public/rdoc*", '**/*.rbc']
 RDOC_DEFAULT_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', 'Sequel: The Database Toolkit for Ruby']
 RDOC_OPTS = RDOC_DEFAULT_OPTS + ['--main', 'README.rdoc']
 

data/doc/dataset_filtering.rdoc

@@ -165,3 +165,10 @@ One of the best features of Sequel is the ability to use datasets as sub-queries
   #=> "SELECT * FROM consumers WHERE (id IN (SELECT consumer_id FROM consumer_refs WHERE logged_in))"
 
 Note that if you are checking for the inclusion of a single column in a subselect, the subselect should only select a single column.
+
+== Using OR instead of AND
+
+By default, if you chain calls to +filter+, the conditions get ANDed together.  If you want to use an OR for a condition, you can use the +or+ method:
+
+  items.filter(:name=>'Food').or(:vendor=>1).sql
+  #=> "SELECT * FROM items WHERE ((name = 'Food') OR (vendor = 1))"

data/doc/release_notes/3.16.0.txt

@@ -0,0 +1,45 @@
+= New Adapter
+
+* A swift adapter was added to Sequel.  Swift is a relatively new
+  ruby database library, built on top of a relatively new backend
+  called dbic++.  While not yet considered production ready, it is
+  very fast.  The swift adapter is about 33% faster and 40% more
+  memory efficient for selects than the postgres adapter using pg
+  with sequel_pg, though it is slower and less memory efficient
+  for inserts and updates.
+
+  Sequel's swift adapter currently supports only PostgreSQL and
+  MySQL, but support for other databases will probably be added in
+  the future.
+
+= Other Improvements
+
+* Sequel now correctly literalizes DateTime objects on ruby 1.9 for
+  databases that support fractional seconds.
+
+* The identity_map plugin now handles composite keys in many_to_one
+  associations.
+
+* The rcte_tree plugin now works when the model's dataset does not
+  select all columns.  This can happen when using the lazy_attributes
+  plugin on the same model.
+
+* Sequel now supports INTERSECT and EXCEPT on Microsoft SQL Server
+  2005+.
+
+* The Database#create_language method in the shared PostgreSQL
+  adapter now accepts a :replace option to replace the currently
+  loaded procedural language if it already exists.  This option
+  is ignored for PostgreSQL versions before 9.0.
+
+* The identity_map plugin now handles cases where the plugin is
+  loaded separately by two different models.
+
+= Backwards Compatibility
+
+* While not technically backwards compatibility related, it was
+  discovered that the identity_map plugin is incompatible with
+  the standard eager loading of many_to_many and many_through_many
+  associations.  If you want to eagerly load those associations and
+  use the identity_map plugin, you should use eager_graph instead
+  of eager.

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

@@ -339,9 +339,9 @@ module Sequel
         db.server_version(@opts[:server])
       end
 
-      # Microsoft SQL Server does not support INTERSECT or EXCEPT
+      # MSSQL 2005+ supports INTERSECT and EXCEPT
       def supports_intersect_except?
-        false
+        is_2005_or_later?
       end
       
       # MSSQL does not support IS TRUE
@@ -356,7 +356,7 @@ module Sequel
 
       # MSSQL 2005+ supports modifying joined datasets
       def supports_modifying_joins?
-        true
+        is_2005_or_later?
       end
 
       # MSSQL does not support multiple columns for the IN/NOT IN operators
@@ -364,9 +364,9 @@ module Sequel
         false
       end
       
-      # Only 2005+ supports the output clause.
+      # MSSQL 2005+ supports the output clause.
       def supports_output_clause?
-        server_version >= 9000000
+        is_2005_or_later?
       end
 
       # MSSQL 2005+ supports window functions
@@ -381,6 +381,9 @@ module Sequel
       end
 
       private
+      def is_2005_or_later?
+        server_version >= 9000000
+      end
 
       # MSSQL supports the OUTPUT clause for DELETE statements.
       # It also allows prepending a WITH clause.

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

@@ -196,6 +196,7 @@ module Sequel
       # * name : Name of the procedural language (e.g. plpgsql)
       # * opts : options hash:
       #   * :handler : The name of a previously registered function used as a call handler for this language.
+      #   * :replace: Replace the installed language if it already exists (on PostgreSQL 9.0+).
       #   * :trusted : Marks the language being created as trusted, allowing unprivileged users to create functions using this language.
       #   * :validator : The name of previously registered function used as a validator of functions defined in this language.
       def create_language(name, opts={})
@@ -428,7 +429,7 @@ module Sequel
       
       # SQL for creating a procedural language.
       def create_language_sql(name, opts={})
-        "CREATE#{' TRUSTED' if opts[:trusted]} LANGUAGE #{name}#{" HANDLER #{opts[:handler]}" if opts[:handler]}#{" VALIDATOR #{opts[:validator]}" if opts[:validator]}"
+        "CREATE#{' OR REPLACE' if opts[:replace] && server_version >= 90000}#{' TRUSTED' if opts[:trusted]} LANGUAGE #{name}#{" HANDLER #{opts[:handler]}" if opts[:handler]}#{" VALIDATOR #{opts[:validator]}" if opts[:validator]}"
       end
       
       # SQL for creating a database trigger. 

data/lib/sequel/adapters/swift.rb

@@ -0,0 +1,145 @@
+require 'swift'
+
+module Sequel
+  # Module holding the Swift support for Sequel.  Swift is a
+  # ruby front-end for dbic++, a fast database access library
+  # written in C++.
+  #
+  # The Swift adapter currently supports PostgreSQL and MySQL:
+  #
+  #   Sequel.connect('swift://user:password@host/database?db_type=postgres')
+  #   Sequel.connect('swift://user:password@host/database?db_type=mysql')
+  module Swift
+    # Contains procs keyed on sub adapter type that extend the
+    # given database object so it supports the correct database type.
+    DATABASE_SETUP = {:postgres=>proc do |db|
+        Sequel.ts_require 'adapters/swift/postgres'
+        db.extend(Sequel::Swift::Postgres::DatabaseMethods)
+        db.swift_class = ::Swift::DB::Postgres
+      end,
+      :mysql=>proc do |db|
+        Sequel.ts_require 'adapters/swift/mysql'
+        db.extend(Sequel::Swift::MySQL::DatabaseMethods)
+        db.swift_class = ::Swift::DB::Mysql
+      end,
+    }
+      
+    class Database < Sequel::Database
+      set_adapter_scheme :swift
+
+      # The Swift adapter class being used by this database.  Connections
+      # in this database's connection pool will be instances of this class.
+      attr_accessor :swift_class
+      
+      # Call the DATABASE_SETUP proc directly after initialization,
+      # so the object always uses sub adapter specific code.  Also,
+      # raise an error immediately if the connection doesn't have a
+      # db_type specified, since one is required to include the correct
+      # subadapter.
+      def initialize(opts)
+        super
+        if db_type = opts[:db_type] and !db_type.to_s.empty? 
+          if prok = DATABASE_SETUP[db_type.to_s.to_sym]
+            prok.call(self)
+          else
+            raise(Error, "No :db_type option specified")
+          end
+        else
+          raise(Error, ":db_type option not valid, should be postgres or mysql")
+        end
+      end
+      
+      # Create an instance of swift_class for the given options.
+      def connect(server)
+        setup_connection(swift_class.new(server_opts(server)))
+      end
+      
+      # Return a Sequel::Swift::Dataset object for this database.
+      def dataset(opts = nil)
+        Swift::Dataset.new(self, opts)
+      end
+    
+      # Execute the given SQL, yielding a Swift::Result if a block is given.
+      def execute(sql, opts={})
+        synchronize(opts[:server]) do |conn|
+          begin
+            res = nil
+            log_yield(sql){res = conn.prepare(sql).execute}
+            yield res if block_given?
+            nil
+          rescue SwiftError => e
+            raise_error(e)
+          ensure
+            res.finish if res
+          end
+        end
+      end
+      
+      # Execute the SQL on the this database, returning the number of affected
+      # rows.
+      def execute_dui(sql, opts={})
+        synchronize(opts[:server]) do |conn|
+          begin
+            log_yield(sql){conn.execute(sql)}
+          rescue SwiftError => e
+            raise_error(e)
+          end
+        end
+      end
+      
+      # Execute the SQL on this database, returning the primary key of the
+      # table being inserted to.
+      def execute_insert(sql, opts={})
+        synchronize(opts[:server]) do |conn|
+          begin
+            log_yield(sql){conn.prepare(sql).execute.insert_id}
+          rescue SwiftError => e
+            raise_error(e)
+          end
+        end
+      end
+      
+      private
+      
+      # Method to call on a statement object to execute SQL that does
+      # not return any rows.
+      def connection_execute_method
+        :execute
+      end
+      
+      # Close the given database connection.
+      def disconnect_connection(c)
+      end
+      
+      # Execute SQL on the connection
+      def log_connection_execute(conn, sql)
+        log_yield(sql){conn.execute(sql)}
+      end
+      
+      # Set the :db entry to the same as the :database entry, since
+      # Swift uses :db.
+      def server_opts(o)
+        o = super
+        o[:db] ||= o[:database]
+        o
+      end
+      
+      # Allow extending the given connection when it is first created.
+      # By default, just returns the connection.
+      def setup_connection(conn)
+        conn
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      # Set the columns and yield the hashes to the block.
+      def fetch_rows(sql, &block)
+        execute(sql) do |res|
+          @columns = res.fields
+          res.each(&block)
+        end
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+Sequel.require 'adapters/shared/mysql'
+
+module Sequel
+  module Swift
+    # Database and Dataset instance methods for MySQL specific
+    # support via Swift.
+    module MySQL
+      # Database instance methods for MySQL databases accessed via Swift.
+      module DatabaseMethods
+        include Sequel::MySQL::DatabaseMethods
+        
+        # Return instance of Sequel::Swift::MySQL::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::Swift::MySQL::Dataset.new(self, opts)
+        end
+        
+        private
+        
+        # The database name for the given database.
+        def database_name
+          opts[:database]
+        end
+
+        # Consider tinyint(1) columns as boolean.
+        def schema_column_type(db_type)
+          db_type == 'tinyint(1)' ? :boolean : super
+        end
+      end
+      
+      # Dataset class for MySQL datasets accessed via Swift.
+      class Dataset < Swift::Dataset
+        include Sequel::MySQL::DatasetMethods
+        
+        # Use execute_insert to execute the replace_sql.
+        def replace(*args)
+          execute_insert(replace_sql(*args))
+        end
+        
+        private
+        
+        # Use Swift's escape method for quoting.
+        def literal_string(s)
+          db.synchronize{|c| "'#{c.escape(s)}'"}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+Sequel.require 'adapters/shared/postgres'
+
+module Sequel
+  Postgres::CONVERTED_EXCEPTIONS << ::SwiftError
+  
+  module Swift
+    # Adapter, Database, and Dataset support for accessing a PostgreSQL
+    # database via Swift.
+    module Postgres
+      # Methods to add to the Swift adapter/connection to allow it to work
+      # with the shared PostgreSQL code.
+      module AdapterMethods
+        include Sequel::Postgres::AdapterMethods
+        
+        # Log all SQL that goes through the execute method to the related
+        # database object.
+        def execute(sql, *args, &block)
+          @db.log_yield(sql){super}
+        rescue SwiftError => e
+          @db.send(:raise_error, e)
+        end
+        
+        private
+        
+        # Swift specific method of getting specific values from a result set.
+        def single_value(row)
+          row.values.at(0)
+        end
+      end
+    
+      # Methods to add to Database instances that access PostgreSQL via Swift.
+      module DatabaseMethods
+        include Sequel::Postgres::DatabaseMethods
+        
+        # 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
+        end
+        
+        # Return instance of Sequel::Swift::Postgres::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::Swift::Postgres::Dataset.new(self, opts)
+        end
+        
+        # Run the DELETE/UPDATE SQL on the database and return the number
+        # of matched rows.
+        def execute_dui(sql, opts={})
+          synchronize(opts[:server]) do |conn|
+            begin
+              conn.execute(sql)
+            rescue SwiftError => e
+              raise_error(e)
+            end
+          end
+        end
+      
+        # Run the INSERT SQL on the database and return the primary key
+        # for the record.
+        def execute_insert(sql, opts={})
+          synchronize(opts[:server]) do |conn|
+            conn.execute(sql)
+            insert_result(conn, opts[:table], opts[:values])
+          end
+        end
+        
+        private
+        
+        # Execute SQL on the connection.
+        def log_connection_execute(conn, sql)
+          conn.execute(sql)
+        end
+      
+        # Extend the adapter with the Swift PostgreSQL AdapterMethods.
+        def setup_connection(conn)
+          conn = super(conn)
+          conn.extend(Sequel::Swift::Postgres::AdapterMethods)
+          conn.db = self
+          conn.apply_connection_settings
+          conn
+        end
+      end
+      
+      class Dataset < Swift::Dataset
+        include Sequel::Postgres::DatasetMethods
+      end
+    end
+  end
+end

data/lib/sequel/database/connecting.rb

@@ -6,7 +6,7 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite db2 dbi do firebird informix jdbc mysql mysql2 odbc openbase oracle postgres sqlite'.collect{|x| x.to_sym}
+    ADAPTERS = %w'ado amalgalite db2 dbi do firebird informix jdbc mysql mysql2 odbc openbase oracle postgres sqlite swift'.collect{|x| x.to_sym}
 
     # Whether to use the single threaded connection pool by default
     @@single_threaded = false

data/lib/sequel/dataset/query.rb

@@ -631,7 +631,7 @@ module Sequel
     def select(*columns, &block)
       columns += Array(Sequel.virtual_row(&block)) if block
       m = []
-      columns.map do |i|
+      columns.each do |i|
         i.is_a?(Hash) ? m.concat(i.map{|k, v| SQL::AliasedExpression.new(k,v)}) : m << i
       end
       clone(:select => m)

data/lib/sequel/dataset/sql.rb

@@ -576,7 +576,7 @@ module Sequel
       v2 = Sequel.application_to_database_timestamp(v)
       fmt = default_timestamp_format.gsub(/%[Nz]/) do |m|
         if m == '%N'
-          format_timestamp_usec(v.is_a?(DateTime) ? v.sec_fraction*86400000000 : v.usec) if supports_timestamp_usecs?
+          format_timestamp_usec(v.is_a?(DateTime) ? v.sec_fraction*(RUBY_VERSION < '1.9.0' ? 86400000000 : 1000000) : v.usec) if supports_timestamp_usecs?
         else
           if supports_timestamp_timezones?
             # Would like to just use %z format, but it doesn't appear to work on Windows

data/lib/sequel/model/base.rb

@@ -236,8 +236,8 @@ module Sequel
       #   # INSERT INTO artists (name) VALUES ('Bob')
       #
       #   Artist.find_or_create(:name=>'Jim'){|a| a.hometown = 'Sactown'}
-      #   # SELECT * FROM artists WHERE (name = 'Bob') LIMIT 1
-      #   # INSERT INTO artists (name, hometown) VALUES ('Bob', 'Sactown')
+      #   # SELECT * FROM artists WHERE (name = 'Jim') LIMIT 1
+      #   # INSERT INTO artists (name, hometown) VALUES ('Jim', 'Sactown')
       def find_or_create(cond, &block)
         find(cond) || create(cond, &block)
       end

data/lib/sequel/plugins/identity_map.rb

@@ -3,7 +3,7 @@ module Sequel
     # The identity_map plugin allows the user to create temporary identity maps
     # via the with_identity_map method, which takes a block.  Inside the block,
     # objects have a 1-1 correspondence with rows in the database.
-    # 
+    #
     # For example, the following is true, and wouldn't be true if you weren't
     # using the identity map:
     #   Sequel::Model.with_identity_map do
@@ -19,9 +19,13 @@ module Sequel
     # in the identity map, the record is returned without a database query being
     # issued.
     #
-    # Identity maps are thread-local and only presist for the duration of the block,
+    # Identity maps are thread-local and only persist for the duration of the block,
     # so they should only be considered as a possible performance enhancer.
-    # 
+    #
+    # The identity_map plugin is not compatible with the standard eager loading of
+    # many_to_many and many_through_many associations.  If you want to use the identity_map plugin,
+    # you should use +eager_graph+ instead of +eager+ for those associations.
+    #
     # Usage:
     #
     #   # Use an identity map that will affect all model classes (called before loading subclasses)
@@ -37,13 +41,13 @@ module Sequel
         def identity_map
           Thread.current[:sequel_identity_map]
         end
-        
+
         # The identity map key for an object of the current class with the given pk.
         # May not always be correct for a class which uses STI.
         def identity_map_key(pk)
           "#{self}:#{pk ? Array(pk).join(',') : "nil:#{rand}"}"
         end
-        
+
         # If the identity map is in use, check it for a current copy of the object.
         # If a copy does not exist, create a new object and add it to the identity map.
         # If a copy exists, add any values in the given row that aren't currently
@@ -61,7 +65,7 @@ module Sequel
           end
           o
         end
-        
+
         # Take a block and inside that block use an identity map to ensure a 1-1
         # correspondence of objects to the database row they represent.
         def with_identity_map
@@ -73,14 +77,14 @@ module Sequel
             self.identity_map = nil
           end
         end
-        
+
         private
 
-        # Set the thread local identity map to the given value. 
-        def identity_map=(v) 
+        # Set the thread local identity map to the given value.
+        def identity_map=(v)
           Thread.current[:sequel_identity_map] = v
         end
-        
+
         # Check the current identity map if it exists for the object with
         # the matching pk.  If one is found, return it, otherwise call super.
         def primary_key_lookup(pk)
@@ -105,15 +109,21 @@ module Sequel
         end
 
         private
-        
+
+        # The primary keys values of the associated object, given the foreign
+        # key columns(s).
+        def _associated_object_pk(fk)
+          fk.is_a?(Array) ? fk.map{|c| send(c)} : send(fk)
+        end
+
         # If the association is a many_to_one and it has a :key option and the
         # key option has a value and the association uses the primary key of
         # the associated class as the :primary_key option, check the identity
         # map for the associated object and return it if present.
         def _load_associated_objects(opts)
           klass = opts.associated_class
-          if idm = model.identity_map and opts[:type] == :many_to_one and opts[:primary_key] == klass.primary_key and
-           opts[:key] and pk = send(opts[:key]) and o = idm[klass.identity_map_key(pk)]
+          if klass.respond_to?(:identity_map) && idm = klass.identity_map and opts[:type] == :many_to_one and opts[:primary_key] == klass.primary_key and
+           opts[:key] and pk = _associated_object_pk(opts[:key]) and o = idm[klass.identity_map_key(pk)]
             o
           else
             super

data/lib/sequel/plugins/rcte_tree.rb

@@ -125,7 +125,7 @@ module Sequel
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
           model.from(t => table_alias).
-           with_recursive(t, base_ds,
+           with_recursive(t, base_ds.select_all,
             recursive_ds.
             select(c_all))
         end
@@ -172,12 +172,14 @@ module Sequel
             end
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
-          model.eager_loading_dataset(r,
+          elds = model.eager_loading_dataset(r,
            model.from(t => table_alias).
             with_recursive(t, base_case,
              recursive_case),
            r.select,
-           eo[:associations], eo).all do |obj|
+           eo[:associations], eo)
+          elds = elds.select_append(ka) unless elds.opts[:select] == nil
+          elds.all do |obj|
             opk = obj[prkey]
             if in_pm = parent_map.has_key?(opk)
               if idm_obj = parent_map[opk]
@@ -220,7 +222,7 @@ module Sequel
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
           model.from(t => table_alias).
-           with_recursive(t, base_ds,
+           with_recursive(t, base_ds.select_all,
             recursive_ds.
             select(SQL::ColumnAll.new(model.table_name)))
           end
@@ -273,10 +275,12 @@ module Sequel
             recursive_case = recursive_case.select_more(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, la) + 1, la)).filter(SQL::QualifiedIdentifier.new(t, la) < level - 1)
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
-          model.eager_loading_dataset(r,
+          elds = model.eager_loading_dataset(r,
            model.from(t => table_alias).with_recursive(t, base_case, recursive_case),
            r.select,
-           associations, eo).all do |obj|
+           associations, eo)
+          elds = elds.select_append(ka) unless elds.opts[:select] == nil
+          elds.all do |obj|
             if level
               no_cache = no_cache_level == obj.values.delete(la)
             end

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 15
+  MINOR = 16
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/mysql_spec.rb

@@ -905,7 +905,7 @@ context "MySQL::Dataset#complex_expression_sql" do
   end
 end
 
-unless MYSQL_DB.adapter_scheme == :do or MYSQL_DB.adapter_scheme == :mysql2
+if MYSQL_DB.adapter_scheme == :mysql or MYSQL_DB.adapter_scheme == :jdbc
   context "MySQL Stored Procedures" do
     before do
       MYSQL_DB.create_table(:items){Integer :id; Integer :value}
@@ -918,7 +918,7 @@ unless MYSQL_DB.adapter_scheme == :do or MYSQL_DB.adapter_scheme == :mysql2
     end
     
     specify "should be callable on the database object" do
-      MYSQL_DB.execute('CREATE PROCEDURE test_sproc() BEGIN DELETE FROM items; END')
+      MYSQL_DB.execute_ddl('CREATE PROCEDURE test_sproc() BEGIN DELETE FROM items; END')
       MYSQL_DB[:items].delete
       MYSQL_DB[:items].insert(:value=>1)
       MYSQL_DB[:items].count.should == 1
@@ -927,7 +927,7 @@ unless MYSQL_DB.adapter_scheme == :do or MYSQL_DB.adapter_scheme == :mysql2
     end
     
     specify "should be callable on the dataset object" do
-      MYSQL_DB.execute('CREATE PROCEDURE test_sproc(a INTEGER) BEGIN SELECT *, a AS b FROM items; END')
+      MYSQL_DB.execute_ddl('CREATE PROCEDURE test_sproc(a INTEGER) BEGIN SELECT *, a AS b FROM items; END')
       MYSQL_DB[:items].delete
       @d = MYSQL_DB[:items]
       @d.call_sproc(:select, :test_sproc, 3).should == []
@@ -938,7 +938,7 @@ unless MYSQL_DB.adapter_scheme == :do or MYSQL_DB.adapter_scheme == :mysql2
     end
     
     specify "should be callable on the dataset object with multiple arguments" do
-      MYSQL_DB.execute('CREATE PROCEDURE test_sproc(a INTEGER, c INTEGER) BEGIN SELECT *, a AS b, c AS d FROM items; END')
+      MYSQL_DB.execute_ddl('CREATE PROCEDURE test_sproc(a INTEGER, c INTEGER) BEGIN SELECT *, a AS b, c AS d FROM items; END')
       MYSQL_DB[:items].delete
       @d = MYSQL_DB[:items]
       @d.call_sproc(:select, :test_sproc, 3, 4).should == []

data/spec/adapters/postgres_spec.rb

@@ -189,7 +189,6 @@ if POSTGRES_DB.pool.respond_to?(:max_size) and POSTGRES_DB.pool.max_size > 1
         String :name
       end
       @ds = POSTGRES_DB[:items]
-      clear_sqls
     end
     after do
       POSTGRES_DB.drop_table(:items)
@@ -241,11 +240,22 @@ context "A PostgreSQL dataset with a timestamp field" do
     @d.delete
   end
 
-  cspecify "should store milliseconds in time fields", :do do
+  cspecify "should store milliseconds in time fields for Time objects", :do do
     t = Time.now
     @d << {:value=>1, :time=>t}
-    @d.literal(@d[:value =>'1'][:time]).should == @d.literal(t)
-    @d[:value=>'1'][:time].usec.should == t.usec
+    t2 = @d[:value =>'1'][:time]
+    @d.literal(t2).should == @d.literal(t)
+    t2.strftime('%Y-%m-%d %H:%M:%S').should == t.strftime('%Y-%m-%d %H:%M:%S')
+    t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000 == t.usec
+  end
+
+  cspecify "should store milliseconds in time fields for DateTime objects", :do do
+    t = DateTime.now
+    @d << {:value=>1, :time=>t}
+    t2 = @d[:value =>'1'][:time]
+    @d.literal(t2).should == @d.literal(t)
+    t2.strftime('%Y-%m-%d %H:%M:%S').should == t.strftime('%Y-%m-%d %H:%M:%S')
+    t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000 == t.strftime('%N').to_i/1000
   end
 end
 
@@ -930,12 +940,12 @@ context "Postgres::Database functions, languages, and triggers" do
   
   specify "#create_language and #drop_language should create and drop languages" do
     @d.send(:create_language_sql, :plpgsql).should == 'CREATE LANGUAGE plpgsql'
-    @d.create_language(:plpgsql)
+    @d.create_language(:plpgsql, :replace=>true)
     proc{@d.create_language(:plpgsql)}.should raise_error(Sequel::DatabaseError)
     @d.send(:drop_language_sql, :plpgsql).should == 'DROP LANGUAGE plpgsql'
     @d.drop_language(:plpgsql)
     proc{@d.drop_language(:plpgsql)}.should raise_error(Sequel::DatabaseError)
-    @d.send(:create_language_sql, :plpgsql, :trusted=>true, :handler=>:a, :validator=>:b).should == 'CREATE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b'
+    @d.send(:create_language_sql, :plpgsql, :replace=>true, :trusted=>true, :handler=>:a, :validator=>:b).should == (@d.server_version >= 90000 ? 'CREATE OR REPLACE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b' : 'CREATE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b')
     @d.send(:drop_language_sql, :plpgsql, :if_exists=>true, :cascade=>true).should == 'DROP LANGUAGE IF EXISTS plpgsql CASCADE'
     # Make sure if exists works
     @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true)

data/spec/core/dataset_spec.rb

@@ -973,7 +973,7 @@ context "Dataset#literal" do
   specify "should literalize DateTime properly" do
     t = DateTime.now
     s = t.strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.sec_fraction* 86400000000)}'"
+    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.sec_fraction * (RUBY_VERSION < '1.9.0' ? 86400000000 : 1000000))}'"
   end
   
   specify "should literalize Date properly" do
@@ -998,7 +998,7 @@ context "Dataset#literal" do
 
     t = DateTime.now
     s = t.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.sec_fraction* 86400000000)}'"
+    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.sec_fraction* (RUBY_VERSION < '1.9.0' ? 86400000000 : 1000000))}'"
 
     d = Date.today
     s = d.strftime("DATE '%Y-%m-%d'")
@@ -1014,7 +1014,7 @@ context "Dataset#literal" do
 
     t = DateTime.now.new_offset(0)
     s = t.strftime("'%Y-%m-%d %H:%M:%S")
-    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.sec_fraction* 86400000000)}+0000'"
+    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.sec_fraction* (RUBY_VERSION < '1.9.0' ? 86400000000 : 1000000))}+0000'"
   end
   
   specify "should literalize Time and DateTime properly if the database doesn't support usecs in timestamps" do

data/spec/extensions/identity_map_spec.rb

@@ -5,7 +5,6 @@ describe "Sequel::Plugins::IdentityMap" do
     class ::IdentityMapModel < Sequel::Model
       plugin :identity_map
       attr_accessor :foo
-      columns :id
       ds = dataset
       def ds.fetch_rows(sql)
         c = @opts[:where].args.first
@@ -16,7 +15,7 @@ describe "Sequel::Plugins::IdentityMap" do
       end
     end
     class ::IdentityMapAlbum < ::IdentityMapModel
-      columns :id, :artist_id
+      columns :artist_id
     end
     class ::IdentityMapArtist < ::IdentityMapModel
     end
@@ -73,7 +72,7 @@ describe "Sequel::Plugins::IdentityMap" do
     end
   end
 
-  it "#load should should store the object in the current identity map if it isn't already there" do
+  it "#load should store the object in the current identity map if it isn't already there" do
     @c.with_identity_map do
       @c.identity_map[@c.identity_map_key(1)].should == nil
       o = @c.load(:id=>1)
@@ -138,6 +137,24 @@ describe "Sequel::Plugins::IdentityMap" do
     end
   end
 
+  it "should use the identity map as a lookup cache when retrieving many_to_one associated records via a composite key" do
+    @c1.columns :another_id
+    @c1.many_to_one :artist, :class=>@c2, :key=>[:id, :another_id]
+    @c.with_identity_map do
+      MODEL_DB.sqls.length.should == 0
+      o = @c1.load(:id=>1, :another_id=>1, :artist_id=>2)
+      a = o.artist
+      a.should be_a_kind_of(@c2)
+      MODEL_DB.sqls.length.should == 1
+      o = @c1.load(:id=>1, :another_id=>2, :artist_id=>2)
+      o.artist.should == a
+      MODEL_DB.sqls.length.should == 1
+      o = @c1.load(:id=>3, :another_id=>3, :artist_id=>3)
+      o.artist.should_not == a
+      MODEL_DB.sqls.length.should == 2
+    end
+  end
+
   it "should use the identity map as a lookup cache when retrieving many_to_one associated records" do
     @c1.many_to_one :artist, :class=>@c2
     @c.with_identity_map do
@@ -170,7 +187,7 @@ describe "Sequel::Plugins::IdentityMap" do
       MODEL_DB.sqls.length.should == 3
     end
   end
-  
+
   it "should not use the identity map as a lookup cache if the assocation has a nil :key option" do
     c = @c2
     @c1.many_to_one :artist, :class=>@c2, :key=>nil, :dataset=>proc{c.filter(:artist_id=>artist_id)}

data/spec/integration/dataset_test.rb

@@ -472,7 +472,9 @@ describe Sequel::SQL::Constants do
   cspecify "should have working CURRENT_DATE", [:odbc, :mssql], [:jdbc, :sqlite] do
     @db.create_table!(:constants){Date :d}
     @ds.insert(:d=>Sequel::CURRENT_DATE)
-    Date.today.should == @c2[@ds.get(:d)]
+    d = @c2[@ds.get(:d)]
+    d.should be_a_kind_of(Date)
+    d.to_s.should == Date.today.to_s
   end
 
   cspecify "should have working CURRENT_TIME", [:do, :mysql], [:jdbc, :sqlite], [:mysql2] do
@@ -925,7 +927,7 @@ describe "Dataset identifier methods" do
     @db.drop_table(:a)
   end
   
-  cspecify "#identifier_output_method should change how identifiers are output", [:mysql2] do
+  cspecify "#identifier_output_method should change how identifiers are output", [:mysql2], [:swift] do
     @ds.identifier_output_method = :upcase
     @ds.first.should == {:AB=>1}
     @ds.identifier_output_method = :uprev

data/spec/integration/plugin_test.rb

@@ -413,13 +413,22 @@ describe "Touch plugin" do
     @album.updated_at.to_i.should be_close(Time.now.to_i, 2)
   end
   
-  cspecify "should update the timestamp column for associated records when the record is updated or destroyed", [:do], [:jdbc, :sqlite] do
+  cspecify "should update the timestamp column for associated records when the record is updated or destroyed", [:do, :sqlite], [:jdbc, :sqlite] do
     @artist.updated_at.should == nil
     @album.update(:name=>'B')
-    @artist.reload.updated_at.to_i.should be_close(Time.now.to_i, 2)
+    ua = @artist.reload.updated_at
+    if ua.is_a?(Time)
+      ua.to_i.should be_close(Time.now.to_i, 2)
+    else
+      (DateTime.now - ua).should be_close(0, 2.0/86400)
+    end
     @artist.update(:updated_at=>nil)
     @album.destroy
-    @artist.reload.updated_at.to_i.should be_close(Time.now.to_i, 2)
+    if ua.is_a?(Time)
+      ua.to_i.should be_close(Time.now.to_i, 2)
+    else
+      (DateTime.now - ua).should be_close(0, 2.0/86400)
+    end
   end
 end
 
@@ -644,6 +653,16 @@ if INTEGRATION_DB.dataset.supports_cte?
       nodes[1].ancestors.should == [@a, @aa]
       nodes[2].ancestors.should == []
     end
+
+    specify "should work correctly if not all columns are selected" do
+      Node.plugin :lazy_attributes, :name
+      @aaaa.descendants.should == [Node.load(:parent_id=>11, :id=>13)]
+      @aa.ancestors.should == [Node.load(:parent_id=>nil, :id=>1)]
+      nodes = Node.filter(:id=>[@a.id, @b.id, @aaa.id]).order(:name).eager(:ancestors, :descendants).all
+      nodes.should == [{:parent_id=>nil, :id=>1}, {:parent_id=>3, :id=>7}, {:parent_id=>nil, :id=>2}].map{|x| Node.load(x)}
+      nodes[2].descendants.should == [{:parent_id=>2, :id=>5}, {:parent_id=>2, :id=>6}].map{|x| Node.load(x)}
+      nodes[1].ancestors.should == [{:parent_id=>nil, :id=>1}, {:parent_id=>1, :id=>3}].map{|x| Node.load(x)}
+    end
     
     specify "should eagerly load descendants to a given level" do
       nodes = Node.filter(:id=>[@a.id, @b.id, @aaa.id]).order(:name).eager(:descendants=>1).all

data/spec/integration/timezone_test.rb

@@ -37,19 +37,19 @@ describe "Sequel timezone support" do
     Sequel.datetime_class = Time
   end
 
-  cspecify "should support using UTC for database storage and local time for the application", [:do, proc{|db| db.database_type != :sqlite}] do
+  cspecify "should support using UTC for database storage and local time for the application", [:swift], [:do, proc{|db| db.database_type != :sqlite}] do
     Sequel.database_timezone = :utc
     Sequel.application_timezone = :local
     test_timezone
   end
 
-  cspecify "should support using local time for database storage and UTC for the application", [:do, proc{|db| db.database_type != :sqlite}] do
+  cspecify "should support using local time for database storage and UTC for the application", [:swift], [:do, proc{|db| db.database_type != :sqlite}] do
     Sequel.database_timezone = :local
     Sequel.application_timezone = :utc
     test_timezone
   end
 
-  cspecify "should support using UTC for both database storage and for application", [:do, proc{|db| db.database_type != :sqlite}] do
+  cspecify "should support using UTC for both database storage and for application", [:swift], [:do, proc{|db| db.database_type != :sqlite}] do
     Sequel.default_timezone = :utc
     test_timezone
   end

data/spec/integration/type_test.rb

@@ -64,7 +64,8 @@ describe "Supported types" do
     ds = create_items_table_with_column(:dat, Date)
     d = Date.today
     ds.insert(:dat => d)
-    ds.first[:dat].should == d
+    ds.first[:dat].should be_a_kind_of(Date)
+    ds.first[:dat].to_s.should == d.to_s
   end
   
   cspecify "should support generic datetime type", [:do, :sqlite], [:jdbc, :sqlite] do
@@ -78,7 +79,7 @@ describe "Supported types" do
     ds.first[:tim].strftime('%Y%m%d%H%M%S').should == t.strftime('%Y%m%d%H%M%S')
   end
   
-  cspecify "should support generic file type", [:do], [:odbc, :mssql], [:mysql2] do
+  cspecify "should support generic file type", [:do], [:odbc, :mssql], [:mysql2], [:swift] do
     ds = create_items_table_with_column(:name, File)
     ds.insert(:name => ("a\0"*300).to_sequel_blob)
     ds.all.should == [{:name=>("a\0"*300).to_sequel_blob}]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sequel
 version: !ruby/object:Gem::Version 
-  hash: 59
+  hash: 71
   prerelease: false
   segments: 
   - 3
-  - 15
+  - 16
   - 0
-  version: 3.15.0
+  version: 3.16.0
 platform: ruby
 authors: 
 - Jeremy Evans
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-01 00:00:00 -07:00
+date: 2010-10-01 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -79,6 +79,7 @@ extra_rdoc_files:
 - doc/release_notes/3.13.0.txt
 - doc/release_notes/3.14.0.txt
 - doc/release_notes/3.15.0.txt
+- doc/release_notes/3.16.0.txt
 files: 
 - COPYING
 - CHANGELOG
@@ -125,6 +126,7 @@ files:
 - doc/release_notes/3.13.0.txt
 - doc/release_notes/3.14.0.txt
 - doc/release_notes/3.15.0.txt
+- doc/release_notes/3.16.0.txt
 - doc/sharding.rdoc
 - doc/sql.rdoc
 - doc/virtual_rows.rdoc
@@ -300,6 +302,9 @@ files:
 - lib/sequel/adapters/sqlite.rb
 - lib/sequel/adapters/utils/stored_procedures.rb
 - lib/sequel/adapters/mysql2.rb
+- lib/sequel/adapters/swift.rb
+- lib/sequel/adapters/swift/mysql.rb
+- lib/sequel/adapters/swift/postgres.rb
 - lib/sequel/connection_pool.rb
 - lib/sequel/connection_pool/sharded_single.rb
 - lib/sequel/connection_pool/sharded_threaded.rb