sqlalchemy.sql.schema.Table

The name of this table as represented in the database.

The table name, along with the value of the schema parameter, forms a key which uniquely identifies this _schema.Table within the owning _schema.MetaData collection. Additional calls to _schema.Table with the same name, metadata, and schema name will return the same _schema.Table object.

Names which contain no upper case characters will be treated as case insensitive names, and will not be quoted unless they are a reserved word or contain special characters. A name with any number of upper case characters is considered to be case sensitive, and will be sent as quoted.

To enable unconditional quoting for the table name, specify the flag quote=True to the constructor, or use the .quoted_name construct to specify the name.

Defaults to False, unless :paramref:`_schema.Table.autoload_with` is set in which case it defaults to True; _schema.Column objects for this table should be reflected from the database, possibly augmenting objects that were explicitly specified. _schema.Column and other objects explicitly set on the table will replace corresponding reflected objects.

Defaults to True; when using :paramref:`_schema.Table.autoload` in conjunction with :paramref:`_schema.Table.extend_existing`, indicates that _schema.Column objects present in the already-existing _schema.Table object should be replaced with columns of the same name retrieved from the autoload process. When False, columns already present under existing names will be omitted from the reflection process.

Note that this setting does not impact _schema.Column objects specified programmatically within the call to _schema.Table that also is autoloading; those _schema.Column objects will always replace existing columns of the same name when :paramref:`_schema.Table.extend_existing` is True.

When True, indicates that if this _schema.Table is already present in the given _schema.MetaData, apply further arguments within the constructor to the existing _schema.Table.

If :paramref:`_schema.Table.extend_existing` or :paramref:`_schema.Table.keep_existing` are not set, and the given name of the new _schema.Table refers to a _schema.Table that is already present in the target _schema.MetaData collection, and this _schema.Table specifies additional columns or other constructs or flags that modify the table's state, an error is raised. The purpose of these two mutually-exclusive flags is to specify what action should be taken when a _schema.Table is specified that matches an existing _schema.Table, yet specifies additional constructs.

:paramref:`_schema.Table.extend_existing` will also work in conjunction with :paramref:`_schema.Table.autoload` to run a new reflection operation against the database, even if a _schema.Table of the same name is already present in the target _schema.MetaData; newly reflected _schema.Column objects and other options will be added into the state of the _schema.Table, potentially overwriting existing columns and options of the same name.

As is always the case with :paramref:`_schema.Table.autoload`, _schema.Column objects can be specified in the same _schema.Table constructor, which will take precedence. Below, the existing table mytable will be augmented with _schema.Column objects both reflected from the database, as well as the given _schema.Column named "y":

Table("mytable", metadata,
            Column('y', Integer),
            extend_existing=True,
            autoload_with=engine
        )

Whether or not to reflect _schema.Table objects related to this one via _schema.ForeignKey objects, when :paramref:`_schema.Table.autoload` or :paramref:`_schema.Table.autoload_with` is specified. Defaults to True. Set to False to disable reflection of related tables as _schema.ForeignKey objects are encountered; may be used either to save on SQL calls or to avoid issues with related tables that can't be accessed. Note that if a related table is already present in the _schema.MetaData collection, or becomes present later, a _schema.ForeignKey object associated with this _schema.Table will resolve to that table normally.

When True, indicates that if this Table is already present in the given _schema.MetaData, ignore further arguments within the constructor to the existing _schema.Table, and return the _schema.Table object as originally created. This is to allow a function that wishes to define a new _schema.Table on first call, but on subsequent calls will return the same _schema.Table, without any of the declarations (particularly constraints) being applied a second time.

If :paramref:`_schema.Table.extend_existing` or :paramref:`_schema.Table.keep_existing` are not set, and the given name of the new _schema.Table refers to a _schema.Table that is already present in the target _schema.MetaData collection, and this _schema.Table specifies additional columns or other constructs or flags that modify the table's state, an error is raised. The purpose of these two mutually-exclusive flags is to specify what action should be taken when a _schema.Table is specified that matches an existing _schema.Table, yet specifies additional constructs.

A list of tuples of the form (<eventname>, <fn>) which will be passed to .event.listen upon construction. This alternate hook to .event.listen allows the establishment of a listener function specific to this _schema.Table before the "autoload" process begins. Historically this has been intended for use with the .DDLEvents.column_reflect event, however note that this event hook may now be associated with the _schema.MetaData object directly:

def listen_for_reflect(table, column_info):
    "handle the column reflection event"
    # ...

t = Table(
    'sometable',
    autoload_with=engine,
    listeners=[
        ('column_reflect', listen_for_reflect)
    ])

Force quoting of this table's name on or off, corresponding to True or False. When left at its default of None, the column identifier will be quoted according to whether the name is case sensitive (identifiers with at least one upper case character are treated as case sensitive), or if it's a reserved word. This flag is only needed to force quoting of a reserved word which is not known by the SQLAlchemy dialect.

The schema name for this table, which is required if the table resides in a schema other than the default selected schema for the engine's database connection. Defaults to None.

If the owning _schema.MetaData of this _schema.Table specifies its own :paramref:`_schema.MetaData.schema` parameter, then that schema name will be applied to this _schema.Table if the schema parameter here is set to None. To set a blank schema name on a _schema.Table that would otherwise use the schema set on the owning _schema.MetaData, specify the special symbol .BLANK_SCHEMA.

The quoting rules for the schema name are the same as those for the name parameter, in that quoting is applied for reserved words or case-sensitive names; to enable unconditional quoting for the schema name, specify the flag quote_schema=True to the constructor, or use the .quoted_name construct to specify the name.

Optional string that will render an SQL comment on table creation.