sequel 3.24.0 → 3.25.0

data/lib/sequel/model/base.rb

@@ -326,9 +326,9 @@ module Sequel
         unless @plugins.include?(m)
           @plugins << m
           m.apply(self, *args, &blk) if m.respond_to?(:apply)
-          include(m::InstanceMethods) if m.const_defined?("InstanceMethods")
-          extend(m::ClassMethods)if m.const_defined?("ClassMethods")
-          if m.const_defined?("DatasetMethods")
+          include(m::InstanceMethods) if plugin_module_defined?(m, :InstanceMethods)
+          extend(m::ClassMethods)if plugin_module_defined?(m, :ClassMethods)
+          if plugin_module_defined?(m, :DatasetMethods)
             dataset.extend(m::DatasetMethods) if @dataset
             dataset_method_modules << m::DatasetMethods
             meths = m::DatasetMethods.public_instance_methods.reject{|x| NORMAL_METHOD_NAME_REGEXP !~ x.to_s}
@@ -337,7 +337,7 @@ module Sequel
         end
         m.configure(self, *args, &blk) if m.respond_to?(:configure)
       end
-  
+
       # Returns primary key attribute hash.  If using a composite primary key
       # value such be an array with values for each primary key in the correct
       # order.  For a standard primary key, value should be an object with a
@@ -419,7 +419,7 @@ module Sequel
       def set_dataset(ds, opts={})
         inherited = opts[:inherited]
         @dataset = case ds
-        when Symbol
+        when Symbol, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression
           @simple_table = db.literal(ds)
           db[ds]
         when Dataset
@@ -427,7 +427,7 @@ module Sequel
           @db = ds.db
           ds
         else
-          raise(Error, "Model.set_dataset takes a Symbol or a Sequel::Dataset")
+          raise(Error, "Model.set_dataset takes one of the following classes as an argument: Symbol, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression, Dataset")
         end
         @dataset.row_proc = Proc.new{|r| load(r)}
         @require_modification = Sequel::Model.require_modification.nil? ? @dataset.provides_accurate_rows_matched? : Sequel::Model.require_modification
@@ -658,6 +658,15 @@ module Sequel
         Sequel::Plugins.const_get(module_name)
       end
 
+      # Check if the plugin module +plugin+ defines the constant named by +submod+.
+      def plugin_module_defined?(plugin, submod)
+        if RUBY_VERSION >= '1.9'
+          plugin.const_defined?(submod, false)
+        else
+          plugin.const_defined?(submod)
+        end
+      end
+  
       # Find the row in the dataset that matches the primary key.  Uses
       # a static SQL optimization if the table and primary key are simple.
       def primary_key_lookup(pk)

data/lib/sequel/model/errors.rb

@@ -40,7 +40,7 @@ module Sequel
       def full_messages
         inject([]) do |m, kv| 
           att, errors = *kv
-          errors.each {|e| m << "#{Array(att).join(ATTRIBUTE_JOINER)} #{e}"}
+          errors.each {|e| m << (e.is_a?(LiteralString) ? e : "#{Array(att).join(ATTRIBUTE_JOINER)} #{e}")}
           m
         end
       end

data/lib/sequel/plugins/association_pks.rb

@@ -56,6 +56,7 @@ module Sequel
             _join_table_dataset(opts).filter(opts[:left_key]=>send(opts[:left_primary_key])).select_map(opts[:right_key])
           end
           def_association_pks_setter(opts) do |pks|
+            pks = convert_pk_array(opts, pks)
             checked_transaction do
               ds = _join_table_dataset(opts).filter(opts[:left_key]=>send(opts[:left_primary_key]))
               ds.exclude(opts[:right_key]=>pks).delete
@@ -74,6 +75,7 @@ module Sequel
             send(opts.dataset_method).select_map(opts.associated_class.primary_key)
           end
           def_association_pks_setter(opts) do |pks|
