sequel 3.48.0 → 4.0.0

data/spec/extensions/pg_auto_parameterize_spec.rb

@@ -1,70 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "pg_auto_parameterize extension" do
-  before do
-    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
-    @db.synchronize{|c| def c.escape_bytea(v) v*2 end}
-    @db.extend_datasets{def use_cursor(*) clone end}
-    @db.extension :pg_auto_parameterize
-  end
-
-  it "should automatically parameterize queries strings, blobs, numerics, dates, and times" do
-    pr = proc do |ds, sql, *args|
-      arg = args[0]
-      parg = args[1] || arg
-      s = ds.filter(:a=>arg).sql
-      s.should == sql
-      s.args.should == (parg == :nil ? nil : [parg])
-    end
-    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::int4)', 1)
-    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::int8)', 18446744073709551616)
-    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::double precision)', 1.1)
-    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::numeric)', BigDecimal.new('1.01'))
-    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1)', "a")
-    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::bytea)', Sequel.blob("a\0b"))
-    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = 1)', Sequel.lit('1'), :nil)
-    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::time)', Sequel::SQLTime.create(1, 2, 3, 500000))
-    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::date)', Date.today)
-    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::timestamp)', DateTime.new(2012, 1, 2, 3, 4, 5))
-    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::timestamp)', Time.utc(2012, 1, 2, 3, 4, 5))
-  end
-
-  it "should extract parameters from query string when executing" do
-    @db.fetch = {:a=>1}
-    @db.numrows = 1
-    @db.autoid = 1
-
-    @db[:table].filter(:a=>1).all.should == [{:a=>1}]
-    @db.sqls.should == ['SELECT * FROM table WHERE (a = $1::int4) -- args: [1]']
-
-    @db[:table].filter(:a=>1).update(:b=>'a').should == 1
-    @db.sqls.should == ['UPDATE table SET b = $1 WHERE (a = $2::int4) -- args: ["a", 1]']
-
-    @db[:table].filter(:a=>1).delete.should == 1
-    @db.sqls.should == ['DELETE FROM table WHERE (a = $1::int4) -- args: [1]']
-
-    @db[:table].insert(:a=>1).should == 1
-    @db.sqls.should == ['INSERT INTO table (a) VALUES ($1::int4) RETURNING id -- args: [1]']
-  end
-
-  it "should not automatically paramiterize if no_auto_parameterize is used" do
-    @db[:table].no_auto_parameterize.filter(:a=>1).sql.should == 'SELECT * FROM table WHERE (a = 1)'
-  end
-
-  it "should not automatically parameterize prepared statements" do
-    @db[:table].filter(:a=>1, :b=>:$b).prepare(:select).sql.should =~ /SELECT \* FROM table WHERE \(\((a = 1|b = \$b)\) AND \((a = 1|b = \$b)\)\)/
-  end
-
-  it "should show args with string when inspecting SQL " do
-    @db[:table].filter(:a=>1).sql.inspect.should == '"SELECT * FROM table WHERE (a = $1::int4); [1]"'
-  end
-
-  it "should not auto parameterize when using cursors" do
-    @db[:table].filter(:a=>1).use_cursor.opts[:no_auto_parameterize].should be_true
-  end
-
-  it "should have a working create_view" do
-    @db.create_view :foo, @db[:table].filter(:a=>1)
-    @db.sqls.should == ["CREATE VIEW foo AS SELECT * FROM table WHERE (a = 1)"]
-  end
-end

data/spec/extensions/pg_statement_cache_spec.rb

