sequel_core 1.5.1 → 2.0.0

data/spec/adapters/postgres_spec.rb

@@ -1,23 +1,19 @@
-require File.join(File.dirname(__FILE__), '../../lib/sequel_core')
 require File.join(File.dirname(__FILE__), '../spec_helper.rb')
 
 unless defined?(POSTGRES_DB)
-  POSTGRES_DB = Sequel.connect(ENV['SEQUEL_PG_SPEC_DB']||'postgres://postgres:postgres@localhost:5432/reality_spec')
+  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
 
-POSTGRES_DB.drop_table(:test) if POSTGRES_DB.table_exists?(:test)
-POSTGRES_DB.drop_table(:test2) if POSTGRES_DB.table_exists?(:test2)
-POSTGRES_DB.drop_table(:test3) if POSTGRES_DB.table_exists?(:test3)
-  
-POSTGRES_DB.create_table :test do
+POSTGRES_DB.create_table! :test do
   text :name
   integer :value, :index => true
 end
-POSTGRES_DB.create_table :test2 do
+POSTGRES_DB.create_table! :test2 do
   text :name
   integer :value
 end
-POSTGRES_DB.create_table :test3 do
+POSTGRES_DB.create_table! :test3 do
   integer :value
   timestamp :time
 end
@@ -37,6 +33,18 @@ context "A PostgreSQL database" do
   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
+    @db.schema(:test3, :reload=>true).should == [[:value, {:type=>:integer, :allow_null=>true, :max_chars=>0, :default=>nil, :db_type=>"integer", :numeric_precision=>32}], [:time, {:type=>:datetime, :allow_null=>true, :max_chars=>0, :default=>nil, :db_type=>"timestamp without time zone", :numeric_precision=>0}]]
+  end
+
+  specify "should get the schema all database tables if no table name is used" do
+    @db.schema(:test3, :reload=>true).should == @db.schema(nil, :reload=>true)[:test3]
+  end
 end
 
 context "A PostgreSQL dataset" do
@@ -93,62 +101,64 @@ context "A PostgreSQL dataset" do
     proc {@d.literal(false)}.should_not raise_error
   end
   
-  specify "should quote columns using double quotes" do
+  specify "should quote columns and tables using double quotes if quoting identifiers" do
+    @d.quote_identifiers = true
     @d.select(:name).sql.should == \
-      'SELECT "name" FROM test'
+      'SELECT "name" FROM "test"'
       
     @d.select('COUNT(*)'.lit).sql.should == \
-      'SELECT COUNT(*) FROM test'
+      'SELECT COUNT(*) FROM "test"'
 
     @d.select(:max[:value]).sql.should == \
-      'SELECT max("value") FROM test'
+      'SELECT max("value") FROM "test"'
       
     @d.select(:NOW[]).sql.should == \
-    'SELECT NOW() FROM test'
+    'SELECT NOW() FROM "test"'
 
     @d.select(:max[:items__value]).sql.should == \
-      'SELECT max(items."value") FROM test'
+      'SELECT max("items"."value") FROM "test"'
 
     @d.order(:name.desc).sql.should == \
-      'SELECT * FROM test ORDER BY "name" DESC'
+      'SELECT * FROM "test" ORDER BY "name" DESC'
 
     @d.select('test.name AS item_name'.lit).sql.should == \
-      'SELECT test.name AS item_name FROM test'
+      'SELECT test.name AS item_name FROM "test"'
       
     @d.select('"name"'.lit).sql.should == \
-      'SELECT "name" FROM test'
+      'SELECT "name" FROM "test"'
 
     @d.select('max(test."name") AS "max_name"'.lit).sql.should == \
-      'SELECT max(test."name") AS "max_name" FROM test'
+      'SELECT max(test."name") AS "max_name" FROM "test"'
       
     @d.select(:test[:abc, 'hello']).sql.should == \
-      "SELECT test(\"abc\", 'hello') FROM test"
+      "SELECT test(\"abc\", 'hello') FROM \"test\""
 
     @d.select(:test[:abc__def, 'hello']).sql.should == \