+            pks = convert_pk_array(opts, pks)
             checked_transaction do
               ds = send(opts.dataset_method)
               primary_key = opts.associated_class.primary_key
@@ -84,6 +86,20 @@ module Sequel
           end
         end
       end
+
+      module InstanceMethods
+        private
+
+        # If the associated class's primary key column type is integer,
+        # typecast all provided values to integer before using them.
+        def convert_pk_array(opts, pks)
+          if klass = opts.associated_class and sch = klass.db_schema and col = sch[klass.primary_key] and col[:type] == :integer
+            pks.map{|pk| model.db.typecast_value(:integer, pk)}
+          else
+            pks
+          end
+        end
+      end
     end
   end
 end

data/lib/sequel/plugins/update_primary_key.rb

@@ -1,6 +1,6 @@
 module Sequel
   module Plugins
-    # The update_primary_key plugin allows you to modify an objects
+    # The update_primary_key plugin allows you to modify an object's
     # primary key and then save the record.  Sequel does not work
     # correctly with primary key modifications by default.  Sequel
     # is designed to work with surrogate primary keys that never need to be

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 = 24
+  MINOR = 25
   # 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

@@ -998,6 +998,13 @@ if MYSQL_DB.adapter_scheme == :mysql or MYSQL_DB.adapter_scheme == :jdbc
       @d.row_proc = proc{|r| r.keys.each{|k| r[k] *= 2 if r[k].is_a?(Integer)}; r}
       @d.call_sproc(:select, :test_sproc, 3, 4).should == [{:id=>nil, :value=>2, :b=>6, :d => 8}]
     end
+
+    specify "should deal with nil values" do
+      MYSQL_DB.execute_ddl('CREATE PROCEDURE test_sproc(i INTEGER, v INTEGER) BEGIN INSERT INTO items VALUES (i, v); END')
+      MYSQL_DB[:items].delete
+      MYSQL_DB.call_sproc(:test_sproc, :args=>[1, nil])
+      MYSQL_DB[:items].all.should == [{:id=>1, :value=>nil}]
+    end
   end
 end
 

data/spec/core/database_spec.rb

@@ -478,233 +478,6 @@ describe "Database#test_connection" do
   end
 end
 
