sequel 4.35.0 → 4.36.0

data/spec/extensions/connection_validator_spec.rb

@@ -78,6 +78,13 @@ connection_validator_specs = shared_description do
       c3.wont_be_same_as(c2)
     end
 
+    it "should not leak connection references during disconnect" do
+      @db.synchronize{}
+      @db.pool.instance_variable_get(:@connection_timestamps).size.must_equal 1
+      @db.disconnect
+      @db.pool.instance_variable_get(:@connection_timestamps).size.must_equal 0
+    end
+
     it "should not leak connection references" do
       c1 = @db.synchronize do |c|
         @db.pool.instance_variable_get(:@connection_timestamps).must_equal({})

data/spec/extensions/constraint_validations_plugin_spec.rb

@@ -185,6 +185,20 @@ describe "Sequel::Plugins::ConstraintValidations" do
     @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/\Afoo\z/i}]])
   end
 
+  it "should handle operator validation" do
+    [[:str_lt, :<], [:str_lte, :<=], [:str_gt, :>], [:str_gte, :>=]].each do |vt, op|
+      model_class(:validation_type=>vt.to_s, :argument=>'a').constraint_validations.must_equal [[:validates_operator, op, 'a', :name]]
+      @c.constraint_validation_reflections.must_equal(:name=>[[:operator, {:operator=>op, :argument=>'a'}]])
+      @c = @c.db.constraint_validations = nil
+    end
+
+    [[:int_lt, :<], [:int_lte, :<=], [:int_gt, :>], [:int_gte, :>=]].each do |vt, op|
+      model_class(:validation_type=>vt.to_s, :argument=>'1').constraint_validations.must_equal [[:validates_operator, op, 1, :name]]
+      @c.constraint_validation_reflections.must_equal(:name=>[[:operator, {:operator=>op, :argument=>1}]])
+      @c = @c.db.constraint_validations = nil
+    end
+  end
+
   it "should handle like validation with % metacharacter" do
     model_class(:validation_type=>'like', :argument=>'%foo%').constraint_validations.must_equal [[:validates_format, /\A.*foo.*\z/, :name]]
     @c.constraint_validation_reflections.must_equal(:name=>[[:format, {:argument=>/\A.*foo.*\z/}]])

data/spec/extensions/constraint_validations_spec.rb

@@ -252,6 +252,62 @@ describe "constraint_validations extension" do
     sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (UPPER(name) LIKE UPPER('foo%') ESCAPE '\\')))"]
   end
 
+  it "should support :operator :< constraint validation with string" do
+    @db.create_table(:foo){String :name; validate{operator :<, 'a', :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"str_lt", :column=>"name", :table=>"foo", :argument=>'a')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name < 'a')))"]
+  end
+
+  it "should support :operator :<= constraint validation with string" do
+    @db.create_table(:foo){String :name; validate{operator :<=, 'a', :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"str_lte", :column=>"name", :table=>"foo", :argument=>'a')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name <= 'a')))"]
+  end
+
+  it "should support :operator :> constraint validation with string" do
+    @db.create_table(:foo){String :name; validate{operator :>, 'a', :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"str_gt", :column=>"name", :table=>"foo", :argument=>'a')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name > 'a')))"]
+  end
+
+  it "should support :operator :>= constraint validation with string" do
+    @db.create_table(:foo){String :name; validate{operator :>=, 'a', :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"str_gte", :column=>"name", :table=>"foo", :argument=>'a')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NOT NULL) AND (name >= 'a')))"]
+  end
+
+  it "should support :operator :< constraint validation with integer" do
+    @db.create_table(:foo){Integer :name; validate{operator :<, 2, :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"int_lt", :column=>"name", :table=>"foo", :argument=>'2')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name integer, CHECK ((name IS NOT NULL) AND (name < 2)))"]
+  end
+
+  it "should support :operator :<= constraint validation with integer" do
+    @db.create_table(:foo){Integer :name; validate{operator :<=, 2, :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"int_lte", :column=>"name", :table=>"foo", :argument=>'2')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name integer, CHECK ((name IS NOT NULL) AND (name <= 2)))"]
+  end
+
+  it "should support :operator :> constraint validation with integer" do
+    @db.create_table(:foo){Integer :name; validate{operator :>, 2, :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"int_gt", :column=>"name", :table=>"foo", :argument=>'2')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name integer, CHECK ((name IS NOT NULL) AND (name > 2)))"]
+  end
+
+  it "should support :operator :>= constraint validation with integer" do
+    @db.create_table(:foo){Integer :name; validate{operator :>=, 2, :name}}
+    sqls = @db.sqls
+    parse_insert(sqls.slice!(1)).must_equal(:validation_type=>"int_gte", :column=>"name", :table=>"foo", :argument=>'2')
+    sqls.must_equal ["BEGIN", "COMMIT", "CREATE TABLE foo (name integer, CHECK ((name IS NOT NULL) AND (name >= 2)))"]
+  end
+
   it "should support :unique constraint validation" do
     @db.create_table(:foo){String :name; validate{unique :name}}
     sqls = @db.sqls
