sequel 4.39.0 → 4.40.0

data/spec/adapters/spec_helper.rb

@@ -15,6 +15,7 @@ begin
 rescue LoadError
 end
 
+Sequel.split_symbols = false if ENV['SEQUEL_NO_SPLIT_SYMBOLS']
 Sequel::Database.extension :duplicate_column_handler if ENV['SEQUEL_DUPLICATE_COLUMN_HANDLER']
 Sequel::Database.extension :columns_introspection if ENV['SEQUEL_COLUMNS_INTROSPECTION']
 Sequel::Model.cache_associations = false if ENV['SEQUEL_NO_CACHE_ASSOCIATIONS']

data/spec/adapters/sqlite_spec.rb

@@ -309,12 +309,12 @@ describe "An SQLite dataset" do
 end
 
 describe "An SQLite dataset AS clause" do
-  it "should use a string literal for :col___alias" do
-    DB.literal(:c___a).must_equal "`c` AS 'a'"
+  it "should use a string literal for Sequel[:col].as(:alias)" do
+    DB.literal(Sequel[:c].as(:a)).must_equal "`c` AS 'a'"
   end
 
-  it "should use a string literal for :table__col___alias" do
-    DB.literal(:t__c___a).must_equal "`t`.`c` AS 'a'"
+  it "should use a string literal for Sequel[:table][:col].as(:alias)" do
+    DB.literal(Sequel[:t][:c].as(:a)).must_equal "`t`.`c` AS 'a'"
   end
 
   it "should use a string literal for :column.as(:alias)" do
@@ -322,11 +322,11 @@ describe "An SQLite dataset AS clause" do
   end
 
   it "should use a string literal in the SELECT clause" do
-    DB[:t].select(:c___a).sql.must_equal "SELECT `c` AS 'a' FROM `t`"
+    DB[:t].select(Sequel[:c].as(:a)).sql.must_equal "SELECT `c` AS 'a' FROM `t`"
   end
 
   it "should use a string literal in the FROM clause" do
-    DB[:t___a].sql.must_equal "SELECT * FROM `t` AS 'a'"
+    DB[Sequel[:t].as(:a)].sql.must_equal "SELECT * FROM `t` AS 'a'"
   end
 
   it "should use a string literal in the JOIN clause" do

data/spec/core/dataset_spec.rb

@@ -5108,13 +5108,13 @@ describe "Dataset emulated complex expression operators" do
   it "should emulate >>" do
     @ds.literal(Sequel::SQL::NumericExpression.new(:>>, @n)).must_equal "x"
     @ds.literal(@n >> 1).must_equal "(x / power(2, 1))"
-    @ds.literal(@n >> 1 >> 2).must_equal "(x / power(2, 1) / power(2, 2))"
+    @ds.literal(@n >> 1 >> 2).must_equal "((x / power(2, 1)) / power(2, 2))"
   end
 
   it "should emulate <<" do
     @ds.literal(Sequel::SQL::NumericExpression.new(:<<, @n)).must_equal "x"
     @ds.literal(@n << 1).must_equal "(x * power(2, 1))"
-    @ds.literal(@n << 1 << 2).must_equal "(x * power(2, 1) * power(2, 2))"
+    @ds.literal(@n << 1 << 2).must_equal "((x * power(2, 1)) * power(2, 2))"
   end
 
   it "should emulate B~" do

data/spec/core/expression_filters_spec.rb

@@ -16,8 +16,26 @@ describe "Blockless Ruby Filters" do
     @d.l(:x).must_equal 'x'
   end
   
-  it "should support qualified columns" do
+  it "should support qualified columns and aliased columns using symbols" do
     @d.l(:x__y).must_equal 'x.y'
+    @d.l(:x___y).must_equal 'x AS y'
+    @d.l(:x__y___z).must_equal 'x.y AS z'
+  end
+
+  it "should support qualified columns using virtual rows" do
+    @d.l(Sequel.expr{x__y}).must_equal 'x.y'
+  end
+
+  it "should not split symbols or virtual row methods if symbol splitting is disabled" do
+    begin
+      Sequel.split_symbols = false
+      @d.l(:x__y).must_equal 'x__y'
+      @d.l(:x___y).must_equal 'x___y'
+      @d.l(:x__y___z).must_equal 'x__y___z'
+      @d.l(Sequel.expr{x__y}).must_equal 'x__y'
+    ensure
+      Sequel.split_symbols = true
+    end
   end
 
   it "should support NOT with SQL functions" do
