sequel 2.12.0 → 3.0.0

data/lib/sequel/dataset/graph.rb

@@ -17,8 +17,7 @@ module Sequel
     # the tables are combined in the single return hash.  You can get around that by
     # using .select with correct aliases for all of the columns, but it is simpler to
     # use graph and have the result set split for you.  In addition, graph respects
-    # any row_proc or transform attributes of the current dataset and the datasets
-    # you use with graph.
+    # any row_proc of the current dataset and the datasets you use with graph.
     #
     # If you are graphing a table and all columns for that table are nil, this
     # indicates that no matching rows existed in the table, so graph will return nil
@@ -186,7 +185,7 @@ module Sequel
     # Fetch the rows, split them into component table parts,
     # tranform and run the row_proc on each part (if applicable),
     # and yield a hash of the parts.
-    def graph_each(opts=(defarg=true;nil), &block)
+    def graph_each
       # Reject tables with nil datasets, as they are excluded from
       # the result set
       datasets = @opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
@@ -194,13 +193,11 @@ module Sequel
       table_aliases = datasets.collect{|ta,ds| ta}
       # Get an array of arrays, one for each dataset, with
       # the necessary information about each dataset, for speed
-      datasets = datasets.collect do |ta, ds|
-        [ta, ds, ds.instance_variable_get(:@transform), ds.row_proc]
-      end
+      datasets = datasets.collect{|ta, ds| [ta, ds, ds.row_proc]}
       # Use the manually set graph aliases, if any, otherwise
       # use the ones automatically created by .graph
       column_aliases = @opts[:graph_aliases] || @opts[:graph][:column_aliases]
-      fetch_rows(defarg ? select_sql : select_sql(opts)) do |r|
+      fetch_rows(select_sql) do |r|
         graph = {}
         # Create the sub hashes, one per table
         table_aliases.each{|ta| graph[ta]={}}
@@ -211,14 +208,11 @@ module Sequel
           ta, column = tc
           graph[ta][column] = r[col_alias]
         end
-        # For each dataset, transform and run the row
-        # row_proc if applicable
-        datasets.each do |ta,ds,tr,rp|
+        # For each dataset run the row_proc if applicable
+        datasets.each do |ta,ds,rp|
           g = graph[ta]
           graph[ta] = if g.values.any?{|x| !x.nil?}
-            g = ds.transform_load(g) if tr
-            g = rp[g] if rp
-            g
+            rp ? rp.call(g) : g
           else
             nil
           end

data/lib/sequel/dataset/sql.rb

@@ -12,7 +12,7 @@ module Sequel
     N_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::N_ARITY_OPERATORS
     NULL = "NULL".freeze
     QUESTION_MARK = '?'.freeze
-    STOCK_COUNT_OPTS = {:select => [LiteralString.new("COUNT(*)").freeze], :order => nil}.freeze
+    STOCK_COUNT_OPTS = {:select => [SQL::AliasedExpression.new(LiteralString.new("COUNT(*)").freeze, :count)], :order => nil}.freeze
     SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
     TWO_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::TWO_ARITY_OPERATORS
     WILDCARD = '*'.freeze
@@ -49,7 +49,7 @@ module Sequel
 
     # SQL fragment for the SQL CAST expression.
     def cast_sql(expr, type)
-      "CAST(#{literal(expr)} AS #{db.send(:type_literal_base, :type=>type)})"
+      "CAST(#{literal(expr)} AS #{db.cast_type_literal(type)})"
     end
 
     # SQL fragment for specifying all columns in a given table.
@@ -87,9 +87,8 @@ module Sequel
     # 
     #   dataset.filter{|o| o.price >= 100}.delete_sql #=>
     #     "DELETE FROM items WHERE (price >= 100)"
-    def delete_sql(opts = (defarg=true;nil))
-      Deprecation.deprecate("Calling Dataset#delete_sql with an argument is deprecated and will raise an error in Sequel 3.0.  Use dataset.clone(opts).delete_sql.") unless defarg
-      opts = opts ? @opts.merge(opts) : @opts
+    def delete_sql
+      opts = @opts
 
       return static_sql(opts[:sql]) if opts[:sql]
 
@@ -136,7 +135,6 @@ module Sequel
     def exclude(*cond, &block)
       clause = (@opts[:having] ? :having : :where)
       cond = cond.first if cond.size == 1