@@ -297,6 +353,14 @@ describe "constraint_validations extension" do
     proc{@db.create_table(:foo){String :name; validate{includes 'a', :name}}}.must_raise(Sequel::Error)
   end
 
+  it "should raise an error if attempting attempting to process an operator validation with an unsupported operator" do
+    proc{@db.alter_table(:foo){String :name;  validate{operator :===, 'a', :name}}}.must_raise(Sequel::Error)
+  end
+
+  it "should raise an error if attempting attempting to process an operator validation with an unsupported argument" do
+    proc{@db.alter_table(:foo){String :name;  validate{operator :>, [], :name}}}.must_raise(Sequel::Error)
+  end
+
   it "should raise an error if attempting to drop a constraint validation in a create_table generator" do
     proc{@db.create_table(:foo){String :name; validate{drop :foo}}}.must_raise(Sequel::Error)
   end

data/spec/extensions/string_agg_spec.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+
+describe "string_agg extension" do
+  dbf = lambda do |db_type|
+    db = Sequel.connect("mock://#{db_type}")
+    db.extension :string_agg
+    db
+  end
+
+  before(:all) do
+    Sequel.extension :string_agg
+  end
+  before do
+    @sa1 = Sequel.string_agg(:c)
+    @sa2 = Sequel.string_agg(:c, '-')
+    @sa3 = Sequel.string_agg(:c, '-').order(:o)
+    @sa4 = Sequel.string_agg(:c).order(:o).distinct
+  end
+
+  it "should use existing method" do
+    db = Sequel.mock
+    db.extend_datasets do
+      def string_agg_sql_append(sql, sa)
+        sql << "sa(#{sa.expr})"
+      end
+    end
+    db.extension :string_agg
+    db.literal(Sequel.string_agg(:c)).must_equal "sa(c)"
+  end
+
+  it "should correctly literalize on Postgres" do
+    db = dbf.call(:postgres)
+    db.literal(@sa1).must_equal "string_agg(c, ',')"
+    db.literal(@sa2).must_equal "string_agg(c, '-')"
+    db.literal(@sa3).must_equal "string_agg(c, '-' ORDER BY o)"
+    db.literal(@sa4).must_equal "string_agg(DISTINCT c, ',' ORDER BY o)"
+  end
+
+  it "should correctly literalize on SQLAnywhere" do
+    db = dbf.call(:sqlanywhere)
+    db.literal(@sa1).must_equal "list(c, ',')"
+    db.literal(@sa2).must_equal "list(c, '-')"
+    db.literal(@sa3).must_equal "list(c, '-' ORDER BY o)"
+    db.literal(@sa4).must_equal "list(DISTINCT c, ',' ORDER BY o)"
+  end
+
+  it "should correctly literalize on MySQL, H2, HSQLDB, CUBRID" do
+    [:mysql, :h2, :hsqldb, :cubrid].each do |type|
+      db = dbf.call(type)
+      db.meta_def(:database_type){type}
+      db.literal(@sa1).must_equal "GROUP_CONCAT(c SEPARATOR ',')"
+      db.literal(@sa2).must_equal "GROUP_CONCAT(c SEPARATOR '-')"
+      db.literal(@sa3).must_equal "GROUP_CONCAT(c ORDER BY o SEPARATOR '-')"
+      db.literal(@sa4).must_equal "GROUP_CONCAT(DISTINCT c ORDER BY o SEPARATOR ',')"
+    end
+  end
+
+  it "should correctly literalize on Oracle and DB2" do
+    [:oracle, :db2].each do |type|
+      db = dbf.call(type)
+      db.literal(@sa1).must_equal "listagg(c, ',') WITHIN GROUP (ORDER BY 1)"
+      db.literal(@sa2).must_equal "listagg(c, '-') WITHIN GROUP (ORDER BY 1)"
+      db.literal(@sa3).must_equal "listagg(c, '-') WITHIN GROUP (ORDER BY o)"
+      proc{db.literal(@sa4)}.must_raise Sequel::Error
+    end
+  end
+
+  it "should handle order without arguments" do
+    db = dbf.call(:postgres)
+    db.literal(@sa1.order).must_equal "string_agg(c, ',')"
+  end
+
+  it "should handle operations on object" do
+    db = dbf.call(:postgres)
+    db.literal(@sa1 + 'b').must_equal "(string_agg(c, ',') || 'b')"
+    db.literal(@sa1.like('b')).must_equal "(string_agg(c, ',') LIKE 'b' ESCAPE '\\')"
+    db.literal(@sa1 < 'b').must_equal "(string_agg(c, ',') < 'b')"
+    db.literal(@sa1.as(:b)).must_equal "string_agg(c, ',') AS b"
+    db.literal(@sa1.cast(:b)).must_equal "CAST(string_agg(c, ',') AS b)"
+    db.literal(@sa1.desc).must_equal "string_agg(c, ',') DESC"
+    db.literal(@sa1 =~ /a/).must_equal "(string_agg(c, ',') ~ 'a')"
+    db.literal(@sa1.sql_subscript(1)).must_equal "string_agg(c, ',')[1]"
+  end
+end

