sequel 5.20.0 → 5.49.0

data/spec/extensions/prepared_statements_spec.rb

@@ -1,177 +0,0 @@
-require_relative "spec_helper"
-
-describe "prepared_statements plugin" do
-  before do
-    @db = Sequel.mock(:fetch=>{:id=>1, :name=>'foo', :i=>2}, :autoid=>proc{|sql| 1}, :numrows=>1, :servers=>{:read_only=>{}})
-    @c = Class.new(Sequel::Model(@db[:people]))
-    @c.columns :id, :name, :i
-    @c.set_primary_key :id
-    @columns = "id, name, i"
-    @c.plugin :prepared_statements
-    @p = @c.load(:id=>1, :name=>'foo', :i=>2)
-    @ds = @c.dataset
-    @db.sqls
-  end
-
-  it "should work with implicit subqueries used for joined datasets" do
-    @c.dataset = @c.dataset.from(:people, :people2)
-    @db.sqls
-    @c[1].must_equal @p
-    @db.sqls.must_equal ["SELECT * FROM (SELECT * FROM people, people2) AS people WHERE (id = 1) LIMIT 1 -- read_only"]
-  end 
-
-  it "should correctly lookup by primary key for dataset using subquery" do
-    @c.dataset = @c.dataset.from(:people, :people2).from_self(:alias=>:people)
-    @db.sqls
-    @c[1].must_equal @p
-    @db.sqls.must_equal ["SELECT * FROM (SELECT * FROM people, people2) AS people WHERE (id = 1) LIMIT 1 -- read_only"]
-  end 
-
-  it "should use prepared statements for pk lookups only if default is not optimized" do
-    @c.send(:use_prepared_statements_for_pk_lookup?).must_equal false 
-    @c.set_primary_key [:id, :name]
-    @c.send(:use_prepared_statements_for_pk_lookup?).must_equal true
-    @c.set_primary_key :id
-    @c.dataset = @c.dataset.from(:people, :people2)
-    @c.send(:use_prepared_statements_for_pk_lookup?).must_equal true
-    @c.dataset = @db[:people].select(:id, :name, :i)
-    @c.send(:use_prepared_statements_for_pk_lookup?).must_equal true
-  end
-
-  it "should raise Error for unsupported prepared statement types" do
-    proc{@p.send(:use_prepared_statements_for?, :foo)}.must_raise Sequel::Error
-  end
-
-  prepared_statements_spec = shared_description do
-    it "should correctly update instance" do
-      @p.update(:name=>'bar').must_equal @c.load(:id=>1, :name=>'bar', :i => 2)
-      @db.sqls.must_equal ["UPDATE people SET name = 'bar' WHERE (id = 1)"]
-    end
-
-    it "should correctly create instance if dataset supports insert_select" do
-      @c.dataset_module do
-        def supports_insert_select?
-          true
-        end
-        def supports_returning?(type)
-          true
-        end
-        def insert_select(h)
-          cache_set(:_fetch, :id=>1, :name=>'foo', :i => 2)
-          server(:default).with_sql_first(insert_select_sql(h))
-        end
-        def insert_select_sql(*v)
-          insert_sql(*v) << " RETURNING #{(opts[:returning] && !opts[:returning].empty?) ? opts[:returning].map{|c| literal(c)}.join(', ') : '*'}"
-        end
-      end
-      @c.create(:name=>'foo').must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
-      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo') RETURNING #{@columns}"]
-    end
-  end
-
-  describe "when #use_prepared_statements_for? returns true" do
-    before do
-      @c.class_eval do
-        def self.use_prepared_statements_for_pk_lookup?; true end
-        def use_prepared_statements_for?(type) true end
-      end
-    end
-
-    include prepared_statements_spec
-
-    it "should correctly create instance" do
-      @c.create(:name=>'foo').must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
-      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo')", "SELECT * FROM people WHERE id = 1"]
-    end
-
-    it "should correctly update instance when specifying server" do
-      @p.set_server(:read_only).update(:name=>'bar').must_equal @c.load(:id=>1, :name=>'bar', :i => 2)
-      @db.sqls.must_equal ["UPDATE people SET name = 'bar' WHERE (id = 1) -- read_only"]
-    end
-
-    it "should correctly create instance when specifying server" do
-      @c.new(:name=>'foo').set_server(:read_only).save.must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
-      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo') -- read_only", "SELECT * FROM people WHERE id = 1 -- read_only"]
-    end
-
-    it "should correctly create instance if dataset supports insert_select when specifying server" do
-      @c.dataset_module do
-        def supports_insert_select?
-          true
-        end
-        def supports_returning?(type)
-          true
-        end
-        def insert_select(h)
-          cache_set(:_fetch, :id=>1, :name=>'foo', :i => 2)
-          server(:default).with_sql_first(insert_select_sql(h))
-        end
-        def insert_select_sql(*v)
-          insert_sql(*v) << " RETURNING #{(opts[:returning] && !opts[:returning].empty?) ? opts[:returning].map{|c| literal(c)}.join(', ') : '*'}"
-        end
-      end
-      @c.new(:name=>'foo').set_server(:read_only).save.must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
-      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo') RETURNING #{@columns} -- read_only"]
-    end
-
-    it "should work correctly when subclassing" do
-      c = Class.new(@c)
-      @db.sqls
-      c.load(:id=>1, :name=>'foo', :i=>2).save
-      @db.sqls.must_equal ["UPDATE people SET name = 'foo', i = 2 WHERE (id = 1)"]
-    end 
-
-    it "should correctly handle without schema type when placeholder type specifiers are required" do
-      @c.dataset = @ds.with_extend{def requires_placeholder_type_specifiers?; true end}
-      @p.save
-      @db.sqls.must_equal ["UPDATE people SET name = 'foo', i = 2 WHERE (id = 1)"]
-    end
-
-    it "should correctly handle with schema type when placeholder type specifiers are required" do
-      @c.dataset = @ds.with_extend do
-        def requires_placeholder_type_specifiers?; true end
-        def prepared_statement_modules
-          [Module.new do
-            def literal_symbol_append(sql, v)
-              if @opts[:bind_vars] && /\A\$(.*)\z/ =~ v
-                literal_append(sql, prepared_arg($1.split('__')[0].to_sym))
-              else
-                super
-              end
-            end
-          end]
-        end
-      end
-      @c.db_schema[:id][:type] = :integer
-      @p.save
-      @db.sqls.must_equal ["UPDATE people SET name = 'foo', i = 2 WHERE (id = 1)"]
-    end 
-  end
-
-  describe "when #use_prepared_statements_for? returns false" do
-    before do
-      @columns = "*"
-      @c.class_eval do
-        def self.use_prepared_statements_for_pk_lookup?; false end
-        def use_prepared_statements_for?(type) false end
-      end
-    end
-
-    include prepared_statements_spec
-
-    it "should correctly create instance" do
-      @c.create(:name=>'foo').must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
-      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo')", "SELECT #{@columns} FROM people WHERE id = 1"]
-    end
-
-    it "should correctly lookup by primary key" do
-      @c[1].must_equal @p
-      @db.sqls.must_equal ["SELECT * FROM people WHERE id = 1 -- read_only"]
-    end 
-
-    it "should correctly delete instance" do
-      @p.destroy.must_equal @p
-      @db.sqls.must_equal ["DELETE FROM people WHERE id = 1"]
-    end
-  end
-end