-      "SELECT test(abc.\"def\", 'hello') FROM test"
+      "SELECT test(\"abc\".\"def\", 'hello') FROM \"test\""
 
     @d.select(:test[:abc__def, 'hello'].as(:x2)).sql.should == \
-      "SELECT test(abc.\"def\", 'hello') AS \"x2\" FROM test"
+      "SELECT test(\"abc\".\"def\", 'hello') AS \"x2\" FROM \"test\""
 
     @d.insert_sql(:value => 333).should == \
-      'INSERT INTO test ("value") VALUES (333)'
+      'INSERT INTO "test" ("value") VALUES (333)'
 
     @d.insert_sql(:x => :y).should == \
-      'INSERT INTO test ("x") VALUES ("y")'
+      'INSERT INTO "test" ("x") VALUES ("y")'
   end
   
-  specify "should quote fields correctly when reversing the order" do
+  specify "should quote fields correctly when reversing the order if quoting identifiers" do
+    @d.quote_identifiers = true
     @d.reverse_order(:name).sql.should == \
-      'SELECT * FROM test ORDER BY "name" DESC'
+      'SELECT * FROM "test" ORDER BY "name" DESC'
 
     @d.reverse_order(:name.desc).sql.should == \
-      'SELECT * FROM test ORDER BY "name"'
+      'SELECT * FROM "test" ORDER BY "name"'
 
     @d.reverse_order(:name, :test.desc).sql.should == \
-      'SELECT * FROM test ORDER BY "name" DESC, "test"'
+      'SELECT * FROM "test" ORDER BY "name" DESC, "test"'
 
     @d.reverse_order(:name.desc, :test).sql.should == \
-      'SELECT * FROM test ORDER BY "name", "test" DESC'
+      'SELECT * FROM "test" ORDER BY "name", "test" DESC'
   end
   
   specify "should support transactions" do
@@ -159,6 +169,39 @@ context "A PostgreSQL dataset" do
     @d.count.should == 1
   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)
+
+    @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 regexps" do
     @d << {:name => 'abc', :value => 1}
     @d << {:name => 'bcd', :value => 2}
@@ -167,8 +210,8 @@ context "A PostgreSQL dataset" do
   end
 
   specify "should consider strings containing backslashes to be escaped string literals" do
-    PGconn.quote("\\dingo").should == "E'\\\\dingo'"   # literally, E'\\dingo'
-    PGconn.quote("dingo").should == "'dingo'"
+    @d.literal("\\dingo").should == "'\\\\dingo'"   # literally, E'\\dingo'
+    @d.literal("dingo").should == "'dingo'"
   end
 end
 
@@ -191,22 +234,21 @@ context "A PostgreSQL database" do
     @db = POSTGRES_DB
   end
 
-  specify "should support add_column operations" do
+  specify "should support column operations" do
+    @db.create_table!(:test2){text :name; integer :value}
+    @db[:test2] << {}
+    @db[:test2].columns.should == [:name, :value]
+
     @db.add_column :test2, :xyz, :text, :default => '000'
-    
     @db[:test2].columns.should == [:name, :value, :xyz]
     @db[:test2] << {:name => 'mmm', :value => 111}
     @db[:test2].first[:xyz].should == '000'
-  end
   
-  specify "should support drop_column operations" do
     @db[:test2].columns.should == [:name, :value, :xyz]
     @db.drop_column :test2, :xyz
     
     @db[:test2].columns.should == [:name, :value]
-  end
   
-  specify "should support rename_column operations" do
     @db[:test2].delete
     @db.add_column :test2, :xyz, :text, :default => '000'
     @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 'qqqq'}
@@ -215,9 +257,7 @@ context "A PostgreSQL database" do
     @db.rename_column :test2, :xyz, :zyx
     @db[:test2].columns.should == [:name, :value, :zyx]
     @db[:test2].first[:zyx].should == 'qqqq'
-  end
   
-  specify "should support set_column_type operations" do
     @db.add_column :test2, :xyz, :float
     @db[:test2].delete
     @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 56.78}
