sequel 0.1.9.5 → 0.1.9.6

data/CHANGELOG

@@ -1,4 +1,12 @@
-=== SVN
+=== 0.2 (2007-08-13)
+
+* Refactored schema definition code. Gets rid of famous primary_key problem as well as other issues (e.g. issue #22).
+
+* Added #pagination_record_count, #page_range and #current_page_record_range for paginated datasets.
+
+* Changed MySQL adapter to automatically reconnect (issue #26).
+
+* Changed Sequel() to acccept variable arity.
 
 * Added :elements option to column definition, in order to support ENUM and SET types.
 

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "sequel"
-VERS = "0.1.9.5"
+VERS = "0.1.9.6"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "Sequel: Concise ORM for Ruby",
   "--opname", "index.html",

data/lib/sequel.rb

@@ -1,8 +1,8 @@
 require 'metaid'
 
 files = %w[
-  core_ext error database connection_pool pretty_table expressions 
-  dataset schema migration model
+  core_ext error schema database connection_pool pretty_table expressions 
+  dataset migration model
 ]
 dir = File.join(File.dirname(__FILE__), 'sequel')
 files.each {|f| require(File.join(dir, f))}
@@ -31,7 +31,7 @@ module Sequel #:nodoc:
 end
 
 class Object
-  def Sequel(uri)
-    Sequel.connect(uri)
+  def Sequel(*args)
+    Sequel.connect(*args)
   end
 end

data/lib/sequel/database.rb

@@ -110,6 +110,38 @@ module Sequel
       true
     end
     
+    include Schema::SQL
+    
+    NULL = "NULL".freeze
+    TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S'".freeze
+    DATE_FORMAT = "DATE '%Y-%m-%d'".freeze
+    TRUE = "'t'".freeze
+    FALSE = "'f'".freeze
+
+    # default literal implementation for use in schema definitions
+    def literal(v)
+      case v
+      when ExpressionString: v
+      when String: "'#{v.gsub(/'/, "''")}'"
+      when Integer, Float: v.to_s
+      when NilClass: NULL
+      when TrueClass: TRUE
+      when FalseClass: FALSE
+      when Symbol: v.to_field_name
+      when Array: v.empty? ? NULL : v.map {|i| literal(i)}.join(COMMA_SEPARATOR)
+      when Time: v.strftime(TIMESTAMP_FORMAT)
+      when Date: v.strftime(DATE_FORMAT)
+      when Dataset: "(#{v.sql})"
+      else
+        raise SequelError, "can't express #{v.inspect} as a SQL literal"
+      end
+    end
+    
+    # default serial primary key definition. this should be overriden for each adapter.
+    def serial_primary_key_options
+      {:primary_key => true, :type => :integer, :auto_increment => true}
+    end
+    
     # Creates a table. The easiest way to use this method is to provide a
     # block:
     #   DB.create_table :posts do
@@ -119,16 +151,13 @@ module Sequel
     #     index :title
     #   end
     def create_table(name, &block)
-      schema = Schema.new
-      schema.create_table(name, &block)
-      schema.create(self)
+      g = Schema::Generator.new(self, name, &block)
+      execute(create_table_sql(*g.create_info))
     end
     
     # Drops a table.
     def drop_table(*names)
-      transaction do
-        execute(names.map {|n| Schema.drop_table_sql(n)}.join)
-      end
+      execute(names.map {|n| drop_table_sql(n)}.join)
     end
     
     # Performs a brute-force check for the existance of a table. This method is
@@ -171,7 +200,7 @@ module Sequel
         end
       end
     end
-    
+
     @@adapters = Hash.new
     
     # Sets the adapter scheme for the Database class. Call this method in

data/lib/sequel/dataset/dataset_convenience.rb

@@ -80,19 +80,27 @@ module Sequel
         end
       end
 
-      # returns a paginated dataset. The resulting dataset also provides the
+      # Returns a paginated dataset. The resulting dataset also provides the
       # total number of pages (Dataset#page_count) and the current page number
       # (Dataset#current_page), as well as Dataset#prev_page and Dataset#next_page
       # for implementing pagination controls.
       def paginate(page_no, page_size)
-        total_pages = (count / page_size.to_f).ceil
+        record_count = count
+        total_pages = (record_count / page_size.to_f).ceil
         paginated = limit(page_size, (page_no - 1) * page_size)
-        paginated.current_page = page_no
-        paginated.page_count = total_pages
+        paginated.set_pagination_info(page_no, page_size, record_count)
         paginated
       end
+      
+      # Sets the pagination info
+      def set_pagination_info(page_no, page_size, record_count)
+        @current_page = page_no
+        @page_size = page_size
+        @pagination_record_count = record_count
+        @page_count = (record_count / page_size.to_f).ceil
+      end
 
-      attr_accessor :page_count, :current_page
+      attr_accessor :page_size, :page_count, :current_page, :pagination_record_count
 
       # Returns the previous page number or nil if the current page is the first
       def prev_page
@@ -103,6 +111,21 @@ module Sequel
       def next_page
         current_page < page_count ? (current_page + 1) : nil
       end
+      
+      # Returns the page range
+      def page_range
+        1..page_count
+      end
+      
+      # Returns the record range for the current page
+      def current_page_record_range
+        return nil if @current_page > @page_count
+        
+        a = 1 + (@current_page - 1) * @page_size
+        b = a + @page_size - 1
+        b = @pagination_record_count if b > @pagination_record_count
+        a..b
+      end
 
       # Returns the minimum value for the given field.
       def min(field)

data/lib/sequel/dataset/dataset_sql.rb

@@ -44,6 +44,8 @@ module Sequel
       NULL = "NULL".freeze
       TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S'".freeze
       DATE_FORMAT = "DATE '%Y-%m-%d'".freeze
+      TRUE = "'t'".freeze
+      FALSE = "'f'".freeze
 
       # Returns a literal representation of a value to be used as part
       # of an SQL expression. The stock implementation supports literalization 
@@ -64,8 +66,8 @@ module Sequel
         when String: "'#{v.gsub(/'/, "''")}'"
         when Integer, Float: v.to_s
         when NilClass: NULL
-        when TrueClass: 't'
-        when FalseClass: 'f'
+        when TrueClass: TRUE
+        when FalseClass: FALSE
         when Symbol: v.to_field_name
         when Array: v.empty? ? NULL : v.map {|i| literal(i)}.join(COMMA_SEPARATOR)
         when Time: v.strftime(TIMESTAMP_FORMAT)

data/lib/sequel/migration.rb

@@ -106,6 +106,7 @@ module Sequel
       target ||= latest_migration_version(directory)
       raise SequelError, "No current version available" if current.nil?
       raise SequelError, "No target version available" if target.nil?
+
       direction = current < target ? :up : :down
       
       classes = migration_classes(directory, target, current, direction)
@@ -121,9 +122,14 @@ module Sequel
     def self.migration_classes(directory, target, current, direction)
       range = direction == :up ?
         (current + 1)..target : (target + 1)..current
-        
-      # load migration files
+
+      # Remove class definitions
+      Migration.descendants.each do |c|
+        Object.send(:remove_const, c.to_s) rescue nil
+      end
       Migration.descendants.clear # remove any defined migration classes
+
+      # load migration files
       migration_files(directory, range).each {|fn| load(fn)}
       
       # get migration classes

data/lib/sequel/mysql.rb

@@ -55,10 +55,21 @@ module Sequel
     class Database < Sequel::Database
       set_adapter_scheme :mysql
     
+      def serial_primary_key_options
+        {:primary_key => true, :type => :integer, :auto_increment => true}
+      end
+      
+      AUTO_INCREMENT = 'AUTO_INCREMENT'.freeze
+      
+      def auto_increment_sql
+        AUTO_INCREMENT
+      end
+
       def connect
         conn = Mysql.real_connect(@opts[:host], @opts[:user], @opts[:password], 
           @opts[:database], @opts[:port])
         conn.query_with_result = false
+        conn.reconnect = true
         conn
       end
       

data/lib/sequel/postgres.rb

@@ -159,7 +159,6 @@ module Sequel
       RELATION_FILTER = "(relkind = 'r') AND (relname !~ '^pg|sql')".freeze
       SYSTEM_TABLE_REGEXP = /^pg|sql/.freeze
     
-    
       def tables
         dataset(RELATION_QUERY).filter(RELATION_FILTER).map {|r| r[:relname].to_sym}
       end
@@ -265,6 +264,13 @@ module Sequel
         end
       end
 
+      def serial_primary_key_options
+        {:primary_key => true, :type => :serial}
+      end
+
+      def drop_table_sql(name)
+        "DROP TABLE #{name} CASCADE;"
+      end
     end
   
     class Dataset < Sequel::Dataset

data/lib/sequel/schema.rb

@@ -1,183 +1,8 @@
 module Sequel
-  class Schema
-    class << self
-      include Dataset::SQL
-    end
-    
-    COMMA_SEPARATOR = ', '.freeze
-    COLUMN_DEF = '%s %s'.freeze
-    COLUMN_MEMBERS_DEF = '(%d)'.freeze
-    UNIQUE = ' UNIQUE'.freeze
-    NOT_NULL = ' NOT NULL'.freeze
-    DEFAULT = ' DEFAULT %s'.freeze
-    PRIMARY_KEY = ' PRIMARY KEY'.freeze
-    REFERENCES = ' REFERENCES %s'.freeze
-    ON_DELETE = ' ON DELETE %s'.freeze
-    AUTOINCREMENT = ' AUTOINCREMENT'.freeze
-    
-    RESTRICT = 'RESTRICT'.freeze
-    CASCADE = 'CASCADE'.freeze
-    NO_ACTION = 'NO ACTION'.freeze
-    SET_NULL = 'SET NULL'.freeze
-    SET_DEFAULT = 'SET DEFAULT'.freeze
-    
-    TYPES = Hash.new {|h, k| k}
-    TYPES[:double] = 'double precision'
-    
-    def self.on_delete_action(action)
-      case action
-      when :restrict: RESTRICT
-      when :cascade: CASCADE
-      when :set_null: SET_NULL
-      when :set_default: SET_DEFAULT
-      else NO_ACTION
-      end
-    end
-    
-    def self.column_definition(column)
-      c = COLUMN_DEF % [column[:name], TYPES[column[:type]]]
-      column[:size] ||= 255 if column[:type] == :varchar
-      atts = column[:size] || column[:elements]
-      c << COLUMN_MEMBERS_DEF % literal(atts) if atts
-      c << UNIQUE if column[:unique]
-      c << NOT_NULL if column[:null] == false
-      c << DEFAULT % literal(column[:default]) if column.include?(:default)
-      c << PRIMARY_KEY if column[:primary_key]
-      c << REFERENCES % column[:table] if column[:table]
-      c << ON_DELETE % on_delete_action(column[:on_delete]) if 
-        column[:on_delete]
-      c << AUTOINCREMENT if column[:auto_increment]
-      c
-    end
-  
-    def self.create_table_column_list(columns)
-      columns.map {|c| column_definition(c)}.join(COMMA_SEPARATOR)
-    end
-    
-    CREATE_INDEX = 'CREATE INDEX %s ON %s (%s);'.freeze
-    CREATE_UNIQUE_INDEX = 'CREATE UNIQUE INDEX %s ON %s (%s);'.freeze
-    INDEX_NAME = '%s_%s_index'.freeze
-    UNDERSCORE = '_'.freeze
-    
-    def self.index_definition(table_name, index)
-      fields = index[:columns].join(COMMA_SEPARATOR)
-      index_name = index[:name] || INDEX_NAME %
-        [table_name, index[:columns].join(UNDERSCORE)]
-      (index[:unique] ? CREATE_UNIQUE_INDEX : CREATE_INDEX) %
-        [index_name, table_name, fields]
-    end
-    
-    def self.create_indexes_sql(table_name, indexes)
-      indexes.map {|i| index_definition(table_name, i)}.join
-    end
-  
-    CREATE_TABLE = "CREATE TABLE %s (%s);".freeze
-    
-    def self.create_table_sql(name, columns, indexes = nil)
-      sql = CREATE_TABLE % [name, create_table_column_list(columns)]
-      sql << create_indexes_sql(name, indexes) if indexes && !indexes.empty?
-      sql
-    end
-    
-    DROP_TABLE = "DROP TABLE %s CASCADE;".freeze
-    
-    def self.drop_table_sql(name)
-      DROP_TABLE % name
-    end
-    
-    class Generator
-      attr_reader :table_name
-    
-      def initialize(table_name, auto_primary_key = nil, &block)
-        @table_name = table_name
-        @primary_key = auto_primary_key
-        @columns = []
-        @indexes = []
-        instance_eval(&block)
-      end
-      
-      def method_missing(type, name = nil, opts = nil)
-        return super unless name
-        column(name, type, opts)
-      end
-      
-      def primary_key(name, type = nil, opts = nil)
-        @primary_key = {
-          :name => name, 
-          :type => type || :serial,
-          :primary_key => true
-        }.merge(opts || {})
-      end
-      
-      def primary_key_name
-        @primary_key && @primary_key[:name]
-      end
-      
-      def column(name, type, opts = nil)
-        @columns << {:name => name, :type => type}.merge(opts || {})
-      end
-      
-      def foreign_key(name, opts)
-        @columns << {:name => name, :type => :integer}.merge(opts || {})
-      end
-      
-      def has_column?(name)
-        @columns.each {|c| return true if c[:name] == name}
-        false
-      end
-      
-      def index(columns, opts = nil)
-        columns = [columns] unless columns.is_a?(Array)
-        @indexes << {:columns => columns}.merge(opts || {})
-      end
-      
-      def create_sql
-        if @primary_key && !has_column?(@primary_key[:name])
-          @columns.unshift(@primary_key)
-        end
-        Schema.create_table_sql(@table_name, @columns, @indexes)
-      end
-      
-      def drop_sql
-        Schema.drop_table_sql(@table_name)
-      end
-    end
-    
-    attr_reader :instructions
-    
-    def initialize(&block)
-      @instructions = []
-      instance_eval(&block) if block
-    end
-    
-    def auto_primary_key(name, type = nil, opts = nil)
-      @auto_primary_key = {
-        :name => name,
-        :type => type || :serial,
-        :primary_key => true
-      }.merge(opts || {})
-    end
-    
-    def create_table(table_name, &block)
-      @instructions << Generator.new(table_name, @auto_primary_key, &block)
-    end
-    
-    def create(db)
-      @instructions.each do |s|
-        db.execute(s.create_sql)
-      end
-    end
-    
-    def drop(db)
-      @instructions.reverse_each do |s|
-        db.execute(s.drop_sql) if db.table_exists?(s.table_name)
-      end
-    end
-    
-    def recreate(db)
-      drop(db)
-      create(db)
-    end
+  module Schema
   end
 end
 
+require File.join(File.dirname(__FILE__), 'schema/schema_sql')
+require File.join(File.dirname(__FILE__), 'schema/schema_generator')
+

data/lib/sequel/schema/schema_generator.rb

@@ -0,0 +1,53 @@
+module Sequel
+  module Schema
+    class Generator
+      def initialize(db, table_name, &block)
+        @db = db
+        @table_name = table_name
+        @columns = []
+        @indexes = []
+        instance_eval(&block)
+      end
+      
+      def method_missing(type, name = nil, opts = nil)
+        return super unless name
+        column(name, type, opts)
+      end
+      
+      def primary_key(name, type = nil, opts = nil)
+        @primary_key = @db.serial_primary_key_options.merge({
+          :name => name
+        })
+        @primary_key.merge!({:type => type}) if type
+        @primary_key.merge!(opts) if opts
+        @primary_key
+      end
+      
+      def column(name, type, opts = nil)
+        @columns << {:name => name, :type => type}.merge(opts || {})
+      end
+      
+      def foreign_key(name, opts)
+        @columns << {:name => name, :type => :integer}.merge(opts || {})
+      end
+      
+      def has_column?(name)
+        @columns.each {|c| return true if c[:name] == name}
+        false
+      end
+      
+      def index(columns, opts = nil)
+        columns = [columns] unless columns.is_a?(Array)
+        @indexes << {:columns => columns}.merge(opts || {})
+      end
+      
+      def create_info
+        if @primary_key && !has_column?(@primary_key[:name])
+          @columns.unshift(@primary_key)
+        end
+        [@table_name, @columns, @indexes]
+      end
+    end
+  end
+end
+

data/lib/sequel/schema/schema_sql.rb

@@ -0,0 +1,85 @@
+module Sequel
+  module Schema
+    module SQL
+      RESTRICT = 'RESTRICT'.freeze
+      CASCADE = 'CASCADE'.freeze
+      NO_ACTION = 'NO ACTION'.freeze
+      SET_NULL = 'SET NULL'.freeze
+      SET_DEFAULT = 'SET DEFAULT'.freeze
+    
+      def on_delete_clause(action)
+        case action
+        when :restrict: RESTRICT
+        when :cascade: CASCADE
+        when :set_null: SET_NULL
+        when :set_default: SET_DEFAULT
+        else NO_ACTION
+        end
+      end
+      
+      AUTOINCREMENT = 'AUTOINCREMENT'.freeze
+
+      def auto_increment_sql
+        AUTOINCREMENT
+      end
+      
+      COMMA_SEPARATOR = ', '.freeze
+      UNIQUE = ' UNIQUE'.freeze
+      NOT_NULL = ' NOT NULL'.freeze
+      PRIMARY_KEY = ' PRIMARY KEY'.freeze
+
+      TYPES = Hash.new {|h, k| k}
+      TYPES[:double] = 'double precision'
+
+      def column_definition_sql(column)
+        sql = "#{column[:name]} #{TYPES[column[:type]]}"
+        column[:size] ||= 255 if column[:type] == :varchar
+        elements = column[:size] || column[:elements]
+        sql << "(#{literal(elements)})" if elements
+        sql << UNIQUE if column[:unique]
+        sql << NOT_NULL if column[:null] == false
+        sql << " DEFAULT #{literal(column[:default])}" if column.include?(:default)
+        sql << PRIMARY_KEY if column[:primary_key]
+        sql << " REFERENCES #{column[:table]}" if column[:table]
+        sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
+        sql << " #{auto_increment_sql}" if column[:auto_increment]
+        sql
+      end
+  
+      def column_list_sql(columns)
+        columns.map {|c| column_definition_sql(c)}.join(COMMA_SEPARATOR)
+      end
+    
+      UNDERSCORE = '_'.freeze
+
+      def default_index_name(table_name, columns)
+        "#{table_name}_#{columns.join(UNDERSCORE)}_index"
+      end
+    
+      def index_definition_sql(table_name, index)
+        fields = index[:columns].join(COMMA_SEPARATOR)
+        index_name = index[:name] || default_index_name(table_name, index[:columns])
+        if index[:unique]
+          "CREATE UNIQUE INDEX #{index_name} ON #{table_name} (#{fields});"
+        else
+          "CREATE INDEX #{index_name} ON #{table_name} (#{fields});"
+        end
+      end
+    
+      def index_list_sql(table_name, indexes)
+        indexes.map {|i| index_definition_sql(table_name, i)}.join
+      end
+  
+      def create_table_sql(name, columns, indexes = nil)
+        sql = "CREATE TABLE #{name} (#{column_list_sql(columns)});"
+        sql << index_list_sql(name, indexes) if indexes && !indexes.empty?
+        sql
+      end
+    
+      def drop_table_sql(name)
+        "DROP TABLE #{name};"
+      end
+    end
+  end
+end
+

data/lib/sequel/sqlite.rb

@@ -9,6 +9,10 @@ module Sequel
     class Database < Sequel::Database
       set_adapter_scheme :sqlite
     
+      def serial_primary_key_options
+        {:primary_key => true, :type => :integer, :auto_increment => true}
+      end
+
       def connect
         if @opts[:database].empty?
           @opts[:database] = ':memory:'

data/spec/database_spec.rb

@@ -182,6 +182,7 @@ end
 class DummyDatabase < Sequel::Database
   attr_reader :sql
   def execute(sql); @sql = sql; end
+  def transaction; yield; end
 
   def dataset
     DummyDataset.new(self)
@@ -200,7 +201,7 @@ context "Database#create_table" do
       index :name, :unique => true
     end
     @db.sql.should == 
-      'CREATE TABLE test (id integer NOT NULL PRIMARY KEY, name text);CREATE UNIQUE INDEX test_name_index ON test (name);'
+      'CREATE TABLE test (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name text);CREATE UNIQUE INDEX test_name_index ON test (name);'
   end
 end
 
@@ -218,13 +219,13 @@ context "Database#drop_table" do
   specify "should construct proper SQL" do
     @db.drop_table :test
     @db.sql.should == 
-      'DROP TABLE test CASCADE;'
+      'DROP TABLE test;'
   end
   
   specify "should accept multiple table names" do
     @db.drop_table :a, :bb, :ccc
     @db.sql.should ==
-      'DROP TABLE a CASCADE;DROP TABLE bb CASCADE;DROP TABLE ccc CASCADE;'
+      'DROP TABLE a;DROP TABLE bb;DROP TABLE ccc;'
   end
 end
 

data/spec/dataset_spec.rb

@@ -1404,6 +1404,17 @@ context "A paginated dataset" do
     @paginated.prev_page.should be_nil
     @d.paginate(4, 50).prev_page.should == 3
   end
+  
+  specify "should return the page range" do
+    @paginated.page_range.should == (1..8)
+    @d.paginate(4, 50).page_range.should == (1..4)
+  end
+  
+  specify "should return the record range for the current page" do
+    @paginated.current_page_record_range.should == (1..20)
+    @d.paginate(4, 50).current_page_record_range.should == (151..153)
+    @d.paginate(5, 50).current_page_record_range.should == nil
+  end
 end
 
 context "Dataset#columns" do

data/spec/schema_spec.rb

@@ -0,0 +1,185 @@
+require File.join(File.dirname(__FILE__), '../lib/sequel')
+
+class SchemaDummyDatabase < Sequel::Database
+  attr_reader :sqls
+  
+  def execute(sql)
+    @sqls ||= []
+    @sqls << sql
+  end
+end
+
+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);']
+  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 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 [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 foreign keys" 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 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 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 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 compound 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
+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

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.1.9.5
-date: 2007-08-11 00:00:00 +03:00
+  version: 0.1.9.6
+date: 2007-08-13 00:00:00 +03:00
 summary: Concise ORM for Ruby.
 require_paths: 
 - lib
@@ -41,6 +41,7 @@ files:
 - spec/dataset_spec.rb
 - spec/expressions_spec.rb
 - spec/migration_spec.rb
+- spec/schema_spec.rb
 - spec/adapters/mysql_spec.rb
 - spec/adapters/sqlite_spec.rb
 - lib/sequel
@@ -59,10 +60,13 @@ files:
 - lib/sequel/odbc.rb
 - lib/sequel/postgres.rb
 - lib/sequel/pretty_table.rb
+- lib/sequel/schema
 - lib/sequel/schema.rb
 - lib/sequel/sqlite.rb
 - lib/sequel/dataset/dataset_convenience.rb
 - lib/sequel/dataset/dataset_sql.rb
+- lib/sequel/schema/schema_generator.rb
+- lib/sequel/schema/schema_sql.rb
 - CHANGELOG
 test_files: []