@@ -1,208 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-Sequel::Postgres::StatementCache::PGError = Sequel::Error
-
-describe "pg_statement_cache and pg_auto_parameterize extensions" do
-  before do
-    @dbp = proc do |opts|
-      @db = Sequel.connect 'mock://postgres', :quote_identifiers=>false, :statement_cache_opts=>{:max_size=>4}.merge(opts),
-        :after_connect=>(proc do |c|
-          c.extend(Module.new do
-            def execute_query(sql, args)
-              raise Sequel::Postgres::StatementCache::PGError if @db.exec_raise
-              @db.execute(sql, :arguments=>args, :no_eq=>true)
-            end
-            def prepare(name, sql)
-              raise Sequel::Postgres::StatementCache::PGError if sql =~ /prepare_raise/
-              @ps ||= {}
-              @ps[name] = sql
-              @db._sqls << "PREPARE #{name} AS #{sql}"
-            end
-            def exec_prepared(name, args=nil)
-              @db._sqls << "EXECUTE #{name} (#{@ps[name]})#{" -- args: #{args.inspect}" if args}"
-            end
-          end)
-        end)
-      @db.extension :pg_auto_parameterize, :pg_statement_cache
-      @db.extend(Module.new do
-        attr_accessor :exec_raise
-        def _execute(c, sql, opts={})
-          opts[:no_eq] ? super : c.send(:execute_query, sql, opts[:arguments])
-        end
-        def _sqls
-          @sqls
-        end
-        def statement_cache
-          synchronize{|c| c.statement_cache}
-        end
-      end)
-      @db
-    end
-    @db = @dbp.call({})
-  end
-
-  it "should automatically prepare statements executed multiple times" do
-    @db[:table].filter(:b=>2).all
-    3.times{|i| @db[:table].filter(:a=>i).all}
-    @db.sqls.should == ["SELECT * FROM table WHERE (b = $1::int4) -- args: [2]",
-      "SELECT * FROM table WHERE (a = $1::int4) -- args: [0]",
-      "PREPARE sequel_pgap_2 AS SELECT * FROM table WHERE (a = $1::int4)",
-      "EXECUTE sequel_pgap_2 (SELECT * FROM table WHERE (a = $1::int4)) -- args: [1]",
-      "EXECUTE sequel_pgap_2 (SELECT * FROM table WHERE (a = $1::int4)) -- args: [2]"]
-  end
-
-  it "should work correctly for queries without parameters" do
-    @db[:table].filter(:b).all
-    3.times{|i| @db[:table].filter(:a).all}
-    @db.sqls.should == ["SELECT * FROM table WHERE b",
-      "SELECT * FROM table WHERE a",
-      "PREPARE sequel_pgap_2 AS SELECT * FROM table WHERE a",
-      "EXECUTE sequel_pgap_2 (SELECT * FROM table WHERE a)",
-      "EXECUTE sequel_pgap_2 (SELECT * FROM table WHERE a)"]
-  end
-
-  it "should correctly return the size of the cache" do
-    sc = @db.statement_cache
-    sc.size.should == 0
-    @db[:table].filter(:b=>2).all
-    sc.size.should == 1
-    3.times{|i| @db[:table].filter(:a=>i).all}
-    sc.size.should == 2
-  end
-
-  it "should correctly clear the cache" do
-    sc = @db.statement_cache
-    sc.size.should == 0
-    @db[:table].filter(:b=>2).all
-    sc.size.should == 1
-    3.times{|i| @db[:table].filter(:a=>i).all}
-    sc.size.should == 2
-    sc.clear
-    sc.size.should == 0
-    3.times{|i| @db[:table].filter(:a=>i).all}
-    sc.size.should == 1
-  end
-
-  it "should correctly yield each entry in the cache" do
-    @db[:table].filter(:b=>2).all
-    3.times{|i| @db[:table].filter(:a=>i).all}
-    a = []
-    @db.statement_cache.each{|k, v| a << [k, v]}
-    a.sort!
-    a[0][0].should == "SELECT * FROM table WHERE (a = $1::int4)"
-    a[1][0].should == "SELECT * FROM table WHERE (b = $1::int4)"
-    s1 = a[1][1]
-    s1.cache_id.should == 1
-    s1.num_executes.should == 1
-    s1 = a[0][1]
-    s1.cache_id.should == 2
-    s1.num_executes.should == 3
-  end
-
-  it "should automatically cleanup the cache when it goes beyond its maximum size" do
-    sc = @db.statement_cache
-    4.times{|i| @db[:table].filter(:"a#{i}"=>1).all}
-    sc.size.should == 4
-    @db[:table].filter(:b=>1).all
-    sc.size.should == 2
-  end
-
-  it "should clear statement caches when altering tables" do
-    @db[:table].filter(:b=>2).all
-    sc = @db.statement_cache
-    @db.alter_table(:foo){drop_column :bar}
-    sc.size.should == 0
-  end
-
-  it "should clear statement caches when dropping tables" do
-    @db[:table].filter(:b=>2).all
-    sc = @db.statement_cache
-    @db.drop_table(:foo)
-    sc.size.should == 0
-  end
-
-  it "should deallocate prepared statements when clearing the cache" do
-    3.times{|i| @db[:table].filter(:a=>i).all}
-    @db.sqls
-    @db.statement_cache.clear
-    @db.sqls.should == ["DEALLOCATE sequel_pgap_1"]
-  end
-
-  it "should deallocate prepared statements when cleaning up the cache" do
-    @db = @dbp.call(:sorter=>proc{|t, s| -s.num_executes})
-    4.times{|i| @db[:table].filter(:"a#{i}"=>1).all}
-    @db[:table].filter(:a0=>1).all
-    @db.sqls
-    @db[:table].filter(:b=>1).all
-    @db.sqls.should == ["DEALLOCATE sequel_pgap_1", "SELECT * FROM table WHERE (b = $1::int4) -- args: [1]"]
-  end
-
-  it "should not deallocate nonprepared statements when clearing the cache" do
-    4.times{|i| @db[:table].filter(:"a#{i}"=>1).all}
-    @db.sqls
-    @db.statement_cache.clear
-    @db.sqls.should == []
-  end
-
-  it "should not deallocate nonprepared statements when cleaning up the cache" do
-    @db = @dbp.call(:sorter=>proc{|t, s| -s.num_executes})
-    4.times{|i| @db[:table].filter(:"a#{i}"=>1).all}
-    @db.sqls
-    @db[:table].filter(:b=>1).all
-    @db.sqls.should == ["SELECT * FROM table WHERE (b = $1::int4) -- args: [1]"]
-  end
-
-  it "should have a configurable max_size and min_size" do
-    @db = @dbp.call(:max_size=>10, :min_size=>2)
-    10.times{|i| @db[:table].filter(:"a#{i}"=>1).all}
-    sc = @db.statement_cache
-    sc.size.should == 10
-    @db[:table].filter(:b=>1).all
-    sc.size.should == 2
-  end
-
-  it "should have a configurable prepare_after" do
-    @db = @dbp.call(:prepare_after=>3)
-    4.times{|i| @db[:table].filter(:a=>i).all}
-    @db.sqls.should == ["SELECT * FROM table WHERE (a = $1::int4) -- args: [0]",
-      "SELECT * FROM table WHERE (a = $1::int4) -- args: [1]",
-      "PREPARE sequel_pgap_1 AS SELECT * FROM table WHERE (a = $1::int4)",
-      "EXECUTE sequel_pgap_1 (SELECT * FROM table WHERE (a = $1::int4)) -- args: [2]",
-      "EXECUTE sequel_pgap_1 (SELECT * FROM table WHERE (a = $1::int4)) -- args: [3]"]
-  end
-
-  it "should have a configurable sorter" do
-    @db = @dbp.call(:sorter=>proc{|t, s| s.num_executes})
-    4.times{|i| (i+1).times{@db[:table].filter(:"a#{i}"=>1).all}}
-    @db[:table].filter(:b=>1).all
-    sc = @db.statement_cache
-    a = []
-    sc.each{|k, v| a << [k, v]}
-    a.sort!
-    a[0][0].should == "SELECT * FROM table WHERE (a3 = $1::int4)"
-    a[1][0].should == "SELECT * FROM table WHERE (b = $1::int4)"
-    s1 = a[1][1]
-    s1.num_executes.should == 1
-    s1 = a[0][1]
-    s1.cache_id.should == 4
-    s1.num_executes.should == 4
-  end
-
-  it "should ignore errors when preparing queries" do
-    3.times{|i| @db[:table].filter(:prepare_raise=>1).all}
-    @db.sqls.should == ["SELECT * FROM table WHERE (prepare_raise = $1::int4) -- args: [1]",
-      "SELECT * FROM table WHERE (prepare_raise = $1::int4) -- args: [1]",
-      "SELECT * FROM table WHERE (prepare_raise = $1::int4) -- args: [1]"]
-  end
-
-  it "should ignore errors when deallocating queries" do
-    3.times{|i| @db[:table].filter(:a=>1).all}
-    @db.exec_raise = true
-    @db.statement_cache.clear
-    @db.sqls.should == ["SELECT * FROM table WHERE (a = $1::int4) -- args: [1]",
-      "PREPARE sequel_pgap_1 AS SELECT * FROM table WHERE (a = $1::int4)",
-      "EXECUTE sequel_pgap_1 (SELECT * FROM table WHERE (a = $1::int4)) -- args: [1]",
-      "EXECUTE sequel_pgap_1 (SELECT * FROM table WHERE (a = $1::int4)) -- args: [1]"]
-  end
-
-end

data/spec/rcov.opts

@@ -1,8 +0,0 @@
---exclude
-gems
---exclude
-spec
---exclude
-00*
---threshold
-100

data/spec/spec_config.rb.example

@@ -1,10 +0,0 @@
-# database objects for running adapter specs
-# ADO_DB = Sequel.connect(:adapter => 'ado', :driver => "{Microsoft Access Driver (*.mdb)}; DBQ=c:\\Nwind.mdb")
-# INFORMIX_DB = Sequel.connect('informix://localhost/mydb')
-# INTEGRATION_URL = 'sqlite:/'
-# MYSQL_USER = 'root'
-# MYSQL_URL = "mysql://#{MYSQL_USER}@localhost/sandbox"
-# MYSQL_SOCKET_FILE = '/tmp/mysql.sock'
-# ORACLE_DB = Sequel.connect('oracle://hr:hr@localhost/XE')
-# POSTGRES_URL = 'postgres://postgres:postgres@localhost:5432/reality_spec'
-# SQLITE_URL = 'sqlite:/'