sequel 2.9.0 → 2.10.0

data/spec/adapters/mysql_spec.rb

@@ -33,6 +33,29 @@ def logger.method_missing(m, msg)
 end
 MYSQL_DB.logger = logger
 
+if MYSQL_DB.class.adapter_scheme == :do
+  SQL_BEGIN = 'Transaction.begin'
+  SQL_ROLLBACK = 'Transaction.rollback'
+  SQL_COMMIT = 'Transaction.commit'
+else
+  SQL_BEGIN = 'BEGIN'
+  SQL_ROLLBACK = 'ROLLBACK'
+  SQL_COMMIT = 'COMMIT'
+end
+
+context "MySQL", '#create_table' do
+  setup do
+    @db = MYSQL_DB
+  end
+  after(:each) do
+    @db.drop_table :dolls
+  end
+  specify "should allow to specify options for MySQL" do
+    @db.create_table(:dolls, :engine => 'MyISAM', :charset => 'latin2') { text :name }
+    @db.sqls.should == ["CREATE TABLE dolls (name text) ENGINE=MyISAM DEFAULT CHARSET=latin2"]
+  end
+end
+
 context "A MySQL database" do
   setup do
     @db = MYSQL_DB
@@ -142,13 +165,13 @@ context "A MySQL dataset" do
     @d.select('COUNT(*)'.lit).sql.should == \
       'SELECT COUNT(*) FROM `items`'
 
-    @d.select(:max[:value]).sql.should == \
+    @d.select(:max.sql_function(:value)).sql.should == \
       'SELECT max(`value`) FROM `items`'
       
-    @d.select(:NOW[]).sql.should == \
+    @d.select(:NOW.sql_function).sql.should == \
     'SELECT NOW() FROM `items`'
 
-    @d.select(:max[:items__value]).sql.should == \
+    @d.select(:max.sql_function(:items__value)).sql.should == \
       'SELECT max(`items`.`value`) FROM `items`'
 
     @d.order(:name.desc).sql.should == \
@@ -163,13 +186,13 @@ context "A MySQL dataset" do
     @d.select('max(items.`name`) AS `max_name`'.lit).sql.should == \
       'SELECT max(items.`name`) AS `max_name` FROM `items`'
       
-    @d.select(:test[:abc, 'hello']).sql.should == \
+    @d.select(:test.sql_function(:abc, 'hello')).sql.should == \
       "SELECT test(`abc`, 'hello') FROM `items`"
 
-    @d.select(:test[:abc__def, 'hello']).sql.should == \
+    @d.select(:test.sql_function(:abc__def, 'hello')).sql.should == \
       "SELECT test(`abc`.`def`, 'hello') FROM `items`"
 
-    @d.select(:test[:abc__def, 'hello'].as(:x2)).sql.should == \
+    @d.select(:test.sql_function(:abc__def, 'hello').as(:x2)).sql.should == \
       "SELECT test(`abc`.`def`, 'hello') AS `x2` FROM `items`"
 
     @d.insert_sql(:value => 333).should == \
@@ -220,7 +243,7 @@ context "A MySQL dataset" do
       end
     end.should raise_error(Interrupt)
 
-    MYSQL_DB.sqls.should == ['BEGIN', "INSERT INTO items (name) VALUES ('abc')", 'ROLLBACK']
+    MYSQL_DB.sqls.should == [SQL_BEGIN, "INSERT INTO items (name) VALUES ('abc')", SQL_ROLLBACK]
   end
 
   specify "should handle returning inside of the block by committing" do
@@ -232,7 +255,7 @@ context "A MySQL dataset" do
       end
     end
     MYSQL_DB.ret_commit
-    MYSQL_DB.sqls.should == ['BEGIN', "INSERT INTO items (name) VALUES ('abc')", 'COMMIT']
+    MYSQL_DB.sqls.should == [SQL_BEGIN, "INSERT INTO items (name) VALUES ('abc')", SQL_COMMIT]
   end
   
   specify "should support regexps" do
@@ -263,9 +286,9 @@ context "MySQL datasets" do
     market = 'ICE'
     ack_stamp = Time.now - 15 * 60 # 15 minutes ago
     @d.query do
