:keyword:`None` the instance's engine will be used

        :param cascade: Issue CASCADE drop if database supports it

        :type engine: :class:`sqlalchemy.engine.base.Engine`

        :type cascade: bool

        :param connection: reuse connection instead of creating new one.

        :type connection: :class:`sqlalchemy.engine.base.Connection` instance

        :returns: Instance with cleared columns

        """

        self.cascade = kw.pop('cascade', False)

        self.__do_imports('constraintdropper', *a, **kw)

        # the spirit of Constraint objects is that they

        # are immutable (just like in a DB.  they're only ADDed

        # or DROPped).

        #self.columns.clear()

        return self

class PrimaryKeyConstraint(ConstraintChangeset, schema.PrimaryKeyConstraint):

    """Construct PrimaryKeyConstraint

    Migrate's additional parameters:

    :param cols: Columns in constraint.

    :param table: If columns are passed as strings, this kw is required

    :type table: Table instance

    :type cols: strings or Column instances

    """

    __migrate_visit_name__ = 'migrate_primary_key_constraint'

    def __init__(self, *cols, **kwargs):

        colnames, table = self._normalize_columns(cols)

        table = kwargs.pop('table', table)

        super(PrimaryKeyConstraint, self).__init__(*colnames, **kwargs)

        if table is not None:

            self._set_parent(table)

    def autoname(self):

        """Mimic the database's automatic constraint names"""

        return "%s_pkey" % self.table.name

class ForeignKeyConstraint(ConstraintChangeset, schema.ForeignKeyConstraint):

    """Construct ForeignKeyConstraint

    Migrate's additional parameters:

    :param columns: Columns in constraint

    :param table: If columns are passed as strings, this kw is required

    :type table: Table instance

    :type columns: list of strings or Column instances

    :type refcolumns: list of strings or Column instances

    """

    __migrate_visit_name__ = 'migrate_foreign_key_constraint'

    def __init__(self, columns, refcolumns, *args, **kwargs):

        colnames, table = self._normalize_columns(columns)

        table = kwargs.pop('table', table)

        refcolnames, reftable = self._normalize_columns(refcolumns,

                                                        table_name=True)

        super(ForeignKeyConstraint, self).__init__(

            colnames, refcolnames, *args,**kwargs

        )

        if table is not None:

            self._set_parent(table)

    @property

    def referenced(self):

        return [e.column for e in self.elements]

    @property

    def reftable(self):

        return self.referenced[0].table

    def autoname(self):

        """Mimic the database's automatic constraint names"""

        if hasattr(self.columns, 'keys'):

            # SA <= 0.5

            firstcol = self.columns[self.columns.keys()[0]]

            ret = "%(table)s_%(firstcolumn)s_fkey" % dict(

                table=firstcol.table.name,

                firstcolumn=firstcol.name,)

        else:

            # SA >= 0.6

            ret = "%(table)s_%(firstcolumn)s_fkey" % dict(

                table=self.table.name,

                firstcolumn=self.columns[0],)

        return ret

class CheckConstraint(ConstraintChangeset, schema.CheckConstraint):

    """Construct CheckConstraint

    Migrate's additional parameters: