sequel_core 2.2.0 → 3.8.0

data/spec/object_graph_spec.rb

@@ -1,230 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe Sequel::Dataset, " graphing" do
-  before do
-    dbc = Class.new
-    @db = dbc.new
-    @ds1 = Sequel::Dataset.new(@db).from(:points)
-    @ds2 = Sequel::Dataset.new(@db).from(:lines)
-    @ds3 = Sequel::Dataset.new(@db).from(:graphs)
-    dss = {:points=>@ds1, :lines=>@ds2, :graphs=>@ds3}
-    dbc.send(:define_method, :[]){|ds| dss[ds]} 
-    def @ds1.columns; [:id, :x, :y] end
-    def @ds2.columns; [:id, :x, :y, :graph_id] end
-    def @ds3.columns; [:id, :name, :x, :y, :lines_x] end
-  end
-
-  it "#graph should not modify the current dataset's opts" do
-    o1 = @ds1.opts
-    o2 = o1.dup
-    ds1 = @ds1.graph(@ds2, :x=>:id)
-    @ds1.opts.should == o1
-    @ds1.opts.should == o2
-    ds1.opts.should_not == o1
-  end
-
-  it "#graph should accept a dataset as the dataset" do
-    ds = @ds1.graph(@ds2, :x=>:id)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-  end
-
-  it "#graph should accept a symbol table name as the dataset" do
-    ds = @ds1.graph(:lines, :x=>:id)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-  end
-
-  it "#graph should accept an object that responds to dataset as the dataset" do
-    oc = Class.new
-    o = oc.new
-    ds = @ds2
-    oc.send(:define_method, :dataset){ds} 
-    ds = @ds1.graph(o, :x=>:id)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    ds = :lines
-    oc.send(:define_method, :dataset){ds} 
-    ds = @ds1.graph(o, :x=>:id)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-  end
-
-  it "#graph should accept a :table_alias option" do
-    ds = @ds1.graph(:lines, {:x=>:id}, :table_alias=>:planes)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, planes.id AS planes_id, planes.x AS planes_x, planes.y AS planes_y, planes.graph_id FROM points LEFT OUTER JOIN lines AS planes ON (planes.x = points.id)'
-  end
-
-  it "#graph should accept a :join_type option" do
-    ds = @ds1.graph(:lines, {:x=>:id}, :join_type=>:inner)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points INNER JOIN lines ON (lines.x = points.id)'
-  end
-
-  it "#graph should not select any columns from the graphed table if :select option is false" do
-    ds = @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, graphs.id AS graphs_id, graphs.name, graphs.x AS graphs_x, graphs.y AS graphs_y, graphs.lines_x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id) LEFT OUTER JOIN graphs ON (graphs.id = lines.graph_id)'
-  end
-
-  it "#graph should use the given columns if :select option is used" do
-    ds = @ds1.graph(:lines, {:x=>:id}, :select=>[:x, :graph_id]).graph(:graphs, :id=>:graph_id)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.x AS lines_x, lines.graph_id, graphs.id AS graphs_id, graphs.name, graphs.x AS graphs_x, graphs.y AS graphs_y, graphs.lines_x AS graphs_lines_x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id) LEFT OUTER JOIN graphs ON (graphs.id = lines.graph_id)'
-  end
-
-  it "#graph should pass all join_conditions to join_table" do
-    ds = @ds1.graph(@ds2, [[:x, :id], [:y, :id]])
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON ((lines.x = points.id) AND (lines.y = points.id))'
-  end
-
-  it "#graph should accept a block instead of conditions and pass it to join_table" do
-    ds = @ds1.graph(@ds2){|ja, lja, js| [[:x.qualify(ja), :id.qualify(lja)], [:y.qualify(ja), :id.qualify(lja)]]}
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON ((lines.x = points.id) AND (lines.y = points.id))'
-  end
-
-  it "#graph should not add columns if graph is called after set_graph_aliases" do
-    ds = @ds1.set_graph_aliases([[:x,[:points, :x]], [:y,[:lines, :y]]])
-    ds.sql.should == 'SELECT points.x, lines.y FROM points'
-    ds = ds.graph(:lines, :x=>:id)
-    ds.sql.should == 'SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-  end
-
-  it "#graph should allow graphing of multiple datasets" do
-    ds = @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id, graphs.id AS graphs_id, graphs.name, graphs.x AS graphs_x, graphs.y AS graphs_y, graphs.lines_x AS graphs_lines_x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id) LEFT OUTER JOIN graphs ON (graphs.id = lines.graph_id)'
-  end
-
-  it "#graph should allow graphing of the same dataset multiple times" do
-    ds = @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id, graph.id AS graph_id_0, graph.x AS graph_x, graph.y AS graph_y, graph.graph_id AS graph_graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id) LEFT OUTER JOIN lines AS graph ON (graph.y = points.id)'
-  end
-
-  it "#graph should raise an error if the table/table alias has already been used" do
-    proc{@ds1.graph(@ds1, :x=>:id)}.should raise_error(Sequel::Error)
-    proc{@ds1.graph(@ds2, :x=>:id)}.should_not raise_error
-    proc{@ds1.graph(@ds2, :x=>:id).graph(@ds2, :x=>:id)}.should raise_error(Sequel::Error)
-    proc{@ds1.graph(@ds2, :x=>:id).graph(@ds2, {:x=>:id}, :table_alias=>:blah)}.should_not raise_error
-  end
-
-  it "#set_graph_aliases should not modify the current dataset's opts" do
-    o1 = @ds1.opts
-    o2 = o1.dup
-    ds1 = @ds1.set_graph_aliases(:x=>[:graphs,:id])
-    @ds1.opts.should == o1
-    @ds1.opts.should == o2
-    ds1.opts.should_not == o1
-  end
-
-  it "#set_graph_aliases should specify the graph mapping" do
-    ds = @ds1.graph(:lines, :x=>:id)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    ds = ds.set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y])
-    ['SELECT points.x, lines.y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
-    'SELECT lines.y, points.x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    ].should(include(ds.sql))
-  end
-
-  it "#set_graph_aliases should only alias columns if necessary" do
-    ds = @ds1.set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y])
-    ['SELECT points.x, lines.y FROM points',
-    'SELECT lines.y, points.x FROM points'
-    ].should(include(ds.sql))
-
-    ds = @ds1.set_graph_aliases(:x1=>[:points, :x], :y=>[:lines, :y])
-    ['SELECT points.x AS x1, lines.y FROM points',
-    'SELECT lines.y, points.x AS x1 FROM points'
-    ].should(include(ds.sql))
-  end
-
-  it "#graph_each should split the result set into component tables" do
-    ds = @ds1.graph(@ds2, :x=>:id)
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}}
-
-    ds = @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id)
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}
-
-    ds = @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph)
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graph_id_0=>8, :graph_x=>9, :graph_y=>10, :graph_graph_id=>11})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11}}
-  end
-
-  it "#graph_each should give a nil value instead of a hash when all values for a table are nil" do
-    ds = @ds1.graph(@ds2, :x=>:id)
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:id=>1, :x=>2, :y=>3}, :lines=>nil}
-
-    ds = @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id)
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil})
-      yield({:id=>2,:x=>4,:y=>5,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil})
-      yield({:id=>3,:x=>5,:y=>6,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>7, :name=>8, :graphs_x=>9, :graphs_y=>10, :graphs_lines_x=>11})
-      yield({:id=>3,:x=>5,:y=>6,:lines_id=>7,:lines_x=>5,:lines_y=>8,:graph_id=>9, :graphs_id=>9, :name=>10, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12})
-    end
-    results = ds.all
-    results.length.should == 4
-    results[0].should == {:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>nil}
-    results[1].should == {:points=>{:id=>2, :x=>4, :y=>5}, :lines=>nil, :graphs=>nil}
-    results[2].should == {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>7, :name=>8, :x=>9, :y=>10, :lines_x=>11}}
-    results[3].should == {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>7, :x=>5, :y=>8, :graph_id=>9}, :graphs=>{:id=>9, :name=>10, :x=>10, :y=>11, :lines_x=>12}}
-  end
-
-  it "#graph_each should not included tables graphed with the :select => false option in the result set" do
-    ds = @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id)
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :lines_x=>12})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:id=>1, :x=>2, :y=>3}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}
-  end
-
-  it "#graph_each should only include the columns selected with #set_graph_aliases, if called" do
-    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y])
-    def ds.fetch_rows(sql, &block)
-      yield({:x=>2,:y=>3})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:x=>2}, :lines=>{:y=>3}}
-
-    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x])
-    def ds.fetch_rows(sql, &block)
-      yield({:x=>2})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:x=>2}, :lines=>nil}
-  end
-
-  it "#graph_each should run the row_proc and transform for graphed datasets" do
-    @ds1.row_proc = proc{|h| h.keys.each{|k| h[k] *= 2}; h}
-    @ds2.row_proc = proc{|h| h.keys.each{|k| h[k] *= 3}; h}
-    @ds1.transform(:x=>[
-      proc{|v| 123},
-      proc{|v| 123}
-    ])
-    @ds2.transform(:x=>[
-      proc{|v| 321},
-      proc{|v| 321}
-    ])
-    ds = @ds1.graph(@ds2, :x=>:id)
-    def ds.fetch_rows(sql, &block)
-      yield({:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7})
-    end
-    results = ds.all
-    results.length.should == 1
-    results.first.should == {:points=>{:id=>2, :x=>246, :y=>6}, :lines=>{:id=>12, :x=>963, :y=>18, :graph_id=>21}}
-  end
-end