-      select :market, :minute[:from_unixtime[:ack]].as(:minute)
-      where {(:ack > ack_stamp) & {:market => market}}
-      group_by :minute[:from_unixtime[:ack]]
+      select :market, :minute.sql_function(:from_unixtime.sql_function(:ack)).as(:minute)
+      where {(:ack.sql_number > ack_stamp) & {:market => market}}
+      group_by :minute.sql_function(:from_unixtime.sql_function(:ack))
     end.sql.should == \
       "SELECT `market`, minute(from_unixtime(`ack`)) AS `minute` FROM `orders` WHERE ((`ack` > #{@d.literal(ack_stamp)}) AND (`market` = 'ICE')) GROUP BY minute(from_unixtime(`ack`))"
   end
@@ -295,21 +318,6 @@ context "MySQL datasets" do
   end
 end
 
-# # Commented out because it was causing subsequent examples to fail for some reason
-# context "Simple stored procedure test" do
-#   setup do
-#     # Create a simple stored procedure but drop it first if there
-#     MYSQL_DB.execute("DROP PROCEDURE IF EXISTS sp_get_server_id;")
-#     MYSQL_DB.execute("CREATE PROCEDURE sp_get_server_id() SQL SECURITY DEFINER SELECT @@SERVER_ID as server_id;")
-#   end
-# 
-#   specify "should return the server-id via a stored procedure call" do
-#     @server_id = MYSQL_DB["SELECT @@SERVER_ID as server_id;"].first[:server_id] # grab the server_id via a simple query
-#     @server_id_by_sp = MYSQL_DB["CALL sp_get_server_id();"].first[:server_id]
-#     @server_id_by_sp.should == @server_id  # compare it to output from stored procedure
-#   end
-# end
-# 
 context "MySQL join expressions" do
   setup do
     @ds = MYSQL_DB[:nodes]
@@ -452,6 +460,52 @@ context "A MySQL database" do
   end
 end  
 
+context "A MySQL database", "with table options" do
+  before(:all) do
+    @options = {}
+    @options[:engine] = 'MyISAM'
+    @options[:charset] = 'latin2'
+    @options[:collate] = 'swedish'
+    
+    Sequel::MySQL.default_engine = 'InnoDB'
+    Sequel::MySQL.default_charset = 'utf8'
+    Sequel::MySQL.default_collate = 'utf8'    
+    
+    @db = MYSQL_DB
+    @g = Sequel::Schema::Generator.new(@db) do
+      integer :size
+      text :name
+    end
+  end
+  
+  after(:all) do
+    Sequel::MySQL.default_engine = nil
+    Sequel::MySQL.default_charset = nil
+    Sequel::MySQL.default_collate = nil
+  end
+  
+  specify "should allow to pass custom options (engine, charset, collate) for table creation" do
+    statements = @db.create_table_sql_list(:items, *(@g.create_info << @options))
+    statements.should == [
+      "CREATE TABLE items (size integer, name text) ENGINE=MyISAM DEFAULT CHARSET=latin2 DEFAULT COLLATE=swedish"
+    ]
+  end
+  
+  specify "should use default options if specified (engine, charset, collate) for table creation" do
+    statements = @db.create_table_sql_list(:items, *(@g.create_info))
+    statements.should == [
+      "CREATE TABLE items (size integer, name text) ENGINE=InnoDB DEFAULT CHARSET=utf8 DEFAULT COLLATE=utf8"
+    ]
+  end
+  
+  specify "should not use default if option has a nil value" do
+    statements = @db.create_table_sql_list(:items, *(@g.create_info << {:engine=>nil, :charset=>nil, :collate=>nil}))
+    statements.should == [
+      "CREATE TABLE items (size integer, name text)"
+    ]
+  end
+end
+
 context "A MySQL database" do
   setup do
     @db = MYSQL_DB
@@ -510,7 +564,7 @@ end
 end  
 
 # Socket tests should only be run if the MySQL server is on localhost
-if %w'localhost 127.0.0.1 ::1'.include? MYSQL_URI.host
+if %w'localhost 127.0.0.1 ::1'.include?(MYSQL_URI.host) and MYSQL_DB.class.adapter_scheme == :mysql
   context "A MySQL database" do
     specify "should accept a socket option" do
       db = Sequel.mysql(MYSQL_DB.opts[:database], :host => 'localhost', :user => MYSQL_DB.opts[:user], :password => MYSQL_DB.opts[:password], :socket => MYSQL_SOCKET_FILE)
