sequel 4.0.0 → 4.1.0

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

@@ -1,3 +1,5 @@
+Sequel.require 'adapters/utils/replace'
+
 module Sequel
   module SQLite
     # No matter how you connect to SQLite, the following Database options
@@ -473,6 +475,8 @@ module Sequel
     
     # Instance methods for datasets that connect to an SQLite database
     module DatasetMethods
+      include Dataset::Replace
+
       SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct columns from join where group having compounds order limit')
       CONSTANT_MAP = {:CURRENT_DATE=>"date(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIMESTAMP=>"datetime(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIME=>"time(CURRENT_TIMESTAMP, 'localtime')".freeze}
       EMULATED_FUNCTION_MAP = {:char_length=>'length'.freeze}

data/lib/sequel/adapters/utils/replace.rb

@@ -0,0 +1,36 @@
+module Sequel
+  class Dataset
+    module Replace
+      INSERT = Dataset::INSERT
+      REPLACE = 'REPLACE'.freeze
+
+      # Execute a REPLACE statement on the database (deletes any duplicate
+      # rows before inserting).
+      def replace(*values)
+        execute_insert(replace_sql(*values))
+      end
+
+      # SQL statement for REPLACE
+      def replace_sql(*values)
+        clone(:replace=>true).insert_sql(*values)
+      end
+
+      # Replace multiple rows in a single query.
+      def multi_replace(*values)
+        clone(:replace=>true).multi_insert(*values)
+      end
+
+      # Databases using this module support REPLACE.
+      def supports_replace?
+        true
+      end
+
+      private
+
+      # If this is an replace instead of an insert, use replace instead
+      def insert_insert_sql(sql)
+        sql << (@opts[:replace] ? REPLACE : INSERT)
+      end
+    end
+  end
+end

data/lib/sequel/database/query.rb

@@ -72,6 +72,7 @@ module Sequel
     #
     #   DB.run("SET some_server_variable = 42")
     def run(sql, opts=OPTS)
+      sql = literal(sql) if sql.is_a?(SQL::PlaceholderLiteralString)
       execute_ddl(sql, opts)
       nil
     end

data/lib/sequel/database/schema_generator.rb

@@ -116,12 +116,16 @@ module Sequel
       end
       
       # Adds a named constraint (or unnamed if name is nil) to the DDL,
-      # with the given block or args.
+      # with the given block or args. To provide options for the constraint, pass
+      # a hash as the first argument.
       #
-      #   constraint(:blah, :num=>1..5) # CONSTRAINT blah CHECK num >= 1 AND num <= 5
-      #   check(:foo){num > 5} # CONSTRAINT foo CHECK num > 5
+      #   constraint(:blah, :num=>1..5)
+      #   # CONSTRAINT blah CHECK num >= 1 AND num <= 5
+      #   constraint({:name=>:blah, :deferrable=>true}, :num=>1..5)
+      #   # CONSTRAINT blah CHECK num >= 1 AND num <= 5 DEFERRABLE INITIALLY DEFERRED
       def constraint(name, *args, &block)
-        constraints << {:name => name, :type => :check, :check => block || args}
+        opts = name.is_a?(Hash) ? name : {:name=>name}
+        constraints << opts.merge(:type=>:check, :check=>block || args)
       end
       
       # Add a foreign key in the table that references another table to the DDL. See column
@@ -319,8 +323,11 @@ module Sequel
       #
       #   add_constraint(:valid_name, Sequel.like(:name, 'A%'))
       #   # ADD CONSTRAINT valid_name CHECK (name LIKE 'A%')
+      #   add_constraint({:name=>:valid_name, :deferrable=>true}, :num=>1..5)
+      #   # CONSTRAINT valid_name CHECK (name LIKE 'A%') DEFERRABLE INITIALLY DEFERRED
       def add_constraint(name, *args, &block)
-        @operations << {:op => :add_constraint, :name => name, :type => :check, :check => block || args}
+        opts = name.is_a?(Hash) ? name : {:name=>name}
+        @operations << opts.merge(:op=>:add_constraint, :type=>:check, :check=>block || args)
       end
 
       # Add a unique constraint to the given column(s)

data/lib/sequel/database/schema_methods.rb

@@ -156,6 +156,8 @@ module Sequel
     #
     # PostgreSQL specific options:
     # :unlogged :: Create the table as an unlogged table.
+    # :inherits :: Inherit from a different tables.  An array can be
+    #              specified to inherit from multiple tables.
     #
     # See <tt>Schema::Generator</tt> and the {"Schema Modification" guide}[link:files/doc/schema_modification_rdoc.html].
     def create_table(name, options=OPTS, &block)

data/lib/sequel/dataset/features.rb

@@ -117,6 +117,11 @@ module Sequel
       false
     end
 
+    # Whether the dataset supports REPLACE syntax, false by default.
+    def supports_replace?
+      false
+    end
+
     # Whether the RETURNING clause is supported for the given type of query.
     # +type+ can be :insert, :update, or :delete.
     def supports_returning?(type)

data/lib/sequel/extensions/pg_json_ops.rb

@@ -184,12 +184,6 @@ module Sequel
         a.is_a?(Array) || (defined?(PGArray) && a.is_a?(PGArray)) || (defined?(ArrayOp) && a.is_a?(ArrayOp))
       end
 
-      # Return a placeholder literal with the given str and args, wrapped
-      # in an SQL::StringExpression, used by operators that return text.
-      def text_op(str, args)
-        Sequel::SQL::StringExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(str, [self, args]))
-      end
-
       # Automatically wrap argument in a PGArray if it is a plain Array.
       # Requires that the pg_array extension has been loaded to work.
       def wrap_array(arg)