@@ -129,6 +147,21 @@ describe "Blockless Ruby Filters" do
     proc{~Sequel.expr(:x).sql_string}.must_raise(NoMethodError) 
   end
 
+  it "should only allow combining associative operators" do
+    @d.lit(Sequel.expr{a + b + c}).must_equal '(a + b + c)'
+    @d.lit(Sequel.expr{a - b - c}).must_equal '((a - b) - c)'
+    @d.lit(Sequel.expr{a * b * c}).must_equal '(a * b * c)'
+    @d.lit(Sequel.expr{a / b / c}).must_equal '((a / b) / c)'
+    @d.lit(Sequel.expr{a & b & c}).must_equal '(a AND b AND c)'
+    @d.lit(Sequel.expr{a | b | c}).must_equal '(a OR b OR c)'
+    @d.lit(Sequel.expr{a.sql_string + b + c}).must_equal '(a || b || c)'
+    @d.lit(Sequel.expr{a.sql_number >> b >> c}).must_equal '((a >> b) >> c)'
+    @d.lit(Sequel.expr{a.sql_number << b << c}).must_equal '((a << b) << c)'
+    @d.lit(Sequel.expr{a.sql_number % b % c}).must_equal '((a % b) % c)'
+    @d.lit(Sequel.expr{a.sql_number & b & c}).must_equal '(a & b & c)'
+    @d.lit(Sequel.expr{a.sql_number | b | c}).must_equal '(a | b | c)'
+  end
+
   it "should allow mathematical or string operations on true, false, or nil" do
     @d.lit(Sequel.expr(:x) + 1).must_equal '(x + 1)'
     @d.lit(Sequel.expr(:x) - true).must_equal "(x - 't')"
@@ -206,7 +239,7 @@ describe "Blockless Ruby Filters" do
     @d.l((Sequel.lit('x') * :y) < 100.01).must_equal '((x * y) < 100.01)'
     @d.l((Sequel.lit('x') ** :y) < 100.01).must_equal '(power(x, y) < 100.01)'
     @d.l((Sequel.lit('x') - Sequel.expr(:y)/2) >= 100000000000000000000000000000000000).must_equal '((x - (y / 2)) >= 100000000000000000000000000000000000)'
-    @d.l((Sequel.lit('z') * ((Sequel.lit('x') / :y)/(Sequel.expr(:x) + :y))) <= 100).must_equal '((z * (x / y / (x + y))) <= 100)'
+    @d.l((Sequel.lit('z') * ((Sequel.lit('x') / :y)/(Sequel.expr(:x) + :y))) <= 100).must_equal '((z * ((x / y) / (x + y))) <= 100)'
     @d.l(~((((Sequel.lit('x') - :y)/(Sequel.expr(:x) + :y))*:z) <= 100)).must_equal '((((x - y) / (x + y)) * z) > 100)'
   end
 
@@ -921,6 +954,14 @@ describe "Sequel core extension replacements" do
     l(Sequel.qualify(:t, :c), "t.c")
   end
 
+  it "Sequel::SQL::Identifier#[] should return a qualified identifier" do
+    l(Sequel[:t][:c], "t.c")
+  end
+
+  it "Sequel::SQL::QualifiedIdentifier#[] should return a nested qualified identifier" do
+    l(Sequel[:s][:t][:c], "s.t.c")
+  end
+
   it "Sequel.identifier should return an identifier" do
     l(Sequel.identifier(:t__c), "t__c")
   end

data/spec/core/schema_spec.rb

@@ -12,10 +12,11 @@ describe "DB#create_table" do
 
   it "should accept the table name in multiple formats" do
     @db.create_table(:cats__cats) {}
+    @db.create_table(Sequel[:cats][:cats]) {}
     @db.create_table("cats__cats1") {}
     @db.create_table(Sequel.identifier(:cats__cats2)) {}
     @db.create_table(Sequel.qualify(:cats3, :cats)) {}
-    @db.sqls.must_equal ['CREATE TABLE cats.cats ()', 'CREATE TABLE cats__cats1 ()', 'CREATE TABLE cats__cats2 ()', 'CREATE TABLE cats3.cats ()']
+    @db.sqls.must_equal ['CREATE TABLE cats.cats ()', 'CREATE TABLE cats.cats ()', 'CREATE TABLE cats__cats1 ()', 'CREATE TABLE cats__cats2 ()', 'CREATE TABLE cats3.cats ()']
   end
 
   it "should raise an error if the table name argument is not valid" do