data/spec/extensions/pretty_table_spec.rb

@@ -1,123 +0,0 @@
-require_relative "spec_helper"
-
-require 'stringio'
-Sequel.extension :pretty_table
-
-describe "Dataset#print" do
-  before do
-    @output = StringIO.new
-    @orig_stdout = $stdout
-    $stdout = @output
-    @dataset = Sequel.mock(:fetch=>[{:a=>1, :b=>2}, {:a=>3, :b=>4}, {:a=>5, :b=>6}])[:items].extension(:pretty_table)
-  end
-
-  after do
-    $stdout = @orig_stdout
-  end
-
-  it "should print out a table with the values" do
-    @dataset.print(:a, :b)
-    @output.rewind
-    @output.read.must_equal \
-      "+-+-+\n|a|b|\n+-+-+\n|1|2|\n|3|4|\n|5|6|\n+-+-+\n"
-  end
-
-  it "should default to the dataset's columns" do
-    @dataset.columns(:a, :b)
-    @dataset.print
-    @output.rewind
-    @output.read.must_equal \
-      "+-+-+\n|a|b|\n+-+-+\n|1|2|\n|3|4|\n|5|6|\n+-+-+\n"
-  end
-end
-
-describe "PrettyTable" do
-  before do
-    @data1 = [
-      {:x => 3, :y => 4}
-    ]
-    
-    @data2 = [
-      {:a => 23, :b => 45},
-      {:a => 45, :b => 2377}
-    ]
-
-    @data3 = [
-      {:aaa => 1},
-      {:bb => 2},
-      {:c => 3.1}
-    ]
-
-    @output = StringIO.new
-    @orig_stdout = $stdout
-    $stdout = @output
-  end
-
-  after do
-    $stdout = @orig_stdout
-  end
-  
-  it "should infer the columns if not given" do
-    Sequel::PrettyTable.print(@data1)
-    @output.rewind
-    @output.read.must_equal(<<OUTPUT)
-+-+-+
-|x|y|
-+-+-+
-|3|4|
-+-+-+
-OUTPUT
-  end
-  
-  it "should have #string return the string without printing" do
-    Sequel::PrettyTable.string(@data1).must_equal((<<OUTPUT).chomp)
-+-+-+
-|x|y|
-+-+-+
-|3|4|
-+-+-+
-OUTPUT
-    @output.rewind
-    @output.read.must_equal ''
-  end
-  
-  it "should calculate the maximum width of each column correctly" do
-    Sequel::PrettyTable.print(@data2, [:a, :b])
-    @output.rewind
-    @output.read.must_equal(<<OUTPUT)
-+--+----+
-|a |b   |
-+--+----+
-|23|  45|
-|45|2377|
-+--+----+
-OUTPUT
-  end
-
-  it "should also take header width into account" do
-    Sequel::PrettyTable.print(@data3, [:aaa, :bb, :c])
-    @output.rewind
-    @output.read.must_equal(<<OUTPUT)
-+---+--+---+
-|aaa|bb|c  |
-+---+--+---+
-|  1|  |   |
-|   | 2|   |
-|   |  |3.1|
-+---+--+---+
-OUTPUT
-  end
-  
-  it "should print only the specified columns" do
-    Sequel::PrettyTable.print(@data2, [:a])
-    @output.rewind
-    @output.read.must_equal(<<OUTPUT)
-+--+
-|a |
-+--+
-|23|
-|45|
-+--+
-OUTPUT
-  end
-end