data/lib/sequel/model/associations.rb

@@ -1512,7 +1512,7 @@ module Sequel
           if o.is_a?(Hash)
             o = klass.new(o)
           elsif o.is_a?(Integer) || o.is_a?(String) || o.is_a?(Array)
-            o = klass[o]
+            o = klass.with_pk!(o)
           elsif !o.is_a?(klass)
             raise(Sequel::Error, "associated object #{o.inspect} not of correct type #{klass}")
           end

data/lib/sequel/plugins/instance_filters.rb

@@ -22,7 +22,7 @@ module Sequel
     #
     #   # Attempting to delete the object where the filter doesn't
     #   # match any rows raises an error.
-    #   i1.delete # raises Sequel::Error
+    #   i1.delete # raises Sequel::NoExistingObject
     #
     #   # The other object that represents the same row has no
     #   # instance filters, and can be updated normally.
@@ -108,6 +108,16 @@ module Sequel
         def _update_dataset
           apply_instance_filters(super)
         end
+
+        # Only use prepared statements for update and delete queries
+        # if there are no instance filters.
+        def use_prepared_statements_for?(type)
+          if (type == :update || type == :delete) && !instance_filters.empty?
+            false
+          else
+            super
+          end
+        end
       end
     end
   end

data/lib/sequel/plugins/pg_typecast_on_load.rb

@@ -21,8 +21,9 @@ module Sequel
     #   Album.add_pg_typecast_on_load_columns :aliases, :config
     #
     # This plugin only handles values that the adapter returns as strings.  If
-    # the adapter returns a value other than a string for a column, that value
-    # will be used directly without typecasting.
+    # the adapter returns a value other than a string, this plugin will have no
+    # effect.  You may be able to use the regular typecast_on_load plugin to
+    # handle those cases.
     module PgTypecastOnLoad
       # Call add_pg_typecast_on_load_columns on the passed column arguments.
       def self.configure(model, *columns)

data/lib/sequel/plugins/prepared_statements.rb

@@ -1,4 +1,16 @@
 module Sequel
+  class Model
+    module InstanceMethods
+      # Whether prepared statements should be used for the given type of query
+      # (:insert, :insert_select, :refresh, :update, or :delete).  True by default,
+      # can be overridden in other plugins to disallow prepared statements for
+      # specific types of queries.
+      def use_prepared_statements_for?(type)
+        true
+      end
+    end
+  end
+
   module Plugins
     # The prepared_statements plugin modifies the model to use prepared statements for
     # instance level deletes and saves, as well as class level lookups by
@@ -11,9 +23,6 @@ module Sequel
     # of prepared statements that can be created, unless you tightly control how your
     # model instances are saved.
     # 
-    # This plugin does not work correctly with the instance filters plugin
-    # or the update_primary_key plugin.
-    # 
     # Usage:
     #
     #   # Make all model subclasses use prepared statements  (called before loading subclasses)
@@ -133,30 +142,50 @@ module Sequel
 
         # Use a prepared statement to delete the row.
         def _delete_without_checking
-          model.send(:prepared_delete).call(pk_hash)
+          if use_prepared_statements_for?(:delete)
+            model.send(:prepared_delete).call(pk_hash)
+          else
+            super
+          end
         end
 
         # Use a prepared statement to insert the values into the model's dataset.
         def _insert_raw(ds)
-          model.send(:prepared_insert, @values.keys).call(@values)
+          if use_prepared_statements_for?(:insert)
+            model.send(:prepared_insert, @values.keys).call(@values)
+          else
+            super
+          end
         end
 
         # Use a prepared statement to insert the values into the model's dataset
         # and return the new column values.
         def _insert_select_raw(ds)