@@ -132,6 +133,23 @@ describe "DB#create_table" do
     @db.sqls.must_equal ['CREATE TABLE cats (id integer CONSTRAINT foo PRIMARY KEY AUTOINCREMENT)']
   end
 
+  it "should automatically set primary key column NOT NULL if database doesn't do it automatically" do
+    def @db.can_add_primary_key_constraint_on_nullable_columns?; false end
+    @db.create_table(:cats) do
+      primary_key :id
+    end
+    @db.sqls.must_equal ['CREATE TABLE cats (id integer NOT NULL PRIMARY KEY AUTOINCREMENT)']
+  end
+
+  it "should automatically set primary key column NOT NULL when adding constraint if database doesn't do it automatically" do
+    def @db.can_add_primary_key_constraint_on_nullable_columns?; false end
+    @db.create_table(:cats) do
+      String :id
+      primary_key [:id]
+    end
+    @db.sqls.must_equal ['CREATE TABLE cats (id varchar(255) NOT NULL, PRIMARY KEY (id))']
+  end
+
   it "should handling splitting named column constraints into table constraints if unsupported" do
     def @db.supports_named_column_constraints?; false end
     @db.create_table(:cats) do
@@ -1100,6 +1118,22 @@ describe "DB#alter_table" do
     @db.sqls.must_equal ["ALTER TABLE cats ADD CONSTRAINT cpk PRIMARY KEY (id, type)"]
   end
 
+  it "should set primary key column NOT NULL when using add_primary_key if database doesn't handle it" do
+    def @db.can_add_primary_key_constraint_on_nullable_columns?; false end
+    @db.alter_table(:cats) do
+      add_primary_key :id
+    end
+    @db.sqls.must_equal ["ALTER TABLE cats ADD COLUMN id integer NOT NULL PRIMARY KEY AUTOINCREMENT"]
+  end
+
+  it "should set primary key column NOT NULL when adding primary key constraint if database doesn't handle it" do
+    def @db.can_add_primary_key_constraint_on_nullable_columns?; false end
+    @db.alter_table(:cats) do
+      add_primary_key [:id, :type]
+    end
+    @db.sqls.must_equal ["ALTER TABLE cats ALTER COLUMN id SET NOT NULL", "ALTER TABLE cats ALTER COLUMN type SET NOT NULL", "ALTER TABLE cats ADD PRIMARY KEY (id, type)"]
+  end
+
   it "should support drop_column" do
     @db.alter_table(:cats) do
       drop_column :score

data/spec/core_extensions_spec.rb

@@ -21,6 +21,7 @@ Sequel.extension :core_extensions
 if RUBY_VERSION < '1.9.0'
   Sequel.extension :ruby18_symbol_extensions
 end
+Sequel.extension :symbol_aref
 
 require 'minitest/autorun'
 
@@ -702,3 +703,29 @@ describe "Postgres extensions integration" do
     @db.literal((1..2).pg_range(:int4range)).must_equal "int4range(1,2,'[]')"
   end
 end
+
+describe "symbol_aref extensions" do
+  before do
+    @db = Sequel.mock
+  end
+
+  it "Symbol#[] should create qualified identifier if given a symbol" do
+    @db.literal(:x[:y]).must_equal "x.y"
+  end
+
+  it "Symbol#[] should create qualified identifier if given an identifier" do
+    @db.literal(:x[Sequel[:y]]).must_equal "x.y"
+  end
+
+  it "Symbol#[] should create qualified identifier if given a qualified identifier" do
+    @db.literal(:x[:y[:z]]).must_equal "x.y.z"
+  end
+
+  it "should not affect other arguments to Symbol#[]" do
+    if RUBY_VERSION >= '1.9'
+      :x[0].must_equal "x"
+    else
+      @db.literal(:x[0]).must_equal "x(0)"
+    end
+  end
+end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -51,6 +51,14 @@ describe "class_table_inheritance plugin" do
     Object.send(:remove_const, :Employee)
   end
 
+  it "should not attempt to use prepared statements" do
+    Manager.plugin :prepared_statements
+    Manager[1]
+    @db.sqls.must_equal ["SELECT employees.id, employees.name, employees.kind, managers.num_staff FROM employees INNER JOIN managers ON (managers.id = employees.id) WHERE (managers.id = 1) LIMIT 1"]
+    Manager.load(:id=>1, :kind=>'Manager', :num_staff=>2).save
+    @db.sqls.must_equal ["UPDATE employees SET kind = 'Manager' WHERE (id = 1)", "UPDATE managers SET num_staff = 2 WHERE (id = 1)"]
+  end
+
   it "#cti_base_model should be the model that loaded the plugin" do
     Executive.cti_base_model.must_equal Employee
   end