-      cond = SQL::BooleanExpression.from_value_pairs(cond, :OR) if Sequel.condition_specifier?(cond)
       cond = filter_expr(cond, &block)
       cond = SQL::BooleanExpression.invert(cond)
       cond = SQL::BooleanExpression.new(:AND, @opts[clause], cond) if @opts[clause]
@@ -147,9 +145,8 @@ module Sequel
     #
     #   DB.select(1).where(DB[:items].exists).sql
     #   #=> "SELECT 1 WHERE EXISTS (SELECT * FROM items)"
-    def exists(opts = (defarg=true;nil))
-      Deprecation.deprecate("Calling Dataset#exists with an argument is deprecated and will raise an error in Sequel 3.0.  Use dataset.clone(opts).exists.") unless defarg
-      LiteralString.new("EXISTS (#{defarg ? select_sql : select_sql(opts)})")
+    def exists
+      LiteralString.new("EXISTS (#{select_sql})")
     end
 
     # Returns a copy of the dataset with the given conditions imposed upon it.  
@@ -223,10 +220,11 @@ module Sequel
 
     # Returns a copy of the dataset with the source changed.
     #
+    #   dataset.from # SQL: SELECT *
     #   dataset.from(:blah) # SQL: SELECT * FROM blah
     #   dataset.from(:blah, :foo) # SQL: SELECT * FROM blah, foo
     def from(*source)
-      clone(:from => source)
+      clone(:from=>source.empty? ? nil : source)
     end
     
     # Returns a dataset selecting from the current dataset.
@@ -324,7 +322,6 @@ module Sequel
       when Hash
         values = @opts[:defaults].merge(values) if @opts[:defaults]
         values = values.merge(@opts[:overrides]) if @opts[:overrides]
-        values = transform_save(values) if @transform
         if values.empty?
           insert_default_values_sql
         else
@@ -362,11 +359,6 @@ module Sequel
       clone(o)
     end
 
-    # SQL fragment specifying an Irregular (cast/extract) SQL function call
-    def irregular_function_sql(f)
-      "#{f.f}(#{literal(f.arg1)} #{f.joiner} #{literal(f.arg2)})"
-    end
-
     # SQL fragment specifying a JOIN clause without ON or USING.
     def join_clause_sql(jc)
       table = jc.table
@@ -608,6 +600,7 @@ module Sequel
     # quote the name with quoted_identifier.
     def quote_identifier(name)
       return name if name.is_a?(LiteralString)
+      name = name.value if name.is_a?(SQL::Identifier)
       name = input_identifier(name)
       name = quoted_identifier(name) if quote_identifiers?
       name
@@ -683,24 +676,21 @@ module Sequel
     # Formats a SELECT statement
     #
     #   dataset.select_sql # => "SELECT * FROM items"
-    def select_sql(opts = (defarg=true;nil))
-      Deprecation.deprecate("Calling Dataset#select_sql with an argument is deprecated and will raise an error in Sequel 3.0.  Use dataset.clone(opts).select_sql.") unless defarg
-      opts = opts ? @opts.merge(opts) : @opts
-      return static_sql(opts[:sql]) if opts[:sql]
+    def select_sql
+      return static_sql(@opts[:sql]) if @opts[:sql]
       sql = 'SELECT'
-      select_clause_order.each{|x| send("select_#{x}_sql", sql, opts)}
+      select_clause_order.each{|x| send(:"select_#{x}_sql", sql)}
       sql
     end
 
     # Same as select_sql, not aliased directly to make subclassing simpler.
-    def sql(opts = (defarg=true;nil))
-      Deprecation.deprecate("Calling Dataset#select_sql with an argument is deprecated and will raise an error in Sequel 3.0.  Use dataset.clone(opts).select_sql.") unless defarg
-      defarg ? select_sql : select_sql(opts)
+    def sql
+      select_sql
     end
 
     # SQL fragment for specifying subscripts (SQL arrays)
     def subscript_sql(s)
-      "#{s.f}[#{s.sub.join(COMMA_SEPARATOR)}]"
+      "#{literal(s.f)}[#{s.sub.join(COMMA_SEPARATOR)}]"
     end
 
     # Returns a copy of the dataset with no filters (HAVING or WHERE clause) applied.