-          if ps = model.send(:prepared_insert_select, @values.keys)
-            ps.call(@values)
+          if use_prepared_statements_for?(:insert_select)
+            if ps = model.send(:prepared_insert_select, @values.keys)
+              ps.call(@values)
+            end
+          else
+            super
           end
         end
 
         # Use a prepared statement to refresh this model's column values.
         def _refresh_get(ds)
-          model.send(:prepared_refresh).call(pk_hash)
+          if use_prepared_statements_for?(:refresh)
+            model.send(:prepared_refresh).call(pk_hash)
+          else
+            super
+          end
         end
 
         # Use a prepared statement to update this model's columns in the database.
         def _update_without_checking(columns)
-          model.send(:prepared_update, columns.keys).call(columns.merge(pk_hash))
+          if use_prepared_statements_for?(:update)
+            model.send(:prepared_update, columns.keys).call(columns.merge(pk_hash))
+          else
+            super
+          end
         end
       end
     end

data/lib/sequel/plugins/update_primary_key.rb

@@ -54,6 +54,16 @@ module Sequel
             associations.delete(k) if model.association_reflection(k)[:type] != :many_to_one
           end
         end
+
+        # Do not use prepared statements for update queries, since they don't work
+        # in the case where the primary key has changed.
+        def use_prepared_statements_for?(type)
+          if type == :update
+            false
+          else
+            super
+          end
+        end
       end
     end
   end

data/lib/sequel/sql.rb

@@ -1624,7 +1624,7 @@ module Sequel
               fun_args = ::Kernel.Array(opts[:*] ? WILDCARD : opts[:args])
               WindowFunction.new(Function.new(m, *fun_args), Window.new(opts))
             else
-              raise Error, 'unsupported VirtualRow method argument used with block'
+              Kernel.raise(Error, 'unsupported VirtualRow method argument used with block')
             end
           end
         elsif args.empty?

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 0
+  MINOR = 1
   # 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

@@ -1070,27 +1070,6 @@ describe "MySQL::Dataset#replace" do
     @d.replace({})
     @d.all.should == [{:id=>1, :value=>2}]
   end
-
-  specify "should use support arrays, datasets, and multiple values" do
-    @d.replace([1, 2])
-    @d.all.should == [{:id=>1, :value=>2}]
-    @d.replace(1, 2)
-    @d.all.should == [{:id=>1, :value=>2}]
-    @d.replace(@d)
-    @d.all.should == [{:id=>1, :value=>2}]
-  end
-
-  specify "should create a record if the condition is not met" do
-    @d.replace(:id => 111, :value => 333)
-    @d.all.should == [{:id => 111, :value => 333}]
-  end
-
-  specify "should update a record if the condition is met" do
-    @d << {:id => 111}
-    @d.all.should == [{:id => 111, :value => nil}]
-    @d.replace(:id => 111, :value => 333)
-    @d.all.should == [{:id => 111, :value => 333}]
-  end
 end
 
 describe "MySQL::Dataset#complex_expression_sql" do
@@ -1303,5 +1282,5 @@ if DB.adapter_scheme == :mysql2
     specify "should correctly handle early returning when streaming results" do
       3.times{@ds.each{|r| break r[:a]}.should == 0}
     end
-  end if false
+  end
 end

data/spec/adapters/postgres_spec.rb

@@ -17,8 +17,7 @@ describe "PostgreSQL", '#create_table' do
     DB.sqls.clear
   end
   after do
-    @db.drop_table?(:tmp_dolls)
-    @db.drop_table?(:unlogged_dolls)
+    @db.drop_table?(:tmp_dolls, :unlogged_dolls)
   end
 
   specify "should create a temporary table" do
@@ -35,6 +34,27 @@ describe "PostgreSQL", '#create_table' do
     end
   end
 
+  specify "should create a table inheriting from another table" do
+    @db.create_table(:unlogged_dolls){text :name}
+    @db.create_table(:tmp_dolls, :inherits=>:unlogged_dolls){}
+    @db[:tmp_dolls].insert('a')
+    @db[:unlogged_dolls].all.should == [{:name=>'a'}]
+  end
+
+  specify "should create a table inheriting from multiple tables" do
+    begin
+      @db.create_table(:unlogged_dolls){text :name}
+      @db.create_table(:tmp_dolls){text :bar}
+      @db.create_table!(:items, :inherits=>[:unlogged_dolls, :tmp_dolls]){text :foo}
+      @db[:items].insert(:name=>'a', :bar=>'b', :foo=>'c')
+      @db[:unlogged_dolls].all.should == [{:name=>'a'}]
+      @db[:tmp_dolls].all.should == [{:bar=>'b'}]
+      @db[:items].all.should == [{:name=>'a', :bar=>'b', :foo=>'c'}]
+    ensure
+      @db.drop_table?(:items)
+    end
+  end
+
   specify "should not allow to pass both :temp and :unlogged" do
     proc do
       @db.create_table(:temp_unlogged_dolls, :temp => true, :unlogged => true){text :name}
