U
|
¸ý°d¤- ã @ s¬ d Z ddlmZ ddlZddlmZ ddlmZ ddlmZ ddlm Z ddl
|
m Z dd l
|
m Z dd
|
l
|
m Z dd l
|
mZ dd l
|
mZ dd l
|
mZ ddl
|
mZ ddl
|
mZ ddl
|
mZ ddl
|
mZ ddl
|
mZ ddl
|
mZ ddl
|
mZ ddl
|
mZ ddlmZ ddlmZ ddl m Z ddl m Z dd l m Z dd l m Z dd l m!Z! dd l m"Z# dd l$m%Z% dd!l&m'Z' dd"l(m)Z) dd#l*m+Z+ dd$l m,Z, dd%l-m.Z. er
|
dd&l/m0Z0 dd'l/m1Z1 dd(l/m2Z2 dd)l/m3Z3 dd*l/m4Z4 dd+l/m5Z5 dd,l/m6Z6 dd-l/m7Z7 dd.l/m8Z8 ed/Z9e j:d0d1d2d3d3d/d4d5d6Z;d7d8d9d:d;Z<e G d<d= d=eZ=e G d>d? d?eZ>e j?G d@dA dAe j@dA ZAe.G dBdC dCZBeG dDdE dEZCdS )Faã Provides an abstraction for obtaining database schema information.
|
|
Usage Notes:
|
|
Here are some general conventions when accessing the low level inspector
|
methods such as get_table_names, get_columns, etc.
|
|
1. Inspector methods return lists of dicts in most cases for the following
|
reasons:
|
|
* They're both standard types that can be serialized.
|
* Using a dict instead of a tuple allows easy expansion of attributes.
|
* Using a list for the outer structure maintains order and is easy to work
|
with (e.g. list comprehension [d['name'] for d in cols]).
|
|
2. Records that contain a name, such as the column name in a column record
|
use the key 'name'. So for most return values, each record will have a
|
'name' attribute..
|
é )Ú annotationsN)Ú dataclass)Úauto)ÚFlag)Úunique)ÚAny)ÚCallable)Ú
|
Collection)ÚDict)Ú Generator)ÚIterable)ÚList)ÚOptional)ÚSequence)ÚSet)ÚTuple)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné )Ú
|
Connection)ÚEngineé )Úexc)Ú
|
inspection)Úsql)Úutil)Ú operators)Úschema)Ú_ad_hoc_cache_key_from_args)Ú
|
TextClause)Ú
|
TypeEngine)ÚInternalTraversal)Ú topological)Úfinal)ÚDialect)ÚReflectedCheckConstraint)ÚReflectedColumn)Ú ReflectedForeignKeyConstraint)ÚReflectedIndex)Ú ReflectedPrimaryKeyConstraint)ÚReflectedTableComment)ÚReflectedUniqueConstraint)ÚTableKeyÚ_RúCallable[..., _R]r% r r ©ÚfnÚselfÚconÚargsÚkwÚreturnc s | dd ¡}|d kr&| ||f||S ddh | jtdd |D t fdd| ¡ D f}| |¡}|d kr| ||f||}|||< |S )NÚ
|
info_cacheÚ unreflectablec s s | ]}t |tr|V qd S ©N)Ú
|
isinstanceÚstr)Ú.0Úa© r> úSd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/engine/reflection.pyÚ <genexpr>\ s
|
zcache.<locals>.<genexpr>c 3 s" | ]\}}| kr||fV qd S r9 r> )r< ÚkÚv©Úexcluder> r? r@ ] s )ÚgetÚ__name__ÚtupleÚitems©r1 r2 r3 r4 r5 r7 ÚkeyÚretr> rC r? ÚcacheN s ý
|
rL z Tuple[str, InternalTraversal]z0Callable[[Callable[..., _R]], Callable[..., _R]])Ú traverse_argsr6 c s& t jddddddd fdd }|S ) Nr/ r% r r r. r0 c sf | dd ¡}|d kr&| ||f||S t| jf |}| |¡}|d krb| ||f||}|||< |S )Nr7 )rE r rF rI ©rM r> r? Úgoi s
|
zflexi_cache.<locals>.go)r Ú decorator)rM rO r> rN r? Ú flexi_cachef s rQ c @ s6 e Zd ZdZe Ze Ze ZeeB ZeeB eB Z dS )Ú
|
ObjectKindaÞ Enumerator that indicates which kind of object to return when calling
|
the ``get_multi`` methods.
|
|
This is a Flag enum, so custom combinations can be passed. For example,
|
to reflect tables and plain views ``ObjectKind.TABLE | ObjectKind.VIEW``
|
may be used.
|
|
.. note::
|
Not all dialect may support all kind of object. If a dialect does
|
not support a particular object an empty dict is returned.
|
In case a dialect supports an object, but the requested method
|
is not applicable for the specified kind the default value
|
will be returned for each reflected object. For example reflecting
|
check constraints of view return a dict with all the views with
|
empty lists as values.
|
N)
|
rF Ú
|
__module__Ú __qualname__Ú__doc__r ÚTABLEZVIEWZMATERIALIZED_VIEWZANY_VIEWÚANYr> r> r> r? rR ~ s rR c @ s$ e Zd ZdZe Ze ZeeB ZdS )Ú ObjectScopez]Enumerator that indicates which scope to use when calling
|
the ``get_multi`` methods.
|
N)rF rS rT rU r ÚDEFAULTÚ TEMPORARYrW r> r> r> r? rX s
|
rX c @ s@ e Zd ZU dZded< ded< ded< ded < d
|
ed < e d d ¡ddddZeddd dddZ dddddZ
|
dddddZ d dd d d Z dd d!d"Z ee d d#¡dd dd$d%Ze e¡dd dd&d'Ze e¡d d dd(d)Zejd*d d+d,Zejd-d d.d/Zed0d d1d2Zd3d4d5d6d7Zd¼d0d3d4d9d:d;Z d½d<d0d3dd=d>d?Z d¾d<d0d3dd@dAdBZ d¿d<d<d0d3ddCdDdEZ d<d3ddFdGdHZ dÀd0d3dId9dJdKZ!dÁdMd3dNdOdPdQZ"d3d4d5dRdSZ#d3d4d5dTdUZ$dÂd<d0d3dVd=dWdXZ%d8d8e&j'e(j)fd0dYdZd[d3d\d]d^d_Z*dÃd0d3d4d9d`daZ+dÄd0d3d4d9dbdcZ,dÅd0d3d4d9dddeZ-dÆd<d0d3d<dfdgdhZ.dÇd<d0d3did=djdkZ/dlddmdndoZ0d8d8e&j'e(j)fd0dYdZd[d3dpd]dqdrZ1dÈd<d0d3dsd=dtduZ2d8d8e&j'e(j)fd0dYdZd[d3dvd]dwdxZ3dÉd<d0d3dyd=dzd{Z4d8d8e&j'e(j)fd0dYdZd[d3d|d]d}d~Z5dÊd<d0d3dd=ddZ6d8d8e&j'e(j)fd0dYdZd[d3dd]ddZ7dËd<d0d3d
d=ddZ8d8d8e&j'e(j)fd0dYdZd[d3dd]ddZ9dÌd<d0d3dd=ddZ:d8d8e&j'e(j)fd0dYdZd[d3dd]ddZ;dÍd<d0d3dd=ddZ<d8d8e&j'e(j)fd0dYdZd[d3dd]ddZ=dÎdddddddddd Z>dd¡ddd¢dd£d¤d¥Z?d¦d§dd¢ddd¨d©dªZ@d¦d§dd¢dddddVdd«
|
d¬dZAeBjCeBjDeBjEeBjFd®ZGd¦d§dd¢dddVdd¯d°d±ZHd¦d§dd¢dddVdd¯d²d³ZId¦d§dd¢dddVdd¯d´dµZJd¦d§ddVdd¶d·d¸ZKdÏd0dddd3d¦d¹dºd»ZLd8S )ÐÚ Inspectora< Performs database schema inspection.
|
|
The Inspector acts as a proxy to the reflection methods of the
|
:class:`~sqlalchemy.engine.interfaces.Dialect`, providing a
|
consistent interface as well as caching support for previously
|
fetched metadata.
|
|
A :class:`_reflection.Inspector` object is usually created via the
|
:func:`_sa.inspect` function, which may be passed an
|
:class:`_engine.Engine`
|
or a :class:`_engine.Connection`::
|
|
from sqlalchemy import inspect, create_engine
|
engine = create_engine('...')
|
insp = inspect(engine)
|
|
Where above, the :class:`~sqlalchemy.engine.interfaces.Dialect` associated
|
with the engine may opt to return an :class:`_reflection.Inspector`
|
subclass that
|
provides additional methods specific to the dialect's target database.
|
|
zUnion[Engine, Connection]Úbindr ÚengineÚboolÚ _op_context_requires_connectr% ÚdialectzDict[Any, Any]r7 z1.4a The __init__() method on :class:`_reflection.Inspector` is deprecated and will be removed in a future release. Please use the :func:`.sqlalchemy.inspect` function on an :class:`_engine.Engine` or :class:`_engine.Connection` in order to acquire an :class:`_reflection.Inspector`.©r\ c C s | |¡ dS )a Initialize a new :class:`_reflection.Inspector`.
|
|
:param bind: a :class:`~sqlalchemy.engine.Connection`,
|
which is typically an instance of
|
:class:`~sqlalchemy.engine.Engine` or
|
:class:`~sqlalchemy.engine.Connection`.
|
|
For a dialect-specific instance of :class:`_reflection.Inspector`, see
|
:meth:`_reflection.Inspector.from_engine`
|
|
N)Ú _init_legacy©r2 r\ r> r> r? Ú__init__Ë s zInspector.__init__zCallable[..., Any])Úinitr\ r6 c C s, t |jdr|jj} | | ¡}||| |S )NÚ inspector)Úhasattrr` rf Ú__new__)Úclsre r\ r2 r> r> r? Ú
|
_constructä s
|
|
|
zInspector._constructÚNone)r\ r6 c C s$ t |dr| |¡ n
|
| |¡ d S )NZexec_driver_sql)rg Ú_init_connectionÚ _init_enginerc r> r> r? rb ð s
|
zInspector._init_legacy)r] r6 c C s2 | | _ | _| ¡ ¡ d| _| jj| _i | _d S )NT)r\ r] ÚconnectÚcloser_ r` r7 )r2 r] r> r> r? rm ö s
|
|
zInspector._init_enginer )Ú
|
connectionr6 c C s( || _ |j| _d| _| jj| _i | _d S )NF)r\ r] r_ r` r7 )r2 rp r> r> r? rl ý s
|
|
zInspector._init_connection©r6 c C s | j ¡ dS )zÈreset the cache for this :class:`.Inspector`.
|
|
Inspection methods that have data cached will emit SQL queries
|
when next called to get new data.
|
|
.. versionadded:: 2.0
|
|
N)r7 Úclear©r2 r> r> r? Ú clear_cache s zInspector.clear_cachea The from_engine() method on :class:`_reflection.Inspector` is deprecated and will be removed in a future release. Please use the :func:`.sqlalchemy.inspect` function on an :class:`_engine.Engine` or :class:`_engine.Connection` in order to acquire an :class:`_reflection.Inspector`.c C s | | j|¡S )aZ Construct a new dialect-specific Inspector object from the given
|
engine or connection.
|
|
:param bind: a :class:`~sqlalchemy.engine.Connection`
|
or :class:`~sqlalchemy.engine.Engine`.
|
|
This method differs from direct a direct constructor call of
|
:class:`_reflection.Inspector` in that the
|
:class:`~sqlalchemy.engine.interfaces.Dialect` is given a chance to
|
provide a dialect-specific :class:`_reflection.Inspector` instance,
|
which may
|
provide additional methods.
|
|
See the example at :class:`_reflection.Inspector`.
|
|
)rj rb )ri r\ r> r> r? Ú from_engine s zInspector.from_enginec C s t t j| ¡S r9 )r[ rj rm ra r> r> r? Ú _engine_insp. s zInspector._engine_inspc C s t t j| ¡S r9 )r[ rj rl ra r> r> r? Ú_connection_insp2 s zInspector._connection_inspz!Generator[Connection, None, None]c c s8 | j r| j ¡ }n| j}z
|
|V W 5 | j r2| ¡ X dS )a Return a context that optimizes for multiple operations on a single
|
transaction.
|
|
This essentially allows connect()/close() to be called if we detected
|
that we're against an :class:`_engine.Engine` and not a
|
:class:`_engine.Connection`.
|
|
N)r_ r\ rn ro )r2 Úconnr> r> r? Ú_operation_context6 s
|
z Inspector._operation_contextz Generator[Inspector, None, None]c c s6 | ¡ $}| | jj|¡}| j|_|V W 5 Q R X dS )z
Return an :class:`_reflection.Inspector`
|
from this one that will run all
|
operations on a single connection.
|
|
N)ry rj Ú __class__rl r7 )r2 rx Zsub_inspr> r> r? Ú_inspection_contextK s
|
z Inspector._inspection_contextz Optional[str]c C s | j jS )zÏReturn the default schema name presented by the dialect
|
for the current engine's database user.
|
|
E.g. this is typically ``public`` for PostgreSQL and ``dbo``
|
for SQL Server.
|
|
)r` Údefault_schema_namers r> r> r? r| X s z Inspector.default_schema_namer z List[str])r5 r6 c
|
K s: | ¡ (}| jj|fd| ji|W 5 Q R £ S Q R X dS )zØReturn all schema names.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
r7 N)ry r` Úget_schema_namesr7 ©r2 r5 rx r> r> r? r} c s
|
ÿÿÿzInspector.get_schema_namesN)r r5 r6 c
|
K s< | ¡ *}| jj||fd| ji|W 5 Q R £ S Q R X dS )aÜ Return all table names within a particular schema.
|
|
The names are expected to be real tables only, not views.
|
Views are instead returned using the
|
:meth:`_reflection.Inspector.get_view_names` and/or
|
:meth:`_reflection.Inspector.get_materialized_view_names`
|
methods.
|
|
:param schema: Schema name. If ``schema`` is left at ``None``, the
|
database's default schema is
|
used, else the named schema is searched. If the database does not
|
support named schemas, behavior is undefined if ``schema`` is not
|
passed as ``None``. For special quoting, use :class:`.quoted_name`.
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
.. seealso::
|
|
:meth:`_reflection.Inspector.get_sorted_table_and_fkc_names`
|
|
:attr:`_schema.MetaData.sorted_tables`
|
|
r7 N)ry r` Úget_table_namesr7 ©r2 r r5 rx r> r> r? r p s
|
ÿÿÿzInspector.get_table_namesr; )Ú
|
table_namer r5 r6 c
|
K s> | ¡ ,}| jj|||fd| ji|W 5 Q R £ S Q R X dS )a Return True if the backend has a table, view, or temporary
|
table of the given name.
|
|
:param table_name: name of the table to check
|
:param schema: schema name to query, if not the default schema.
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
.. versionadded:: 1.4 - the :meth:`.Inspector.has_table` method
|
replaces the :meth:`_engine.Engine.has_table` method.
|
|
.. versionchanged:: 2.0:: :meth:`.Inspector.has_table` now formally
|
supports checking for additional table-like objects:
|
|
* any type of views (plain or materialized)
|
* temporary tables of any kind
|
|
Previously, these two checks were not formally specified and
|
different dialects would vary in their behavior. The dialect
|
testing suite now includes tests for all of these object types
|
and should be supported by all SQLAlchemy-included dialects.
|
Support among third party dialects may be lagging, however.
|
|
r7 N)ry r` Ú has_tabler7 ©r2 r r r5 rx r> r> r? r s
|
ÿÿÿzInspector.has_table)Ú sequence_namer r5 r6 c
|
K s> | ¡ ,}| jj|||fd| ji|W 5 Q R £ S Q R X dS )a¢ Return True if the backend has a sequence with the given name.
|
|
:param sequence_name: name of the sequence to check
|
:param schema: schema name to query, if not the default schema.
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
.. versionadded:: 1.4
|
|
r7 N)ry r` Ú has_sequencer7 )r2 r r r5 rx r> r> r? r
² s
|
ÿÿÿzInspector.has_sequence)r Ú
|
index_namer r5 r6 c
|
K s@ | ¡ .}| jj||||fd| ji|W 5 Q R £ S Q R X dS )aç Check the existence of a particular index name in the database.
|
|
:param table_name: the name of the table the index belongs to
|
:param index_name: the name of the index to check
|
:param schema: schema name to query, if not the default schema.
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
.. versionadded:: 2.0
|
|
r7 N)ry r` Ú has_indexr7 )r2 r r r r5 rx r> r> r? r Å s
|
üûúzInspector.has_index)Ú schema_namer5 r6 c
|
K s< | ¡ *}| jj||fd| ji|W 5 Q R £ S Q R X dS )aT Return True if the backend has a schema with the given name.
|
|
:param schema_name: name of the schema to check
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
.. versionadded:: 2.0
|
|
r7 N)ry r` Ú
|
has_schemar7 )r2 r r5 rx r> r> r? r â s
|
ÿÿÿzInspector.has_schemaz;List[Tuple[Optional[str], List[Tuple[str, Optional[str]]]]]c K s dd | j |fdD S )ag Return dependency-sorted table and foreign key constraint names in
|
referred to within a particular schema.
|
|
This will yield 2-tuples of
|
``(tablename, [(tname, fkname), (tname, fkname), ...])``
|
consisting of table names in CREATE order grouped with the foreign key
|
constraint names that are not detected as belonging to a cycle.
|
The final element
|
will be ``(None, [(tname, fkname), (tname, fkname), ..])``
|
which will consist of remaining
|
foreign key constraint names that would require a separate CREATE
|
step after-the-fact, based on dependencies between tables.
|
|
:param schema: schema name to query, if not the default schema.
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
.. seealso::
|
|
:meth:`_reflection.Inspector.get_table_names`
|
|
:func:`.sort_tables_and_constraints` - similar method which works
|
with an already-given :class:`_schema.MetaData`.
|
|
c S s. g | ]&\}}|r|d nddd |D fqS )r Nc S s g | ]\\}}}||fqS r> r> )r< Ú_ÚtnameZfksr> r> r? Ú
|
<listcomp> s
|
zGInspector.get_sorted_table_and_fkc_names.<locals>.<listcomp>.<listcomp>r> )r< Ú table_keyZ fk_collectionr> r> r? r s û þz<Inspector.get_sorted_table_and_fkc_names.<locals>.<listcomp>)Úconsider_schemas)Ú%sort_tables_on_foreign_key_dependency)r2 r r5 r> r> r? Ú get_sorted_table_and_fkc_namesò s
|
ÿøz(Inspector.get_sorted_table_and_fkc_namesr9 zCollection[Optional[str]]zgList[Tuple[Optional[Tuple[Optional[str], str]], List[Tuple[Tuple[Optional[str], str], Optional[str]]]]])r r5 r6 c
|
sZ t tt tf }t }t i g }|D ]}| j|f|}| |¡ | ¡ D ]b\\}} }
|
dd |
|
D || f< |
|
D ]:} | | d ks|| d krr| | d | d f|| ff¡ qrqLq(ztt
|
||¡} W nl t j k
|
r2 } zJ| j D ]. | ¡ fdd d D ¡ qâtt
|
||¡} W 5 d} ~ X Y nX fd d
|
| D }|dtfg S ) aÄ Return dependency-sorted table and foreign key constraint names
|
referred to within multiple schemas.
|
|
This method may be compared to
|
:meth:`.Inspector.get_sorted_table_and_fkc_names`, which
|
works on one schema at a time; here, the method is a generalization
|
that will consider multiple schemas at once including that it will
|
resolve for cross-schema foreign keys.
|
|
.. versionadded:: 2.0
|
|
c S s h | ] }|d qS )Únamer> ©r< Zfkr> r> r? Ú <setcomp>@ s zBInspector.sort_tables_on_foreign_key_dependency.<locals>.<setcomp>Úreferred_tableÚreferred_schemac 3 s | ]} d |fV qdS )r Nr> )r< Zfkc)Úedger> r? r@ W s zBInspector.sort_tables_on_foreign_key_dependency.<locals>.<genexpr>r Nc sD g | ]<\ f fd d f dd D ¡D fqS )c s g | ]} f|fqS r> r> r ©Úschnamer r> r? r b s ÿzNInspector.sort_tables_on_foreign_key_dependency.<locals>.<listcomp>.<listcomp>c s s | ]\}}|V qd S r9 r> )r< r r r> r> r? r@ d s zMInspector.sort_tables_on_foreign_key_dependency.<locals>.<listcomp>.<genexpr>)Ú
|
difference)r< )Úfknames_for_tableÚremaining_fkcsr r? r _ s
|
ø ÿþþzCInspector.sort_tables_on_foreign_key_dependency.<locals>.<listcomp>)r r r; ÚsetÚget_multi_foreign_keysÚextendrH ÚaddÚlistr# Úsortr ZCircularDependencyErrorÚedgesÚremoveÚupdate)r2 r r5 Z SchemaTabZtuplesZtnamesr Z schema_fkeysr r ÚfkeysZfkeyZcandidate_sortÚerrrK r> )r r r r? r sJ
|
ÿ
|
ÿ
|
þþûÿ
|
|
|
|
ÿ
|
"
|
ö z/Inspector.sort_tables_on_foreign_key_dependencyc
|
K s: | ¡ (}| jj|fd| ji|W 5 Q R £ S Q R X dS )aw Return a list of temporary table names for the current bind.
|
|
This method is unsupported by most dialects; currently
|
only Oracle, PostgreSQL and SQLite implements it.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
r7 N)ry r` Úget_temp_table_namesr7 r~ r> r> r? r§ m s
|
ÿÿÿz Inspector.get_temp_table_namesc
|
K s: | ¡ (}| jj|fd| ji|W 5 Q R £ S Q R X dS )an Return a list of temporary view names for the current bind.
|
|
This method is unsupported by most dialects; currently
|
only PostgreSQL and SQLite implements it.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
r7 N)ry r` Úget_temp_view_namesr7 r~ r> r> r? r¨ ~ s
|
ÿÿÿz Inspector.get_temp_view_namesúDict[str, Any]c
|
K s> | ¡ ,}| jj|||fd| ji|W 5 Q R £ S Q R X dS )aq Return a dictionary of options specified when the table of the
|
given name was created.
|
|
This currently includes some options that apply to MySQL and Oracle
|
tables.
|
|
:param table_name: string name of the table. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a dict with the table options. The returned keys depend on the
|
dialect in use. Each one is prefixed with the dialect name.
|
|
.. seealso:: :meth:`Inspector.get_multi_table_options`
|
|
r7 N)ry r` Úget_table_optionsr7 r r> r> r? rª s
|
ÿÿÿzInspector.get_table_optionszOptional[Sequence[str]]rR rX ú Dict[TableKey, Dict[str, Any]])r Ú filter_namesÚkindÚscoper5 r6 c
|
K sJ | ¡ 8}| jj|f||||| jd|}t|W 5 Q R £ S Q R X dS )aÏ Return a dictionary of options specified when the tables in the
|
given schema were created.
|
|
The tables can be filtered by passing the names to use to
|
``filter_names``.
|
|
This currently includes some options that apply to MySQL and Oracle
|
tables.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param filter_names: optionally return information only for the
|
objects listed here.
|
|
:param kind: a :class:`.ObjectKind` that specifies the type of objects
|
to reflect. Defaults to ``ObjectKind.TABLE``.
|
|
:param scope: a :class:`.ObjectScope` that specifies if options of
|
default, temporary or any tables should be reflected.
|
Defaults to ``ObjectScope.DEFAULT``.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a dictionary where the keys are two-tuple schema,table-name
|
and the values are dictionaries with the table options.
|
The returned keys in each dict depend on the
|
dialect in use. Each one is prefixed with the dialect name.
|
The schema is ``None`` if no schema is provided.
|
|
.. versionadded:: 2.0
|
|
.. seealso:: :meth:`Inspector.get_table_options`
|
©r r¬ r r® r7 N)ry r` Úget_multi_table_optionsr7 Údict)r2 r r¬ r r® r5 rx Úresr> r> r? r° s -
|
ÿúù z!Inspector.get_multi_table_optionsc
|
K s< | ¡ *}| jj||fd| ji|W 5 Q R £ S Q R X dS )a Return all non-materialized view names in `schema`.
|
|
:param schema: Optional, retrieve names from a non-default schema.
|
For special quoting, use :class:`.quoted_name`.
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
|
.. versionchanged:: 2.0 For those dialects that previously included
|
the names of materialized views in this list (currently PostgreSQL),
|
this method no longer returns the names of materialized views.
|
the :meth:`.Inspector.get_materialized_view_names` method should
|
be used instead.
|
|
.. seealso::
|
|
:meth:`.Inspector.get_materialized_view_names`
|
|
r7 N)ry r` Úget_view_namesr7 r r> r> r? r³ æ s
|
ÿÿÿzInspector.get_view_namesc
|
K s< | ¡ *}| jj||fd| ji|W 5 Q R £ S Q R X dS )aØ Return all materialized view names in `schema`.
|
|
:param schema: Optional, retrieve names from a non-default schema.
|
For special quoting, use :class:`.quoted_name`.
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
:meth:`.Inspector.get_view_names`
|
|
r7 N)ry r` Úget_materialized_view_namesr7 r r> r> r? r´ s
|
ÿÿÿz%Inspector.get_materialized_view_namesc
|
K s< | ¡ *}| jj||fd| ji|W 5 Q R £ S Q R X dS )ak Return all sequence names in `schema`.
|
|
:param schema: Optional, retrieve names from a non-default schema.
|
For special quoting, use :class:`.quoted_name`.
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
r7 N)ry r` Úget_sequence_namesr7 r r> r> r? rµ s
|
ÿÿÿz Inspector.get_sequence_names)Ú view_namer r5 r6 c
|
K s> | ¡ ,}| jj|||fd| ji|W 5 Q R £ S Q R X dS )aà Return definition for the plain or materialized view called
|
``view_name``.
|
|
:param view_name: Name of the view.
|
:param schema: Optional, retrieve names from a non-default schema.
|
For special quoting, use :class:`.quoted_name`.
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
r7 N)ry r` Úget_view_definitionr7 )r2 r¶ r r5 rx r> r> r? r· - s
|
ÿÿÿz Inspector.get_view_definitionúList[ReflectedColumn]c K sF | ¡ $}| jj|||fd| ji|}W 5 Q R X |rB| |g¡ |S )aJ Return information about columns in ``table_name``.
|
|
Given a string ``table_name`` and an optional string ``schema``,
|
return column information as a list of :class:`.ReflectedColumn`.
|
|
:param table_name: string name of the table. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: list of dictionaries, each representing the definition of
|
a database column.
|
|
.. seealso:: :meth:`Inspector.get_multi_columns`.
|
|
r7 )ry r` Ú get_columnsr7 Ú_instantiate_types)r2 r r r5 rx Úcol_defsr> r> r? r¹ A s
|
ÿÿÿ zInspector.get_columnsz Iterable[List[ReflectedColumn]])Údatar6 c C s4 |D ]*}|D ] }|d }t |ts | |d< q qd S )NÚtype)r: r! )r2 r¼ r» Zcol_defÚcoltyper> r> r? rº c s
|
|
z Inspector._instantiate_typesú%Dict[TableKey, List[ReflectedColumn]]c
|
K sL | ¡ ,}t| jj|f||||| jd|}W 5 Q R X | | ¡ ¡ |S )aW Return information about columns in all objects in the given
|
schema.
|
|
The objects can be filtered by passing the names to use to
|
``filter_names``.
|
|
For each table the value is a list of :class:`.ReflectedColumn`.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param filter_names: optionally return information only for the
|
objects listed here.
|
|
:param kind: a :class:`.ObjectKind` that specifies the type of objects
|
to reflect. Defaults to ``ObjectKind.TABLE``.
|
|
:param scope: a :class:`.ObjectScope` that specifies if columns of
|
default, temporary or any tables should be reflected.
|
Defaults to ``ObjectScope.DEFAULT``.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a dictionary where the keys are two-tuple schema,table-name
|
and the values are list of dictionaries, each representing the
|
definition of a database column.
|
The schema is ``None`` if no schema is provided.
|
|
.. versionadded:: 2.0
|
|
.. seealso:: :meth:`Inspector.get_columns`
|
r¯ )ry r± r` Úget_multi_columnsr7 rº Úvalues)r2 r r¬ r r® r5 rx Ztable_col_defsr> r> r? rÀ m s ,
|
ÿúùÿ zInspector.get_multi_columnsr* c
|
K s> | ¡ ,}| jj|||fd| ji|W 5 Q R £ S Q R X dS )a` Return information about primary key constraint in ``table_name``.
|
|
Given a string ``table_name``, and an optional string `schema`, return
|
primary key information as a :class:`.ReflectedPrimaryKeyConstraint`.
|
|
:param table_name: string name of the table. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a dictionary representing the definition of
|
a primary key constraint.
|
|
.. seealso:: :meth:`Inspector.get_multi_pk_constraint`
|
r7 N)ry r` Úget_pk_constraintr7 r r> r> r? r ¨ s
|
ÿÿÿzInspector.get_pk_constraintz-Dict[TableKey, ReflectedPrimaryKeyConstraint]c
|
K sF | ¡ 4}t| jj|f||||| jd|W 5 Q R £ S Q R X dS )au Return information about primary key constraints in
|
all tables in the given schema.
|
|
The tables can be filtered by passing the names to use to
|
``filter_names``.
|
|
For each table the value is a :class:`.ReflectedPrimaryKeyConstraint`.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param filter_names: optionally return information only for the
|
objects listed here.
|
|
:param kind: a :class:`.ObjectKind` that specifies the type of objects
|
to reflect. Defaults to ``ObjectKind.TABLE``.
|
|
:param scope: a :class:`.ObjectScope` that specifies if primary keys of
|
default, temporary or any tables should be reflected.
|
Defaults to ``ObjectScope.DEFAULT``.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a dictionary where the keys are two-tuple schema,table-name
|
and the values are dictionaries, each representing the
|
definition of a primary key constraint.
|
The schema is ``None`` if no schema is provided.
|
|
.. versionadded:: 2.0
|
|
.. seealso:: :meth:`Inspector.get_pk_constraint`
|
r¯ N)ry r± r` Úget_multi_pk_constraintr7 ©r2 r r¬ r r® r5 rx r> r> r? rà Šs +
|
ÿúùÿz!Inspector.get_multi_pk_constraintú#List[ReflectedForeignKeyConstraint]c
|
K s> | ¡ ,}| jj|||fd| ji|W 5 Q R £ S Q R X dS )ag Return information about foreign_keys in ``table_name``.
|
|
Given a string ``table_name``, and an optional string `schema`, return
|
foreign key information as a list of
|
:class:`.ReflectedForeignKeyConstraint`.
|
|
:param table_name: string name of the table. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a list of dictionaries, each representing the
|
a foreign key definition.
|
|
.. seealso:: :meth:`Inspector.get_multi_foreign_keys`
|
r7 N)ry r` Úget_foreign_keysr7 r r> r> r? rÆ ý s
|
ÿÿÿzInspector.get_foreign_keysú3Dict[TableKey, List[ReflectedForeignKeyConstraint]]c
|
K sF | ¡ 4}t| jj|f||||| jd|W 5 Q R £ S Q R X dS )ao Return information about foreign_keys in all tables
|
in the given schema.
|
|
The tables can be filtered by passing the names to use to
|
``filter_names``.
|
|
For each table the value is a list of
|
:class:`.ReflectedForeignKeyConstraint`.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param filter_names: optionally return information only for the
|
objects listed here.
|
|
:param kind: a :class:`.ObjectKind` that specifies the type of objects
|
to reflect. Defaults to ``ObjectKind.TABLE``.
|
|
:param scope: a :class:`.ObjectScope` that specifies if foreign keys of
|
default, temporary or any tables should be reflected.
|
Defaults to ``ObjectScope.DEFAULT``.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a dictionary where the keys are two-tuple schema,table-name
|
and the values are list of dictionaries, each representing
|
a foreign key definition.
|
The schema is ``None`` if no schema is provided.
|
|
.. versionadded:: 2.0
|
|
.. seealso:: :meth:`Inspector.get_foreign_keys`
|
r¯ N)ry r± r` r r7 rÄ r> r> r? r s -
|
ÿúùÿz Inspector.get_multi_foreign_keysúList[ReflectedIndex]c
|
K s> | ¡ ,}| jj|||fd| ji|W 5 Q R £ S Q R X dS )a= Return information about indexes in ``table_name``.
|
|
Given a string ``table_name`` and an optional string `schema`, return
|
index information as a list of :class:`.ReflectedIndex`.
|
|
:param table_name: string name of the table. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a list of dictionaries, each representing the
|
definition of an index.
|
|
.. seealso:: :meth:`Inspector.get_multi_indexes`
|
r7 N)ry r` Ú get_indexesr7 r r> r> r? rÉ V s
|
ÿÿÿzInspector.get_indexesú$Dict[TableKey, List[ReflectedIndex]]c
|
K sF | ¡ 4}t| jj|f||||| jd|W 5 Q R £ S Q R X dS )aP Return information about indexes in in all objects
|
in the given schema.
|
|
The objects can be filtered by passing the names to use to
|
``filter_names``.
|
|
For each table the value is a list of :class:`.ReflectedIndex`.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param filter_names: optionally return information only for the
|
objects listed here.
|
|
:param kind: a :class:`.ObjectKind` that specifies the type of objects
|
to reflect. Defaults to ``ObjectKind.TABLE``.
|
|
:param scope: a :class:`.ObjectScope` that specifies if indexes of
|
default, temporary or any tables should be reflected.
|
Defaults to ``ObjectScope.DEFAULT``.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a dictionary where the keys are two-tuple schema,table-name
|
and the values are list of dictionaries, each representing the
|
definition of an index.
|
The schema is ``None`` if no schema is provided.
|
|
.. versionadded:: 2.0
|
|
.. seealso:: :meth:`Inspector.get_indexes`
|
r¯ N)ry r± r` Úget_multi_indexesr7 rÄ r> r> r? rË t s ,
|
ÿúùÿzInspector.get_multi_indexesú List[ReflectedUniqueConstraint]c
|
K s> | ¡ ,}| jj|||fd| ji|W 5 Q R £ S Q R X dS )a~ Return information about unique constraints in ``table_name``.
|
|
Given a string ``table_name`` and an optional string `schema`, return
|
unique constraint information as a list of
|
:class:`.ReflectedUniqueConstraint`.
|
|
:param table_name: string name of the table. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a list of dictionaries, each representing the
|
definition of an unique constraint.
|
|
.. seealso:: :meth:`Inspector.get_multi_unique_constraints`
|
r7 N)ry r` Úget_unique_constraintsr7 r r> r> r? rÍ s
|
ÿÿÿz Inspector.get_unique_constraintsú/Dict[TableKey, List[ReflectedUniqueConstraint]]c
|
K sF | ¡ 4}t| jj|f||||| jd|W 5 Q R £ S Q R X dS )a Return information about unique constraints in all tables
|
in the given schema.
|
|
The tables can be filtered by passing the names to use to
|
``filter_names``.
|
|
For each table the value is a list of
|
:class:`.ReflectedUniqueConstraint`.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param filter_names: optionally return information only for the
|
objects listed here.
|
|
:param kind: a :class:`.ObjectKind` that specifies the type of objects
|
to reflect. Defaults to ``ObjectKind.TABLE``.
|
|
:param scope: a :class:`.ObjectScope` that specifies if constraints of
|
default, temporary or any tables should be reflected.
|
Defaults to ``ObjectScope.DEFAULT``.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a dictionary where the keys are two-tuple schema,table-name
|
and the values are list of dictionaries, each representing the
|
definition of an unique constraint.
|
The schema is ``None`` if no schema is provided.
|
|
.. versionadded:: 2.0
|
|
.. seealso:: :meth:`Inspector.get_unique_constraints`
|
r¯ N)ry r± r` Ú get_multi_unique_constraintsr7 rÄ r> r> r? rÏ Ì s -
|
ÿúùÿz&Inspector.get_multi_unique_constraintsr+ c
|
K s> | ¡ ,}| jj|||fd| ji|W 5 Q R £ S Q R X dS )a« Return information about the table comment for ``table_name``.
|
|
Given a string ``table_name`` and an optional string ``schema``,
|
return table comment information as a :class:`.ReflectedTableComment`.
|
|
Raises ``NotImplementedError`` for a dialect that does not support
|
comments.
|
|
:param table_name: string name of the table. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a dictionary, with the table comment.
|
|
.. versionadded:: 1.2
|
|
.. seealso:: :meth:`Inspector.get_multi_table_comment`
|
r7 N)ry r` Úget_table_commentr7 r r> r> r? rÐ s
|
ÿÿÿzInspector.get_table_commentz%Dict[TableKey, ReflectedTableComment]c
|
K sF | ¡ 4}t| jj|f||||| jd|W 5 Q R £ S Q R X dS )a¦ Return information about the table comment in all objects
|
in the given schema.
|
|
The objects can be filtered by passing the names to use to
|
``filter_names``.
|
|
For each table the value is a :class:`.ReflectedTableComment`.
|
|
Raises ``NotImplementedError`` for a dialect that does not support
|
comments.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param filter_names: optionally return information only for the
|
objects listed here.
|
|
:param kind: a :class:`.ObjectKind` that specifies the type of objects
|
to reflect. Defaults to ``ObjectKind.TABLE``.
|
|
:param scope: a :class:`.ObjectScope` that specifies if comments of
|
default, temporary or any tables should be reflected.
|
Defaults to ``ObjectScope.DEFAULT``.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a dictionary where the keys are two-tuple schema,table-name
|
and the values are dictionaries, representing the
|
table comments.
|
The schema is ``None`` if no schema is provided.
|
|
.. versionadded:: 2.0
|
|
.. seealso:: :meth:`Inspector.get_table_comment`
|
r¯ N)ry r± r` Úget_multi_table_commentr7 rÄ r> r> r? rÑ ( s /
|
ÿúùÿz!Inspector.get_multi_table_commentú List[ReflectedCheckConstraint]c
|
K s> | ¡ ,}| jj|||fd| ji|W 5 Q R £ S Q R X dS )ay Return information about check constraints in ``table_name``.
|
|
Given a string ``table_name`` and an optional string `schema`, return
|
check constraint information as a list of
|
:class:`.ReflectedCheckConstraint`.
|
|
:param table_name: string name of the table. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a list of dictionaries, each representing the
|
definition of a check constraints.
|
|
.. seealso:: :meth:`Inspector.get_multi_check_constraints`
|
r7 N)ry r` Úget_check_constraintsr7 r r> r> r? rÓ d s
|
ÿÿÿz Inspector.get_check_constraintsú.Dict[TableKey, List[ReflectedCheckConstraint]]c
|
K sF | ¡ 4}t| jj|f||||| jd|W 5 Q R £ S Q R X dS )a Return information about check constraints in all tables
|
in the given schema.
|
|
The tables can be filtered by passing the names to use to
|
``filter_names``.
|
|
For each table the value is a list of
|
:class:`.ReflectedCheckConstraint`.
|
|
:param schema: string schema name; if omitted, uses the default schema
|
of the database connection. For special quoting,
|
use :class:`.quoted_name`.
|
|
:param filter_names: optionally return information only for the
|
objects listed here.
|
|
:param kind: a :class:`.ObjectKind` that specifies the type of objects
|
to reflect. Defaults to ``ObjectKind.TABLE``.
|
|
:param scope: a :class:`.ObjectScope` that specifies if constraints of
|
default, temporary or any tables should be reflected.
|
Defaults to ``ObjectScope.DEFAULT``.
|
|
:param \**kw: Additional keyword argument to pass to the dialect
|
specific implementation. See the documentation of the dialect
|
in use for more information.
|
|
:return: a dictionary where the keys are two-tuple schema,table-name
|
and the values are list of dictionaries, each representing the
|
definition of a check constraints.
|
The schema is ``None`` if no schema is provided.
|
|
.. versionadded:: 2.0
|
|
.. seealso:: :meth:`Inspector.get_check_constraints`
|
r¯ N)ry r± r` Úget_multi_check_constraintsr7 rÄ r> r> r? rÕ s -
|
ÿúùÿz%Inspector.get_multi_check_constraintsr> Tzsa_schema.TablezOptional[Collection[str]]zCollection[str]z Optional[Set[sa_schema.Table]]zOptional[_ReflectionInfo])ÚtableÚinclude_columnsÚexclude_columnsÚ resolve_fksÚ
|
_extend_onÚ _reflect_infor6 c s² |dk r |krdS | ¡ | jj}| ¡ }| ¡} W 5 Q R X j}
|
fdd|jD } | |
|
f} |dksx| |jkr| j| f|
|
gt j
|
t j
|
|d j }| |j kr°|j | | |jkrÄt |
|
¡|jrä|j | ¡} | rä | ¡ d}i }|j| D ]}d}| ||||¡ qö|s0| |
|
| ¡s0t |
|
¡| || ||¡ | || |||||| ¡ | || |||| ¡ | || |||| ¡ | || |||| ¡ | || | ¡ dS )aZ Given a :class:`_schema.Table` object, load its internal
|
constructs based on introspection.
|
|
This is the underlying method used by most dialects to produce
|
table reflection. Direct usage is like::
|
|
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)
|
|
.. versionchanged:: 1.4 Renamed from ``reflecttable`` to
|
``reflect_table``
|
|
:param table: a :class:`~sqlalchemy.schema.Table` instance.
|
:param include_columns: a list of string column names to include
|
in the reflection process. If ``None``, all columns are reflected.
|
|
Nc s$ i | ] }| j kr| j |¡qS r> )Údialect_kwargsrE ©r< rA ©rÖ r> r? Ú
|
<dictcomp>ï s
|
þ z+Inspector.reflect_table.<locals>.<dictcomp>)r¬ r r® rÛ FT)r r\ r` ry Zschema_for_objectr Úreflection_optionsÚcolumnsÚ_get_reflection_inforR rW rX rÜ r8 r ZNoSuchTableErrorÚ table_optionsrE Z_validate_dialect_kwargsÚ_reflect_columnr Ú _reflect_pkÚ _reflect_fkÚ_reflect_indexesÚ_reflect_unique_constraintsÚ_reflect_check_constraintsÚ_reflect_table_comment)r2 rÖ r× rØ rÙ rÚ rÛ r` rx r r rà r Ztbl_optsZ found_tableÚcols_by_orig_nameÚcol_dr> rÞ r? Ú reflect_table½ s¾ !
|
|
|
þÿûú
|
|
|
|
|
û
|
ÿ÷ ù
|
ù
|
ù
|
üzInspector.reflect_tabler' z Dict[str, sa_schema.Column[Any]])rÖ rì r× rØ rë r6 c sx d }|j j | | ¡ |j | | ¡ d }|r>||ksJ|rN||krNd S d } fdddD } d kr~| d ¡ g }
|
d¡d k rî d } | d k s¤tt| tr¾tj | dd } n&t| tj
|
sàtj t | ¡dd } n| } |
|
| ¡ d
|
krtjf d
|
} |
|
| ¡ d kr6tjf d }|
|
|¡ tj||f|
|
| ||< }|j|jkrfd|_|j|dd d S ) Nr r½ c s i | ]}| kr| | qS r> r> rÝ ©rì r> r? rß n s ÷ z-Inspector._reflect_column.<locals>.<dictcomp>)ZnullableZ autoincrementÚquoteÚinforJ ÚcommentÚdialect_optionsÚdefaultT)Z
|
_reflectedÚcomputedÚidentity)Zreplace_existing)ÚmetadataÚdispatchZcolumn_reflectr¤ rE ÚAssertionErrorr: r Ú sa_schemaZ DefaultClauseZ FetchedValuer ÚtextÚappendZComputedZIdentityZColumnrJ Ú primary_keyZ append_column)r2 rÖ rì r× rØ rë Ú orig_namer r¾ Zcol_kwZcolargsZ default_textró rô rõ Úcolr> rî r? rä T sj ÿ ÿÿ
|
þ
|
ÿ ÿ
|
|
|
|
|
ÿÿÿ zInspector._reflect_columnÚ_ReflectionInfor- )rÛ r rÖ rë rØ r6 c sV |j |¡}|rR fdd|d D }| d¡|j_| dd ¡|j_|j |¡ d S )Nc s$ g | ] }| kr|kr | qS r> r> )r< Úpk©rë rØ r> r? r © s þz)Inspector._reflect_pk.<locals>.<listcomp>Úconstrained_columnsr rñ )Ú pk_constraintrE rü r rñ Z_reload)r2 rÛ r rÖ rë rØ Zpk_consZpk_colsr> r r? rå s þzInspector._reflect_pk)
|
rÛ r rÖ rë r× rØ rÙ rÚ rà r6 c
|
s |j |g ¡}
|
|
|
D ]~} | d } fdd| d D } |rHt| |¡s|r\t| |¡r\q| d }| d }| d }g }|d k rÈ|r¦tj||jf|| j||d| |D ]}| d
|
|||g¡¡ qªnF|rðtj||jf| jtj ||d
|
| |D ]}| d
|
||g¡¡ qôd | kr"| d }ni }z,| tj | || fd | d ¡d|¡ W q tjk
|
r t d|j d| dd
|
| ¡ d¡ Y qX qd S )Nr c s" g | ]}| kr | j n|qS r> )rJ )r< Úc©rë r> r? r È s ÿz)Inspector._reflect_fk.<locals>.<listcomp>r r r Úreferred_columns)r Ú autoload_withrÚ rÛ Ú.)r r rÚ rÛ ÚoptionsTrñ )Z link_to_namerñ zOn reflected table z0, skipping reflection of foreign key constraint z-; one or more subject columns within name(s) z, z are not present in the table)Ú foreign_keysrE r Ú intersectionr rù ZTablerö r\ rû ÚjoinZ BLANK_SCHEMAÚappend_constraintZForeignKeyConstraintr Z ConstraintColumnNotFoundErrorr Úwarnr )r2 rÛ r rÖ rë r× rØ rÙ rÚ rà r¥ Zfkey_dÚconnamer r r r ZrefspecÚcolumnr r> r r? ræ · s
|
|
þÿ þü ûþúù ÿþúù
|
|
ýûúÿ
|
ÿzInspector._reflect_fk)ZascÚdescZ nulls_firstZ
|
nulls_last)rÛ r rÖ rë r× rØ rà r6 c C s |j |g ¡}|D ]v} | d }
|
| d } | d¡} | di ¡} | d }| dd¡}| di ¡}| d ¡}|r|t| |¡s|q|rqg }t| D ]Þ\}}|d krØ| sÈt d
|
| d |
|
d |d d¡ qt | | ¡}nz ||krì|| }n
|
|j | }W n6 t
|
k
|
r. t | d|d|j ¡ Y qY nX | |d¡D ]$}|| j kr<| j | }||}q<| |¡ qtj|
|
f|||d| qd S )Nr Ú column_namesÚ expressionsÚcolumn_sortingr r½ Úindexrò Zduplicates_constraintz Skipping ú z because key r z5 reflected as None but no 'expressions' were returnedz key z& was not located in columns for table r> )Z_tabler )ÚindexesrE r ÚissubsetÚ enumerater r r rú r ÚKeyErrorr Ú_index_sort_exprsrû rù ZIndex)r2 rÛ r rÖ rë r× rØ rà r Zindex_dr rá r r r Zflavorrò Ú
|
duplicatesZ idx_elementsr r Z idx_elementÚoptionÚopr> r> r? rç s^
|
|
|
ÿ
|
ÿ
|
|
ÿþüûzInspector._reflect_indexesc
|
C sÒ |j |g ¡}|D ]º} | d }
|
| d } | d¡} | d¡} |rNt| |¡sNq| rTqg }| D ]V}z ||krr|| n|j| }W n( tk
|
r¦ t d||jf ¡ Y q\X | |¡ q\|
|
t j ||
|
| d¡ qd S )Nr r rñ Zduplicates_indexzDunique constraint key '%s' was not located in columns for table '%s')r rñ ) Úunique_constraintsrE r r r r r r r rû r rù ZUniqueConstraint)r2 rÛ r rÖ rë r× rØ rà Ú constraintsÚconst_dr rá rñ r Zconstrained_colsr Zconstrained_colr> r> r? rè Y s>
|
|
|
ÿ
|
ýÿÿ
|
ÿÿz%Inspector._reflect_unique_constraintsc
|
C s. |j |g ¡}|D ]} | tjf | ¡ qd S r9 )Úcheck_constraintsrE r rù ZCheckConstraint)
|
r2 rÛ r rÖ rë r× rØ rà r r! r> r> r? ré
s
|
z$Inspector._reflect_check_constraints)rÛ r rÖ rà r6 c C s |j |¡}|r|d |_d S ©Nrú )Ú table_commentrE rñ )r2 rÛ r rÖ rà Z comment_dictr> r> r? rê s z Inspector._reflect_table_comment)r r¬ Ú availablerÛ r5 r6 c sâ |d< r.|r.t dkr.t t | nd i d< }ddddddddd fd
|
d }t|jdd |j|j|j|jdd |jdd |jdd |j dd |d }|rÚ|
|
|¡ |S |S d S )Nr éd r8 TF)ÚoptionalÚ check_filter_names_from_methr r^ )Úmethr' r( r6 c sx d ks dks j | j¡s$ }nd }z,rN| f d|i}|rR|sRdni }W n tk
|
rr |sj i }Y nX |S )Ng à?r¬ F)r` Z_overrides_defaultrF ÚNotImplementedError)r) r' r( Ú_fnr² ©r¬ ÚfractionZ
|
has_resultr5 r2 r> r? Úrun² s& ÿþ ý
|
z+Inspector._get_reflection_info.<locals>.run)r( )r' ) rá r r
|
r r r$ r" rã r8 ) Úlenrÿ rÀ rà r rË rÏ rÑ rÕ r° r¤ ) r2 r r¬ r% rÛ r5 r8 r. rð r> r, r? râ sB ü$# ÿ ÿ ÿ ñ
|
z Inspector._get_reflection_info)N)N)N)N)N)r9 )N)N)N)N)N)N)N)N)N)N)N)N)r> TNN)NNNN)MrF rS rT rU Ú__annotations__r Ú
|
deprecatedrd Ú classmethodrj rb rm rl rt ru r Z _inspectsr rv r rw Ú
|
contextlibÚcontextmanagerry r{ Úpropertyr| r} r r r
r r r r r§ r¨ rª rR rV rX rY r° r³ r´ rµ r· r¹ rº rÀ r rà rÆ r rÉ rË rÍ rÏ rÐ rÑ rÓ rÕ rí rä rå ræ r Zasc_opZdesc_opZnulls_first_opZ nulls_last_opr rç rè ré rê râ r> r> r> r? r[ ¬ s
|
þ þ
|
ÿ" ÿ" ÿ ü þ/ þN ÿ!û: ÿ ÿ ÿ ÿ ÿ" û< ÿ û9 ÿ!û; ÿ û: ÿ!û; ÿ$û= ÿ!û> ù K Zü B , ûr[ c @ s e Zd ZdZeddddZeddddZed dd
|
d Zed dd dZeddddZ eddddZ
|
eddddZ eddddZ dS ) ÚReflectionDefaultsz5provides blank default values for reflection methods.r¸ rq c C s g S r9 r> ©ri r> r> r? rá ñ s zReflectionDefaults.columnsr* c C s
|
d g dS )N)r r r> r7 r> r> r? r õ s þz ReflectionDefaults.pk_constraintrÅ c C s g S r9 r> r7 r> r> r? r
|
ü s z ReflectionDefaults.foreign_keysrÈ c C s g S r9 r> r7 r> r> r? r s zReflectionDefaults.indexesrÌ c C s g S r9 r> r7 r> r> r? r s z%ReflectionDefaults.unique_constraintsrÒ c C s g S r9 r> r7 r> r> r? r" s z$ReflectionDefaults.check_constraintsr© c C s i S r9 r> r7 r> r> r? rã s z ReflectionDefaults.table_optionsr+ c C s dd iS r# r> r7 r> r> r? r$ s z ReflectionDefaults.table_commentN) rF rS rT rU r2 rá r r
|
r r r" rã r$ r> r> r> r? r6 í s" r6 c @ sf e Zd ZU ded< ded< ded< ded< d ed
|
< d ed < d ed< ded< ded< d ddddZdS )rÿ r¿ rá z7Dict[TableKey, Optional[ReflectedPrimaryKeyConstraint]]r rÇ r
|
rÊ r rÎ r z/Dict[TableKey, Optional[ReflectedTableComment]]r$ rÔ r" r« rã z+Dict[TableKey, exc.UnreflectableTableError]r8 rk )Úotherr6 c C sJ | j ¡ D ]:\}}t||}|d k r
|
|d kr:t| || q
|
| |¡ q
|
d S r9 )Ú__dict__rH ÚgetattrÚsetattrr¤ )r2 r8 rA rB Úovr> r> r? r¤ " s
|
z_ReflectionInfo.updateN)rF rS rT r0 r¤ r> r> r> r? rÿ s
|
rÿ )DrU Ú
|
__future__r r3 Z dataclassesr Úenumr r r Útypingr r r r
|
r r r r r r r r r r Úbaser r Ú r r r r r r rù Z sql.cache_keyr Z sql.elementsr Z sql.type_apir! Z sql.visitorsr" r# Z util.typingr$ Z
|
interfacesr% r& r' r( r) r* r+ r, r- r. rP rL rQ rR rX Z_self_inspectsZ Inspectabler[ r6 rÿ r> r> r> r? Ú<module> s N'
|