@@ -667,9 +721,9 @@ context "MySQL::Dataset#multi_insert" do
     @d.multi_insert([{:name => 'abc'}, {:name => 'def'}])
     
     MYSQL_DB.sqls.should == [
-      'BEGIN',
+      SQL_BEGIN,
       "INSERT INTO items (name) VALUES ('abc'), ('def')",
-      'COMMIT'
+      SQL_COMMIT
     ]
 
     @d.all.should == [
@@ -682,12 +736,12 @@ context "MySQL::Dataset#multi_insert" do
       :commit_every => 2)
 
     MYSQL_DB.sqls.should == [
-      'BEGIN',
+      SQL_BEGIN,
       "INSERT INTO items (value) VALUES (1), (2)",
-      'COMMIT',
-      'BEGIN',
+      SQL_COMMIT,
+      SQL_BEGIN,
       "INSERT INTO items (value) VALUES (3), (4)",
-      'COMMIT'
+      SQL_COMMIT
     ]
     
     @d.all.should == [
@@ -703,12 +757,12 @@ context "MySQL::Dataset#multi_insert" do
       :slice => 2)
 
     MYSQL_DB.sqls.should == [
-      'BEGIN',
+      SQL_BEGIN,
       "INSERT INTO items (value) VALUES (1), (2)",
-      'COMMIT',
-      'BEGIN',
+      SQL_COMMIT,
+      SQL_BEGIN,
       "INSERT INTO items (value) VALUES (3), (4)",
-      'COMMIT'
+      SQL_COMMIT
     ]
     
     @d.all.should == [
@@ -723,9 +777,9 @@ context "MySQL::Dataset#multi_insert" do
     @d.multi_insert([:name, :value], [['abc', 1], ['def', 2]])
 
     MYSQL_DB.sqls.should == [
-      'BEGIN',
+      SQL_BEGIN,
       "INSERT INTO items (name, value) VALUES ('abc', 1), ('def', 2)",
-      'COMMIT'
+      SQL_COMMIT
     ]
     
     @d.all.should == [
@@ -778,7 +832,7 @@ context "MySQL::Dataset#complex_expression_sql" do
   specify "should handle string concatenation with CONCAT if more than one record" do
     @d.literal([:x, :y].sql_string_join).should == "CONCAT(x, y)"
     @d.literal([:x, :y].sql_string_join(' ')).should == "CONCAT(x, ' ', y)"
-    @d.literal([:x[:y], 1, 'z'.lit].sql_string_join(:y|1)).should == "CONCAT(x(y), y[1], '1', y[1], z)"
+    @d.literal([:x.sql_function(:y), 1, 'z'.lit].sql_string_join(:y|1)).should == "CONCAT(x(y), y[1], '1', y[1], z)"
   end
 
   specify "should handle string concatenation as simple string if just one record" do
@@ -787,27 +841,29 @@ context "MySQL::Dataset#complex_expression_sql" do
   end
 end
 
-context "MySQL Stored Procedures" do
-  teardown do
-    MYSQL_DB.execute('DROP PROCEDURE test_sproc')
-  end
-  
-  specify "should be callable on the database object" do
-    MYSQL_DB.execute('CREATE PROCEDURE test_sproc() BEGIN DELETE FROM items; END')
-    MYSQL_DB[:items].delete
-    MYSQL_DB[:items].insert(:value=>1)
-    MYSQL_DB[:items].count.should == 1
-    MYSQL_DB.call_sproc(:test_sproc)
-    MYSQL_DB[:items].count.should == 0
-  end
-  
-  specify "should be callable on the dataset object" do
-    MYSQL_DB.execute('CREATE PROCEDURE test_sproc(a INTEGER) BEGIN SELECT *, a AS b FROM items; END')
-    @d = MYSQL_DB[:items]
-    @d.call_sproc(:select, :test_sproc, 3).should == []
-    @d.insert(:value=>1)
-    @d.call_sproc(:select, :test_sproc, 4).should == [{:id=>nil, :value=>1, :b=>4}]
-    @d.row_proc = proc{|r| r.keys.each{|k| r[k] *= 2 if r[k].is_a?(Integer)}; r}
-    @d.call_sproc(:select, :test_sproc, 3).should == [{:id=>nil, :value=>2, :b=>6}]
+unless MYSQL_DB.class.adapter_scheme == :do
+  context "MySQL Stored Procedures" do
+    teardown do
+      MYSQL_DB.execute('DROP PROCEDURE test_sproc')
+    end
+    
+    specify "should be callable on the database object" do
+      MYSQL_DB.execute('CREATE PROCEDURE test_sproc() BEGIN DELETE FROM items; END')
+      MYSQL_DB[:items].delete
+      MYSQL_DB[:items].insert(:value=>1)
+      MYSQL_DB[:items].count.should == 1
+      MYSQL_DB.call_sproc(:test_sproc)
+      MYSQL_DB[:items].count.should == 0
+    end
+    
+    specify "should be callable on the dataset object" do
+      MYSQL_DB.execute('CREATE PROCEDURE test_sproc(a INTEGER) BEGIN SELECT *, a AS b FROM items; END')
+      @d = MYSQL_DB[:items]
+      @d.call_sproc(:select, :test_sproc, 3).should == []
+      @d.insert(:value=>1)
+      @d.call_sproc(:select, :test_sproc, 4).should == [{:id=>nil, :value=>1, :b=>4}]
+      @d.row_proc = proc{|r| r.keys.each{|k| r[k] *= 2 if r[k].is_a?(Integer)}; r}
+      @d.call_sproc(:select, :test_sproc, 3).should == [{:id=>nil, :value=>2, :b=>6}]
+    end
   end
 end

data/spec/adapters/oracle_spec.rb

@@ -113,25 +113,25 @@ context "An Oracle dataset" do
     
     @d.max(:value).to_i.should == 789
     
-    @d.select(:name, :AVG[:value]).filter(:name => 'abc').group(:name).to_a.should == [
+    @d.select(:name, :AVG.sql_function(:value)).filter(:name => 'abc').group(:name).to_a.should == [
       {:name => 'abc', :"avg(value)" => (456+123)/2.0}
     ]
 
-    @d.select(:AVG[:value]).group(:name).order(:name).limit(1).to_a.should == [
+    @d.select(:AVG.sql_function(:value)).group(:name).order(:name).limit(1).to_a.should == [
       {:"avg(value)" => (456+123)/2.0}
     ]
         
-    @d.select(:name, :AVG[:value]).group(:name).order(:name).to_a.should == [
+    @d.select(:name, :AVG.sql_function(:value)).group(:name).order(:name).to_a.should == [
       {:name => 'abc', :"avg(value)" => (456+123)/2.0},
       {:name => 'def', :"avg(value)" => 789*1.0}
     ]
     
-    @d.select(:name, :AVG[:value]).group(:name).order(:name).to_a.should == [
+    @d.select(:name, :AVG.sql_function(:value)).group(:name).order(:name).to_a.should == [
       {:name => 'abc', :"avg(value)" => (456+123)/2.0},
       {:name => 'def', :"avg(value)" => 789*1.0}
     ]
 
-    @d.select(:name, :AVG[:value]).group(:name).having(:name => ['abc', 'def']).order(:name).to_a.should == [
+    @d.select(:name, :AVG.sql_function(:value)).group(:name).having(:name => ['abc', 'def']).order(:name).to_a.should == [
       {:name => 'abc', :"avg(value)" => (456+123)/2.0},
       {:name => 'def', :"avg(value)" => 789*1.0}
     ]

data/spec/adapters/postgres_spec.rb

@@ -4,7 +4,7 @@ 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
-
+#POSTGRES_DB.instance_variable_set(:@server_version, 80100)
 POSTGRES_DB.create_table! :test do
   text :name
   integer :value, :index => true
@@ -125,13 +125,13 @@ context "A PostgreSQL dataset" do
     @d.select('COUNT(*)'.lit).sql.should == \
       'SELECT COUNT(*) FROM "test"'
 
-    @d.select(:max[:value]).sql.should == \
+    @d.select(:max.sql_function(:value)).sql.should == \
       'SELECT max("value") FROM "test"'
       
-    @d.select(:NOW[]).sql.should == \
+    @d.select(:NOW.sql_function).sql.should == \
     'SELECT NOW() FROM "test"'
 
-    @d.select(:max[:items__value]).sql.should == \
+    @d.select(:max.sql_function(:items__value)).sql.should == \
       'SELECT max("items"."value") FROM "test"'
 
     @d.order(:name.desc).sql.should == \
@@ -146,13 +146,13 @@ context "A PostgreSQL dataset" do
     @d.select('max(test."name") AS "max_name"'.lit).sql.should == \
       'SELECT max(test."name") AS "max_name" FROM "test"'
       
-    @d.select(:test[:abc, 'hello']).sql.should == \
+    @d.select(:test.sql_function(:abc, 'hello')).sql.should == \
       "SELECT test(\"abc\", 'hello') FROM \"test\""
 
-    @d.select(:test[:abc__def, 'hello']).sql.should == \
+    @d.select(:test.sql_function(:abc__def, 'hello')).sql.should == \
       "SELECT test(\"abc\".\"def\", 'hello') FROM \"test\""
 
-    @d.select(:test[:abc__def, 'hello'].as(:x2)).sql.should == \
+    @d.select(:test.sql_function(:abc__def, 'hello').as(:x2)).sql.should == \
       "SELECT test(\"abc\".\"def\", 'hello') AS \"x2\" FROM \"test\""
 
     @d.insert_sql(:value => 333).should =~ \
@@ -260,6 +260,10 @@ context "A PostgreSQL dataset" 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_blob].get(:a) == "\1\2\3"
   end
@@ -343,7 +347,7 @@ context "A PostgreSQL database" do
       full_text_index [:title, :body]
     end
     POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
-      "CREATE TABLE public.posts (title text, body text)",
+      "CREATE TABLE posts (title text, body text)",
       "CREATE INDEX posts_title_body_index ON posts USING gin (to_tsvector('simple', (COALESCE(title, '') || ' ' || COALESCE(body, ''))))"
     ]
   end
@@ -355,7 +359,7 @@ 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 public.posts (title text, body text)",
+      "CREATE TABLE posts (title text, body text)",
       "CREATE INDEX posts_title_body_index ON posts USING gin (to_tsvector('french', (COALESCE(title, '') || ' ' || COALESCE(body, ''))))"
     ]
   end
@@ -377,7 +381,7 @@ context "A PostgreSQL database" do
       spatial_index [:geom]
     end
     POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
-      "CREATE TABLE public.posts (geom geometry)",
+      "CREATE TABLE posts (geom geometry)",
       "CREATE INDEX posts_geom_index ON posts USING gist (geom)"
     ]
   end
@@ -388,7 +392,7 @@ context "A PostgreSQL database" do
       index :title, :type => 'hash'
     end
     POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
-      "CREATE TABLE public.posts (title varchar(5))",
+      "CREATE TABLE posts (title varchar(5))",
       "CREATE INDEX posts_title_index ON posts USING hash (title)"
     ]
   end
@@ -399,7 +403,7 @@ 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 public.posts (title varchar(5))",
+      "CREATE TABLE posts (title varchar(5))",
       "CREATE UNIQUE INDEX posts_title_index ON posts USING hash (title)"
     ]
   end
@@ -410,10 +414,21 @@ context "A PostgreSQL database" do
       index :title, :where => {:something => 5}
     end
     POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
-      "CREATE TABLE public.posts (title varchar(5))",
+      "CREATE TABLE posts (title varchar(5))",
       "CREATE INDEX posts_title_index ON posts (title) WHERE (something = 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.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)"
+    ]
+  end
 end
 
 context "Postgres::Dataset#multi_insert_sql / #import" do