data/spec/extensions/validation_helpers_spec.rb

@@ -546,6 +546,8 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @m.errors.full_messages.must_equal ['value is not > 3']
     @m.value = 3
     @m.wont_be :valid?
+    @m.value = nil
+    @m.wont_be :valid?
     @m.value = 4
     @m.must_be :valid?
   end

data/spec/integration/plugin_test.rb

@@ -2014,17 +2014,20 @@ describe "Sequel::Plugins::ConstraintValidations" do
       includes %w'abc def', :inc, opts.merge(:name=>:i)
       unique :uniq, opts.merge(:name=>:u)
       max_length 6, :minlen, opts.merge(:name=>:maxl2)
+      operator :<, 'm', :exactlen, opts.merge(:name=>:lt)
+      operator :>=, 5, :num, opts.merge(:name=>:gte)
     end
-    @valid_row = {:pre=>'a', :exactlen=>'12345', :minlen=>'12345', :maxlen=>'12345', :lenrange=>'1234', :lik=>'fooabc', :ilik=>'FooABC', :inc=>'abc', :uniq=>'u'}
+    @valid_row = {:pre=>'a', :exactlen=>'12345', :minlen=>'12345', :maxlen=>'12345', :lenrange=>'1234', :lik=>'fooabc', :ilik=>'FooABC', :inc=>'abc', :uniq=>'u', :num=>5}
     @violations = [
       [:pre, [nil, '', ' ']],
-      [:exactlen, [nil, '', '1234', '123456']],
+      [:exactlen, [nil, '', '1234', '123456', 'n1234']],
       [:minlen, [nil, '', '1234']],
       [:maxlen, [nil, '123456']],
       [:lenrange, [nil, '', '12', '123456']],
       [:lik, [nil, '', 'fo', 'fotabc', 'FOOABC']],
       [:ilik, [nil, '', 'fo', 'fotabc']],
       [:inc, [nil, '', 'ab', 'abcd']],
+      [:num, [nil, 3, 4]],
     ]
 
     if @regexp
@@ -2101,6 +2104,7 @@ describe "Sequel::Plugins::ConstraintValidations" do
           String :ilik
           String :inc
           String :uniq, :null=>false
+          Integer :num
           validate(&validate_block)
         end
       end
@@ -2146,6 +2150,7 @@ describe "Sequel::Plugins::ConstraintValidations" do
           if regexp
             add_column :form, String
           end
+          add_column :num, Integer
           validate(&validate_block)
         end
       end
@@ -2260,3 +2265,33 @@ describe "date_arithmetic extension" do
     @check.call(:date_sub, @dt, @h2, @s2)
   end
 end
+
+describe "string_agg extension" do
+  before(:all) do
+    @db = DB
+    @db.extension(:string_agg)
+    @db.create_table!(:string_agg_test) do
+      Integer :id
+      String :s
+      Integer :o
+    end
+    @db[:string_agg_test].import([:id, :s, :o], [[1, 'a', 3], [1, 'a', 3], [1, 'b', 5], [1, 'c', 4], [2, 'aa', 2], [2, 'bb', 1]])
+    @ds = @db[:string_agg_test].select_group(:id).order(:id)
+  end
+  after(:all) do
+    @db.drop_table?(:string_agg_test)
+  end
+
+  cspecify "should have string_agg return aggregated concatenation", :mssql, :sqlite, :derby do
+    h = @ds.select_append(Sequel.string_agg(:s).as(:v)).to_hash(:id, :v)
+    h[1].must_match(/\A[abc],[abc],[abc],[abc]\z/)
+    h[2].must_match(/\A(aa|bb),(aa|bb)\z/)
+
+    @ds.select_append(Sequel.string_agg(:s).order(:o).as(:v)).map([:id, :v]).must_equal [[1, 'a,a,c,b'], [2, 'bb,aa']]
+    @ds.select_append(Sequel.string_agg(:s, '-').order(:o).as(:v)).map([:id, :v]).must_equal [[1, 'a-a-c-b'], [2, 'bb-aa']]
+  end
+
+  cspecify "should have string_agg return aggregated concatenation for distinct values", :mssql, :sqlite, :oracle, :db2, :derby do
+    @ds.select_group(:id).select_append(Sequel.string_agg(:s).order(:s).distinct.as(:v)).map([:id, :v]).must_equal [[1, 'a,b,c'], [2, 'aa,bb']]
+  end
+end

data/spec/model/association_reflection_spec.rb

@@ -20,6 +20,16 @@ describe Sequel::Model::Associations::AssociationReflection, "#associated_class"
     @c.association_reflection(:c).keys.wont_include(:class)
     @c.association_reflection(:c).associated_class.must_equal ParParent
   end
+
+  it "should respect :class_namespace option for specifying the namespace" do
+    class ::ParParent
+      class ParParent < Sequel::Model; end
+    end
+    ParParent.many_to_one :par_parent, :class=>'ParParent'
+    ParParent.association_reflection(:par_parent).associated_class.must_equal ParParent
+    ParParent.many_to_one :par_parent, :class=>'ParParent', :class_namespace=>'ParParent'
+    ParParent.association_reflection(:par_parent).associated_class.must_equal ParParent::ParParent
+  end
 end
 
 describe Sequel::Model::Associations::AssociationReflection, "#primary_key" do

data/spec/model/model_spec.rb

@@ -54,6 +54,40 @@ describe "Sequel::Model()" do
     c.dataset.must_equal ds
   end
 