data/spec/pretty_table_spec.rb

@@ -1,58 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-require 'stringio'
-
-context "PrettyTable" do
-  setup do
-    @data1 = [
-      {:x => 3, :y => 4}
-    ]
-    
-    @data2 = [
-      {:a => 23, :b => 45},
-      {:a => 45, :b => 2377}
-    ]
-
-    @data3 = [
-      {:aaa => 1},
-      {:bb => 2},
-      {:c => 3}
-    ]
-
-    @output = StringIO.new
-    @orig_stdout = $stdout
-    $stdout = @output
-  end
-
-  teardown do
-    $stdout = @orig_stdout
-  end
-  
-  specify "should infer the columns if not given" do
-    Sequel::PrettyTable.print(@data1)
-    @output.rewind
-    @output.read.should =~ \
-      /\n(\|x\|y\|)|(\|y\|x\|)\n/
-  end
-  
-  specify "should calculate the maximum width of each column correctly" do
-    Sequel::PrettyTable.print(@data2, [:a, :b])
-    @output.rewind
-    @output.read.should == \
-      "+--+----+\n|a |b   |\n+--+----+\n|23|  45|\n|45|2377|\n+--+----+\n"
-  end
-
-  specify "should also take header width into account" do
-    Sequel::PrettyTable.print(@data3, [:aaa, :bb, :c])
-    @output.rewind
-    @output.read.should == \
-      "+---+--+-+\n|aaa|bb|c|\n+---+--+-+\n|  1|  | |\n|   | 2| |\n|   |  |3|\n+---+--+-+\n"
-  end
-  
-  specify "should print only the specified columns" do
-    Sequel::PrettyTable.print(@data2, [:a])
-    @output.rewind
-    @output.read.should == \
-      "+--+\n|a |\n+--+\n|23|\n|45|\n+--+\n"
-  end
-end