@@ -238,8 +278,8 @@ context "A PostgreSQL database" do
       full_text_index [:title, :body]
     end
     POSTGRES_DB.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(\"title\" || \"body\"))"
+      "CREATE TABLE posts (title text, body text)",
+      "CREATE INDEX posts_title_body_index ON posts USING gin (to_tsvector(title || body))"
     ]
   end
   
@@ -250,20 +290,20 @@ context "A PostgreSQL database" do
       full_text_index [:title, :body], :language => 'french'
     end
     POSTGRES_DB.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('french', \"title\" || \"body\"))"
+      "CREATE TABLE posts (title text, body text)",
+      "CREATE INDEX posts_title_body_index ON posts USING gin (to_tsvector('french', title || body))"
     ]
   end
   
   specify "should support full_text_search" do
     POSTGRES_DB[:posts].full_text_search(:title, 'ruby').sql.should ==
-      "SELECT * FROM posts WHERE (to_tsvector(\"title\") @@ to_tsquery('ruby'))"
+      "SELECT * FROM posts WHERE (to_tsvector(title) @@ to_tsquery('ruby'))"
     
     POSTGRES_DB[:posts].full_text_search([:title, :body], ['ruby', 'sequel']).sql.should ==
-      "SELECT * FROM posts WHERE (to_tsvector(\"title\" || \"body\") @@ to_tsquery('ruby | sequel'))"
+      "SELECT * FROM posts WHERE (to_tsvector(title || body) @@ to_tsquery('ruby | sequel'))"
       
     POSTGRES_DB[:posts].full_text_search(:title, 'ruby', :language => 'french').sql.should ==
-      "SELECT * FROM posts WHERE (to_tsvector('french', \"title\") @@ to_tsquery('french', 'ruby'))"
+      "SELECT * FROM posts WHERE (to_tsvector('french', title) @@ to_tsquery('french', 'ruby'))"
   end
 
   specify "should support spatial indexes" do
@@ -272,8 +312,8 @@ context "A PostgreSQL database" do
       spatial_index [:geom]
     end
     POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
-      "CREATE TABLE posts (\"geom\" geometry)",
-      "CREATE INDEX posts_geom_index ON posts USING gist (\"geom\")"
+      "CREATE TABLE posts (geom geometry)",
+      "CREATE INDEX posts_geom_index ON posts USING gist (geom)"
     ]
   end
   
@@ -283,8 +323,8 @@ context "A PostgreSQL database" do
       index :title, :type => 'hash'
     end
     POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
-      "CREATE TABLE posts (\"title\" varchar(5))",
-      "CREATE INDEX posts_title_index ON posts USING hash (\"title\")"
+      "CREATE TABLE posts (title varchar(5))",
+      "CREATE INDEX posts_title_index ON posts USING hash (title)"
     ]
   end
   
@@ -294,8 +334,8 @@ context "A PostgreSQL database" do
       index :title, :type => 'hash', :unique => true
     end
     POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
-      "CREATE TABLE posts (\"title\" varchar(5))",
-      "CREATE UNIQUE INDEX posts_title_index ON posts USING hash (\"title\")"
+      "CREATE TABLE posts (title varchar(5))",
+      "CREATE UNIQUE INDEX posts_title_index ON posts USING hash (title)"
     ]
   end
   
@@ -305,8 +345,8 @@ context "A PostgreSQL database" do
       index :title, :where => {:something => 5}
     end
     POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
-      "CREATE TABLE posts (\"title\" varchar(5))",
-      "CREATE INDEX posts_title_index ON posts (\"title\") WHERE (\"something\" = 5)"
+      "CREATE TABLE posts (title varchar(5))",
+      "CREATE INDEX posts_title_index ON posts (title) WHERE (something = 5)"
     ]
   end
 end