@@ -232,6 +252,43 @@ describe "A PostgreSQL dataset" do
     proc{@db[:atest].insert(2)}.should raise_error(Sequel::Postgres::ExclusionConstraintViolation)
     @db.alter_table(:atest){drop_constraint 'atest_ex'}
   end if DB.server_version >= 90000
+  
+  specify "should support deferrable exclusion constraints" do
+    @db.create_table!(:atest){Integer :t; exclude [[Sequel.desc(:t, :nulls=>:last), '=']], :using=>:btree, :where=>proc{t > 0}, :deferrable => true}
+    proc do 
+      @db.transaction do
+        @db[:atest].insert(2)
+        proc{@db[:atest].insert(2)}.should_not raise_error
+      end
+    end.should raise_error(Sequel::Postgres::ExclusionConstraintViolation)
+  end if DB.server_version >= 90000
+
+  specify "should support Database#error_info for getting info hash on the given error" do
+    @db.create_table!(:atest){Integer :t; Integer :t2, :null=>false, :default=>1; constraint :f, :t=>0}
+    begin
+      @db[:atest].insert(1)
+    rescue => e
+    end
+    e.should_not be_nil
+    info = @db.error_info(e)
+    info[:schema].should == 'public'
+    info[:table].should == 'atest'
+    info[:constraint].should == 'f'
+    info[:column].should be_nil
+    info[:type].should be_nil
+
+    begin
+      @db[:atest].insert(0, nil)
+    rescue => e
+    end
+    e.should_not be_nil
+    info = @db.error_info(e.wrapped_exception)
+    info[:schema].should == 'public'
+    info[:table].should == 'atest'
+    info[:constraint].should be_nil
+    info[:column].should == 't2'
+    info[:type].should be_nil
+  end if DB.server_version >= 90300 && DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && Object.const_defined?(:PG) && ::PG.const_defined?(:Constants) && ::PG::Constants.const_defined?(:PG_DIAG_SCHEMA_NAME)
 
   specify "should support Database#do for executing anonymous code blocks" do
     @db.drop_table?(:btest)
@@ -255,6 +312,19 @@ describe "A PostgreSQL dataset" do
     proc{@db.alter_table(:atest){validate_constraint :atest_fk}}.should_not raise_error
   end if DB.server_version >= 90200
 
+  specify "should support adding check constarints that are not yet valid, and validating them later" do
+    @db.create_table!(:atest){Integer :a}
+    @db[:atest].insert(5)
+    @db.alter_table(:atest){add_constraint({:name=>:atest_check, :not_valid=>true}){a >= 10}}
+    @db[:atest].insert(10)
+    proc{@db[:atest].insert(6)}.should raise_error(Sequel::DatabaseError)
+
+    proc{@db.alter_table(:atest){validate_constraint :atest_check}}.should raise_error(Sequel::DatabaseError)
+    @db[:atest].where{a < 10}.update(:a=>Sequel.+(:a, 10))
+    @db.alter_table(:atest){validate_constraint :atest_check}
+    proc{@db.alter_table(:atest){validate_constraint :atest_check}}.should_not raise_error
+  end if DB.server_version >= 90200
+
   specify "should support :using when altering a column's type" do
     @db.create_table!(:atest){Integer :t}
     @db[:atest].insert(1262304000)
@@ -927,6 +997,13 @@ describe "Postgres::Database schema qualified tables" do
     @db.table_exists?(:schema_test__schema_test).should == true
   end
 
+  specify "should be able to add and drop indexes in a schema" do
+    @db.create_table(:schema_test__schema_test){Integer :i, :index=>true}
+    @db.indexes(:schema_test__schema_test).keys.should == [:schema_test_schema_test_i_index]
+    @db.drop_index :schema_test__schema_test, :i
+    @db.indexes(:schema_test__schema_test).keys.should == []
+  end
+
   specify "should be able to get primary keys for tables in a given schema" do
     @db.create_table(:schema_test__schema_test){primary_key :i}
     @db.primary_key(:schema_test__schema_test).should == 'i'