-class DummyDataset < Sequel::Dataset
-  def first
-    raise if @opts[:from] == [:a]
-    true
-  end
-end
-
-class DummyDatabase < Sequel::Database
-  attr_reader :sqls
-  
-  def execute(sql, opts={})
-    @sqls ||= []
-    @sqls << sql
-  end
-  
-  def transaction; yield; end
-
-  def dataset
-    DummyDataset.new(self)
-  end
-end
-
-describe "Database#create_table" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.create_table :test do
-      primary_key :id, :integer, :null => false
-      column :name, :text
-      index :name, :unique => true
-    end
-    @db.sqls.should == [
-      'CREATE TABLE test (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name text)',
-      'CREATE UNIQUE INDEX test_name_index ON test (name)'
-    ]
-  end
-  
-  specify "should create a temporary table" do
-    @db.create_table :test_tmp, :temp => true do
-      primary_key :id, :integer, :null => false
-      column :name, :text
-      index :name, :unique => true
-    end
-    
-    @db.sqls.should == [
-      'CREATE TEMPORARY TABLE test_tmp (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name text)',
-      'CREATE UNIQUE INDEX test_tmp_name_index ON test_tmp (name)'
-    ]
-  end
-
-  specify "should not use default schema when creating a temporary table" do
-    @db.default_schema = :foo
-    @db.create_table :test_tmp, :temp => true do
-      column :name, :text
-    end
-    @db.sqls.should == ['CREATE TEMPORARY TABLE test_tmp (name text)']
-  end
-end
-
-describe "Database#alter_table" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.alter_table :xyz do
-      add_column :aaa, :text, :null => false, :unique => true
-      drop_column :bbb
-      rename_column :ccc, :ddd
-      set_column_type :eee, :integer
-      set_column_default :hhh, 'abcd'
-      
-      add_index :fff, :unique => true
-      drop_index :ggg
-    end
-    
-    @db.sqls.should == [
-      'ALTER TABLE xyz ADD COLUMN aaa text NOT NULL UNIQUE',
-      'ALTER TABLE xyz DROP COLUMN bbb',
-      'ALTER TABLE xyz RENAME COLUMN ccc TO ddd',
-      'ALTER TABLE xyz ALTER COLUMN eee TYPE integer',
-      "ALTER TABLE xyz ALTER COLUMN hhh SET DEFAULT 'abcd'",
-      
-      'CREATE UNIQUE INDEX xyz_fff_index ON xyz (fff)',
-      'DROP INDEX xyz_ggg_index'
-    ]
-  end
-end
-
-describe "Database#add_column" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.add_column :test, :name, :text, :unique => true
-    @db.sqls.should == [
-      'ALTER TABLE test ADD COLUMN name text UNIQUE'
-    ]
-  end
-end
-
-describe "Database#drop_column" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.drop_column :test, :name
-    @db.sqls.should == [
-      'ALTER TABLE test DROP COLUMN name'
-    ]
-  end
-end
-
-describe "Database#rename_column" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.rename_column :test, :abc, :def
-    @db.sqls.should == [
-      'ALTER TABLE test RENAME COLUMN abc TO def'
-    ]
-  end
-end
-
-describe "Database#set_column_type" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.set_column_type :test, :name, :integer
-    @db.sqls.should == [
-      'ALTER TABLE test ALTER COLUMN name TYPE integer'
-    ]
-  end
-end
-
-describe "Database#set_column_default" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.set_column_default :test, :name, 'zyx'
-    @db.sqls.should == [
-      "ALTER TABLE test ALTER COLUMN name SET DEFAULT 'zyx'"
-    ]
-  end
-end
-
-describe "Database#add_index" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.add_index :test, :name, :unique => true
-    @db.sqls.should == [
-      'CREATE UNIQUE INDEX test_name_index ON test (name)'
-    ]
-  end
-  
-  specify "should accept multiple columns" do
-    @db.add_index :test, [:one, :two]
-    @db.sqls.should == [
-      'CREATE INDEX test_one_two_index ON test (one, two)'
-    ]
-  end
-end
-
-describe "Database#drop_index" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.drop_index :test, :name
-    @db.sqls.should == [
-      'DROP INDEX test_name_index'
-    ]
-  end
-  
-end
-
-class Dummy2Database < Sequel::Database
-  attr_reader :sql
-  def execute(sql); @sql = sql; end
-  def transaction; yield; end
-end
-
-describe "Database#drop_table" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.drop_table :test
-    @db.sqls.should == ['DROP TABLE test']
-  end
-  
-  specify "should accept multiple table names" do
-    @db.drop_table :a, :bb, :ccc
-    @db.sqls.should == [
-      'DROP TABLE a',
-      'DROP TABLE bb',
-      'DROP TABLE ccc'
-    ]
-  end
-end
-
-describe "Database#rename_table" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.rename_table :abc, :xyz
-    @db.sqls.should == ['ALTER TABLE abc RENAME TO xyz']
-  end
-end
-
 describe "Database#table_exists?" do
   specify "should try to select the first record from the table's dataset" do
     db2 = DummyDatabase.new
@@ -1282,74 +1055,6 @@ describe "Database#[]" do
   end
 end
 
