镜像数据库对象¶
可以指示 Table 对象从数据库中已存在的相应数据库架构对象加载有关自身的信息。此过程称为反射。在最简单的情况下，您只需要指定表名，即 MetaData
object 和 autoload_with 参数：
>>> messages = Table("messages", metadata_obj, autoload_with=engine)
>>> [c.name for c in messages.columns]
['message_id', 'message_name', 'date']
上述作将使用给定的引擎查询数据库以获取有关 messages 表的信息，然后生成
列 ， ForeignKey，
和其他与此信息对应的对象，就像
Table 对象是用 Python 手动构造的。
当表被镜像时，如果给定的表通过外键引用另一个表，则会在
表示连接的 MetaData 对象。下面，假设该表shopping_cart_items引用一个名为
shopping_carts。反映 shopping_cart_items 表的效果是，shopping_carts 表也将被加载：
>>> shopping_cart_items = Table("shopping_cart_items", metadata_obj, autoload_with=engine)
>>> "shopping_carts" in metadata_obj.tables
TrueMetaData 有一个有趣的 “单例式”
行为，因此，如果您单独请求两个表，
MetaData 将确保只有一个
为每个不同的表名创建 Table 对象。如果已经存在具有给定名称的 Table 对象，则 Table 构造函数实际上会向您返回已经存在的 Table 对象。如下，我们只需命名即可访问已经生成的 shopping_carts 表：
shopping_carts = Table("shopping_carts", metadata_obj)
当然，将 autoload_with=engine 与上表一起使用是个好主意
无论。这样，如果表的属性具有
还没有。autoload作仅在以下情况下对表发生
尚未加载;加载后，对
具有相同名称的 Table 将不会重新发出任何反射查询。
覆盖反射列¶
在反射 table 时，可以用显式值覆盖单个列;这对于指定自定义数据类型、约束（例如可能无法在数据库中配置的主键等）非常方便：
>>> mytable = Table(
... "mytable",
... metadata_obj,
... Column(
... "id", Integer, primary_key=True
... ), # override reflected 'id' to have primary key
... Column("mydata", Unicode(50)), # override reflected 'mydata' to be Unicode
... # additional Column objects which require no change are reflected normally
... autoload_with=some_engine,
... )
另请参阅
使用自定义类型和反射 - 说明上述列覆盖技术如何应用于将自定义数据类型与表反射一起使用。
镜像视图¶
反射系统还可以反射视图。基本用法与表相同：
my_view = Table("some_view", metadata, autoload_with=engine)
在上面，my_view 是一个 Table 对象，其中
表示视图 “some_view” 中每列的名称和类型的 Column 对象。
通常，在反映视图时，如果不是外键的话，则希望至少有一个主键约束。视图反射不会推断这些约束。
为此，请使用 “override” 技术，明确指定那些属于主键或具有外键约束的列：
my_view = Table(
"some_view",
metadata,
Column("view_id", Integer, primary_key=True),
Column("related_thing", Integer, ForeignKey("othertable.thing_id")),
autoload_with=engine,
)
一次反映所有表¶
MetaData 对象还可以获取
表并反映全套。这是通过使用
reflect（） 方法。调用后，所有找到的表都存在于 MetaData 中
对象的表字典：
metadata_obj = MetaData()
metadata_obj.reflect(bind=someengine)
users_table = metadata_obj.tables["users"]
addresses_table = metadata_obj.tables["addresses"]metadata.reflect（） 还提供了一种清除或删除数据库所有行的便捷方法：
metadata_obj = MetaData()
metadata_obj.reflect(bind=someengine)
with someengine.begin() as conn:
for table in reversed(metadata_obj.sorted_tables):
conn.execute(table.delete())
从其他 Schema 镜像表¶
指定 Schema Name 部分介绍了 table 的概念
架构，它们是数据库中包含表和其他
对象，并且可以显式指定。的 “schema” 用于
Table 对象以及其他对象（如视图、索引和序列）可以使用 Table.schema 参数进行设置，也可以使用
MetaData.schema 参数。
使用此架构参数会直接影响表反射功能在被要求反射对象时的外观。例如，给定一个 MetaData 对象，通过其 MetaData.schema 参数配置了默认架构名称 “project”：
>>> metadata_obj = MetaData(schema="project")
然后，MetaData.reflect（） 将使用该配置的 .schema
对于反射：
>>> # uses `schema` configured in metadata_obj
>>> metadata_obj.reflect(someengine)
最终结果是 “project” 模式中的 Table 对象将被反映出来，并且它们将被填充为使用该名称的模式限定对象：
>>> metadata_obj.tables["project.messages"]
Table('messages', MetaData(), Column('message_id', INTEGER(), table=<messages>), schema='project')
同样，包含
Table.schema 参数也将从该数据库架构中反映出来，覆盖可能在拥有的 MetaData 集合上配置的任何默认架构：
>>> messages = Table("messages", metadata_obj, schema="project", autoload_with=someengine)
>>> messages
Table('messages', MetaData(), Column('message_id', INTEGER(), table=<messages>), schema='project')
最后，MetaData.reflect（） 方法本身也允许
MetaData.reflect.schema 参数，因此我们
还可以从默认配置的 “project” 架构中加载表
MetaData 对象：
>>> metadata_obj = MetaData()
>>> metadata_obj.reflect(someengine, schema="project")
我们可以使用不同的
MetaData.schema 参数（或根本不使用）来继续用更多对象填充 MetaData 对象：
>>> # add tables from the "customer" schema
>>> metadata_obj.reflect(someengine, schema="customer")
>>> # add tables from the default schema
>>> metadata_obj.reflect(someengine)
Schema 限定的 Reflection 与 Default Schema 的交互¶
部分 最佳实践总结
在本节中，我们将讨论 SQLAlchemy 对数据库会话的 “default schema” 中可见的表的反射行为，以及这些表如何与显式包含该 schema 的 SQLAlchemy 指令交互。作为最佳实践，请确保数据库的 “default” 架构只是一个名称，而不是一个名称列表;对于属于此“默认”架构的一部分并且可以在 DDL 和 SQL 中无需架构限定即可命名的表，请将相应的 Table.schema 和类似架构参数设置为其默认值 None。
如使用 MetaData 指定默认架构名称中所述，具有
架构的概念通常还包括 “default” 架构的概念。
这样做的原因自然是，当引用没有
a schema 一样常见，支持 schema 的数据库仍会考虑
table 中的某个 app 的 app 中。 一些数据库，如 PostgreSQL
将此概念进一步纳入
Schema 搜索路径
其中，在特定数据库会话中可以将多个模式名称视为“隐式”;引用表名是这些模式中的任何一个都不需要模式名称存在（同时，如果存在模式名称也完全没问题）。
因此，由于大多数关系数据库都具有特定表对象的概念，该表对象既可以以模式限定的方式引用，也可以以不存在模式的“隐式”方式引用，这给 SQLAlchemy 的反射功能带来了复杂性。以 schema 限定的方式反映表将始终填充其 Table.schema
属性，并且还会影响此 Table 在 MetaData.tables 集合中的组织方式，即以架构限定的方式。相反，以非模式限定的方式反映同一个表会将其组织到 MetaData.tables 中
集合，而无需进行 schema 限定。最终结果是单个 Table 中将有两个单独的 Table 对象
MetaData 集合，表示实际数据库中的同一表。
为了说明此问题的后果，请考虑
“project” 架构，并假设 “project”
schema 是我们数据库连接的默认 schema，或者如果使用数据库
例如 PostgreSQL，假设 “project” 架构是在 PostgreSQL 中设置的
search_path。这意味着数据库接受以下两个等效的 SQL 语句：
-- schema qualified
SELECT message_id FROM project.messages
-- non-schema qualified
SELECT message_id FROM messages
这不是问题，因为可以通过两种方式找到该表。但是，在 SQLAlchemy 中，它是 Table 对象的标识
，它决定了它在 SQL 语句中的语义角色。 基于当前
decisions 中，这意味着如果我们在 SQLAlchemy 中反映相同的 “messages” 表
无论是 Schema 限定的方式还是非 Schema 限定的方式，我们都会得到
两个Table 对象，它们不会被视为语义等效：
>>> # reflect in non-schema qualified fashion
>>> messages_table_1 = Table("messages", metadata_obj, autoload_with=someengine)
>>> # reflect in schema qualified fashion
>>> messages_table_2 = Table(
... "messages", metadata_obj, schema="project", autoload_with=someengine
... )
>>> # two different objects
>>> messages_table_1 is messages_table_2
False
>>> # stored in two different ways
>>> metadata.tables["messages"] is messages_table_1
True
>>> metadata.tables["project.messages"] is messages_table_2
True
当所反映的表包含对其他表的外键引用时，上述问题变得更加复杂。假设 “messages” 有一个 “project_id” 列，该列引用另一个模式本地表 “projects” 中的行，这意味着有一个 ForeignKeyConstraint 对象是 “messages” 表定义的一部分。
我们可能会发现自己处于一个 MetaData
collection 可能包含多达四个 Table 对象，这些对象表示这两个数据库表，其中一两个附加表是由反射过程生成的;这是因为当反射过程在正在反射的表上遇到外键约束时，它也会分支出来以反映该引用的表。它用于将 schema 分配给此引用表的决策是 SQLAlchemy 将从反映的
ForeignKeyConstraint 对象（如果拥有的
Table 还省略了其架构名称，并且这两个对象位于同一架构中，但如果未省略，则会包含它。
常见情况是，以模式限定的方式反射表，然后加载一个相关表，该表也将以模式限定的方式执行：
>>> # reflect "messages" in a schema qualified fashion
>>> messages_table_1 = Table(
... "messages", metadata_obj, schema="project", autoload_with=someengine
... )
上述messages_table_1也将以架构限定的方式引用项目。这个 “projects” 表将通过 “messages” 引用它的事实自动反映出来：
>>> messages_table_1.c.project_id
Column('project_id', INTEGER(), ForeignKey('project.projects.project_id'), table=<messages>)
如果代码的某个其他部分以非模式限定的方式反映“projects”，则现在有两个 projects 表不同：
>>> # reflect "projects" in a non-schema qualified fashion
>>> projects_table_1 = Table("projects", metadata_obj, autoload_with=someengine)>>> # messages does not refer to projects_table_1 above
>>> messages_table_1.c.project_id.references(projects_table_1.c.project_id)
False>>> # it refers to this one
>>> projects_table_2 = metadata_obj.tables["project.projects"]
>>> messages_table_1.c.project_id.references(projects_table_2.c.project_id)
True>>> # they're different, as one non-schema qualified and the other one is
>>> projects_table_1 is projects_table_2
False
上述混淆可能会导致使用表反射加载应用程序级 Table 对象的应用程序中以及迁移方案中出现问题，尤其是在使用 Alembic Migrations 检测新表和外键约束时。
上述行为可以通过坚持一个简单的做法来补救：
不要包含任何Table.schema参数 Table 的Table 的 API请求。
对于支持架构的 “search” 路径的 PostgreSQL 和其他数据库，请添加以下附加做法：
将 “search path” 缩小到仅一个架构，即 default 架构。
另请参阅
Remote-Schema Table Introspection 和 PostgreSQL search_path - 有关 PostgreSQL 数据库的此行为的其他详细信息。
使用 Inspector 进行细粒度反射¶
还提供一个低级接口，该接口提供从给定数据库加载架构、表、列和约束描述列表的后端不可知的系统。这称为 “检查器”：
from sqlalchemy import create_engine
from sqlalchemy import inspect
engine = create_engine("...")
insp = inspect(engine)
print(insp.get_table_names())对象名称 |
描述 |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
-
类 sqlalchemy.engine.reflection 中。检查器¶
执行数据库架构检查。
Inspector 充当Dialect，提供一致的接口以及对以前获取的元数据的缓存支持。Inspector对象通常是通过inspect（）函数，该函数可以传递一个发动机或Connection：from sqlalchemy import inspect, create_engine engine = create_engine("...") insp = inspect(engine)
在上述情况下，与引擎关联的Dialect可以选择返回Inspector子类，该 提供了特定于方言的目标数据库的其他方法。
成员
__init__（）， 绑定， clear_cache（）， default_schema_name， 方言， 引擎， from_engine（）， get_check_constraints（）， get_columns（）， get_foreign_keys（）， get_indexes（）， get_materialized_view_names（）， get_multi_check_constraints（）、get_multi_columns（）、get_multi_foreign_keys（）、get_multi_indexes（）、get_multi_pk_constraint（）、get_multi_table_comment（）、get_multi_table_options（）、get_multi_unique_constraints（）、get_pk_constraint（）、get_schema_names（）get_sequence_names（）， get_sorted_table_and_fkc_names（）， get_table_comment（）， get_table_names（）， get_table_options（）， get_temp_table_names（）， get_temp_view_names（）， get_unique_constraints（）， get_view_definition（）， get_view_names（）， has_index（）、has_schema（）、has_sequence（）、has_table（）、info_cache、reflect_table（）、sort_tables_on_foreign_key_dependency（）
类签名
类sqlalchemy.engine.reflection.Inspector（sqlalchemy.inspection.Inspectable）-
方法sqlalchemy.engine.reflection.Inspector.__init__（bind：EngineConnection）¶
初始化新的Inspector。
1.4 版后已移除：Inspector上的 __init__（） 方法已弃用，并将在未来版本中删除。请在Engine或Connection上使用inspect（）函数以获取Inspector。
参数
bind¶——一个 Connection， 它通常是Engine或连接。
有关特定于方言的Inspector实例，请参阅Inspector.from_engine（）
-
attributesqlalchemy.engine.reflection.Inspector.bind：EngineConnection¶
-
方法sqlalchemy.engine.reflection.Inspector.clear_cache（） 无¶
重置此Inspector的缓存。
缓存了数据的检查方法将在下次调用以获取新数据时发出 SQL 查询。
2.0 版的新Function。
-
属性sqlalchemy.engine.reflection.Inspector.default_schema_name¶
返回当前引擎的数据库用户的方言提供的默认模式名称。
例如，对于 PostgreSQL 和dbo，这通常是公开的 用于 SQL Server。
-
attributesqlalchemy.engine.reflection.Inspector.dialect： 方言¶
-
属性sqlalchemy.engine.reflection.Inspector.engine： 引擎¶
-
类方法sqlalchemy.engine.reflection.Inspector.from_engine（bind： Engine） 检查器¶
从给定的引擎或连接构造一个新的特定于方言的 Inspector 对象。
1.4 版后已移除：Inspector上的 from_engine（） 方法已弃用，并将在未来发行版中删除。请在Engine或Connection上使用inspect（）函数以获取Inspector。
参数
bind¶ ——一个 Connection或Engine （引擎）。
此方法不同于 direct，后者是Inspector的Dialect有机会提供特定于方言的Inspector实例，该实例可能会提供其他方法。
请参阅Inspector中的示例。
-
方法sqlalchemy.engine.reflection.Inspector.get_check_constraints（table_name： str， schema：strNone=None， **kw： Any） List[ReflectedCheckConstraint]¶
返回有关table_name中的 check 约束的信息。
给定一个字符串table_name和一个可选的字符串架构，返回 将约束信息检查为ReflectedCheckConstraint 的 Constraint实例。
参数
table_name¶ – 表的字符串名称。对于特殊引用，请使用quoted_name。
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
字典列表，每个字典表示 CHECK 约束的定义。
-
方法sqlalchemy.engine.reflection.Inspector.get_columns（table_name： str， schema：strNone=None， **kw： Any） List[ReflectedColumn]¶
返回有关table_name中的列的信息。
给定一个字符串table_name和一个可选的字符串架构，将列信息作为ReflectedColumn列表返回。
参数
table_name¶ – 表的字符串名称。对于特殊引用，请使用quoted_name。
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
字典列表，每个字典表示数据库列的定义。
另请参阅
-
方法sqlalchemy.engine.reflection.Inspector.get_foreign_keys（table_name： str， schema：strNone=None， **kw： Any） List[ReflectedForeignKeyConstraint]¶
在 table_name 中返回有关foreign_keys的信息。
给定一个字符串table_name和一个可选的字符串架构，返回 外键信息作为ReflectedForeignKeyConstraint 的 Constraint对象。
参数
table_name¶ – 表的字符串名称。对于特殊引用，请使用quoted_name。
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
一个字典列表，每个字典都表示 A 外键定义。
-
方法sqlalchemy.engine.reflection.Inspector.get_indexes（table_name： str， schema：strNone=None， **kw： Any） List[ReflectedIndex]¶
返回有关table_name中的索引的信息。
给定一个字符串table_name和一个可选的字符串架构，将索引信息作为ReflectedIndex列表返回。
参数
table_name¶ – 表的字符串名称。对于特殊引用，请使用quoted_name。
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
字典列表，每个字典都表示索引的定义。
-
方法sqlalchemy.engine.reflection.Inspector.get_materialized_view_names（schema：strNone=None， **kw： Any） List[str]¶
返回 schema 中的所有具体化视图名称。
参数
schema¶– 可选，从非默认 schema 中检索名称。对于特殊引用，请使用quoted_name。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
2.0 版的新Function。
-
methodsqlalchemy.engine.reflection.Inspector.get_multi_check_constraints（schema：strNone=None， filter_names：Sequence[str]None=None， kind： ObjectKind = ObjectKind.TABLE， scope： ObjectScope = ObjectScope.DEFAULT， **kw： Any） Dict[TableKey， List[ReflectedCheckConstraint]]¶
返回有关给定架构中所有表中的 check 约束的信息。
可以通过将要使用的名称传递给filter_names。
对于每个表，该值是ReflectedCheckConstraint 的 Constraint实例。
参数
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
filter_names¶ – （可选）仅返回此处列出的对象的信息。
kind¶ —— 一个ObjectKind，指定要反映的对象类型。默认为ObjectKind.TABLE。
scope¶—— 一个ObjectScope，指定是否应该反映 default、temporary 或任何 table 的约束。默认为ObjectScope.DEFAULT。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
一个字典，其中键是两元组 schema，table-name 和 values 是字典列表，每个字典都表示检查约束的定义。如果未提供 schema，则schema 为 None。
2.0 版的新Function。
-
methodsqlalchemy.engine.reflection.Inspector.get_multi_columns（schema：strNone=None， filter_names：Sequence[str]None=None， kind： ObjectKind = ObjectKind.TABLE， scope： ObjectScope = ObjectScope.DEFAULT， **kw： Any） Dict[TableKey， List[ReflectedColumn]]¶
返回有关给定架构中所有对象中的列的信息。
可以通过将要使用的名称传递给filter_names。
对于每个表，该值是ReflectedColumn的列表。
参数
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
filter_names¶ – （可选）仅返回此处列出的对象的信息。
kind¶ —— 一个ObjectKind，指定要反映的对象类型。默认为ObjectKind.TABLE。
scope¶—— 一个ObjectScope，指定是否应该反映 default、temporary 或任何表的列。默认为ObjectScope.DEFAULT。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
一个字典，其中键是两元组 schema，table-name 和 values 是字典列表，每个字典都表示数据库列的定义。如果未提供 schema，则schema 为 None。
2.0 版的新Function。
-
methodsqlalchemy.engine.reflection.Inspector.get_multi_foreign_keys（schema：strNone=None， filter_names：Sequence[str]None=None， kind： ObjectKind = ObjectKind.TABLE， scope： ObjectScope = ObjectScope.DEFAULT， **kw： Any） Dict[TableKey， List[ReflectedForeignKeyConstraint]]¶
返回有关给定架构中所有表中foreign_keys的信息。
可以通过将要使用的名称传递给filter_names。
对于每个表，该值是ReflectedForeignKeyConstraint 的 Constraint对象。
参数
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
filter_names¶ – （可选）仅返回此处列出的对象的信息。
kind¶ —— 一个ObjectKind，指定要反映的对象类型。默认为ObjectKind.TABLE。
scope¶—— 一个ObjectScope，指定是否应反映 default、temporary 或任何表的外键。默认为ObjectScope.DEFAULT。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
一个字典，其中键是双元组 schema，table-name 和 values 是字典列表，每个字典都表示一个外键定义。如果未提供 schema，则schema 为 None。
2.0 版的新Function。
-
methodsqlalchemy.engine.reflection.Inspector.get_multi_indexes（schema：strNone=None， filter_names：Sequence[str]None=None， kind： ObjectKind = ObjectKind.TABLE， scope： ObjectScope = ObjectScope.DEFAULT， **kw： Any） Dict[TableKey， List[ReflectedIndex]]¶
返回有关给定架构中所有对象中的 索引 的信息。
可以通过将要使用的名称传递给filter_names。
对于每个表，该值是ReflectedIndex的列表。
参数
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
filter_names¶ – （可选）仅返回此处列出的对象的信息。
kind¶ —— 一个ObjectKind，指定要反映的对象类型。默认为ObjectKind.TABLE。
scope¶—— 一个ObjectScope，指定是否应反映 default、temporary 或任何表的索引。默认为ObjectScope.DEFAULT。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
一个字典，其中键是两元组 schema，table-name 和 values 是字典列表，每个字典都表示索引的定义。如果未提供 schema，则schema 为 None。
2.0 版的新Function。
-
methodsqlalchemy.engine.reflection.Inspector.get_multi_pk_constraint（schema：strNone=None， filter_names：Sequence[str]None=None， kind： ObjectKind = ObjectKind.TABLE， 范围： ObjectScope = ObjectScope.DEFAULT， **kw： Any） Dict[TableKey， ReflectedPrimaryKeyConstraint]¶
返回有关给定架构中所有表中的主键约束的信息。
可以通过将要使用的名称传递给filter_names。
对于每个表，该值为ReflectedPrimaryKeyConstraint。
参数
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
filter_names¶ – （可选）仅返回此处列出的对象的信息。
kind¶ —— 一个ObjectKind，指定要反映的对象类型。默认为ObjectKind.TABLE。
scope¶—— 一个ObjectScope，指定是否应反映 default、temporary 或任何表的主键。默认为ObjectScope.DEFAULT。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
一个字典，其中键是双元组 schema，table-name 和 values 是字典，每个字典都表示主键约束的定义。如果未提供 schema，则schema 为 None。
2.0 版的新Function。
-
methodsqlalchemy.engine.reflection.Inspector.get_multi_table_comment（schema：strNone=None， filter_names：Sequence[str]None=None， kind： ObjectKind = ObjectKind.TABLE， scope： ObjectScope = ObjectScope.DEFAULT， **kw： Any） Dict[TableKey， ReflectedTableComment]¶
返回有关给定架构中所有对象的表注释的信息。
可以通过将要使用的名称传递给filter_names。
对于每个表，该值为ReflectedTableComment。
对于不支持注释的方言，引发NotImplementedError。
参数
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
filter_names¶ – （可选）仅返回此处列出的对象的信息。
kind¶ —— 一个ObjectKind，指定要反映的对象类型。默认为ObjectKind.TABLE。
scope¶—— 一个ObjectScope，指定是否应该反映 default、temporary 或任何表的注释。默认为ObjectScope.DEFAULT。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
一个字典，其中键是双元组 schema，table-name，值是字典，表示表 comments。如果未提供 schema，则schema 为 None。
2.0 版的新Function。
-
methodsqlalchemy.engine.reflection.Inspector.get_multi_table_options（schema：strNone=None， filter_names：Sequence[str]None=None， kind： ObjectKind = ObjectKind.TABLE， scope： ObjectScope = ObjectScope.DEFAULT， **kw： Any） Dict[TableKey， Dict[str， Any]]¶
返回在创建给定架构中的表时指定的选项字典。
可以通过将要使用的名称传递给filter_names。
这当前包括一些适用于 MySQL 和 Oracle 表的选项。
参数
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
filter_names¶ – （可选）仅返回此处列出的对象的信息。
kind¶ —— 一个ObjectKind，指定要反映的对象类型。默认为ObjectKind.TABLE。
scope¶—— 一个ObjectScope，指定是否应反映 default、temporary 或任何 tables 的选项。默认为ObjectScope.DEFAULT。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
一个字典，其中键是二元组 schema，table-name 和 values 是带有 table 选项的字典。每个 dict 中返回的键取决于所使用的方言。每个 Matrix 都带有方言名称的前缀。如果未提供 schema，则schema 为 None。
2.0 版的新Function。
-
methodsqlalchemy.engine.reflection.Inspector.get_multi_unique_constraints（schema：strNone=None， filter_names：Sequence[str]None=None， kind： ObjectKind = ObjectKind.TABLE， scope： ObjectScope = ObjectScope.DEFAULT， **kw： Any） Dict[TableKey， List[ReflectedUniqueConstraint]]¶
返回有关给定架构中所有表中唯一约束的信息。
可以通过将要使用的名称传递给filter_names。
对于每个表，该值是ReflectedUniqueConstraint 的 ReflectedUniqueConstraint中。
参数
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
filter_names¶ – （可选）仅返回此处列出的对象的信息。
kind¶ —— 一个ObjectKind，指定要反映的对象类型。默认为ObjectKind.TABLE。
scope¶—— 一个ObjectScope，指定是否应该反映 default、temporary 或任何 table 的约束。默认为ObjectScope.DEFAULT。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
一个字典，其中键是 two-tuple schema，table-name 和 values 是字典列表，每个字典都表示唯一约束的定义。如果未提供 schema，则schema 为 None。
2.0 版的新Function。
-
方法sqlalchemy.engine.reflection.Inspector.get_pk_constraint（table_name： str， schema：strNone=None， **kw： Any） ReflectedPrimaryKeyConstraint¶
返回有关table_name中 primary key constraint 的信息。
给定一个字符串table_name和一个可选的字符串架构，将主键信息作为ReflectedPrimaryKeyConstraint返回。
参数
table_name¶ – 表的字符串名称。对于特殊引用，请使用quoted_name。
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
表示主键约束定义的字典。
-
方法sqlalchemy.engine.reflection.Inspector.get_schema_names（**kw： Any） List[str]¶
返回所有 schema 名称。
参数
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
-
方法sqlalchemy.engine.reflection.Inspector.get_sequence_names（schema：strNone=None， **kw： Any） List[str]¶
返回 schema 中的所有序列名称。
参数
schema¶– 可选，从非默认 schema 中检索名称。对于特殊引用，请使用quoted_name。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
-
方法sqlalchemy.engine.reflection.Inspector.get_sorted_table_and_fkc_names（schema：strNone=None， **kw： Any）→List[Tuple[strNone，List[Tuple[str，strNone]]]]¶
返回特定架构中引用的依赖项排序的表和外键约束名称。
这将产生 2 元组(tablename, [(tname, fkname), (tname, fkname), ...])由按CREATE顺序分组的表名组成，并与外键分组 未被检测为属于循环的约束名称。 最后一个元素(None, [(tname, fkname), (tname, fkname), ..])将是 其中将包括剩余的 需要单独 CREATE 的外键约束名称 事后步骤，基于表之间的依赖关系。
-
方法sqlalchemy.engine.reflection.Inspector.get_table_comment（table_name： str， schema：strNone=None， **kw： Any） ReflectedTableComment¶
返回有关table_name的表注释的信息。
给定一个字符串table_name和一个可选的字符串架构，将表注释信息作为ReflectedTableComment返回。
对于不支持注释的方言，引发NotImplementedError。
参数
table_name¶ – 表的字符串名称。对于特殊引用，请使用quoted_name。
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
一个字典，带有 table comment。
在 1.2 版本加入.
-
方法sqlalchemy.engine.reflection.Inspector.get_table_names（schema：strNone=None， **kw： Any） List[str]¶
返回特定架构中的所有表名。
这些名称应仅为实际表，而不是视图。 视图则使用Inspector.get_view_names（）和/或Inspector.get_materialized_view_names()方法。
参数
schema¶- 架构名称。如果schema保留为None，则使用数据库的默认 schema，否则搜索命名 schema。如果数据库不支持命名架构，则如果架构未作为None传递，则行为未定义。对于特殊引用，请使用quoted_name。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
-
方法sqlalchemy.engine.reflection.Inspector.get_table_options（table_name： str， schema：strNone=None， **kw： Any） Dict[str， Any]¶
返回在创建给定名称的表时指定的选项字典。
这当前包括一些适用于 MySQL 和 Oracle Database 表的选项。
参数
table_name¶ – 表的字符串名称。对于特殊引用，请使用quoted_name。
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
带有 table 选项的 dict。返回的键取决于所使用的方言。每个 Matrix 都带有方言名称的前缀。
-
方法sqlalchemy.engine.reflection.Inspector.get_temp_table_names（**kw： Any） List[str]¶
返回当前绑定的临时表名列表。
大多数方言不支持此方法;目前只有 Oracle Database、PostgreSQL 和 SQLite 实现了它。
参数
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
-
方法sqlalchemy.engine.reflection.Inspector.get_temp_view_names（**kw： Any） List[str]¶
返回当前绑定的临时视图名称列表。
大多数方言不支持此方法;目前只有 PostgreSQL 和 SQLite 实现了它。
参数
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
-
方法sqlalchemy.engine.reflection.Inspector.get_unique_constraints（table_name： str， schema：strNone=None， **kw： Any） List[ReflectedUniqueConstraint]¶
返回有关table_name中唯一约束的信息。
给定一个字符串table_name和一个可选的字符串架构，返回 唯一约束信息作为ReflectedUniqueConstraint 的 ReflectedUniqueConstraint中。
参数
table_name¶ – 表的字符串名称。对于特殊引用，请使用quoted_name。
schema¶ – 字符串 schema name;如果省略，则使用 Database Connection 的默认架构。对于特殊引用，请使用quoted_name。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
结果
字典列表，每个字典表示唯一约束的定义。
-
方法sqlalchemy.engine.reflection.Inspector.get_view_definition（view_name： str， schema：strNone=None， **kw： Any） str¶
返回名为view_name。
参数
view_name¶– 视图的名称。
schema¶– 可选，从非默认 schema 中检索名称。对于特殊引用，请使用quoted_name。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
-
方法sqlalchemy.engine.reflection.Inspector.get_view_names（schema：strNone=None， **kw： Any） List[str]¶
返回 schema 中所有未具体化的视图名称。
参数
schema¶– 可选，从非默认 schema 中检索名称。对于特殊引用，请使用quoted_name。
**kw¶– 传递给 dialect 特定实现的额外关键字参数。有关更多信息，请参阅正在使用的方言的文档。
在 2.0 版更改： 对于以前在此列表中包含物化视图名称的方言（当前为 PostgreSQL），此方法不再返回物化视图的名称。应改用Inspector.get_materialized_view_names()该方法。
-
方法sqlalchemy.engine.reflection.Inspector.has_index（table_name： str， index_name： str， schema：strNone=None， **kw： Any 布尔值¶
检查数据库中是否存在特定索引名称。
参数
2.0 版的新Function。
-
方法sqlalchemy.engine.reflection.Inspector.has_schema（schema_name： str， **kw： Any） bool¶
如果后端具有具有给定名称的架构，则返回 True。
2.0 版的新Function。
-
方法sqlalchemy.engine.reflection.Inspector.has_sequence（sequence_name： str， schema：strNone=None， **kw： Any） bool¶
如果后端具有具有给定名称的序列，则返回 True。
参数
在 1.4 版本加入.
-
方法sqlalchemy.engine.reflection.Inspector.has_table（table_name： str， schema：strNone=None， **kw： Any） bool¶
如果后端具有给定名称的表、视图或临时表，则返回 True。
参数
在 1.4 版本加入： -Inspector.has_table（）方法取代了Engine.has_table（）方法。
在 2.0 版本发生变更：Inspector.has_table（）现在正式支持检查其他类似表的对象：
任何类型的视图 （普通视图或实例化视图）
任何类型的临时表
以前，这两项检查没有正式指定，不同的方言的行为会有所不同。dialect 测试套件现在包括对所有这些对象类型的测试，并且应该受到所有 SQLAlchemy 包含的 dialect 的支持。但是，第三方方言之间的支持可能滞后。
-
属性sqlalchemy.engine.reflection.Inspector.info_cache： Dict[Any， Any]¶
-
方法sqlalchemy.engine.reflection.Inspector.reflect_table（table： Table， include_columns：Collection[str]None， exclude_columns： Collection[str] = （）， resolve_fks： bool = True， _extend_on：Set[Table]None=None， _reflect_info：_ReflectionInfoNone=None） 无¶
给定一个Table对象，根据内省加载其内部构造。
这是大多数方言用于生成表反射的基本方法。直接使用如下：from sqlalchemy import create_engine, MetaData, Table from sqlalchemy import inspect engine = create_engine("...") meta = MetaData() user_table = Table("user", meta) insp = inspect(engine) insp.reflect_table(user_table, None)
在 1.4 版本发生变更： 已从reflecttable重命名为reflect_table
-
方法sqlalchemy.engine.reflection.Inspector.sort_tables_on_foreign_key_dependency（consider_schemas：Collection[strNone]=（None，）， **kw： Any）→List[Tuple[Tuple[strNone，str]None，List[Tuple[Tuple[strNone，str]，strNone]]]]¶
返回多个架构中引用的依赖项排序的表和外键约束名称。
此方法可以与Inspector.get_sorted_table_and_fkc_names()，一次处理一个架构;在这里，该方法是一种泛化，它将一次考虑多个架构，包括它将解析跨架构外键。
2.0 版的新Function。
-
-
类 sqlalchemy.engine.interfaces 中。ReflectedColumn¶
表示与Column对象对应的反射元素的字典。ReflectedColumn结构由get_columns方法。
成员
autoincrement， comment， computed， default， dialect_options， identity， name， nullable， type
类签名
类sqlalchemy.engine.interfaces.ReflectedColumn（builtins.dict）-
属性sqlalchemy.engine.interfaces.ReflectedColumn.自动递增： NotRequired[bool]¶
依赖于数据库的 autoincrement 标志。
此标志指示该列是否具有某种类型的数据库端 “autoincrement” 标志。在 SQLAlchemy 中，其他类型的列也可以充当“自动递增”列，而不必有这样的标志。
有关 “autoincrement” 的更多背景信息，请参见Column.autoincrement。
-
attributesqlalchemy.engine.interfaces.ReflectedColumn.comment：NotRequired[strNone]¶
comment（如果存在）。只有某些方言返回此键
-
attributesqlalchemy.engine.interfaces.ReflectedColumn.computed： NotRequired[ReflectedComputed]¶
表示该列由数据库计算。只有一些 dialect 返回此键。
1.3.16 版中的新功能： - 添加了对计算反射的支持。
-
attributesqlalchemy.engine.interfaces.ReflectedColumn.default：strNone¶
列默认表达式作为 SQL 字符串
-
属性sqlalchemy.engine.interfaces.ReflectedColumn.dialect_options：NotRequired[Dict[str， Any]]¶
为此反射对象检测到的其他特定于方言的选项
-
属性sqlalchemy.engine.interfaces.ReflectedColumn.标识：NotRequired[ReflectedIdentity]¶
表示该列是 IDENTITY 列。只有一些 dialect 返回此键。
1.4 新版功能： - 添加了对标识列反射的支持。
-
属性sqlalchemy.engine.interfaces.ReflectedColumn.名称：str¶
列名称
-
可为 nulls 的属性sqlalchemy.engine.interfaces.ReflectedColumn.：bool¶
boolean 标志（如果列为 NULL 或 NOT NULL）
-
attributesqlalchemy.engine.interfaces.ReflectedColumn.type： TypeEngine[Any]¶
列类型表示为TypeEngine实例。
-
-
类 sqlalchemy.engine.interfaces 中。ReflectedComputed¶
表示 computed 列的反射元素，对应于Computed构造。ReflectedComputed结构是ReflectedColumn结构，该结构由Inspector.get_columns（）方法。
类签名
类sqlalchemy.engine.interfaces.ReflectedComputed（builtins.dict）-
保留的属性sqlalchemy.engine.interfaces.ReflectedComputed.：NotRequired[bool]¶
指示值是存储在表中还是按需计算
-
属性sqlalchemy.engine.interfaces.ReflectedComputed.sqltext： str¶
用于生成此列的表达式，以字符串 SQL 表达式形式返回
-
-
类 sqlalchemy.engine.interfaces 中。ReflectedCheckConstraint 参数¶
表示对应的反射元素的字典CheckConstraint 的 Constraint实例。ReflectedCheckConstraint结构由Inspector.get_check_constraints()方法。
类签名
类sqlalchemy.engine.interfaces.ReflectedCheckConstraint（builtins.dict）-
属性sqlalchemy.engine.interfaces.ReflectedCheckConstraint.dialect_options：NotRequired[Dict[str， Any]]¶
为此检查约束检测到的其他特定于 dialect 的选项
在 1.3.8 版本加入.
-
属性sqlalchemy.engine.interfaces.ReflectedCheckConstraint.sqltext： str¶
check 约束的 SQL 表达式
-
-
类 sqlalchemy.engine.interfaces 中。ReflectedForeignKeyConstraint 插件¶
表示对应的反射元素的字典ForeignKeyConstraint 的 Constraint对象。ReflectedForeignKeyConstraint结构由Inspector.get_foreign_keys（）方法返回。
类签名
类sqlalchemy.engine.interfaces.ReflectedForeignKeyConstraint（builtins.dict）-
属性sqlalchemy.engine.interfaces.ReflectedForeignKeyConstraint.constrained_columns： List[str]¶
组成外键的 local column names
-
属性sqlalchemy.engine.interfaces.ReflectedForeignKeyConstraint.选项： NotRequired[Dict[str， Any]]¶
为此外键约束检测到的其他选项
-
属性sqlalchemy.engine.interfaces.ReflectedForeignKeyConstraint.referred_columns：List[str]¶
对应于constrained_columns的引用列名称
-
属性sqlalchemy.engine.interfaces.ReflectedForeignKeyConstraint.referred_schema：strNone¶
所引用的表的架构名称
-
属性sqlalchemy.engine.interfaces.ReflectedForeignKeyConstraint.referred_table： str¶
所引用的表的名称
-
-
类 sqlalchemy.engine.interfaces 中。ReflectedIdentity（反射身份）¶
表示列的反射 IDENTITY 结构，对应于Identity构造。ReflectedIdentity结构是ReflectedColumn结构，该结构由Inspector.get_columns（）方法。
类签名
类sqlalchemy.engine.interfaces.ReflectedIdentity（builtins.dict）-
属性sqlalchemy.engine.interfaces.ReflectedIdentity.始终：bool¶
Identity 列的类型
-
attributesqlalchemy.engine.interfaces.ReflectedIdentity.cache：intNone¶
序列中预先计算的未来值的数量。
-
attributesqlalchemy.engine.interfaces.ReflectedIdentity.cycle： bool （布尔值） ¶
允许序列在达到 MaxValue 或 MinValue 时回绕。
-
attributesqlalchemy.engine.interfaces.ReflectedIdentity.increment： int（属性增量）：int¶
序列的 increment 值
-
属性sqlalchemy.engine.interfaces.ReflectedIdentity.maxValue： int¶
序列的最大值。
-
属性sqlalchemy.engine.interfaces.ReflectedIdentity.minvalue： int¶
序列的最小值。
-
属性sqlalchemy.engine.interfaces.ReflectedIdentity.nomaxValue： bool¶
序列没有最大值。
-
属性sqlalchemy.engine.interfaces.ReflectedIdentity.nominValue： bool¶
序列没有最小值。
-
属性sqlalchemy.engine.interfaces.ReflectedIdentity.on_null： bool¶
表示 ON NULL
-
属性sqlalchemy.engine.interfaces.ReflectedIdentity.顺序：bool¶
如果为 true，则呈现 ORDER 关键字。
-
属性sqlalchemy.engine.interfaces.ReflectedIdentity.start： int¶
序列的起始索引
-
-
类 sqlalchemy.engine.interfaces 中。反射索引¶
表示对应的反射元素的字典索引。ReflectedIndex结构由Inspector.get_indexes（）方法。
类签名
类sqlalchemy.engine.interfaces.ReflectedIndex（builtins.dict）-
属性sqlalchemy.engine.interfaces.ReflectedIndex.column_names：List[strNone]¶
索引引用的列名。如果此列表的元素是表达式，则为None，并在表达式列表中返回。
-
属性sqlalchemy.engine.interfaces.ReflectedIndex.column_sorting：NotRequired[Dict[str， Tuple[str]]]¶
可选的 dict 将列名或表达式映射到排序关键字的元组，其中可能包括asc、desc、nulls_first、nulls_last。
在 1.3.5 版本加入.
-
属性sqlalchemy.engine.interfaces.ReflectedIndex.dialect_options：NotRequired[Dict[str， Any]]¶
为此索引检测到的其他特定于方言的选项
-
属性sqlalchemy.engine.interfaces.ReflectedIndex.duplicates_constraint：NotRequired[strNone]¶
指示此索引是否镜像具有此名称的约束
-
属性sqlalchemy.engine.interfaces.ReflectedIndex.表达式： NotRequired[List[str]]¶
组成索引的表达式。此列表（如果存在）包含纯列名（也以column_names为单位）和表达式（以column_names为单位为None）。
-
属性sqlalchemy.engine.interfaces.ReflectedIndex.include_columns：NotRequired[List[str]]¶
要包含在支持数据库的 INCLUDE 子句中的列。
2.0 版后已移除： legacy 值将替换为index_dict["dialect_options"]["<dialect name>_include"]
-
attributesqlalchemy.engine.interfaces.ReflectedIndex.name：strNone¶
索引名称
-
唯一属性sqlalchemy.engine.interfaces.ReflectedIndex.：bool¶
索引是否具有唯一标志
-
-
类 sqlalchemy.engine.interfaces 中。ReflectedPrimaryKeyConstraint 函数¶
表示对应的反射元素的字典PrimaryKeyConstraint 的 PrimaryKeyConstraint中。ReflectedPrimaryKeyConstraint结构由Inspector.get_pk_constraint（）方法。
类签名
类sqlalchemy.engine.interfaces.ReflectedPrimaryKeyConstraint（builtins.dict）-
属性sqlalchemy.engine.interfaces.ReflectedPrimaryKeyConstraint.constrained_columns： List[str]¶
组成主键的列名
-
属性sqlalchemy.engine.interfaces.ReflectedPrimaryKeyConstraint.dialect_options：NotRequired[Dict[str， Any]]¶
为此主键检测到的其他特定于方言的选项
-
-
类 sqlalchemy.engine.interfaces 中。ReflectedUniqueConstraint （反射唯一约束）¶
表示对应的反射元素的字典UniqueConstraint 的 UniqueConstraint中。ReflectedUniqueConstraint结构由Inspector.get_unique_constraints()方法。
类签名
类sqlalchemy.engine.interfaces.ReflectedUniqueConstraint（builtins.dict）-
属性sqlalchemy.engine.interfaces.ReflectedUniqueConstraint.column_names：List[str]¶
组成唯一约束的列名
-
属性sqlalchemy.engine.interfaces.ReflectedUniqueConstraint.dialect_options：NotRequired[Dict[str， Any]]¶
为此唯一约束检测到的其他特定于 dialect 的选项
-
attributesqlalchemy.engine.interfaces.ReflectedUniqueConstraint.duplicates_index：NotRequired[strNone]¶
指示此唯一约束是否与具有此名称的索引重复
-
-
类 sqlalchemy.engine.interfaces 中。ReflectedTableComment¶
表示对应于Table.comment属性的反射注释的字典。ReflectedTableComment结构由Inspector.get_table_comment（）方法。
成员
类签名
类sqlalchemy.engine.interfaces.ReflectedTableComment（builtins.dict）-
attributesqlalchemy.engine.interfaces.ReflectedTableComment.text：strNone¶
评论文本
-
使用与数据库无关的类型进行反射¶
当反映表的列时，使用
Table.autoload_with Table 的 parameter 或 Inspector.get_columns（） 的
Inspector 的 Inspector，数据类型将尽可能具体
添加到目标数据库。 这意味着，如果反映 “integer” 数据类型
从 MySQL 数据库中，类型将由
sqlalchemy.dialects.mysql.INTEGER 类，其中包括特定于 MySQL 的属性，例如 “display_width”。或者在 PostgreSQL 上，特定于 PostgreSQL 的数据类型，例如 sqlalchemy.dialects.postgresql.INTERVAL
sqlalchemy.dialects.postgresql.ENUM 可能会返回。
反射有一个用例，即给定的 Table
将转移到不同的供应商数据库。 为了适应此用例，
有一种技术可以转换这些特定于供应商的数据类型
动态成为 SQLAlchemy 后端不可知数据类型的实例，对于
上面的示例类型，例如 Integer、Interval
和 Enum。这可以通过将 DDLEvents.column_reflect（） 事件与 TypeEngine.as_generic（） 方法结合使用来拦截列反射来实现。
给定 MySQL 中的一个表（选择 MySQL 是因为 MySQL 有很多特定于供应商的数据类型和选项）：
CREATE TABLE IF NOT EXISTS my_table (
id INTEGER PRIMARY KEY AUTO_INCREMENT,
data1 VARCHAR(50) CHARACTER SET latin1,
data2 MEDIUMINT(4),
data3 TINYINT(2)
)
上表包括仅限 MySQL 的整数类型 MEDIUMINT 和
TINYINT 以及包含仅限 MySQL 的 CHARACTER 的 VARCHAR
设置选择。 如果我们正常地反映这个表，它会生成一个
Table 对象，该对象将包含这些特定于 MySQL 的数据类型和选项：
>>> from sqlalchemy import MetaData, Table, create_engine
>>> mysql_engine = create_engine("mysql+mysqldb://scott:tiger@localhost/test")
>>> metadata_obj = MetaData()
>>> my_mysql_table = Table("my_table", metadata_obj, autoload_with=mysql_engine)
上面的示例将上面的 Table 架构反映到一个新的 Table 中
对象。 然后，出于演示目的，我们可以打印出特定于 MySQL 的
使用 CreateTable 构造的 “CREATE TABLE” 语句：
>>> from sqlalchemy.schema import CreateTable
>>> print(CreateTable(my_mysql_table).compile(mysql_engine))
CREATE TABLE my_table (
id INTEGER(11) NOT NULL AUTO_INCREMENT,
data1 VARCHAR(50) CHARACTER SET latin1,
data2 MEDIUMINT(4),
data3 TINYINT(2),
PRIMARY KEY (id)
)ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
上面，维护了特定于 MySQL 的数据类型和选项。如果我们想要一个 Table，我们可以将其干净地转移到另一个 Table
数据库供应商， 替换特殊数据类型
sqlalchemy.dialects.mysql.MEDIUMINT 和
sqlalchemy.dialects.mysql.TINYINT 使用 Integer，我们可以
而是选择“泛化”此表上的数据类型，或更改
它们，通过使用
DDLEvents.column_reflect（） 事件。自定义处理程序将使用 TypeEngine.as_generic（） 方法将上述特定于 MySQL 的类型对象转换为通用对象，方法是将 “type”
条目。
此字典的格式在 Inspector.get_columns（） 中描述：
>>> from sqlalchemy import event
>>> metadata_obj = MetaData()
>>> @event.listens_for(metadata_obj, "column_reflect")
... def genericize_datatypes(inspector, tablename, column_dict):
... column_dict["type"] = column_dict["type"].as_generic()
>>> my_generic_table = Table("my_table", metadata_obj, autoload_with=mysql_engine)
现在，我们得到了一个泛型的新 Table，并使用
这些数据类型的 Integer。例如，我们现在可以在 PostgreSQL 数据库上发出 “CREATE TABLE” 语句：
>>> pg_engine = create_engine("postgresql+psycopg2://scott:tiger@localhost/test", echo=True)
>>> my_generic_table.create(pg_engine)
CREATE TABLE my_table (
id SERIAL NOT NULL,
data1 VARCHAR(50),
data2 INTEGER,
data3 INTEGER,
PRIMARY KEY (id)
)
还要注意，SQLAlchemy 通常会对其他行为进行不错的猜测，例如 MySQL AUTO_INCREMENT 指令在 PostgreSQL 中最接近地使用 SERIAL 自动递增数据类型表示。
1.4 版本中的新功能： 添加了 TypeEngine.as_generic（） 方法，并额外改进了 DDLEvents.column_reflect（） 的使用
事件，以便将其应用于 MetaData 对象以方便起见。
反射的限制¶
请务必注意，反射过程会重新创建 Table
元数据仅使用关系数据库中表示的信息。
根据定义，此过程无法还原架构中不是
实际存储在数据库中。 无法从反射中获得的状态
包括但不限于：
客户端默认值，Python 函数或使用Column的 default关键字定义的 SQL 表达式（请注意，这与server_default是分开的，后者具体是通过反射提供的）。
列信息，例如可能已放入Column.info词典
在许多情况下，关系数据库还以与 SQLAlchemy 中指定的格式不同的格式报告表元数据。桌子
从反射返回的对象不能总是依赖于产生相同的
DDL 作为原始 Python 定义的 Table 对象。发生这种情况的区域包括服务器默认值、列关联序列以及有关约束和数据类型的各种特性。服务器端默认值可以通过 cast 指令返回（通常 PostgreSQL 将包含一个 ：：<type>
cast） 或与最初指定的引用模式不同的引用模式。
另一类限制包括反射仅部分定义或尚未定义反射的架构结构。最近对反射的改进允许反映视图、索引和外键选项等内容。在撰写本文时，CHECK 约束、表注释和触发器等结构尚未反映出来。