'Construct a column-level FOREIGN KEY.
The :class:`.ForeignKey` object when constructed generates a
:class:`.ForeignKeyConstraint` which is associated with the parent
:class:`.Table` object\'s collection of constraints.
:param column: A single target column for the key relationship. A
:class:`.Column` object or a column name as a string:
``tablename.columnkey`` or ``schema.tablename.columnkey``.
``columnkey`` is the ``key`` which has been assigned to the column
(defaults to the column name itself), unless ``link_to_name`` is
``True`` in which case the rendered name of the column is used.
.. versionadded:: 0.7.4
Note that if the schema name is not included, and the
underlying :class:`.MetaData` has a "schema", that value will
be used.
:param name: Optional string. An in-database name for the key if
`constraint` is not provided.
:param onupdate: Optional string. If set, emit ON UPDATE <value> when
issuing DDL for this constraint. Typical values include CASCADE,
DELETE and RESTRICT.
:param ondelete: Optional string. If set, emit ON DELETE <value> when
issuing DDL for this constraint. Typical values include CASCADE,
DELETE and RESTRICT.
:param deferrable: Optional bool. If set, emit DEFERRABLE or NOT
DEFERRABLE when issuing DDL for this constraint.
:param initially: Optional string. If set, emit INITIALLY <value> when
issuing DDL for this constraint.
:param link_to_name: if True, the string name given in ``column`` is
the rendered name of the referenced column, not its locally
assigned ``key``.
:param use_alter: passed to the underlying
:class:`.ForeignKeyConstraint` to indicate the constraint should be
generated/dropped externally from the CREATE TABLE/ DROP TABLE
statement. See that classes\' constructor for details.
:param match: Optional string. If set, emit MATCH <value> when issuing
DDL for this constraint. Typical values include SIMPLE, PARTIAL
and FULL.
:param \**dialect_kw:  Additional keyword arguments are dialect specific,
and passed in the form ``<dialectname>_<argname>``.  The arguments
are ultimately handled by a corresponding :class:`.ForeignKeyConstraint`.
See the documentation regarding an individual dialect at
:ref:`dialect_toplevel` for detail on documented arguments.
.. versionadded:: 0.9.2'

def __init__(self, column, _constraint=None, use_alter=False, name=None, onupdate=None, ondelete=None, deferrable=None, initially=None, link_to_name=False, match=None, **dialect_kw):

    self._colspec = column
    if isinstance(self._colspec, util.string_types):
        self._table_column = None
    else:
        if hasattr(self._colspec, '__clause_element__'):
            self._table_column = self._colspec.__clause_element__()
        else:
            self._table_column = self._colspec
        if (not isinstance(self._table_column, ColumnClause)):
            raise exc.ArgumentError(('String,    Column,    or    Column-bound    argument    expected,    got    %r' % self._table_column))
        elif (not isinstance(self._table_column.table, (util.NoneType, TableClause))):
            raise exc.ArgumentError(('ForeignKey    received    Column    not    bound    to    a    Table,    got:    %r' % self._table_column.table))
    self.constraint = _constraint
    self.parent = None
    self.use_alter = use_alter
    self.name = name
    self.onupdate = onupdate
    self.ondelete = ondelete
    self.deferrable = deferrable
    self.initially = initially
    self.link_to_name = link_to_name
    self.match = match
    self._unvalidated_dialect_kw = dialect_kw