+  it "should be callable on Sequel::Model" do
+    ds = @db[:blah]
+    c = Sequel::Model::Model(ds)
+    c.superclass.must_equal Sequel::Model
+    c.dataset.must_equal ds
+  end
+
+  it "should be callable on subclasses of Sequel::Model" do
+    ds = @db[:blah]
+    c = Class.new(Sequel::Model)
+    sc = c::Model(ds)
+    sc.superclass.must_equal c
+    sc.dataset.must_equal ds
+  end
+
+  it "should be callable on other modules if def_Model is used" do
+    m = Module.new
+    Sequel::Model.def_Model(m)
+    ds = @db[:blah]
+    c = m::Model(ds)
+    c.superclass.must_equal Sequel::Model
+    c.dataset.must_equal ds
+  end
+
+  it "should be callable using model subclasses on other modules if def_Model is used" do
+    m = Module.new
+    c = Class.new(Sequel::Model)
+    c.def_Model(m)
+    ds = @db[:blah]
+    sc = m::Model(ds)
+    sc.superclass.must_equal c
+    sc.dataset.must_equal ds
+  end
+
   it "should return a model subclass associated to the given database if given a database" do
     db = Sequel.mock
     c = Sequel::Model(db)
@@ -122,6 +156,21 @@ describe "Sequel::Model()" do
         class ::Album < Sequel::Model(@db[Sequel.identifier(:table)]); end
       end.must_raise TypeError
     end
+
+    it "should use separate cache and cache settings for subclasses" do
+      c = Class.new(Sequel::Model)
+      c.cache_anonymous_models.must_equal true
+      class ::Album < c::Model(:table); end
+      class ::Album < c::Model(:table); end
+
+      c1 = c::Model(:t1)
+      c1.must_equal c::Model(:t1)
+      c1.wont_equal Sequel::Model(:t1)
+
+      c.cache_anonymous_models = false
+      Sequel::Model.cache_anonymous_models.must_equal true
+      c1.wont_equal c::Model(:t1)
+    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 4.35.0
+  version: 4.36.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-01 00:00:00.000000000 Z
+date: 2016-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -236,6 +236,7 @@ extra_rdoc_files:
 - doc/release_notes/4.33.0.txt
 - doc/release_notes/4.34.0.txt
 - doc/release_notes/4.35.0.txt
+- doc/release_notes/4.36.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -360,6 +361,7 @@ files:
 - doc/release_notes/4.33.0.txt
 - doc/release_notes/4.34.0.txt
 - doc/release_notes/4.35.0.txt
+- doc/release_notes/4.36.0.txt
 - doc/release_notes/4.4.0.txt
 - doc/release_notes/4.5.0.txt
 - doc/release_notes/4.6.0.txt
@@ -475,6 +477,7 @@ files:
 - lib/sequel/extensions/arbitrary_servers.rb
 - lib/sequel/extensions/blank.rb
 - lib/sequel/extensions/columns_introspection.rb
+- lib/sequel/extensions/connection_expiration.rb
 - lib/sequel/extensions/connection_validator.rb
 - lib/sequel/extensions/constraint_validations.rb
 - lib/sequel/extensions/core_extensions.rb
@@ -531,6 +534,7 @@ files:
 - lib/sequel/extensions/split_array_nil.rb
 - lib/sequel/extensions/sql_comments.rb
 - lib/sequel/extensions/sql_expr.rb
+- lib/sequel/extensions/string_agg.rb
 - lib/sequel/extensions/string_date_time.rb
 - lib/sequel/extensions/thread_local_timezones.rb
 - lib/sequel/extensions/to_dot.rb
@@ -671,6 +675,7 @@ files:
 - spec/extensions/column_select_spec.rb
 - spec/extensions/columns_introspection_spec.rb
 - spec/extensions/composition_spec.rb
+- spec/extensions/connection_expiration_spec.rb
 - spec/extensions/connection_validator_spec.rb
 - spec/extensions/constraint_validations_plugin_spec.rb
 - spec/extensions/constraint_validations_spec.rb
@@ -767,6 +772,7 @@ files:
 - spec/extensions/sql_comments_spec.rb
 - spec/extensions/sql_expr_spec.rb
 - spec/extensions/static_cache_spec.rb
+- spec/extensions/string_agg_spec.rb
 - spec/extensions/string_date_time_spec.rb
 - spec/extensions/string_stripper_spec.rb
 - spec/extensions/subclasses_spec.rb