data/spec/rcov.opts

@@ -1,6 +0,0 @@
---exclude
-gems
---exclude
-spec
---exclude
-00*

data/spec/schema_generator_spec.rb

@@ -1,122 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe Sequel::Schema::Generator do
-  before do
-    @generator = Sequel::Schema::Generator.new(SchemaDummyDatabase.new) do
-      string :title
-      column :body, :text
-      foreign_key :parent_id
-      primary_key :id
-      check 'price > 100'
-      constraint(:xxx) {:yyy == :zzz}
-      index :title
-      index [:title, :body]
-      foreign_key :node_id, :nodes
-    end
-    @columns, @indexes = @generator.create_info
-  end
-  
-  {:name => :id, :primary_key => true}.each do |column, expected|
-    it "uses default primary key #{column}" do
-      @columns.first[column].should == expected
-    end
-  end
-  
-  it "counts primary key, column and constraint definitions as columns" do
-    @columns.size.should == 7
-  end
-  
-  it "places primary key first" do
-    @columns[0][:primary_key].should     be_true
-    @columns[1][:primary_key].should_not be_true
-    @columns[2][:primary_key].should_not be_true
-  end
-
-  it "retrieves primary key name" do
-    @generator.primary_key_name.should == :id
-  end
-
-  it "keeps columns in order" do
-    @columns[1][:name].should == :title
-    @columns[1][:type].should == :string
-    @columns[2][:name].should == :body
-    @columns[2][:type].should == :text
-  end
-  
-  it "creates foreign key column" do
-    @columns[3][:name].should == :parent_id
-    @columns[3][:type].should == :integer
-    @columns[6][:name].should == :node_id
-    @columns[6][:type].should == :integer
-  end
-  
-  it "uses table for foreign key columns, if specified" do
-    @columns[6][:table].should == :nodes
-    @columns[3][:table].should == nil
-  end
-  
-  it "finds columns" do
-    [:title, :body, :parent_id, :id].each do |col|
-      @generator.has_column?(col).should be_true
-    end
-    @generator.has_column?(:foo).should_not be_true
-  end
-  
-  it "creates constraints" do
-    @columns[4][:name].should == nil
-    @columns[4][:type].should == :check
-    @columns[4][:check].should == ['price > 100']
-
-    @columns[5][:name].should == :xxx
-    @columns[5][:type].should == :check
-    @columns[5][:check].should be_a_kind_of(Proc)
-  end
-  
-  it "creates indexes" do
-    @indexes[0][:columns].should include(:title)
-    @indexes[1][:columns].should include(:title)
-    @indexes[1][:columns].should include(:body)
-  end
-end
-
-describe Sequel::Schema::AlterTableGenerator do
-  before do
-    @generator = Sequel::Schema::AlterTableGenerator.new(SchemaDummyDatabase.new) do
-      add_column :aaa, :text
-      drop_column :bbb
-      rename_column :ccc, :ho
-      set_column_type :ddd, :float
-      set_column_default :eee, 1
-      add_index [:fff, :ggg]
-      drop_index :hhh
-      add_full_text_index :blah
-      add_spatial_index :geom
-      add_index :blah, :type => :hash
-      add_index :blah, :where => {:something => true}
-      add_constraint :con1, ':fred > 100'
-      drop_constraint :con2
-      add_primary_key :id
-      add_foreign_key :node_id, :nodes
-    end
-  end
-  
-  specify "should generate operation records" do
-    @generator.operations.should == [
-      {:op => :add_column, :name => :aaa, :type => :text},
-      {:op => :drop_column, :name => :bbb},
-      {:op => :rename_column, :name => :ccc, :new_name => :ho},
-      {:op => :set_column_type, :name => :ddd, :type => :float},
-      {:op => :set_column_default, :name => :eee, :default => 1},
-      {:op => :add_index, :columns => [:fff, :ggg]},
-      {:op => :drop_index, :columns => [:hhh]},
-      {:op => :add_index, :columns => [:blah], :type => :full_text},
-      {:op => :add_index, :columns => [:geom], :type => :spatial},
-      {:op => :add_index, :columns => [:blah], :type => :hash},
-      {:op => :add_index, :columns => [:blah], :where => {:something => true}},
-      {:op => :add_constraint, :type => :check, :name => :con1, :check => [':fred > 100']},
-      {:op => :drop_constraint, :name => :con2},
-      {:op => :add_column, :name => :id, :type => :integer, :primary_key=>true, :auto_increment=>true},
-      {:op => :add_column, :name => :node_id, :type => :integer, :table=>:nodes}
-    ]
-  end
-end