data/spec/extensions/query_spec.rb

@@ -1,94 +0,0 @@
-require_relative "spec_helper"
-
-describe "Database#query" do
-  before do
-    @db = Sequel.mock.extension(:query)
-  end
-
-  it "should delegate to Dataset#query if block is provided" do
-    @d = @db.query {select :x; from :y}
-    @d.must_be_kind_of(Sequel::Dataset)
-    @d.sql.must_equal "SELECT x FROM y"
-  end
-end
-
-describe "Dataset#query" do
-  before do
-    @d = Sequel.mock.dataset.extension(:query)
-  end
-  
-  it "should allow cloning without arguments" do
-    q = @d.query {clone}
-    q.class.must_equal @d.class
-    q.sql.must_equal "SELECT *"
-  end
-  
-  it "should support #from" do
-    q = @d.query {from :xxx}
-    q.class.must_equal @d.class
-    q.sql.must_equal "SELECT * FROM xxx"
-  end
-  
-  it "should support #select" do
-    q = @d.query do
-      select :a, Sequel[:b].as(:mongo)
-      from :yyy
-    end
-    q.class.must_equal @d.class
-    q.sql.must_equal "SELECT a, b AS mongo FROM yyy"
-  end
-  
-  it "should support #where" do
-    q = @d.query do
-      from :zzz
-      where{x + 2 > Sequel.expr(:y) + 3}
-    end
-    q.class.must_equal @d.class
-    q.sql.must_equal "SELECT * FROM zzz WHERE ((x + 2) > (y + 3))"
-
-    q = @d.from(:zzz).query do
-      where{(x > 1) & (Sequel.expr(:y) > 2)}
-    end
-    q.class.must_equal @d.class
-    q.sql.must_equal "SELECT * FROM zzz WHERE ((x > 1) AND (y > 2))"
-
-    q = @d.from(:zzz).query do
-      where :x => 33
-    end
-    q.class.must_equal @d.class
-    q.sql.must_equal "SELECT * FROM zzz WHERE (x = 33)"
-  end
-  
-  it "should support #group_by and #having" do
-    q = @d.query do
-      from :abc
-      group_by :id
-      having{x >= 2}
-    end
-    q.class.must_equal @d.class
-    q.sql.must_equal "SELECT * FROM abc GROUP BY id HAVING (x >= 2)"
-  end
-  
-  it "should support #order, #order_by" do
-    q = @d.query do
-      from :xyz
-      order_by :stamp
-    end
-    q.class.must_equal @d.class
-    q.sql.must_equal "SELECT * FROM xyz ORDER BY stamp"
-  end
-
-  it "should support blocks that end in nil" do
-    condition = false
-    q = @d.query do
-      from :xyz
-      order_by :stamp if condition
-    end
-    q.sql.must_equal "SELECT * FROM xyz"
-  end
-  
-  it "should raise on non-chainable method calls" do
-    proc {@d.query {row_proc}}.must_raise(Sequel::Error)
-    proc {@d.query {all}}.must_raise(Sequel::Error)
-  end
-end