data/spec/extensions/column_select_spec.rb

@@ -98,6 +98,14 @@ describe "Sequel::Plugins::ColumnSelect" do
     @Album.dataset.sql.must_equal 'SELECT albums.id, albums.a, albums.b, albums.c FROM albums'
   end
 
+  it "should handle case where schema parsing and columns does not produce results" do
+    def @db.supports_schema_parsing?() true end
+    def @db.schema_parse_table(t, *) [] end
+    @db.extend_datasets{def columns; raise Sequel::DatabaseError; end}
+    @Album.plugin :column_select
+    @Album.dataset.sql.must_equal 'SELECT * FROM albums'
+  end
+
   it "works correctly when loaded on model without a dataset" do
     c = Class.new(Sequel::Model)
     c.plugin :column_select

data/spec/extensions/core_refinements_spec.rb

@@ -1,6 +1,6 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
-if RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby'
+if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') # || (RUBY_VERSION >= '2.3.0' && RUBY_ENGINE == 'jruby')
 Sequel.extension :core_refinements, :pg_array, :pg_hstore, :pg_row, :pg_range, :pg_row_ops, :pg_range_ops, :pg_array_ops, :pg_hstore_ops, :pg_json, :pg_json_ops
 using Sequel::CoreRefinements
 

data/spec/extensions/dataset_associations_spec.rb

@@ -26,6 +26,7 @@ describe "Sequel::Plugins::DatasetAssociations" do
     @Album.columns :id, :name, :artist_id
     @Tag.columns :id, :name
 
+    @Album.plugin :many_through_many
     @Artist.plugin :many_through_many
     @Artist.plugin :pg_array_associations
     @Tag.plugin :pg_array_associations
@@ -33,6 +34,7 @@ describe "Sequel::Plugins::DatasetAssociations" do
     @Artist.one_to_one :first_album, :class=>@Album
     @Album.many_to_one :artist, :class=>@Artist
     @Album.many_to_many :tags, :class=>@Tag
+    @Album.many_through_many :mthm_tags, [[:albums_tags, :album_id, :tag_id]], :class=>@Tag
     @Album.one_through_one :first_tag, :class=>@Tag, :right_key=>:tag_id
     @Tag.many_to_many :albums, :class=>@Album
     @Artist.pg_array_to_many :artist_tags, :class=>@Tag, :key=>:tag_ids
@@ -83,6 +85,13 @@ describe "Sequel::Plugins::DatasetAssociations" do
     ds.sql.must_equal "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))"
   end
 
+  it "should work for many_through_many associations with a single join table" do
+    ds = @Album.mthm_tags
+    ds.must_be_kind_of(Sequel::Dataset)
+    ds.model.must_equal @Tag
+    ds.sql.must_equal "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id IN (SELECT albums.id FROM albums))))"
+  end
+
   it "should work for one_through_many associations" do
     ds = @Artist.otags
     ds.must_be_kind_of(Sequel::Dataset)

data/spec/extensions/insert_returning_select_spec.rb

@@ -12,6 +12,26 @@ describe "Sequel::Plugins::InsertReturningSelect" do
     @db.sqls
   end
 
+  it "should work if loaded into a model without a dataset that also uses the lazy_attributes or dataset associations plugins" do
+    c = Sequel::Model(@db)
+    c.plugin :insert_returning_select
+    c.columns :id, :x
+    c.plugin :lazy_attributes
+    c.plugin :dataset_associations
+
+    c.set_dataset @db[:albums].select(:id, :x)
+    c.plugin :lazy_attributes, :x
+    c.many_to_one :c, :key=>:id, :class=>c
+    @db.sqls
+
+    c.dataset.sql.must_equal 'SELECT id FROM albums'
+    c.create(:x=>2)
+    @db.sqls.must_equal ['INSERT INTO albums (x) VALUES (2) RETURNING id']
+    c.load(:id=>2).x
+    @db.sqls.must_equal ['SELECT albums.x FROM albums WHERE (id = 2) LIMIT 1']
+    c.dataset.cs.sql.must_equal "SELECT id FROM albums WHERE (albums.id IN (SELECT albums.id FROM albums))"
+  end
+
   it "should add a returning clause when inserting using selected columns" do
     @Album.plugin :insert_returning_select
     @Album.create(:x=>2).must_equal @Album.load(:id=>1, :x=>2)

