Class | Sequel::Schema::Generator
In: | lib/sequel/extensions/schema_dumper.rb lib/sequel/database/schema_generator.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.

### Methods

add_type_method check column constraint dump_columns dump_constraints dump_indexes foreign_key full_text_index has_column? index method_missing new primary_key primary_key_name spatial_index unique

### Constants

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.

### Attributes

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

### Public Class methods

add_type_method(*types)

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.

[Source]

        # 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

new(db, &block)

Set the database in which to create the table, and evaluate the block in the context of this object.

[Source]

        # 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

### Public Instance methods

check(*args, &block)

Add a unnamed constraint to the DDL, specified by the given block or args.

[Source]

        # File lib/sequel/database/schema_generator.rb, line 53
    53:       def check(*args, &block)
    54:         constraint(nil, *args, &block)
    55:       end

column(name, type, opts = {})

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:

- :default - The default value for the column.
- :index - Create an index on this column.
- :key - For foreign key columns, the column in the associated table that this column references. Unnecessary if this column references the primary key of the associated table.
- :null - Mark the column as allowing NULL values (if true), or not allowing NULL values (if false). If unspecified, will default to whatever the database default is.
- :on_delete - Specify the behavior of this column when being deleted. See Dataset#on_delete_clause for options.
- :on_update - Specify the behavior of this column when being updated. See Schema::SQL#on_delete_clause for options.
- :size - The size of the column, generally used with string columns to specify the maximum number of characters the column will hold.
- :unique - Mark the column as unique, generally has the same effect as creating a unique index on the column.
- :unsigned - Make the column type unsigned, only useful for integer columns.

[Source]

        # File lib/sequel/database/schema_generator.rb, line 85
    85:       def column(name, type, opts = {})
    86:         columns << {:name => name, :type => type}.merge(opts)
    87:         index(name) if opts[:index]
    88:       end

constraint(name, *args, &block)

Adds a named constraint (or unnamed if name is nil) to the DDL, with the given block or args.

[Source]

        # File lib/sequel/database/schema_generator.rb, line 92
    92:       def constraint(name, *args, &block)
    93:         constraints << {:name => name, :type => :check, :check => block || args}
    94:       end

dump_columns()

Dump this generator‘s columns to a string that could be evaled inside another instance to represent the same columns

[Source]

         # File lib/sequel/extensions/schema_dumper.rb, line 169
    169:       def dump_columns
    170:         strings = []
    171:         cols = columns.dup
    172:         if pkn = primary_key_name
    173:           cols.delete_if{|x| x[:name] == pkn}
    174:           pk = @primary_key.dup
    175:           pkname = pk.delete(:name)
    176:           @db.serial_primary_key_options.each{|k,v| pk.delete(k) if v == pk[k]}
    177:           strings << "primary_key #{pkname.inspect}#{opts_inspect(pk)}"
    178:         end
    179:         cols.each do |c|
    180:           c = c.dup
    181:           name = c.delete(:name)
    182:           type = c.delete(:type)
    183:           opts = opts_inspect(c)
    184:           strings << if type.is_a?(Class)
    185:             "#{type.name} #{name.inspect}#{opts}"
    186:           else
    187:             "column #{name.inspect}, #{type.inspect}#{opts}"
    188:           end
    189:         end
    190:         strings.join("\n")
    191:       end

dump_constraints()

Dump this generator‘s constraints to a string that could be evaled inside another instance to represent the same constraints

[Source]

         # File lib/sequel/extensions/schema_dumper.rb, line 195
    195:       def dump_constraints
    196:         constraints.map do |c|
    197:           c = c.dup
    198:           type = c.delete(:type)
    199:           case type
    200:           when :check
    201:             raise(Error, "can't dump check/constraint specified with Proc") if c[:check].is_a?(Proc)
    202:             name = c.delete(:name)
    203:             if !name and c[:check].length == 1 and c[:check].first.is_a?(Hash)
    204:               "check #{c[:check].first.inspect[1...-1]}"
    205:             else
    206:               "#{name ? "constraint #{name.inspect}," : 'check'} #{c[:check].map{|x| x.inspect}.join(', ')}"
    207:             end
    208:           else
    209:             cols = c.delete(:columns)
    210:             "#{type} #{cols.inspect}#{opts_inspect(c)}"
    211:           end
    212:         end.join("\n")
    213:       end