@@ -733,9 +723,8 @@ module Sequel
     #
     # Raises an error if the dataset is grouped or includes more
     # than one table.
-    def update_sql(values = {}, opts = (defarg=true;nil))
-      Deprecation.deprecate("Calling Dataset#update_sql with an argument is deprecated and will raise an error in Sequel 3.0.  Use dataset.clone(opts).update_sql.") unless defarg
-      opts = opts ? @opts.merge(opts) : @opts
+    def update_sql(values = {})
+      opts = @opts
 
       return static_sql(opts[:sql]) if opts[:sql]
 
@@ -750,7 +739,6 @@ module Sequel
         values = opts[:defaults].merge(values) if opts[:defaults]
         values = values.merge(opts[:overrides]) if opts[:overrides]
         # get values from hash
-        values = transform_save(values) if @transform
         values.map do |k, v|
           "#{[String, Symbol].any?{|c| k.is_a?(c)} ? quote_identifier(k) : literal(k)} = #{literal(v)}"
         end.join(COMMA_SEPARATOR)
@@ -775,7 +763,7 @@ module Sequel
     end
 
     # Returns a copy of the dataset with the static SQL used.  This is useful if you want
-    # to keep the same row_proc/transform/graph, but change the SQL used to custom SQL.
+    # to keep the same row_proc/graph, but change the SQL used to custom SQL.
     #
     #   dataset.with_sql('SELECT * FROM foo') # SELECT * FROM foo
     def with_sql(sql, *args)
@@ -802,7 +790,6 @@ module Sequel
     # Internal filter method so it works on either the having or where clauses.
     def _filter(clause, *cond, &block)
       cond = cond.first if cond.size == 1
-      cond = transform_save(cond) if @transform if cond.is_a?(Hash)
       cond = filter_expr(cond, &block)
       cond = SQL::BooleanExpression.new(:AND, @opts[clause], cond) if @opts[clause]
       clone(clause => cond)
@@ -851,8 +838,10 @@ module Sequel
       when Array
         if String === expr[0]
           SQL::PlaceholderLiteralString.new(expr.shift, expr, true)
-        else
+        elsif Sequel.condition_specifier?(expr)
           SQL::BooleanExpression.from_value_pairs(expr)
+        else
+          SQL::BooleanExpression.new(:AND, *expr.map{|x| filter_expr(x)})
         end
       when Proc
         filter_expr(virtual_row_block_call(expr))
@@ -1021,13 +1010,13 @@ module Sequel
     end
 
     # Modify the sql to add the columns selected
-    def select_columns_sql(sql, opts)
-      sql << " #{column_list(opts[:select])}"
+    def select_columns_sql(sql)
+      sql << " #{column_list(@opts[:select])}"
     end
 
     # Modify the sql to add the DISTINCT modifier