@@ -320,8 +360,8 @@ context "Postgres::Dataset#multi_insert_sql / #import" do
     @ds.db.meta_def(:server_version) {80199}
     
     @ds.multi_insert_sql([:x, :y], [[1, 2], [3, 4]]).should == [
-      'INSERT INTO test ("x", "y") VALUES (1, 2)',
-      'INSERT INTO test ("x", "y") VALUES (3, 4)'
+      'INSERT INTO test (x, y) VALUES (1, 2)',
+      'INSERT INTO test (x, y) VALUES (3, 4)'
     ]
   end
   
@@ -329,13 +369,13 @@ context "Postgres::Dataset#multi_insert_sql / #import" do
     @ds.db.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)'
+      'INSERT INTO test (x, y) VALUES (1, 2), (3, 4)'
     ]
 
     @ds.db.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)'
+      'INSERT INTO test (x, y) VALUES (1, 2), (3, 4)'
     ]
   end
 end

data/spec/adapters/sqlite_spec.rb

@@ -1,4 +1,3 @@
-require File.join(File.dirname(__FILE__), '../../lib/sequel_core')
 require File.join(File.dirname(__FILE__), '../spec_helper.rb')
 
 unless defined?(SQLITE_DB)
@@ -17,9 +16,12 @@ end
 SQLITE_DB.create_table(:time) {timestamp :t}
 
 context "An SQLite database" do
-  setup do
+  before do
     @db = Sequel.connect('sqlite:/')
   end
+  after do
+    @db.disconnect
+  end
   
   specify "should provide a list of existing tables" do
     @db.tables.should == []
@@ -37,13 +39,15 @@ context "An SQLite database" do
   specify "should support setting pragma values" do
     @db.pragma_set(:auto_vacuum, '1')
     @db.pragma_get(:auto_vacuum).should == '1'
+    @db.pragma_set(:auto_vacuum, '2')
+    @db.pragma_get(:auto_vacuum).should == '2'
   end
   
   specify "should support getting and setting the auto_vacuum pragma" do
     @db.auto_vacuum = :full
     @db.auto_vacuum.should == :full
-    @db.auto_vacuum = :none
-    @db.auto_vacuum.should == :none
+    @db.auto_vacuum = :incremental
+    @db.auto_vacuum.should == :incremental
     
     proc {@db.auto_vacuum = :invalid}.should raise_error(Sequel::Error)
   end
@@ -123,6 +127,29 @@ context "An SQLite database" do
     @db.tables.should == [:t]
   end
   
+  specify "should handle returning inside of transaction by committing" do
+    @db.create_table(:items){text :name}
+    def @db.ret_commit
+      transaction do
+        self[:items] << {:name => 'abc'}
+        return
+        self[:items] << {:name => 'd'}
+      end
+    end
+    @db[:items].count.should == 0
+    @db.ret_commit
+    @db[:items].count.should == 1
+    @db.ret_commit
+    @db[:items].count.should == 2
+    proc do
+      @db.transaction do
+        raise Interrupt, 'asdf'
+      end
+    end.should raise_error(Interrupt)
+
+    @db[:items].count.should == 2
+  end
+
   specify "should provide disconnect functionality" do
     @db.tables
     @db.pool.size.should == 1
@@ -162,6 +189,20 @@ context "An SQLite database" do
     proc {@db.single_value 'blah blah'}.should raise_error(
       Sequel::Error::InvalidStatement, "blah blah\r\nnear \"blah\": syntax error")
   end
+  
+  specify "should not swallow non-SQLite based exceptions" do
+    proc {@db.pool.hold{raise Interrupt, "test"}}.should raise_error(Interrupt)
+  end
+
+  specify "should correctly parse the schema" do
+    @db.create_table(:time) {timestamp :t}
+    @db.schema(:time, :reload=>true).should == [[:t, {:type=>:datetime, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"timestamp", :numeric_precision=>nil, :primary_key=>false}]]
+  end
+
+  specify "should get the schema all database tables if no table name is used" do
+    @db.create_table(:time) {timestamp :t}
+    @db.schema(:time, :reload=>true).should == @db.schema(nil, :reload=>true)[:time]
+  end
 end
 
 context "An SQLite dataset" do