@@ -542,18 +557,18 @@ context "Postgres::Database schema qualified tables" do
   
   specify "should be able to get primary keys for tables in a given schema" do
     POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
-    POSTGRES_DB.synchronize{|c| POSTGRES_DB.send(:primary_key_for_table, c, :schema_test__schema_test).should == 'i'}
+    POSTGRES_DB.primary_key(:schema_test__schema_test).should == 'i'
   end
   
   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.synchronize{|c| POSTGRES_DB.send(:primary_key_sequence_for_table, c, :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 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.synchronize{|c| POSTGRES_DB.send(:primary_key_sequence_for_table, c, :schema_test__schema_test).should == '"schema_test"."kseq"'}
+    POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test"."kseq"'
   end
   
   specify "#default_schema= should change the default schema used from public" do
@@ -561,8 +576,8 @@ context "Postgres::Database schema qualified tables" do
     POSTGRES_DB.default_schema = :schema_test
     POSTGRES_DB.table_exists?(:schema_test).should == true
     POSTGRES_DB.tables.should == [:schema_test]
-    POSTGRES_DB.synchronize{|c| POSTGRES_DB.send(:primary_key_for_table, c, :schema_test).should == 'i'}
-    POSTGRES_DB.synchronize{|c| POSTGRES_DB.send(:primary_key_sequence_for_table, c, :schema_test).should == '"schema_test"."schema_test_i_seq"'}
+    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"'
   end
 end