-    def select_distinct_sql(sql, opts)
-      if distinct = opts[:distinct]
+    def select_distinct_sql(sql)
+      if distinct = @opts[:distinct]
         sql << " DISTINCT#{" ON (#{expression_list(distinct)})" unless distinct.empty?}"
       end
     end
@@ -1035,9 +1024,9 @@ module Sequel
     # Modify the sql to add a dataset to the via an EXCEPT, INTERSECT, or UNION clause.
     # This uses a subselect for the compound datasets used, because using parantheses doesn't
     # work on all databases.  I consider this an ugly hack, but can't I think of a better default.
-    def select_compounds_sql(sql, opts)
-      return unless opts[:compounds]
-      opts[:compounds].each do |type, dataset, all|
+    def select_compounds_sql(sql)
+      return unless @opts[:compounds]
+      @opts[:compounds].each do |type, dataset, all|
         compound_sql = subselect_sql(dataset)
         compound_sql = "SELECT * FROM (#{compound_sql})" if dataset.opts[:compounds]
         sql.replace("#{sql} #{type.to_s.upcase}#{' ALL' if all} #{compound_sql}")
@@ -1045,39 +1034,39 @@ module Sequel
     end
 
     # Modify the sql to add the list of tables to select FROM
-    def select_from_sql(sql, opts)
-      sql << " FROM #{source_list(opts[:from])}" if opts[:from]
+    def select_from_sql(sql)
+      sql << " FROM #{source_list(@opts[:from])}" if @opts[:from]
     end
 
     # Modify the sql to add the expressions to GROUP BY
-    def select_group_sql(sql, opts)
-      sql << " GROUP BY #{expression_list(opts[:group])}" if opts[:group]
+    def select_group_sql(sql)
+      sql << " GROUP BY #{expression_list(@opts[:group])}" if @opts[:group]
     end
 
     # Modify the sql to add the filter criteria in the HAVING clause
-    def select_having_sql(sql, opts)
-      sql << " HAVING #{literal(opts[:having])}" if opts[:having]
+    def select_having_sql(sql)
+      sql << " HAVING #{literal(@opts[:having])}" if @opts[:having]
     end
 
     # Modify the sql to add the list of tables to JOIN to
-    def select_join_sql(sql, opts)
-      opts[:join].each{|j| sql << literal(j)} if opts[:join]
+    def select_join_sql(sql)
+      @opts[:join].each{|j| sql << literal(j)} if @opts[:join]
     end
 
     # Modify the sql to limit the number of rows returned and offset
-    def select_limit_sql(sql, opts)
-      sql << " LIMIT #{opts[:limit]}" if opts[:limit]
-      sql << " OFFSET #{opts[:offset]}" if opts[:offset]
+    def select_limit_sql(sql)
+      sql << " LIMIT #{@opts[:limit]}" if @opts[:limit]
+      sql << " OFFSET #{@opts[:offset]}" if @opts[:offset]
     end
 
     # Modify the sql to add the expressions to ORDER BY
-    def select_order_sql(sql, opts)
-      sql << " ORDER BY #{expression_list(opts[:order])}" if opts[:order]
+    def select_order_sql(sql)
+      sql << " ORDER BY #{expression_list(@opts[:order])}" if @opts[:order]
     end
 
     # Modify the sql to add the filter criteria in the WHERE clause
-    def select_where_sql(sql, opts)
-      sql << " WHERE #{literal(opts[:where])}" if opts[:where]
+    def select_where_sql(sql)
+      sql << " WHERE #{literal(@opts[:where])}" if @opts[:where]
     end
 
     # Converts an array of source names into into a comma separated list.

data/lib/sequel/extensions/inflector.rb

@@ -32,7 +32,6 @@ class String
     #   clear :all
     #   clear :plurals
     def self.clear(scope = :all)
-      Sequel::Inflections.clear(scope)
       case scope
       when :all
         @plurals, @singulars, @uncountables = [], [], []
@@ -48,7 +47,6 @@ class String
     #   irregular 'octopus', 'octopi'
     #   irregular 'person', 'people'
     def self.irregular(singular, plural)
-      Sequel::Inflections.irregular(singular, plural)
       plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
       singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
     end
@@ -59,7 +57,6 @@ class String
     # Example:
     #   plural(/(x|ch|ss|sh)$/i, '\1es')
     def self.plural(rule, replacement)
-      Sequel::Inflections.plural(rule, replacement)
       @plurals.insert(0, [rule, replacement])
     end
 
@@ -69,7 +66,6 @@ class String
     # Example:
     #   singular(/([^aeiouy]|qu)ies$/i, '\1y') 
     def self.singular(rule, replacement)
-      Sequel::Inflections.singular(rule, replacement)
       @singulars.insert(0, [rule, replacement])
     end
 
@@ -80,7 +76,6 @@ class String
     #   uncountable "money", "information"
     #   uncountable %w( money information rice )
     def self.uncountable(*words)
-      Sequel::Inflections.uncountable(*words)
       (@uncountables << words).flatten!
     end
 

data/lib/sequel/extensions/schema_dumper.rb

@@ -0,0 +1,238 @@
+module Sequel
+  class Database
+    # Dump indexes for all tables as a migration.  This complements
+    # the :indexes=>false option to dump_schema_migration.
+    def dump_indexes_migration
+      ts = tables
+      <<END_MIG
+Class.new(Sequel::Migration) do
+  def up
+#{ts.map{|t| dump_table_indexes(t, :add_index)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
+  end
+  
+  def down
+#{ts.map{|t| dump_table_indexes(t, :drop_index)}.reject{|x| x == ''}.join("\n\n").gsub(/^/o, '    ')}
+  end
+end
+END_MIG
+    end
+
+    # Return a string that contains a Sequel::Migration subclass that when
+    # run would recreate the database structure. Options:
+    # * :same_db - Don't attempt to translate database types to ruby types.
+    #   If this isn't set to true, all database types will be translated to
+    #   ruby types, but there is no guarantee that the migration generated
+    #   will yield the same type.  Without this set, types that aren't
+    #   recognized will be translated to a string-like type.
+    # * :indexes - If set to false, don't dump indexes (they can be added
+    #   later via dump_index_migration).
+    def dump_schema_migration(options={})
+      ts = tables
+      <<END_MIG
+Class.new(Sequel::Migration) do
+  def up
+#{ts.map{|t| dump_table_schema(t, options)}.join("\n\n").gsub(/^/o, '    ')}
+  end
+  
+  def down
+    drop_table(#{ts.inspect[1...-1]})
+  end
+end
+END_MIG
+    end
+
+    # Return a string with a create table block that will recreate the given
+    # table's schema.  Takes the same options as dump_schema_migration.
+    def dump_table_schema(table, options={})
+      s = schema(table).dup
+      pks = s.find_all{|x| x.last[:primary_key] == true}.map{|x| x.first}
+      options = options.merge(:single_pk=>true) if pks.length == 1
+      m = method(:column_schema_to_generator_opts)
+      im = method(:index_to_generator_opts)
+      indexes = indexes(table).sort_by{|k,v| k.to_s} if options[:indexes] != false and respond_to?(:indexes)
+      gen = Schema::Generator.new(self) do
+        s.each{|name, info| send(*m.call(name, info, options))}
+        primary_key(pks) if !@primary_key && pks.length > 0
+        indexes.each{|iname, iopts| send(:index, iopts[:columns], im.call(table, iname, iopts))} if indexes
+      end
+      commands = [gen.dump_columns, gen.dump_constraints, gen.dump_indexes].reject{|x| x == ''}.join("\n\n")
+      "create_table(#{table.inspect}) do\n#{commands.gsub(/^/o, '  ')}\nend"
+    end
+
+    private
+
+    # Convert the given default, which should be a database specific string, into
+    # a ruby object.  If it can't be converted, return the string with the inspect
+    # method modified so that .lit is always appended after it.
+    def column_schema_to_ruby_default(default, type)
+      case default 
+      when /false/
+        false
+      when 'true'
+        true
+      when /\A\d+\z/
+        default.to_i
+      else
+        def default.inspect
+          "#{super}.lit"
+        end
+        default
+      end
+    end
+
+    # Convert the given name and parsed database schema into an array with a method
+    # name and arguments to it to pass to a Schema::Generator to recreate the column.
+    def column_schema_to_generator_opts(name, schema, options)
+      if options[:single_pk] && schema_autoincrementing_primary_key?(schema)
+        [:primary_key, name]
+      else
+        col_opts = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
+        type = col_opts.delete(:type)
+        col_opts.delete(:size) if col_opts[:size].nil?
+        col_opts[:default] = column_schema_to_ruby_default(schema[:default], type) if schema[:default]
+        col_opts[:null] = false if schema[:allow_null] == false
+        [:column, name, type, col_opts]
+      end
+    end
+
+    # Convert the column schema information to a hash of column options, one of which must
+    # be :type.  The other options added should modify that type (e.g. :size).  If a
+    # database type is not recognized, return it as a String type.
+    def column_schema_to_ruby_type(schema)
+      case t = schema[:db_type].downcase
+      when /\A(?:medium|small)?int(?:eger)?(?:\((?:\d+)\))?\z/o
+        {:type=>Integer}
+      when /\Atinyint(?:\((?:\d+)\))?\z/o
+        {:type=>(Sequel.convert_tinyint_to_bool ? TrueClass : Integer)}
+      when /\Abigint(?:\((?:\d+)\))?\z/o
+        {:type=>Bignum}
+      when /\A(?:real|float|double(?: precision)?)\z/o
+        {:type=>Float}
+      when 'boolean'
+        {:type=>TrueClass}
+      when /\A(?:(?:tiny|medium|long)?text|clob)\z/o
+        {:type=>String, :text=>true}
+      when 'date'
+        {:type=>Date}
+      when 'datetime'
+        {:type=>DateTime}
+      when /\Atimestamp(?: with(?:out)? time zone)?\z/o
+        {:type=>DateTime}
+      when /\Atime(?: with(?:out)? time zone)?\z/o
+        {:type=>Time, :only_time=>true}
+      when /\Achar(?:acter)?(?:\((\d+)\))?\z/o
+        {:type=>String, :size=>($1.to_i if $1), :fixed=>true}
+      when /\A(?:varchar|character varying|bpchar|string)(?:\((\d+)\))?\z/o
+        s = ($1.to_i if $1)
+        {:type=>String, :size=>(s == 255 ? nil : s)}
+      when 'money'
+        {:type=>BigDecimal, :size=>[19,2]}
+      when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?\z/o
+        s = [($1.to_i if $1), ($2.to_i if $2)].compact
+        {:type=>BigDecimal, :size=>(s.empty? ? nil : s)}
+      when /\A(?:bytea|(?:tiny|medium|long)?blob|(?:var)?binary)(?:\((\d+)\))?\z/o
+        {:type=>File, :size=>($1.to_i if $1)}
+      when 'year'
+        {:type=>Integer}
+      else
+        {:type=>String}
+      end
+    end
+
+    # Return a string that containing add_index/drop_index method calls for
+    # creating the index migration.
+    def dump_table_indexes(table, meth)
+      return '' unless respond_to?(:indexes)
+      im = method(:index_to_generator_opts)
+      indexes = indexes(table).sort_by{|k,v| k.to_s} 
+      gen = Schema::Generator.new(self) do
+        indexes.each{|iname, iopts| send(:index, iopts[:columns], im.call(table, iname, iopts))}
+      end
+      gen.dump_indexes(meth=>table)
+    end
+
+    # Convert the parsed index information into options to the Generators index method. 
+    def index_to_generator_opts(table, name, index_opts)
+      h = {}
+      h[:name] = name unless default_index_name(table, index_opts[:columns]) == name.to_s
+      h[:unique] = true if index_opts[:unique]
+      h
+    end
+  end
+
+  module Schema
+    class Generator
+      # Dump this generator's columns to a string that could be evaled inside
+      # another instance to represent the same columns
+      def dump_columns
+        strings = []
+        cols = columns.dup
+        if pkn = primary_key_name
+          cols.delete_if{|x| x[:name] == pkn}
+          pk = @primary_key.dup
+          pkname = pk.delete(:name)
+          @db.serial_primary_key_options.each{|k,v| pk.delete(k) if v == pk[k]}
+          strings << "primary_key #{pkname.inspect}#{opts_inspect(pk)}"
+        end
+        cols.each do |c|
+          c = c.dup
+          name = c.delete(:name)
+          type = c.delete(:type)
+          opts = opts_inspect(c)
+          strings << if type.is_a?(Class)
+            "#{type.name} #{name.inspect}#{opts}"
+          else
+            "column #{name.inspect}, #{type.inspect}#{opts}"
+          end
+        end
+        strings.join("\n")
+      end
+
+      # Dump this generator's constraints to a string that could be evaled inside
+      # another instance to represent the same constraints
+      def dump_constraints
+        constraints.map do |c|
+          c = c.dup
+          type = c.delete(:type)
+          case type
+          when :check
+            raise(Error, "can't dump check/constraint specified with Proc") if c[:check].is_a?(Proc)
+            name = c.delete(:name)
+            if !name and c[:check].length == 1 and c[:check].first.is_a?(Hash)
+              "check #{c[:check].first.inspect[1...-1]}"
+            else
+              "#{name ? "constraint #{name.inspect}," : 'check'} #{c[:check].map{|x| x.inspect}.join(', ')}"
+            end
+          else
+            cols = c.delete(:columns)
+            "#{type} #{cols.inspect}#{opts_inspect(c)}"
+          end
+        end.join("\n")
+      end
+
+      # 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.
+      def dump_indexes(options={})
+        indexes.map do |c|
+          c = c.dup
+          cols = c.delete(:columns)
+          if table = options[:add_index] || options[:drop_index]
+            "#{options[:drop_index] ? 'drop' : 'add'}_index #{table.inspect}, #{cols.inspect}#{opts_inspect(c)}"
+          else
+            "index #{cols.inspect}#{opts_inspect(c)}"
+          end
+        end.join("\n")
+      end
+
+      private
+
+      def opts_inspect(opts)
+        ", #{opts.inspect[1...-1]}" if opts.length > 0
+      end
+    end
+  end
+end