sequel 2.12.0 → 3.0.0

data/spec/adapters/oracle_spec.rb

@@ -58,6 +58,19 @@ context "An Oracle database" do
       expected_schema.should == schema
     end
   end
+  
+  specify "should create a temporary table" do
+    ORACLE_DB.create_table :test_tmp, :temporary => true do
+      primary_key :id, :integer, :null => false
+      column :name, :text
+      index :name, :unique => true
+    end
+    
+    ORACLE_DB.sqls.should == [
+      'CREATE GLOBAL 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
 end
 
 context "An Oracle dataset" do

data/spec/adapters/postgres_spec.rb

@@ -4,6 +4,16 @@ unless defined?(POSTGRES_DB)
   POSTGRES_URL = 'postgres://postgres:postgres@localhost:5432/reality_spec' unless defined? POSTGRES_URL
   POSTGRES_DB = Sequel.connect(ENV['SEQUEL_PG_SPEC_DB']||POSTGRES_URL)
 end
+
+def POSTGRES_DB.sqls
+  (@sqls ||= [])
+end
+logger = Object.new
+def logger.method_missing(m, msg)
+  POSTGRES_DB.sqls << msg
+end
+POSTGRES_DB.logger = logger
+
 #POSTGRES_DB.instance_variable_set(:@server_version, 80100)
 POSTGRES_DB.create_table! :test do
   text :name
@@ -21,33 +31,17 @@ POSTGRES_DB.create_table! :test4 do
   varchar :name, :size => 20
   bytea :value
 end
-POSTGRES_DB.create_table! :test5 do
-  primary_key :xid
-  integer :value
-end
 
 context "A PostgreSQL database" do
   before do
     @db = POSTGRES_DB
   end
   
-  specify "should provide disconnect functionality" do
-    @db.tables
-    @db.pool.size.should == 1
-    @db.disconnect
-    @db.pool.size.should == 0
-  end
-  
   specify "should provide the server version" do
     @db.server_version.should > 70000
   end
 
-  specify "should raise Sequel::Error on error" do
-    proc{@db << "SELECT 1 + 'a'"}.should raise_error(Sequel::Error)
-  end
-
   specify "should correctly parse the schema" do
-    require 'logger'
     @db.schema(:test3, :reload=>true).should == [
       [:value, {:type=>:integer, :allow_null=>true, :default=>nil, :db_type=>"integer", :primary_key=>false}],
       [:time, {:type=>:datetime, :allow_null=>true, :default=>nil, :db_type=>"timestamp without time zone", :primary_key=>false}]
@@ -65,54 +59,6 @@ context "A PostgreSQL dataset" do
     @d.delete # remove all records
   end
   
-  specify "should return the correct record count" do
-    @d.count.should == 0
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
-    @d.count.should == 3
-  end
-  
-  specify "should return the correct records" do
-    @d.to_a.should == []
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
-
-    @d.order(:value).to_a.should == [
-      {:name => 'abc', :value => 123},
-      {:name => 'abc', :value => 456},
-      {:name => 'def', :value => 789}
-    ]
-  end
-  
-  specify "should update records correctly" do
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
-    @d.filter(:name => 'abc').update(:value => 530)
-    
-    # the third record should stay the same
-    # floating-point precision bullshit
-    @d[:name => 'def'][:value].should == 789
-    @d.filter(:value => 530).count.should == 2
-  end
-  
-  specify "should delete records correctly" do
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
-    @d.filter(:name => 'abc').delete
-    
-    @d.count.should == 1
-    @d.first[:name].should == 'def'
-  end
-  
-  specify "should be able to literalize booleans" do
-    proc {@d.literal(true)}.should_not raise_error
-    proc {@d.literal(false)}.should_not raise_error
-  end
-  
   specify "should quote columns and tables using double quotes if quoting identifiers" do
     @d.quote_identifiers = true
     @d.select(:name).sql.should == \
@@ -176,60 +122,6 @@ context "A PostgreSQL dataset" do
       'SELECT * FROM "test" ORDER BY "name" ASC, "test" DESC'
   end
   
-  specify "should support transactions" do
-    POSTGRES_DB.transaction do
-      @d << {:name => 'abc', :value => 1}
-    end
-
-    @d.count.should == 1
-  end
-  
-  specify "should have #transaction yield the connection" do
-    POSTGRES_DB.transaction do |conn|
-      conn.should_not == nil
-    end
-  end
-  
-  specify "should correctly rollback transactions" do
-    proc do
-      POSTGRES_DB.transaction do
-        @d << {:name => 'abc', :value => 1}
-        raise Interrupt, 'asdf'
-      end
-    end.should raise_error(Interrupt)
-
-    proc do
-      POSTGRES_DB.transaction do
-        @d << {:name => 'abc', :value => 1}
-        raise Sequel::Rollback
-      end
-    end.should_not raise_error
-
-    @d.count.should == 0
-  end
-  
-  specify "should handle returning inside of the block by committing" do
-    def POSTGRES_DB.ret_commit
-      transaction do
-        self[:test] << {:name => 'abc'}
-        return
-        self[:test] << {:name => 'd'}
-      end
-    end
-    @d.count.should == 0
-    POSTGRES_DB.ret_commit
-    @d.count.should == 1
-    POSTGRES_DB.ret_commit
-    @d.count.should == 2
-    proc do
-      POSTGRES_DB.transaction do
-        raise Interrupt, 'asdf'
-      end
-    end.should raise_error(Interrupt)
-
-    @d.count.should == 2
-  end
-
   specify "should support nested transactions through savepoints using the savepoint option" do
     POSTGRES_DB.transaction do
       @d << {:name => '1'}
@@ -260,33 +152,6 @@ context "A PostgreSQL dataset" do
     @d.filter(:name => /bc/).count.should == 2
     @d.filter(:name => /^bc/).count.should == 1
   end
-
-  specify "should correctly escape strings" do
-    POSTGRES_DB['SELECT ? AS a', "\\dingo"].get(:a) == "\\dingo"
-  end
-
-  specify "should correctly escape strings with quotes" do
-    POSTGRES_DB['SELECT ? AS a', "\\'dingo"].get(:a) == "\\'dingo"
-  end
-
-  specify "should properly escape binary data" do
-    POSTGRES_DB['SELECT ? AS a', "\1\2\3".to_sequel_blob].get(:a) == "\1\2\3"
-  end
-
-  specify "should retrieve binary data as Blob object" do
-    d = POSTGRES_DB[:test4]
-    d << {:name => '123', :value => "\1\2\3".to_sequel_blob}
-    retrieved_binary_value = d[:name => '123'][:value]
-    retrieved_binary_value.should be_a_kind_of(::Sequel::SQL::Blob)
-    retrieved_binary_value.should == "\1\2\3"
-    retrieved_binary_value = d[:value => "\1\2\3".to_sequel_blob][:value]
-    retrieved_binary_value.should be_a_kind_of(::Sequel::SQL::Blob)
-    retrieved_binary_value.should == "\1\2\3"
-  end
-
-  specify "should properly receive binary data" do
-    POSTGRES_DB['SELECT ?::bytea AS a', "a"].get(:a) == "a"
-  end
 end
 
 context "A PostgreSQL dataset with a timestamp field" do
@@ -343,141 +208,161 @@ end
 
 context "A PostgreSQL database" do
   before do
+    @db = POSTGRES_DB
+    @db.drop_table(:posts) rescue nil
+    @db.sqls.clear
+  end
+  after do
+    @db.drop_table(:posts) rescue nil
   end
   
-  specify "should support fulltext indexes" do
-    g = Sequel::Schema::Generator.new(POSTGRES_DB) do
-      text :title
-      text :body
-      full_text_index [:title, :body]
-    end
-    POSTGRES_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [
-      "CREATE TABLE posts (title text, body text)",
-      "CREATE INDEX posts_title_body_index ON posts USING gin (to_tsvector('simple', (COALESCE(title, '') || ' ' || COALESCE(body, ''))))"
-    ]
+  specify "should support resetting the primary key sequence" do
+    @db.create_table(:posts){primary_key :a}
+    @db[:posts].insert(:a=>20).should == 20
+    @db[:posts].insert.should == 1
+    @db[:posts].insert.should == 2
+    @db[:posts].insert(:a=>10).should == 10
+    @db.reset_primary_key_sequence(:posts).should == 21
+    @db[:posts].insert.should == 21
+    @db[:posts].order(:a).map(:a).should == [1, 2, 10, 20, 21]
   end
   
-  specify "should support fulltext indexes with a specific language" do
-    g = Sequel::Schema::Generator.new(POSTGRES_DB) do
-      text :title
-      text :body
-      full_text_index [:title, :body], :language => 'french'
-    end
-    POSTGRES_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [
+  specify "should support fulltext indexes and searching" do
+    @db.create_table(:posts){text :title; text :body; full_text_index [:title, :body]; full_text_index :title, :language => 'french'}
+    @db.sqls.should == [
       "CREATE TABLE posts (title text, body text)",
-      "CREATE INDEX posts_title_body_index ON posts USING gin (to_tsvector('french', (COALESCE(title, '') || ' ' || COALESCE(body, ''))))"
+      "CREATE INDEX posts_title_body_index ON posts USING gin (to_tsvector('simple', (COALESCE(title, '') || ' ' || COALESCE(body, ''))))",
+      "CREATE INDEX posts_title_index ON posts USING gin (to_tsvector('french', (COALESCE(title, ''))))"
     ]
-  end
-  
-  specify "should support full_text_search" do
-    POSTGRES_DB[:posts].full_text_search(:title, 'ruby').sql.should ==
-      "SELECT * FROM posts WHERE (to_tsvector('simple', (COALESCE(title, ''))) @@ to_tsquery('simple', 'ruby'))"
-    
-    POSTGRES_DB[:posts].full_text_search([:title, :body], ['ruby', 'sequel']).sql.should ==
-      "SELECT * FROM posts WHERE (to_tsvector('simple', (COALESCE(title, '') || ' ' || COALESCE(body, ''))) @@ to_tsquery('simple', 'ruby | sequel'))"
-      
-    POSTGRES_DB[:posts].full_text_search(:title, 'ruby', :language => 'french').sql.should ==
-      "SELECT * FROM posts WHERE (to_tsvector('french', (COALESCE(title, ''))) @@ to_tsquery('french', 'ruby'))"
+
+    @db[:posts].insert(:title=>'ruby rails', :body=>'yowsa')
+    @db[:posts].insert(:title=>'sequel', :body=>'ruby')
+    @db[:posts].insert(:title=>'ruby scooby', :body=>'x')
+    @db.sqls.clear
+
+    @db[:posts].full_text_search(:title, 'rails').all.should == [{:title=>'ruby rails', :body=>'yowsa'}]
+    @db[:posts].full_text_search([:title, :body], ['yowsa', 'rails']).all.should == [:title=>'ruby rails', :body=>'yowsa']
+    @db[:posts].full_text_search(:title, 'scooby', :language => 'french').all.should == [{:title=>'ruby scooby', :body=>'x'}]
+    @db.sqls.should == [
+      "SELECT * FROM posts WHERE (to_tsvector('simple', (COALESCE(title, ''))) @@ to_tsquery('simple', 'rails'))",
+      "SELECT * FROM posts WHERE (to_tsvector('simple', (COALESCE(title, '') || ' ' || COALESCE(body, ''))) @@ to_tsquery('simple', 'yowsa | rails'))",
+      "SELECT * FROM posts WHERE (to_tsvector('french', (COALESCE(title, ''))) @@ to_tsquery('french', 'scooby'))"]
   end
 
   specify "should support spatial indexes" do
-    g = Sequel::Schema::Generator.new(POSTGRES_DB) do
-      geometry :geom
-      spatial_index [:geom]
-    end
-    POSTGRES_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [
-      "CREATE TABLE posts (geom geometry)",
+    @db.create_table(:posts){box :geom; spatial_index [:geom]}
+    @db.sqls.should == [
+      "CREATE TABLE posts (geom box)",
       "CREATE INDEX posts_geom_index ON posts USING gist (geom)"
     ]
   end
   
   specify "should support indexes with index type" do
-    g = Sequel::Schema::Generator.new(POSTGRES_DB) do
-      varchar :title, :size => 5
-      index :title, :type => 'hash'
-    end
-    POSTGRES_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [
+    @db.create_table(:posts){varchar :title, :size => 5; index :title, :type => 'hash'}
+    @db.sqls.should == [
       "CREATE TABLE posts (title varchar(5))",
       "CREATE INDEX posts_title_index ON posts USING hash (title)"
     ]
   end
   
   specify "should support unique indexes with index type" do
-    g = Sequel::Schema::Generator.new(POSTGRES_DB) do
-      varchar :title, :size => 5
-      index :title, :type => 'hash', :unique => true
-    end
-    POSTGRES_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [
+    @db.create_table(:posts){varchar :title, :size => 5; index :title, :type => 'btree', :unique => true}
+    @db.sqls.should == [
       "CREATE TABLE posts (title varchar(5))",
-      "CREATE UNIQUE INDEX posts_title_index ON posts USING hash (title)"
+      "CREATE UNIQUE INDEX posts_title_index ON posts USING btree (title)"
     ]
   end
   
   specify "should support partial indexes" do
-    g = Sequel::Schema::Generator.new(POSTGRES_DB) do
-      varchar :title, :size => 5
-      index :title, :where => {:something => 5}
-    end
-    POSTGRES_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [
+    @db.create_table(:posts){varchar :title, :size => 5; index :title, :where => {:title => '5'}}
+    @db.sqls.should == [
       "CREATE TABLE posts (title varchar(5))",
-      "CREATE INDEX posts_title_index ON posts (title) WHERE (something = 5)"
+      "CREATE INDEX posts_title_index ON posts (title) WHERE (title = '5')"
     ]
   end
   
   specify "should support identifiers for table names in indicies" do
-    g = Sequel::Schema::Generator.new(POSTGRES_DB) do
-      varchar :title, :size => 5
-      index :title, :where => {:something => 5}
-    end
-    POSTGRES_DB.send(:create_table_sql_list, Sequel::SQL::Identifier.new(:posts__test), *g.create_info).should == [
-      "CREATE TABLE posts__test (title varchar(5))",
-      "CREATE INDEX posts__test_title_index ON posts__test (title) WHERE (something = 5)"
+    @db.create_table(Sequel::SQL::Identifier.new(:posts)){varchar :title, :size => 5; index :title, :where => {:title => '5'}}
+    @db.sqls.should == [
+      "CREATE TABLE posts (title varchar(5))",
+      "CREATE INDEX posts_title_index ON posts (title) WHERE (title = '5')"
     ]
   end
 end
 
-context "Postgres::Dataset#multi_insert_sql" do
+context "Postgres::Dataset#import" do
   before do
-    @ds = POSTGRES_DB[:test]
+    @db = POSTGRES_DB
+    @db.create_table!(:test){Integer :x; Integer :y}
+    @db.sqls.clear
+    @ds = @db[:test]
+  end
+  after do
+    @db.drop_table(:test) rescue nil
   end
   
-  specify "should return separate insert statements if server_version < 80200" do
+  specify "#import should return separate insert statements if server_version < 80200" do
     @ds.meta_def(:server_version){80199}
     
-    @ds.multi_insert_sql([:x, :y], [[1, 2], [3, 4]]).should == [
+    @ds.import([:x, :y], [[1, 2], [3, 4]])
+    
+    @db.sqls.should == [
+      'BEGIN',
       'INSERT INTO test (x, y) VALUES (1, 2)',
-      'INSERT INTO test (x, y) VALUES (3, 4)'
+      'INSERT INTO test (x, y) VALUES (3, 4)',
+      'COMMIT'
     ]
+    @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
   
-  specify "should a single insert statement if server_version >= 80200" do
+  specify "#import should a single insert statement if server_version >= 80200" do
     @ds.meta_def(:server_version){80200}
-   
-    @ds.multi_insert_sql([:x, :y], [[1, 2], [3, 4]]).should == [
-      'INSERT INTO test (x, y) VALUES (1, 2), (3, 4)'
-    ]
-
-    @ds.meta_def(:server_version){80201}
     
-    @ds.multi_insert_sql([:x, :y], [[1, 2], [3, 4]]).should == [
-      'INSERT INTO test (x, y) VALUES (1, 2), (3, 4)'
+    @ds.import([:x, :y], [[1, 2], [3, 4]])
+    
+    @db.sqls.should == [
+      'BEGIN',
+      'INSERT INTO test (x, y) VALUES (1, 2), (3, 4)',
+      'COMMIT'
     ]
+    @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
 end
 
 context "Postgres::Dataset#insert" do
   before do
-    @ds = POSTGRES_DB[:test5]
-    @ds.delete
+    @db = POSTGRES_DB
+    @db.create_table!(:test5){primary_key :xid; Integer :value}
+    @db.sqls.clear
+    @ds = @db[:test5]
+  end
+  after do
+    @db.drop_table(:test5) rescue nil
+  end
+
+  specify "should work regardless of how it is used" do
+    @ds.insert(:value=>10).should == 1
+    @ds.disable_insert_returning.insert(:value=>20).should == 2
+    @ds.meta_def(:server_version){80100}
+    @ds.insert(:value=>13).should == 3
+    
+    @db.sqls.reject{|x| x =~ /pg_class/}.should == [
+      'INSERT INTO test5 (value) VALUES (10) RETURNING xid',
+      'INSERT INTO test5 (value) VALUES (20)',
+      "SELECT currval('\"public\".test5_xid_seq')",
+      'INSERT INTO test5 (value) VALUES (13)',
+      "SELECT currval('\"public\".test5_xid_seq')"
+    ]
+    @ds.all.should == [{:xid=>1, :value=>10}, {:xid=>2, :value=>20}, {:xid=>3, :value=>13}]
   end
   
-  specify "should call insert_sql if server_version < 80200" do
+  specify "should call execute_insert if server_version < 80200" do
     @ds.meta_def(:server_version){80100}
     @ds.should_receive(:execute_insert).once.with('INSERT INTO test5 (value) VALUES (10)', :table=>:test5, :values=>{:value=>10})
     @ds.insert(:value=>10)
   end
 
-  specify "should call insert_sql if disabling insert returning" do
+  specify "should call execute_insert if disabling insert returning" do
     @ds.disable_insert_returning!
     @ds.should_receive(:execute_insert).once.with('INSERT INTO test5 (value) VALUES (10)', :table=>:test5, :values=>{:value=>10})
     @ds.insert(:value=>10)
@@ -530,6 +415,7 @@ context "Postgres::Database schema qualified tables" do
     POSTGRES_DB.instance_variable_set(:@primary_key_sequences, {})
   end
   after do
+    POSTGRES_DB.quote_identifiers = false
     POSTGRES_DB << "DROP SCHEMA schema_test CASCADE"
     POSTGRES_DB.default_schema = :public
   end
@@ -574,13 +460,26 @@ context "Postgres::Database schema qualified tables" do
   
   specify "should be able to get serial sequences for tables in a given schema" do
     POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
-    POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test"."schema_test_i_seq"'
+    POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test".schema_test_i_seq'
+  end
+  
+  specify "should be able to get serial sequences for tables that have spaces in the name in a given schema" do
+    POSTGRES_DB.quote_identifiers = true
+    POSTGRES_DB.create_table(:"schema_test__schema test"){primary_key :i}
+    POSTGRES_DB.primary_key_sequence(:"schema_test__schema test").should == '"schema_test"."schema test_i_seq"'
   end
   
   specify "should be able to get custom sequences for tables in a given schema" do
     POSTGRES_DB << "CREATE SEQUENCE schema_test.kseq"
     POSTGRES_DB.create_table(:schema_test__schema_test){integer :j; primary_key :k, :type=>:integer, :default=>"nextval('schema_test.kseq'::regclass)".lit}
-    POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test"."kseq"'
+    POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test".kseq'
+  end
+  
+  specify "should be able to get custom sequences for tables that have spaces in the name in a given schema" do
+    POSTGRES_DB.quote_identifiers = true
+    POSTGRES_DB << "CREATE SEQUENCE schema_test.\"ks eq\""
+    POSTGRES_DB.create_table(:"schema_test__schema test"){integer :j; primary_key :k, :type=>:integer, :default=>"nextval('schema_test.\"ks eq\"'::regclass)".lit}
+    POSTGRES_DB.primary_key_sequence(:"schema_test__schema test").should == '"schema_test"."ks eq"'
   end
   
   specify "#default_schema= should change the default schema used from public" do
@@ -589,7 +488,7 @@ context "Postgres::Database schema qualified tables" do
     POSTGRES_DB.table_exists?(:schema_test).should == true
     POSTGRES_DB.tables.should == [:schema_test]
     POSTGRES_DB.primary_key(:schema_test__schema_test).should == 'i'
-    POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test"."schema_test_i_seq"'
+    POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test".schema_test_i_seq'
   end
 end
 
@@ -637,9 +536,9 @@ context "Postgres::Database functions, languages, and triggers" do
     @d.drop_function('tf', :if_exists=>true, :cascade=>true)
     @d.drop_function('tf', :if_exists=>true, :cascade=>true, :args=>%w'integer integer')
     @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true)
-    @d.drop_trigger(:test5, :identity, :if_exists=>true, :cascade=>true)
+    @d.drop_table(:test) rescue nil
   end
-  
+
   specify "#create_function and #drop_function should create and drop functions" do
     proc{@d['SELECT tf()'].all}.should raise_error(Sequel::DatabaseError)
     args = ['tf', 'SELECT 1', {:returns=>:integer}]
@@ -682,6 +581,7 @@ context "Postgres::Database functions, languages, and triggers" do
     @d.create_language(:plpgsql)
     @d.create_function(:tf, 'BEGIN IF NEW.value IS NULL THEN RAISE EXCEPTION \'Blah\'; END IF; RETURN NEW; END;', :language=>:plpgsql, :returns=>:trigger)
     @d.send(:create_trigger_sql, :test, :identity, :tf, :each_row=>true).should == 'CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON public.test FOR EACH ROW EXECUTE PROCEDURE tf()'
+    @d.create_table(:test){String :name; Integer :value}
     @d.create_trigger(:test, :identity, :tf, :each_row=>true)
     @d[:test].insert(:name=>'a', :value=>1)
     @d[:test].filter(:name=>'a').all.should == [{:name=>'a', :value=>1}]