data/spec/extensions/prepared_statements_spec.rb

@@ -17,6 +17,13 @@ describe "prepared_statements plugin" do
     @db.sqls.must_equal ["SELECT id, name, i FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
   end 
 
+  it "should correctly lookup by primary key for joined dataset" do
+    @c.dataset = @c.dataset.from(:people, :people2)
+    @db.sqls
+    @c[1].must_equal @p
+    @db.sqls.must_equal ["SELECT * FROM people, people2 WHERE (people.id = 1) LIMIT 1 -- read_only"]
+  end 
+
   prepared_statements_spec = shared_description do
     it "should correctly delete instance" do
       @p.destroy.must_equal @p

data/spec/extensions/s_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+Sequel.extension :s
+
+describe "s extension as refinement" do
+  include Sequel::S
+
+  before do
+    @db = Sequel.mock
+  end
+
+  it "S should be callable with different arguments" do
+    @db.literal(S(:s) + 1).must_equal "(s + 1)"
+    @db.literal(S('s') + '1').must_equal "('s' || '1')"
+    @db.literal(~S([[:s, 1], [:z, 2]])).must_equal "((s != 1) OR (z != 2))"
+  end
+
+  it "S should be callable with blocks" do
+    @db.literal(S{x + 1}).must_equal "(x + 1)"
+  end
+
+  it "S should raise an error if called with multiple objects" do
+    proc{S(:x, 1)}.must_raise ArgumentError
+  end
+
+  it "S should raise an error if called with objects and block" do
+    proc{S(:x){}}.must_raise Sequel::Error
+  end
+end
+
+
+if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') # || (RUBY_VERSION >= '2.3.0' && RUBY_ENGINE == 'jruby')
+using Sequel::S
+
+describe "s extension as refinement" do
+  before do
+    @db = Sequel.mock
+  end
+
+  it "S should be callable with different arguments" do
+    @db.literal(S(:s) + 1).must_equal "(s + 1)"
+    @db.literal(S('s') + '1').must_equal "('s' || '1')"
+    @db.literal(~S([[:s, 1], [:z, 2]])).must_equal "((s != 1) OR (z != 2))"
+  end
+
+  it "S should be callable with blocks" do
+    @db.literal(S{x + 1}).must_equal "(x + 1)"
+  end
+
+  it "S should raise an error if called with multiple objects" do
+    proc{S(:x, 1)}.must_raise ArgumentError
+  end
+
+  it "S should raise an error if called with objects and block" do
+    proc{S(:x){}}.must_raise Sequel::Error
+  end
+end
+end
+
+

data/spec/extensions/symbol_aref_refinement_spec.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') || (RUBY_VERSION >= '2.3.0' && RUBY_ENGINE == 'jruby')
+Sequel.extension :symbol_aref_refinement
+using Sequel::SymbolAref
+
+describe "symbol_aref_refinement extension" do
+  before do
+    @db = Sequel.mock
+  end
+
+  it "Symbol#[] should create qualified identifier if given a symbol" do
+    @db.literal(:x[:y]).must_equal "x.y"
+  end
+
+  it "Symbol#[] should create qualified identifier if given an identifier" do
+    @db.literal(:x[Sequel[:y]]).must_equal "x.y"
+  end
+
+  it "Symbol#[] should create qualified identifier if given a qualified identifier" do
+    @db.literal(:x[:y[:z]]).must_equal "x.y.z"
+  end
+
+  it "should not affect other arguments to Symbol#[]" do
+    :x[0].must_equal "x"
+  end
+end
+end

data/spec/extensions/symbol_as_refinement_spec.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+if (RUBY_VERSION >= '2.0.0' && RUBY_ENGINE == 'ruby') || (RUBY_VERSION >= '2.3.0' && RUBY_ENGINE == 'jruby')
+Sequel.extension :symbol_as_refinement
+using Sequel::SymbolAs
+
+describe "symbol_as_refinement extension" do
+  before do
+    @db = Sequel.mock
+  end
+
+  it "Symbol#as should create aliased expression" do
+    @db.literal(:x.as(:y)).must_equal "x AS y"
+  end
+
+  it "Symbol#as should create aliased expression with columns" do
+    @db.literal(:x.as(:y, [:c1, :c2])).must_equal "x AS y(c1, c2)"
+  end
+end
+end
+