-describe "Database#create_view" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL with raw SQL" do
-    @db.create_view :test, "SELECT * FROM xyz"
-    @db.sqls.should == ['CREATE VIEW test AS SELECT * FROM xyz']
-    @db.sqls.clear
-    @db.create_view :test.identifier, "SELECT * FROM xyz"
-    @db.sqls.should == ['CREATE VIEW test AS SELECT * FROM xyz']
-  end
-  
-  specify "should construct proper SQL with dataset" do
-    @db.create_view :test, @db[:items].select(:a, :b).order(:c)
-    @db.sqls.should == ['CREATE VIEW test AS SELECT a, b FROM items ORDER BY c']
-    @db.sqls.clear
-    @db.create_view :test.qualify(:sch), @db[:items].select(:a, :b).order(:c)
-    @db.sqls.should == ['CREATE VIEW sch.test AS SELECT a, b FROM items ORDER BY c']
-  end
-end
-
-describe "Database#create_or_replace_view" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL with raw SQL" do
-    @db.create_or_replace_view :test, "SELECT * FROM xyz"
-    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT * FROM xyz']
-    @db.sqls.clear
-    @db.create_or_replace_view :sch__test, "SELECT * FROM xyz"
-    @db.sqls.should == ['CREATE OR REPLACE VIEW sch.test AS SELECT * FROM xyz']
-  end
-
-  specify "should construct proper SQL with dataset" do
-    @db.create_or_replace_view :test, @db[:items].select(:a, :b).order(:c)
-    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT a, b FROM items ORDER BY c']
-    @db.sqls.clear
-    @db.create_or_replace_view :test.identifier, @db[:items].select(:a, :b).order(:c)
-    @db.sqls.should == ['CREATE OR REPLACE VIEW test AS SELECT a, b FROM items ORDER BY c']
-  end
-end
-
-describe "Database#drop_view" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should construct proper SQL" do
-    @db.drop_view :test
-    @db.drop_view :test.identifier
-    @db.drop_view :sch__test
-    @db.drop_view :test.qualify(:sch)
-    @db.sqls.should == ['DROP VIEW test', 'DROP VIEW test', 'DROP VIEW sch.test', 'DROP VIEW sch.test']
-  end
-end
-
-describe "Database#alter_table_sql" do
-  before do
-    @db = DummyDatabase.new
-  end
-  
-  specify "should raise error for an invalid op" do
-    proc {@db.send(:alter_table_sql, :mau, :op => :blah)}.should raise_error(Sequel::Error)
-  end
-end
-
 describe "Database#inspect" do
   before do
     @db = DummyDatabase.new

data/spec/core/dataset_spec.rb

@@ -759,6 +759,11 @@ describe "Dataset#exclude" do
       "SELECT * FROM test WHERE (region != 'Asia')"
   end
 