dump_indexes(options={})

Dump this generator‘s indexes to a string that could be evaled inside another instance to represent the same indexes. Options:

- :add_index - Use add_index instead of index, so the methods can be called outside of a generator but inside a migration. The value of this option should be the table name to use.
- :drop_index - Same as add_index, but create drop_index statements.

[Source]

         # File lib/sequel/extensions/schema_dumper.rb, line 221
    221:       def dump_indexes(options={})
    222:         indexes.map do |c|
    223:           c = c.dup
    224:           cols = c.delete(:columns)
    225:           if table = options[:add_index] || options[:drop_index]
    226:             "#{options[:drop_index] ? 'drop' : 'add'}_index #{table.inspect}, #{cols.inspect}#{opts_inspect(c)}"
    227:           else
    228:             "index #{cols.inspect}#{opts_inspect(c)}"
    229:           end
    230:         end.join("\n")
    231:       end

foreign_key(name, table=nil, opts = {})

Add a foreign key in the table that references another table to the DDL. See column for available options.

[Source]

         # File lib/sequel/database/schema_generator.rb, line 98
     98:       def foreign_key(name, table=nil, opts = {})
     99:         opts = case table
    100:         when Hash
    101:           table.merge(opts)
    102:         when Symbol
    103:           opts.merge(:table=>table)
    104:         when NilClass
    105:           opts
    106:         else
    107:           raise(Error, "The second argument to foreign_key should be a Hash, Symbol, or nil")
    108:         end
    109:         return composite_foreign_key(name, opts) if name.is_a?(Array)
    110:         column(name, Integer, opts)
    111:       end

full_text_index(columns, opts = {})

Add a full text index on the given columns to the DDL.

[Source]

         # File lib/sequel/database/schema_generator.rb, line 114
    114:       def full_text_index(columns, opts = {})
    115:         index(columns, opts.merge(:type => :full_text))
    116:       end

has_column?(name)

True if the DDL includes the creation of a column with the given name.

[Source]

         # File lib/sequel/database/schema_generator.rb, line 119
    119:       def has_column?(name)
    120:         columns.any?{|c| c[:name] == name}
    121:       end

index(columns, opts = {})

Add an index on the given column(s) with the given options to the DDL. The available options are:

- :type - The type of index to use (only supported by some databases)
- :unique - Make the index unique, so duplicate values are not allowed.
- :where - Create a partial index (only supported by some databases)

[Source]

         # File lib/sequel/database/schema_generator.rb, line 129
    129:       def index(columns, opts = {})
    130:         indexes << {:columns => Array(columns)}.merge(opts)
    131:       end

method_missing(type, name = nil, opts = {})

Add a column with the given type, name, and opts to the DDL. See column for available options.

[Source]

         # File lib/sequel/database/schema_generator.rb, line 135
    135:       def method_missing(type, name = nil, opts = {})
    136:         name ? column(name, type, opts) : super
    137:       end

primary_key(name, *args)

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)

[Source]

         # File lib/sequel/database/schema_generator.rb, line 151
    151:       def primary_key(name, *args)
    152:         return composite_primary_key(name, *args) if name.is_a?(Array)
    153:         @primary_key = @db.serial_primary_key_options.merge({:name => name})
    154:
    155:         if opts = args.pop
    156:           opts = {:type => opts} unless opts.is_a?(Hash)
    157:           if type = args.pop
    158:             opts.merge!(:type => type)
    159:           end
    160:           @primary_key.merge!(opts)
    161:         end
    162:         @primary_key
    163:       end

primary_key_name()

The name of the primary key for this table, if it has a primary key.

[Source]

         # File lib/sequel/database/schema_generator.rb, line 166
    166:       def primary_key_name
    167:         @primary_key[:name] if @primary_key
    168:       end

spatial_index(columns, opts = {})

Add a spatial index on the given columns to the DDL.

[Source]

         # File lib/sequel/database/schema_generator.rb, line 171
    171:       def spatial_index(columns, opts = {})
    172:         index(columns, opts.merge(:type => :spatial))
    173:       end

unique(columns, opts = {})

Add a unique constraint on the given columns to the DDL.

[Source]

         # File lib/sequel/database/schema_generator.rb, line 176
    176:       def unique(columns, opts = {})
    177:         constraints << {:type => :unique, :columns => Array(columns)}.merge(opts)
    178:       end

[Validate]