data/spec/schema_spec.rb

@@ -1,422 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-context "DB#create_table" do
-  setup do
-    @db = SchemaDummyDatabase.new
-  end
-  
-  specify "should accept the table name" do
-    @db.create_table(:cats) {}
-    @db.sqls.should == ['CREATE TABLE cats ()']
-  end
-
-  specify "should accept multiple columns" do
-    @db.create_table(:cats) do
-      column :id, :integer
-      column :name, :text
-    end
-    @db.sqls.should == ['CREATE TABLE cats (id integer, name text)']
-  end
-  
-  specify "should accept method calls as data types" do
-    @db.create_table(:cats) do
-      integer :id
-      text :name
-    end
-    @db.sqls.should == ['CREATE TABLE cats (id integer, name text)']
-  end
-
-  specify "should accept primary key definition" do
-    @db.create_table(:cats) do
-      primary_key :id
-    end
-    @db.sqls.should == ['CREATE TABLE cats (id integer PRIMARY KEY AUTOINCREMENT)']
-
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      primary_key :id, :serial, :auto_increment => false
-    end
-    @db.sqls.should == ['CREATE TABLE cats (id serial PRIMARY KEY)']
-
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      primary_key :id, :type => :serial, :auto_increment => false
-    end
-    @db.sqls.should == ['CREATE TABLE cats (id serial PRIMARY KEY)']
-  end
-
-  specify "should accept and literalize default values" do
-    @db.create_table(:cats) do
-      integer :id, :default => 123
-      text :name, :default => "abc'def"
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer DEFAULT 123, name text DEFAULT 'abc''def')"]
-  end
-  
-  specify "should accept not null definition" do
-    @db.create_table(:cats) do
-      integer :id
-      text :name, :null => false
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer, name text NOT NULL)"]
-  end
-  
-  specify "should accept null definition" do
-    @db.create_table(:cats) do
-      integer :id
-      text :name, :null => true
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer, name text NULL)"]
-  end
-  
-  specify "should accept unique definition" do
-    @db.create_table(:cats) do
-      integer :id
-      text :name, :unique => true
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer, name text UNIQUE)"]
-  end
-  
-  specify "should accept unsigned definition" do
-    @db.create_table(:cats) do
-      integer :value, :unsigned => true
-    end
-    @db.sqls.should == ["CREATE TABLE cats (value integer UNSIGNED)"]
-  end
-  
-  specify "should accept [SET|ENUM](...) types" do
-    @db.create_table(:cats) do
-      set :color, :elements => ['black', 'tricolor', 'grey']
-    end
-    @db.sqls.should == ["CREATE TABLE cats (color set('black', 'tricolor', 'grey'))"]
-  end
-  
-  specify "should accept varchar size" do
-    @db.create_table(:cats) do
-      varchar :name
-    end
-    @db.sqls.should == ["CREATE TABLE cats (name varchar(255))"]
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      varchar :name, :size => 51
-    end
-    @db.sqls.should == ["CREATE TABLE cats (name varchar(51))"]
-  end
-  
-  specify "should accept varchar size as sql function" do
-    @db.create_table(:cats) do
-      column :name, :varchar[102]
-    end
-    @db.sqls.should == ["CREATE TABLE cats (name varchar(102))"]
-  end
-
-  specify "should accept foreign keys without options" do
-    @db.create_table(:cats) do
-      foreign_key :project_id
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer)"]
-  end
-
-  specify "should accept foreign keys with options" do
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects)"]
-  end
-
-  specify "should accept foreign keys with separate table argument" do
-    @db.create_table(:cats) do
-      foreign_key :project_id, :projects, :default=>3
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer DEFAULT 3 REFERENCES projects)"]
-  end
-  
-  specify "should accept foreign keys with arbitrary keys" do
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :key => :id
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects(id))"]
-
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :key => :zzz
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects(zzz))"]
-  end
-  
-  specify "should accept foreign keys with ON DELETE clause" do
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :on_delete => :restrict
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE RESTRICT)"]
-
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :on_delete => :cascade
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE CASCADE)"]
-
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :on_delete => :no_action
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE NO ACTION)"]
-    @db.sqls.clear
-
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :on_delete => :set_null
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE SET NULL)"]
-    @db.sqls.clear
-
-    @db.sqls.clear
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :on_delete => :set_default
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE SET DEFAULT)"]
-    @db.sqls.clear
-  end
-  
-  specify "should accept inline index definition" do
-    @db.create_table(:cats) do
-      integer :id, :index => true
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_id_index ON cats (id)"]
-  end
-  
-  specify "should accept inline index definition for foreign keys" do
-    @db.create_table(:cats) do
-      foreign_key :project_id, :table => :projects, :on_delete => :cascade, :index => true
-    end
-    @db.sqls.should == ["CREATE TABLE cats (project_id integer REFERENCES projects ON DELETE CASCADE)",
-      "CREATE INDEX cats_project_id_index ON cats (project_id)"]
-  end
-  
-  specify "should accept index definitions" do
-    @db.create_table(:cats) do
-      integer :id
-      index :id
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_id_index ON cats (id)"]
-  end
-
-  specify "should accept unique index definitions" do
-    @db.create_table(:cats) do
-      text :name
-      unique :name
-    end
-    @db.sqls.should == ["CREATE TABLE cats (name text)", "CREATE UNIQUE INDEX cats_name_index ON cats (name)"]
-  end
-
-  specify "should raise on full-text index definitions" do
-    proc {
-      @db.create_table(:cats) do
-        text :name
-        full_text_index :name
-      end
-    }.should raise_error(Sequel::Error)
-  end
-
-  specify "should raise on spatial index definitions" do
-    proc {
-      @db.create_table(:cats) do
-        point :geom
-        spatial_index :geom
-      end
-    }.should raise_error(Sequel::Error)
-  end
-
-  specify "should raise on partial index definitions" do
-    proc {
-      @db.create_table(:cats) do
-        text :name
-        index :name, :where => {:something => true}
-      end
-    }.should raise_error(Sequel::Error)
-  end
-
-  specify "should raise index definitions with type" do
-    proc {
-      @db.create_table(:cats) do
-        text :name
-        index :name, :type => :hash
-      end
-    }.should raise_error(Sequel::Error)
-  end
-
-  specify "should accept multiple index definitions" do
-    @db.create_table(:cats) do
-      integer :id
-      index :id
-      index :name
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX cats_id_index ON cats (id)", "CREATE INDEX cats_name_index ON cats (name)"]
-  end
-  
-  specify "should accept custom index names" do
-    @db.create_table(:cats) do
-      integer :id
-      index :id, :name => 'abc'
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE INDEX abc ON cats (id)"]
-  end
-
-  specify "should accept unique index definitions" do
-    @db.create_table(:cats) do
-      integer :id
-      index :id, :unique => true
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE UNIQUE INDEX cats_id_index ON cats (id)"]
-  end
-  
-  specify "should accept composite index definitions" do
-    @db.create_table(:cats) do
-      integer :id
-      index [:id, :name], :unique => true
-    end
-    @db.sqls.should == ["CREATE TABLE cats (id integer)", "CREATE UNIQUE INDEX cats_id_name_index ON cats (id, name)"]
-  end
-  
-  specify "should accept unnamed constraint definitions with blocks" do
-    @db.create_table(:cats) do
-      integer :score
-      check {(:x > 0) & (:y < 1)}
-    end
-    @db.sqls.should == ["CREATE TABLE cats (score integer, CHECK ((x > 0) AND (y < 1)))"]
-  end
-
-  specify "should accept unnamed constraint definitions" do
-    @db.create_table(:cats) do
-      check 'price < ?', 100
-    end
-    @db.sqls.should == ["CREATE TABLE cats (CHECK (price < 100))"]
-  end
-
-  specify "should accept named constraint definitions" do
-    @db.create_table(:cats) do
-      integer :score
-      constraint :valid_score, 'score <= 100'
-    end
-    @db.sqls.should == ["CREATE TABLE cats (score integer, CONSTRAINT valid_score CHECK (score <= 100))"]
-  end
-
-  specify "should accept named constraint definitions with block" do
-    @db.create_table(:cats) do
-      constraint(:blah_blah) {(:x > 0) & (:y < 1)}
-    end
-    @db.sqls.should == ["CREATE TABLE cats (CONSTRAINT blah_blah CHECK ((x > 0) AND (y < 1)))"]
-  end
-end
-
-context "DB#create_table!" do
-  setup do
-    @db = SchemaDummyDatabase.new
-  end
-  
-  specify "should drop the table and then create it" do
-    @db.create_table!(:cats) {}
-    @db.sqls.should == ['DROP TABLE cats', 'CREATE TABLE cats ()']
-  end
-end
-
-context "DB#drop_table" do
-  setup do
-    @db = SchemaDummyDatabase.new
-  end
-
-  specify "should generate a DROP TABLE statement" do
-    @db.drop_table :cats
-    @db.sqls.should == ['DROP TABLE cats']
-  end
-end
-
-context "DB#alter_table" do
-  setup do
-    @db = SchemaDummyDatabase.new
-  end
-
-  specify "should support add_column" do
-    @db.alter_table(:cats) do
-      add_column :score, :integer
-    end
-    @db.sqls.should == ["ALTER TABLE cats ADD COLUMN score integer"]
-  end
-
-  specify "should support add_constraint" do
-    @db.alter_table(:cats) do
-      add_constraint :valid_score, 'score <= 100'
-    end
-    @db.sqls.should == ["ALTER TABLE cats ADD CONSTRAINT valid_score CHECK (score <= 100)"]
-  end
-
-  specify "should support add_constraint with block" do
-    @db.alter_table(:cats) do
-      add_constraint(:blah_blah) {(:x > 0) & (:y < 1)}
-    end
-    @db.sqls.should == ["ALTER TABLE cats ADD CONSTRAINT blah_blah CHECK ((x > 0) AND (y < 1))"]
-  end
-
-  specify "should support add_foreign_key" do
-    @db.alter_table(:cats) do
-      add_foreign_key :node_id, :nodes
-    end
-    @db.sqls.should == ["ALTER TABLE cats ADD COLUMN node_id integer REFERENCES nodes"]
-  end
-
-  specify "should support add_index" do
-    @db.alter_table(:cats) do
-      add_index :name
-    end
-    @db.sqls.should == ["CREATE INDEX cats_name_index ON cats (name)"]
-  end
-
-  specify "should support add_primary_key" do
-    @db.alter_table(:cats) do
-      add_primary_key :id
-    end
-    @db.sqls.should == ["ALTER TABLE cats ADD COLUMN id integer PRIMARY KEY AUTOINCREMENT"]
-  end
-
-  specify "should support drop_column" do
-    @db.alter_table(:cats) do
-      drop_column :score
-    end
-    @db.sqls.should == ["ALTER TABLE cats DROP COLUMN score"]
-  end
-
-  specify "should support drop_constraint" do
-    @db.alter_table(:cats) do
-      drop_constraint :valid_score
-    end
-    @db.sqls.should == ["ALTER TABLE cats DROP CONSTRAINT valid_score"]
-  end
-
-  specify "should support drop_index" do
-    @db.alter_table(:cats) do
-      drop_index :name
-    end
-    @db.sqls.should == ["DROP INDEX cats_name_index"]
-  end
-
-  specify "should support rename_column" do
-    @db.alter_table(:cats) do
-      rename_column :name, :old_name
-    end
-    @db.sqls.should == ["ALTER TABLE cats RENAME COLUMN name TO old_name"]
-  end
-
-  specify "should support set_column_default" do
-    @db.alter_table(:cats) do
-      set_column_default :score, 3
-    end
-    @db.sqls.should == ["ALTER TABLE cats ALTER COLUMN score SET DEFAULT 3"]
-  end
-
-  specify "should support set_column_type" do
-    @db.alter_table(:cats) do
-      set_column_type :score, :real
-    end
-    @db.sqls.should == ["ALTER TABLE cats ALTER COLUMN score TYPE real"]
-  end
-end