module ActiveRecord::ConnectionAdapters::SchemaStatements

def add_column(table_name, column_name, type, options = {})
  add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
  add_column_options!(add_column_sql, options)
  execute(add_column_sql)
end

def add_column_options!(sql, options) #:nodoc:
  sql << " DEFAULT #{quote(options[:default], options[:column])}" if options_include_default?(options)
  # must explicitly check for :null to allow change_column to work on migrations
  if options[:null] == false
    sql << " NOT NULL"
  end
end

def add_index(table_name, column_name, options = {})
  column_names = Array(column_name)
  index_name   = index_name(table_name, :column => column_names)
  if Hash === options # legacy support, since this param was a string
    index_type = options[:unique] ? "UNIQUE" : ""
    index_name = options[:name].to_s if options[:name]
  else
    index_type = options
  end
  if index_name.length > index_name_length
    @logger.warn("Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters. Skipping.")
    return
  end
  if index_exists?(table_name, index_name, false)
    @logger.warn("Index name '#{index_name}' on table '#{table_name}' already exists. Skipping.")
    return
  end
  quoted_column_names = quoted_columns_for_index(column_names, options).join(", ")
  execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})"
end

def add_order_by_for_association_limiting!(sql, options)
  sql << " ORDER BY #{options[:order]}"
end

def add_timestamps(table_name)
  add_column table_name, :created_at, :datetime
  add_column table_name, :updated_at, :datetime
end

def assume_migrated_upto_version(version, migrations_path = ActiveRecord::Migrator.migrations_path)
  version = version.to_i
  sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name)
  migrated = select_values("SELECT version FROM #{sm_table}").map(&:to_i)
  versions = Dir["#{migrations_path}/[0-9]*_*.rb"].map do |filename|
    filename.split('/').last.split('_').first.to_i
  end
  unless migrated.include?(version)
    execute "INSERT INTO #{sm_table} (version) VALUES ('#{version}')"
  end
  inserted = Set.new
  (versions - migrated).each do |v|
    if inserted.include?(v)
      raise "Duplicate migration #{v}. Please renumber your migrations to resolve the conflict."
    elsif v < version
      execute "INSERT INTO #{sm_table} (version) VALUES ('#{v}')"
      inserted << v
    end
  end
end

def change_column(table_name, column_name, type, options = {})
  raise NotImplementedError, "change_column is not implemented"
end

def change_column_default(table_name, column_name, default)
  raise NotImplementedError, "change_column_default is not implemented"
end

def change_table(table_name)
  yield Table.new(table_name, self)
end

def columns(table_name, name = nil) end

def create_table(table_name, options = {})
  table_definition = TableDefinition.new(self)
  table_definition.primary_key(options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)) unless options[:id] == false
  yield table_definition if block_given?
  if options[:force] && table_exists?(table_name)
    drop_table(table_name, options)
  end
  create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
  create_sql << "#{quote_table_name(table_name)} ("
  create_sql << table_definition.to_sql
  create_sql << ") #{options[:options]}"
  execute create_sql
end

def distinct(columns, order_by)
  "DISTINCT #{columns}"
end

def drop_table(table_name, options = {})
  execute "DROP TABLE #{quote_table_name(table_name)}"
end

def dump_schema_information #:nodoc:
  sm_table = ActiveRecord::Migrator.schema_migrations_table_name
  migrated = select_values("SELECT version FROM #{sm_table}")
  migrated.map { |v| "INSERT INTO #{sm_table} (version) VALUES ('#{v}');" }.join("\n\n")
end

def index_exists?(table_name, index_name, default)
  return default unless respond_to?(:indexes)
  index_name = index_name.to_s
  indexes(table_name).detect { |i| i.name == index_name }
end

def index_name(table_name, options) #:nodoc:
  if Hash === options # legacy support
    if options[:column]
      "index_#{table_name}_on_#{Array(options[:column]) * '_and_'}"
    elsif options[:name]
      options[:name]
    else
      raise ArgumentError, "You must specify the index name"
    end
  else
    index_name(table_name, :column => options)
  end
end

def initialize_schema_migrations_table
  sm_table = ActiveRecord::Migrator.schema_migrations_table_name
  unless tables.detect { |t| t == sm_table }
    create_table(sm_table, :id => false) do |schema_migrations_table|
      schema_migrations_table.column :version, :string, :null => false
    end
    add_index sm_table, :version, :unique => true,
      :name => "#{Base.table_name_prefix}unique_schema_migrations#{Base.table_name_suffix}"
    # Backwards-compatibility: if we find schema_info, assume we've
    # migrated up to that point:
    si_table = Base.table_name_prefix + 'schema_info' + Base.table_name_suffix
    if tables.detect { |t| t == si_table }
      old_version = select_value("SELECT version FROM #{quote_table_name(si_table)}").to_i
      assume_migrated_upto_version(old_version)
      drop_table(si_table)
    end
  end
end

def native_database_types
  {}
end

def options_include_default?(options)
  options.include?(:default) && !(options[:null] == false && options[:default].nil?)
end

def quoted_columns_for_index(column_names, options = {})
  column_names.map {|name| quote_column_name(name) }
end

def remove_column(table_name, *column_names)
  raise ArgumentError.new("You must specify at least one column name.  Example: remove_column(:people, :first_name)") if column_names.empty?
  column_names.flatten.each do |column_name|
    execute "ALTER TABLE #{quote_table_name(table_name)} DROP #{quote_column_name(column_name)}"
  end
end

def remove_index(table_name, options = {})
  index_name = index_name(table_name, options)
  unless index_exists?(table_name, index_name, true)
    @logger.warn("Index name '#{index_name}' on table '#{table_name}' does not exist. Skipping.")
    return
  end
  remove_index!(table_name, index_name)
end

def remove_index!(table_name, index_name) #:nodoc:
  execute "DROP INDEX #{quote_column_name(index_name)} ON #{table_name}"
end

def remove_timestamps(table_name)
  remove_column table_name, :updated_at
  remove_column table_name, :created_at
end

def rename_column(table_name, column_name, new_column_name)
  raise NotImplementedError, "rename_column is not implemented"
end

def rename_index(table_name, old_name, new_name)
  # this is a naive implementation; some DBs may support this more efficiently (Postgres, for instance)
  old_index_def = indexes(table_name).detect { |i| i.name == old_name }
  return unless old_index_def
  remove_index(table_name, :name => old_name)
  add_index(table_name, old_index_def.columns, :name => new_name, :unique => old_index_def.unique)
end

def rename_table(table_name, new_name)
  raise NotImplementedError, "rename_table is not implemented"
end

def structure_dump
end

def table_alias_for(table_name)
  table_name[0..table_alias_length-1].gsub(/\./, '_')
end

def table_exists?(table_name)
  tables.include?(table_name.to_s)
end

def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
  if native = native_database_types[type]
    column_type_sql = (native.is_a?(Hash) ? native[:name] : native).dup
    if type == :decimal # ignore limit, use precision and scale
      scale ||= native[:scale]
      if precision ||= native[:precision]
        if scale
          column_type_sql << "(#{precision},#{scale})"
        else
          column_type_sql << "(#{precision})"
        end
      elsif scale
        raise ArgumentError, "Error adding decimal column: precision cannot be empty if scale if specified"
      end
    elsif (type != :primary_key) && (limit ||= native.is_a?(Hash) && native[:limit])
      column_type_sql << "(#{limit})"
    end
    column_type_sql
  else
    type
  end
end