+  specify "should affect the having clause if having clause is already used" do
+    @dataset.group_and_count(:name).having{count > 2}.exclude{count > 5}.sql.should ==
+      "SELECT name, count(*) AS count FROM test GROUP BY name HAVING ((count > 2) AND (count <= 5))"
+  end
+
   specify "should take multiple conditions as a hash and express the logic correctly in SQL" do
     @dataset.exclude(:region => 'Asia', :name => 'Japan').select_sql.
       should match(Regexp.union(/WHERE \(\(region != 'Asia'\) OR \(name != 'Japan'\)\)/,
@@ -793,6 +798,28 @@ describe "Dataset#exclude" do
   end
 end
 
+describe "Dataset#exclude_where" do
+  before do
+    @dataset = Sequel::Dataset.new(nil).from(:test)
+  end
+
+  specify "should correctly negate the expression and add it to the where clause" do
+    @dataset.exclude_where(:region=>'Asia').sql.should == "SELECT * FROM test WHERE (region != 'Asia')"
+    @dataset.exclude_where(:region=>'Asia').exclude_where(:region=>'NA').sql.should == "SELECT * FROM test WHERE ((region != 'Asia') AND (region != 'NA'))"
+  end
+
+  specify "should affect the where clause even if having clause is already used" do
+    @dataset.group_and_count(:name).having{count > 2}.exclude_where(:region=>'Asia').sql.should ==
+      "SELECT name, count(*) AS count FROM test WHERE (region != 'Asia') GROUP BY name HAVING (count > 2)"
+  end
+end
+
+describe "Dataset#exclude_having" do
+  specify "should correctly negate the expression and add it to the having clause" do
+    Sequel::Dataset.new(nil).from(:test).exclude_having{count > 2}.exclude_having{count < 0}.sql.should == "SELECT * FROM test HAVING ((count <= 2) AND (count >= 0))"
+  end
+end
+
 describe "Dataset#invert" do
   before do
     @d = Sequel::Dataset.new(nil).from(:test)
@@ -897,7 +924,7 @@ describe "Dataset#group_by" do
       "SELECT * FROM test GROUP BY (type_id IS NULL)"
   end
 
-  specify "should ungroup when passed nil, empty, or no arguments" do
+  specify "should ungroup when passed nil or no arguments" do
     @dataset.group_by.select_sql.should ==
       "SELECT * FROM test"
     @dataset.group_by(nil).select_sql.should ==
@@ -915,6 +942,13 @@ describe "Dataset#group_by" do
     @dataset.group(:type_id=>nil).select_sql.should ==
       "SELECT * FROM test GROUP BY (type_id IS NULL)"
   end
+
+  specify "should take a virtual row block" do
+    @dataset.group{type_id > 1}.sql.should == "SELECT * FROM test GROUP BY (type_id > 1)"
+    @dataset.group_by{type_id > 1}.sql.should == "SELECT * FROM test GROUP BY (type_id > 1)"
+    @dataset.group{[type_id > 1, type_id < 2]}.sql.should == "SELECT * FROM test GROUP BY (type_id > 1), (type_id < 2)"
+    @dataset.group(:foo){type_id > 1}.sql.should == "SELECT * FROM test GROUP BY foo, (type_id > 1)"
+  end
 end
 
 describe "Dataset#as" do
@@ -1219,6 +1253,27 @@ describe "Dataset#select" do
   end
 end
 
+describe "Dataset#select_group" do
+  before do
+    @d = Sequel::Dataset.new(nil).from(:test)
+  end
+
+  specify "should set both SELECT and GROUP" do
+    @d.select_group(:name).sql.should == 'SELECT name FROM test GROUP BY name'
+    @d.select_group(:a, :b__c, :d___e).sql.should == 'SELECT a, b.c, d AS e FROM test GROUP BY a, b.c, d'
+  end
+
+  specify "should remove from both SELECT and GROUP if no arguments" do
+    @d.select_group(:name).select_group.sql.should == 'SELECT * FROM test'
+  end
+
+  specify "should accept virtual row blocks" do
+    @d.select_group{name}.sql.should == 'SELECT name FROM test GROUP BY name'
+    @d.select_group{[name, f(v).as(a)]}.sql.should == 'SELECT name, f(v) AS a FROM test GROUP BY name, f(v)'
+    @d.select_group(:name){f(v).as(a)}.sql.should == 'SELECT name, f(v) AS a FROM test GROUP BY name, f(v)'
+  end
+end
+  
 describe "Dataset#select_all" do
   before do
     @d = Sequel::Dataset.new(nil).from(:test)
@@ -1231,6 +1286,14 @@ describe "Dataset#select_all" do
   specify "should overrun the previous select option" do
     @d.select!(:a, :b, :c).select_all.sql.should == 'SELECT * FROM test'
   end
+
+  specify "should select all columns in a table if given an argument" do
+    @d.select_all(:test).sql.should == 'SELECT test.* FROM test'
+  end
+  
+  specify "should select all columns all tables if given a multiple arguments" do
+    @d.select_all(:test, :foo).sql.should == 'SELECT test.*, foo.* FROM test'
+  end
 end
 
 describe "Dataset#select_more" do
@@ -1774,6 +1837,12 @@ describe "Dataset#group_and_count" do
     @ds.group_and_count(:name.identifier.as(:n)).sql.should ==
       "SELECT name AS n, count(*) AS count FROM test GROUP BY name"
   end
+
+  specify "should take a virtual row block" do
+    @ds.group_and_count{(type_id > 1).as(t)}.sql.should == "SELECT (type_id > 1) AS t, count(*) AS count FROM test GROUP BY (type_id > 1)"
+    @ds.group_and_count{[(type_id > 1).as(t), type_id < 2]}.sql.should == "SELECT (type_id > 1) AS t, (type_id < 2), count(*) AS count FROM test GROUP BY (type_id > 1), (type_id < 2)"
+    @ds.group_and_count(:foo){type_id > 1}.sql.should == "SELECT foo, (type_id > 1), count(*) AS count FROM test GROUP BY foo, (type_id > 1)"
+  end
 end
 
 describe "Dataset#empty?" do

data/spec/core/expression_filters_spec.rb

@@ -452,6 +452,45 @@ describe "Blockless Ruby Filters" do
     e2 = ~:comment.like('%:hidden:%')
     e1.should == e2
   end
+
+  it "should support expression filter methods on Datasets" do
+    d = @d.select(:a)
+
+    @d.lit(d + 1).should == '((SELECT a FROM items) + 1)'
+    @d.lit(d - 1).should == '((SELECT a FROM items) - 1)'
+    @d.lit(d * 1).should == '((SELECT a FROM items) * 1)'
+    @d.lit(d / 1).should == '((SELECT a FROM items) / 1)'
+
+    @d.lit(d => 1).should == '((SELECT a FROM items) = 1)'
+    @d.lit(~{d => 1}).should == '((SELECT a FROM items) != 1)'
+    @d.lit(d > 1).should == '((SELECT a FROM items) > 1)'
+    @d.lit(d < 1).should == '((SELECT a FROM items) < 1)'
+    @d.lit(d >= 1).should == '((SELECT a FROM items) >= 1)'
+    @d.lit(d <= 1).should == '((SELECT a FROM items) <= 1)'
+
+    @d.lit(d.as(:b)).should == '(SELECT a FROM items) AS b'
+
+    @d.lit(d & :b).should == '((SELECT a FROM items) AND b)'
+    @d.lit(d | :b).should == '((SELECT a FROM items) OR b)'
+    @d.lit(~d).should == 'NOT (SELECT a FROM items)'
+
+    @d.lit(d.cast(Integer)).should == 'CAST((SELECT a FROM items) AS integer)'
+    @d.lit(d.cast_numeric).should == 'CAST((SELECT a FROM items) AS integer)'
+    @d.lit(d.cast_string).should == 'CAST((SELECT a FROM items) AS varchar(255))'
+    @d.lit(d.cast_numeric << :b).should == '(CAST((SELECT a FROM items) AS integer) << b)'
+    @d.lit(d.cast_string + :b).should == '(CAST((SELECT a FROM items) AS varchar(255)) || b)'
+
+    @d.lit(d.extract(:year)).should == 'extract(year FROM (SELECT a FROM items))'
+    @d.lit(d.sql_boolean & :b).should == '((SELECT a FROM items) AND b)'
+    @d.lit(d.sql_number << :b).should == '((SELECT a FROM items) << b)'
+    @d.lit(d.sql_string + :b).should == '((SELECT a FROM items) || b)'
+
+    @d.lit(d.asc).should == '(SELECT a FROM items) ASC'
+    @d.lit(d.desc).should == '(SELECT a FROM items) DESC'
+
+    @d.lit(d.like(:b)).should == '((SELECT a FROM items) LIKE b)'
+    @d.lit(d.ilike(:b)).should == '((SELECT a FROM items) ILIKE b)'
+  end
   
   if RUBY_VERSION < '1.9.0'
     it "should not allow inequality operations on true, false, or nil" do