o [h@sdZddlmZddlmZddlmZddlmZddlmZddlmZdd lm Z dd l m Z dd lm Z dd lmZejd dZGdddeZdS)aProvides 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.. ) Connectable)exc) inspection)sql)util) operators)schema) TypeEngine) deprecated) topologicalcOs|dd}|dur|||g|Ri|S|jtdd|Dtdd|Df}||}|durE|||g|Ri|}|||<|S)N info_cachecss |] }t|tjr|VqdSN) isinstancer string_types).0ar/home/ubuntu/experiments/live_experiments/Pythonexperiments/Otree/venv/lib/python3.10/site-packages/sqlalchemy/engine/reflection.py /szcache..css$|] \}}|dkr||fVqdS)r Nr)rkvrrrr0s")get__name__tupleitems)fnselfconargskwr keyretrrrcache(s  r#c@sfeZdZdZddZeddZee ddZ e dd Z d d Z ejd d dGddZdHddZddZddZdHddZdHddZdHddZdHddZedd dHd!d"ZdHd#d$ZdHd%d&ZdHd'd(ZdHd)d*ZdHd+d,ZdHd-d.Z / 0 dId1d2Z d3d4Z!d5d6Z"d7d8Z#d9d:Z$d;e%j&fde%j)fgZ*d?d@Z+dAdBZ,dCdDZ-dEdFZ.dS)J InspectoraPerforms 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:: from sqlalchemy import inspect, create_engine engine = create_engine('...') insp = inspect(engine) The inspection method above is equivalent to using the :meth:`_reflection.Inspector.from_engine` method, i.e.:: engine = create_engine('...') insp = Inspector.from_engine(engine) Where above, the :class:`~sqlalchemy.engine.interfaces.Dialect` may opt to return an :class:`_reflection.Inspector` subclass that provides additional methods specific to the dialect's target database. cCsJ||_t|dr |j|_n||_|j|ur||jj|_i|_dS)aInitialize a new :class:`_reflection.Inspector`. :param bind: a :class:`~sqlalchemy.engine.Connectable`, 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` engineN)bindhasattrr%connectclosedialectr )rr&rrr__init__Us      zInspector.__init__cCs t|jdr |j|St|S)aConstruct a new dialect-specific Inspector object from the given engine or connection. :param bind: a :class:`~sqlalchemy.engine.Connectable`, which is typically an instance of :class:`~sqlalchemy.engine.Engine` or :class:`~sqlalchemy.engine.Connection`. 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`. inspector)r'r*r,r$)clsr&rrr from_engineqs  zInspector.from_enginecCs t|Sr)r$r.)r&rrr_insps zInspector._inspcCs|jjS)zReturn 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_namerrrrr0s zInspector.default_schema_namecCs$t|jdr|jj|j|jdSgS)zReturn all schema names.get_schema_namesr )r'r*r2r&r r1rrrr2s zInspector.get_schema_names)z1.0a The :paramref:`get_table_names.order_by` parameter is deprecated and will be removed in a future release. Please refer to :meth:`_reflection.Inspector.get_sorted_table_and_fkc_names` for a more comprehensive solution to resolving foreign key cycles between tables.)order_byNcCst|jdr|jj|j||jd}n|j|}|dkrCg}|D]}|||D]}||dkr9||d|fq(q t t ||}|S)aReturn all table names in referred to 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` method. :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 order_by: Optional, may be the string "foreign_key" to sort the result on foreign key dependencies. Does not automatically resolve cycles, and will raise :class:`.CircularDependencyError` if cycles exist. .. seealso:: :meth:`_reflection.Inspector.get_sorted_table_and_fkc_names` :attr:`_schema.MetaData.sorted_tables` get_table_namesr3Z foreign_keyreferred_table) r'r*r5r&r r% table_namesget_foreign_keysappendlistr sort)rr r4tnamestuplestnamefkeyrrrr5s '   zInspector.get_table_namesc s8t|jdr|jj|j||jd}n|j|}t}ti|D]'}|||}tdd|D|<|D]}||dkrH| |d|fq7q"z t t ||}Wn6t jy}z)|jD]|fdddDq`t t ||}WYd }~nd }~wwfd d|Dd t fgS) aReturn 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. .. versionadded:: 1.0.- .. seealso:: :meth:`_reflection.Inspector.get_table_names` :func:`.sort_tables_and_constraints` - similar method which works with an already-given :class:`_schema.MetaData`. r5r3cSsg|]}|dqS)namer)rZfkrrr sz.r6c3s|] }d|fVqdS)rNr)rZfkc)edgerrrs  z;Inspector.get_sorted_table_and_fkc_names..rNcsg|] }||fqSr) difference)rr>)fknames_for_tableremaining_fkcsrrrA s)r'r*r5r&r r%r7setr8addr:r r;rZCircularDependencyErroredgesremoveupdate) rr r<r=r>fkeysr?Zcandidate_sorterrr)rBrDrErget_sorted_table_and_fkc_namess@           z(Inspector.get_sorted_table_and_fkc_namescC|jj|j|jdS)zReturn a list of temporary table names for the current bind. This method is unsupported by most dialects; currently only SQLite implements it. .. versionadded:: 1.0.0 r3)r*get_temp_table_namesr&r r1rrrrO zInspector.get_temp_table_namescCrN)zReturn a list of temporary view names for the current bind. This method is unsupported by most dialects; currently only SQLite implements it. .. versionadded:: 1.0.0 r3)r*get_temp_view_namesr&r r1rrrrQrPzInspector.get_temp_view_namescKs0t|jdr|jj|j||fd|ji|SiS)aReturn a dictionary of options specified when the table of the given name was created. This currently includes some options that apply to MySQL 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`. get_table_optionsr )r'r*rRr&r r table_namer r rrrrR)s zInspector.get_table_optionscCs|jj|j||jdS)zReturn all view names in `schema`. :param schema: Optional, retrieve names from a non-default schema. For special quoting, use :class:`.quoted_name`. r3)r*get_view_namesr&r )rr rrrrU=s zInspector.get_view_namescCs|jj|j|||jdS)zReturn definition for `view_name`. :param schema: Optional, retrieve names from a non-default schema. For special quoting, use :class:`.quoted_name`. r3)r*get_view_definitionr&r )rZ view_namer rrrrVIs zInspector.get_view_definitioncKsJ|jj|j||fd|ji|}|D]}|d}t|ts"||d<q|S)aReturn information about columns in `table_name`. Given a string `table_name` and an optional string `schema`, return column information as a list of dicts with these keys: * ``name`` - the column's name * ``type`` - the type of this column; an instance of :class:`~sqlalchemy.types.TypeEngine` * ``nullable`` - boolean flag if the column is NULL or NOT NULL * ``default`` - the column's server default value - this is returned as a string SQL expression. * ``autoincrement`` - indicates that the column is auto incremented - this is returned as a boolean or 'auto' * ``comment`` - (optional) the comment on the column. Only some dialects return this key * ``computed`` - (optional) when present it indicates that this column is computed by the database. Only some dialects return this key. Returned as a dict with the keys: * ``sqltext`` - the expression used to generate this column returned as a string SQL expression * ``persisted`` - (optional) boolean that indicates if the column is stored in the table .. versionadded:: 1.3.16 - added support for computed reflection. * ``dialect_options`` - (optional) a dict with dialect specific options :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`. :return: list of dictionaries, each representing the definition of a database column. r type)r* get_columnsr&r rr )rrTr r Zcol_defsZcol_defcoltyperrrrXUs1  zInspector.get_columnsz0.7zThe :meth:`_reflection.Inspector.get_primary_keys` method is deprecated and will be removed in a future release. Please refer to the :meth:`_reflection.Inspector.get_pk_constraint` method.cKs$|jj|j||fd|ji|dS)zReturn information about primary keys in `table_name`. Given a string `table_name`, and an optional string `schema`, return primary key information as a list of column names. r constrained_columnsr*get_pk_constraintr&r rSrrrget_primary_keysszInspector.get_primary_keyscK |jj|j||fd|ji|S)aReturn information about primary key constraint on `table_name`. Given a string `table_name`, and an optional string `schema`, return primary key information as a dictionary with these keys: * ``constrained_columns`` - a list of column names that make up the primary key * ``name`` - optional name of the primary key constraint. :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`. r r[rSrrrr\szInspector.get_pk_constraintcKr^)aReturn 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 dicts with these keys: * ``constrained_columns`` - a list of column names that make up the foreign key * ``referred_schema`` - the name of the referred schema * ``referred_table`` - the name of the referred table * ``referred_columns`` - a list of column names in the referred table that correspond to constrained_columns * ``name`` - optional name of the foreign key constraint. :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`. r )r*r8r&r rSrrrr8szInspector.get_foreign_keyscKr^)aReturn information about indexes in `table_name`. Given a string `table_name` and an optional string `schema`, return index information as a list of dicts with these keys: * ``name`` - the index's name * ``column_names`` - list of column names in order * ``unique`` - boolean * ``column_sorting`` - optional dict mapping column names to tuple of sort keywords, which may include ``asc``, ``desc``, ``nullsfirst``, ``nullslast``. .. versionadded:: 1.3.5 * ``dialect_options`` - dict of dialect-specific index options. May not be present for all dialects. .. versionadded:: 1.0.0 :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`. r )r* get_indexesr&r rSrrrr_s$zInspector.get_indexescKr^)aReturn 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 dicts with these keys: * ``name`` - the unique constraint's name * ``column_names`` - list of column names in order :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`. r )r*get_unique_constraintsr&r rSrrrr`sz Inspector.get_unique_constraintscKr^)aReturn information about the table comment for ``table_name``. Given a string ``table_name`` and an optional string ``schema``, return table comment information as a dictionary with these keys: * ``text`` - text of the comment. Raises ``NotImplementedError`` for a dialect that does not support comments. .. versionadded:: 1.2 r )r*get_table_commentr&r rSrrrraszInspector.get_table_commentcKr^)acReturn 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 dicts with these keys: * ``name`` - the check constraint's name * ``sqltext`` - the check constraint's SQL expression * ``dialect_options`` - may or may not be present; a dictionary with additional dialect-specific options for this CHECK constraint .. versionadded:: 1.3.8 :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`. .. versionadded:: 1.1.0 r )r*get_check_constraintsr&r rSrrrrb2szInspector.get_check_constraintsrTc sp|dur|vr dS||jj}|j}j}tfdd|jD} |j||fij} | r: | t j rSt |t rH||j}t |t rS||j}d} i} |j||fijD] } d} || ||| qb| sxtj|||| ||||| |||| |||| ||| |||| ||| |||| ||| |||| dS)aGiven 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.engine.reflection import Inspector engine = create_engine('...') meta = MetaData() user_table = Table('user', meta) insp = Inspector.from_engine(engine) insp.reflecttable(user_table, None) :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. Nc3s*|]}|jvr|j|fVqdSr)dialect_kwargsrrrtablerrrs z)Inspector.reflecttable..FT)rGr&r*Zschema_for_objectr@dictreflection_optionsrRrcZ_validate_dialect_kwargsrZpy2krstrdecodeencodingrX_reflect_columnrZNoSuchTableError _reflect_pk _reflect_fk_reflect_indexes_reflect_unique_constraints_reflect_check_constraints_reflect_table_comment)rrfinclude_columnsexclude_columns resolve_fks _extend_onr*r rTrhZtbl_optsZ found_tablecols_by_orig_namecol_drrer reflecttableSs               zInspector.reflecttablecsRd}|j||d}|r||vs|r||vrdSd}tfdddD} dvr8| dg} ddurkd} t| tjjrTt j | dd } nt| t j sft j t ddd } | | d vr~t jd id } | | d vr|| t j||g| Ri| ||<} | j|jvrd| _|| dS) Nr@rWc3s$|] }|vr||fVqdSrrrdrxrrrs  z,Inspector._reflect_column..)ZnullableZ autoincrementquoteinfor!commentdialect_optionsdefaultT)Z _reflectedcomputedsequencer)dispatchZcolumn_reflectrgrJrrrelementsZ TextClause sa_schemaZ DefaultClauseZ FetchedValuetextr9ZComputed_reflect_col_sequenceColumnr! primary_key append_column)rrfrxrsrtrwZ orig_namer@rYZcol_kwcolargsrrcolrrzrrlsN        zInspector._reflect_columncCsXd|vr*|d}t|ddd}d|vr|d|_d|vr#|d|_||dSdS)Nrr@rstart increment)rSequencerrr9)rrxrseqrrrrrs  zInspector._reflect_col_sequencecsT|j||fi|j}|r(fdd|dD}|d|j_|j|dSdS)Ncs$g|]}|vr|vr|qSrr)rpkrwrtrrrA(s z)Inspector._reflect_pk..rZr@)r\rcrrr@Z_reload)rrTr rfrwrtZpk_consZpk_colsrrrrm!s zInspector._reflect_pkc  s>|j||fi|j} | D]} | d} fdd| dD} |r(t| |r(q | d} | d}| d}g}| dur^|rMtj||jfd| |j|d ||D] }|d | ||gqOn#|rrtj||jfd|jtj |d ||D] }|d ||gqtd | vr| d }ni}| tj | || fd di|q dS)Nr@cs"g|] }|vr |jn|qSr)r!)rcrwrrrAGsz)Inspector._reflect_fk..rZreferred_schemar6referred_columnsT)autoloadr autoload_withrv.)rrr rvoptionsZ link_to_name) r8rcrF intersectionrTablemetadatar&r9joinZ BLANK_SCHEMAappend_constraintZForeignKeyConstraint)rrTr rfrwrtrurvrhrKZfkey_dconnamerZrr6rZrefspeccolumnrrrrrn5s      zInspector._reflect_fkascZdescZ nullsfirstZ nullslastc CsN|||}|D]} | d} | d} | di} | d} | dd}| di}| d}|rCt| |sCtd |d | fq|rFqg}| D]@}z||vrU||n|j|}Wntyntd |||fYqJw| |d }|j D] \}}||vr||}qx| |qJt j | g|Rd |it t|d| fgqdS)Nr@ column_namescolumn_sortinguniquerWindexr~Zduplicates_constraintz5Omitting %s key for (%s), key covers omitted columns., z5%s key '%s' was not located in columns for table '%s'r_table)r_rrFissubsetrwarnrrKeyError_index_sort_exprsr9rIndexrgr:r)rrTr rfrwrsrtrhZindexesZindex_dr@columnsrrZflavorr~ duplicatesZidx_colsrZidx_colZ c_sortingroprrrrosb         zInspector._reflect_indexesc Csz|||}Wn tyYdSw|D]_} | d} | d} | d} |r8t| |s8tdd| q| r;qg} | D])}z||vrJ||n|j|}Wnt ybtd||fYq?w| |q?| t j | d| iqdS)Nr@rZduplicates_indexzDOmitting unique constraint key for (%s), key covers omitted columns.rzDunique constraint key '%s' was not located in columns for table '%s')r`NotImplementedErrorrrFrrrrrrr9rrZUniqueConstraint)rrTr rfrwrsrtrh constraintsconst_drrrZconstrained_colsrZconstrained_colrrrrpsJ     z%Inspector._reflect_unique_constraintsc CsJz|||}Wn tyYdSw|D] } |tjdi| qdS)Nr)rbrrrZCheckConstraint) rrTr rfrwrsrtrhrrrrrrqs  z$Inspector._reflect_check_constraintscCs8z|||}Wn tyYdSw|dd|_dS)Nr)rarrr})rrTr rfrhZ comment_dictrrrrrs  z Inspector._reflect_table_comment)NNr)rTN)/r __module__ __qualname____doc__r+ classmethodr.rZ _inspectsrr/propertyr0r2rZdeprecated_paramsr5rMrOrQrRrUrVrXr r]r\r8r_r`rarbryrlrrmrnrZasc_opZdesc_opZ nullsfirst_opZ nullslast_oprrorprqrrrrrrr$9sd      +8  ;   # (  % = I:3 r$N)rbaserrrrrrr rZ sql.type_apir r r decoratorr#objectr$rrrrs