| Class | Sequel::Schema::Generator | 
| In: | lib/sequel/database/schema_generator.rb lib/sequel/extensions/schema_dumper.rb | 
| Parent: | Object | 
Schema::Generator is an internal class that the user is not expected to instantiate directly. Instances are created by Database#create_table. It is used to specify table creation parameters. It takes a Database object and a block of column/index/constraint specifications, and gives the Database a table description, which the database uses to create a table.
Schema::Generator has some methods but also includes method_missing, allowing users to specify column type as a method instead of using the column method, which makes for a nicer DSL.
| GENERIC_TYPES | = | [String, Integer, Fixnum, Bignum, Float, Numeric, BigDecimal, Date, DateTime, Time, File, TrueClass, FalseClass] | Classes specifying generic types that Sequel will convert to database-specific types. | 
| columns | [R] | Return the columns created by this generator | 
| constraints | [R] | Return the constraints created by this generator | 
| indexes | [R] | Return the indexes created by this generator | 
Add a method for each of the given types that creates a column with that type as a constant. Types given should either already be constants/classes or a capitalized string/symbol with the same name as a constant/class.
    # File lib/sequel/database/schema_generator.rb, line 45
45:       def self.add_type_method(*types)
46:         types.each do |type|
47:           class_eval("def #{type}(name, opts={}); column(name, #{type}, opts); end", __FILE__, __LINE__)
48:         end
49:       end
          Set the database in which to create the table, and evaluate the block in the context of this object.
    # File lib/sequel/database/schema_generator.rb, line 31
31:       def initialize(db, &block)
32:         @db = db
33:         @columns = []
34:         @indexes = []
35:         @constraints = []
36:         @primary_key = nil
37:         instance_eval(&block) if block
38:         @columns.unshift(@primary_key) if @primary_key && !has_column?(primary_key_name)
39:       end
          Add a unnamed constraint to the DDL, specified by the given block or args.
    # File lib/sequel/database/schema_generator.rb, line 53
53:       def check(*args, &block)
54:         constraint(nil, *args, &block)
55:       end
          Add a column with the given name, type, and opts to the DDL.
You can also create columns via method missing, so the following are equivalent:
column :number, :integer integer :number
The following options are supported:
    # File lib/sequel/database/schema_generator.rb, line 87
87:       def column(name, type, opts = {})
88:         columns << {:name => name, :type => type}.merge(opts)
89:         index(name) if opts[:index]
90:       end
          Adds a named constraint (or unnamed if name is nil) to the DDL, with the given block or args.
    # File lib/sequel/database/schema_generator.rb, line 94
94:       def constraint(name, *args, &block)
95:         constraints << {:name => name, :type => :check, :check => block || args}
96:       end
          Dump this generator‘s columns to a string that could be evaled inside another instance to represent the same columns
     # File lib/sequel/extensions/schema_dumper.rb, line 182
182:       def dump_columns
183:         strings = []
184:         cols = columns.dup
185:         if pkn = primary_key_name
186:           cols.delete_if{|x| x[:name] == pkn}
187:           pk = @primary_key.dup
188:           pkname = pk.delete(:name)
189:           @db.serial_primary_key_options.each{|k,v| pk.delete(k) if v == pk[k]}
190:           strings << "primary_key #{pkname.inspect}#{opts_inspect(pk)}"
191:         end
192:         cols.each do |c|
193:           c = c.dup
194:           name = c.delete(:name)
195:           type = c.delete(:type)
196:           opts = opts_inspect(c)
197:           strings << if type.is_a?(Class)
198:             "#{type.name} #{name.inspect}#{opts}"
199:           else
200:             "column #{name.inspect}, #{type.inspect}#{opts}"
201:           end
202:         end
203:         strings.join("\n")
204:       end
          Dump this generator‘s constraints to a string that could be evaled inside another instance to represent the same constraints
     # File lib/sequel/extensions/schema_dumper.rb, line 208
208:       def dump_constraints
209:         constraints.map do |c|
210:           c = c.dup
211:           type = c.delete(:type)
212:           case type
213:           when :check
214:             raise(Error, "can't dump check/constraint specified with Proc") if c[:check].is_a?(Proc)
215:             name = c.delete(:name)
216:             if !name and c[:check].length == 1 and c[:check].first.is_a?(Hash)
217:               "check #{c[:check].first.inspect[1...-1]}"
218:             else
219:               "#{name ? "constraint #{name.inspect}," : 'check'} #{c[:check].map{|x| x.inspect}.join(', ')}"
220:             end
221:           else
222:             cols = c.delete(:columns)
223:             "#{type} #{cols.inspect}#{opts_inspect(c)}"
224:           end
225:         end.join("\n")
226:       end
          Dump this generator‘s indexes to a string that could be evaled inside another instance to represent the same indexes. Options:
     # File lib/sequel/extensions/schema_dumper.rb, line 235
235:       def dump_indexes(options={})
236:         indexes.map do |c|
237:           c = c.dup
238:           cols = c.delete(:columns)
239:           if table = options[:add_index] || options[:drop_index]
240:             "#{options[:drop_index] ? 'drop' : 'add'}_index #{table.inspect}, #{cols.inspect}#{', :ignore_errors=>true' if options[:ignore_errors]}#{opts_inspect(c)}"
241:           else
242:             "index #{cols.inspect}#{opts_inspect(c)}"
243:           end
244:         end.join("\n")
245:       end
          Add a foreign key in the table that references another table to the DDL. See column for available options.
     # File lib/sequel/database/schema_generator.rb, line 100
100:       def foreign_key(name, table=nil, opts = {})
101:         opts = case table
102:         when Hash
103:           table.merge(opts)
104:         when Symbol
105:           opts.merge(:table=>table)
106:         when NilClass
107:           opts
108:         else
109:           raise(Error, "The second argument to foreign_key should be a Hash, Symbol, or nil")
110:         end
111:         return composite_foreign_key(name, opts) if name.is_a?(Array)
112:         column(name, Integer, opts)
113:       end
          Add an index on the given column(s) with the given options to the DDL. The available options are:
     # File lib/sequel/database/schema_generator.rb, line 131
131:       def index(columns, opts = {})
132:         indexes << {:columns => Array(columns)}.merge(opts)
133:       end
          Add primary key information to the DDL. Takes between one and three arguments. The last one is an options hash as for Generator#column. The first one distinguishes two modes: an array of existing column names adds a composite primary key constraint. A single symbol adds a new column of that name and makes it the primary key. In that case the optional middle argument denotes the type.
Examples:
primary_key(:id) primary_key(:zip_code, :null => false) primary_key([:street_number, :house_number]) primary_key(:id, :string, :auto_increment => false)
     # File lib/sequel/database/schema_generator.rb, line 153
153:       def primary_key(name, *args)
154:         return composite_primary_key(name, *args) if name.is_a?(Array)
155:         @primary_key = @db.serial_primary_key_options.merge({:name => name})
156:         
157:         if opts = args.pop
158:           opts = {:type => opts} unless opts.is_a?(Hash)
159:           if type = args.pop
160:             opts.merge!(:type => type)
161:           end
162:           @primary_key.merge!(opts)
163:         end
164:         @primary_key
165:       end
          The name of the primary key for this table, if it has a primary key.
     # File lib/sequel/database/schema_generator.rb, line 168
168:       def primary_key_name
169:         @primary_key[:name] if @primary_key
170:       end
          Add a unique constraint on the given columns to the DDL.
     # File lib/sequel/database/schema_generator.rb, line 178
178:       def unique(columns, opts = {})
179:         constraints << {:type => :unique, :columns => Array(columns)}.merge(opts)
180:       end