o Rc@sdZddlZddlmZddlmZddlmZddlmZdd lmZdd lm Z dd lm Z dd l m Z dd l m Z ddlmZddl mZe jddZejGdddeZdS)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.. N) Connectable) Connection)Engine)exc) inspection)sql)util) operators)schema) TypeEngine) topologicalcOs|dd}|dur|||g|Ri|S|jtdd|Dtdd|Df}||}|durE|||g|Ri|}|||<|S)N info_cachecss |] }t|tjr|VqdSN) isinstancer string_types).0ar>D:\Flask\env\Lib\site-packages\sqlalchemy/engine/reflection.py 2szcache..css$|] \}}|dkr||fVqdS)rNr)rkvrrrr3s")get__name__tupleitems)fnselfconargskwrkeyretrrrcache+s  r%c@seZdZdZeddddZeddZdd Z d d Z d d Z eeddddZ e eddZe eddZe eddZejddZejddZeddZddZd^d d!Zd^d"d#Zd^d$d%Zd^d&d'Zd(d)Z d*d+Z!d^d,d-Z"d^d.d/Z#d^d0d1Z$d^d2d3Z%d^d4d5Z&d^d6d7Z'd^d8d9Z(d^d:d;Z)d^dd?Z+d^d@dAZ,e-dBdCdDdEZ. F G d_dHdIZ/dJdKZ0dLdMZ1dNdOZ2dPdQZ3dRe4j5fdSe4j6fdTe4j7fdUe4j8fgZ9dVdWZ:dXdYZ;dZd[ZzInspector._connection_inspccsL|jr |j}n|j}z|VW|jr|dSdS|jr%|ww)aReturn 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)r7r)r5r6rconnrrr_operation_contexts   zInspector._operation_contextccsN|}||jj|}|j|_|VWddS1s wYdS)zReturn an :class:`_reflection.Inspector` from this one that will run all operations on a single connection. N)rBr1 __class__r2r)rrAZsub_insprrr_inspection_contexts  "zInspector._inspection_contextcCs|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_name)rrrrrEs zInspector.default_schema_namecCsJt|jdr#|}|jj||jdWdS1swYgS)zReturn all schema names.get_schema_namesrN)r,r-rBrFrr@rrrrFs   zInspector.get_schema_namesNcC@|}|jj|||jdWdS1swYdS)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`. .. seealso:: :meth:`_reflection.Inspector.get_sorted_table_and_fkc_names` :attr:`_schema.MetaData.sorted_tables` rGN)rBr-get_table_namesrrr rArrrrIs $zInspector.get_table_namescC<|}|j|||WdS1swYdS)aMReturn True if the backend has a 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. .. versionadded:: 1.4 - the :meth:`.Inspector.has_table` method replaces the :meth:`_engine.Engine.has_table` method. N)rBr- has_table)r table_namer rArrrrLs $zInspector.has_tablecCrK)zReturn True if the backend has a table of the given name. :param sequence_name: name of the table to check :param schema: schema name to query, if not the default schema. .. versionadded:: 1.4 N)rBr- has_sequence)rZ sequence_namer rArrrrNs $zInspector.has_sequencec sD|}|jj|||jd}Wdn1swYt}ti|D]'}|||}tdd|D|<|D]}||dkrN||d|fq=q(z tt ||}Wn6t j y} z)| j D]| fdddDqftt ||}WYd} ~ nd} ~ wwfd d|DdtfgS) 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`. rGNcSsg|]}|dqS)namer)rZfkrrr Nsz.referred_tablec3s|] }d|fVqdS)rNr)rZfkc)edgerrrWs  z;Inspector.get_sorted_table_and_fkc_names..rcsg|] }||fqSr) difference)rtname)fknames_for_tableremaining_fkcsrrrP\s)rBr-rIrsetget_foreign_keysaddlistrsortrZCircularDependencyErroredgesremoveupdate) rr rAZtnamesZtuplesrTfkeysZfkeyZcandidate_sorterrr)rRrUrVrget_sorted_table_and_fkc_names*s@         z(Inspector.get_sorted_table_and_fkc_namescC>|}|jj||jdWdS1swYdS)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 rGN)rBr-get_temp_table_namesrr@rrrrcas $zInspector.get_temp_table_namescCrb)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 rGN)rBr-get_temp_view_namesrr@rrrrdps $zInspector.get_temp_view_namescKsVt|jdr)|}|jj|||fd|ji|WdS1s$wYiS)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_optionsrN)r,r-rBrerrrMr r"rArrrre~s   zInspector.get_table_optionscCrH)zReturn all view names in `schema`. :param schema: Optional, retrieve names from a non-default schema. For special quoting, use :class:`.quoted_name`. rGN)rBr-get_view_namesrrJrrrrg $zInspector.get_view_namescCrH)zReturn all sequence names in `schema`. :param schema: Optional, retrieve names from a non-default schema. For special quoting, use :class:`.quoted_name`. rGN)rBr-get_sequence_namesrrJrrrrirhzInspector.get_sequence_namescCsB|}|jj||||jdWdS1swYdS)zReturn definition for `view_name`. :param schema: Optional, retrieve names from a non-default schema. For special quoting, use :class:`.quoted_name`. rGN)rBr-get_view_definitionr)rZ view_namer rArrrrjs  $zInspector.get_view_definitioncKsp|}|jj|||fd|ji|}Wdn1swY|D]}|d}t|ts5||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. * ``identity`` - (optional) when present it indicates that this column is a generated always column. Only some dialects return this key. For a list of keywords on this dict see :class:`_schema.Identity`. .. versionadded:: 1.4 - added support for identity column 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. rNtype)rBr- get_columnsrrr )rrMr r"rAZcol_defsZcol_defcoltyperrrrls 6  zInspector.get_columnscKJ|}|jj|||fd|ji|WdS1swYdS)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`. rN)rBr-get_pk_constraintrrfrrrros $zInspector.get_pk_constraintcKrn)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`. rN)rBr-rXrrfrrrrXs $zInspector.get_foreign_keyscKrn)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``, ``nulls_first``, ``nulls_last``. .. 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`. rN)rBr- get_indexesrrfrrrrp8s $$zInspector.get_indexescKrn)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`. rN)rBr-get_unique_constraintsrrfrrrrqas $z Inspector.get_unique_constraintscKrn)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 rN)rBr-get_table_commentrrfrrrrr{s $zInspector.get_table_commentcKrn)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 rN)rBr-get_check_constraintsrrfrrrrss $zInspector.get_check_constraintsz*:meth:`_reflection.Inspector.reflecttable`zThe :meth:`_reflection.Inspector.reflecttable` method was renamed to :meth:`_reflection.Inspector.reflect_table`. This deprecated alias will be removed in a future release.cOs|j|i|S)z1See reflect_table. This method name is deprecated) reflect_table)rr!kwargsrrr reflecttables zInspector.reflecttablerTc s|dur|vr dS||jj}| }|}Wdn1s'wYj} tfdd|jD} |j| |fij } | rM | t j rft |tr[||j}t | trf| |j} d} i} |j| |fij D] }d} ||||| qu| s|| |st| || || ||| || ||||| || || ||| || || ||| || || ||| || || dS)aZGiven 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. Nc3s*|]}|jvr|j|fVqdSr)dialect_kwargsrrrtablerrrs z*Inspector.reflect_table..FT)rYr)r-rBZschema_for_objectrOdictreflection_optionsrerwZ_validate_dialect_kwargsr Zpy2krstrdecodeencodingrl_reflect_columnrLrZNoSuchTableError _reflect_pk _reflect_fk_reflect_indexes_reflect_unique_constraints_reflect_check_constraints_reflect_table_comment)rrzinclude_columnsexclude_columns resolve_fks _extend_onr-rAr rMr|Ztbl_optsZ found_tablecols_by_orig_namecol_drryrrts                 zInspector.reflect_tablecsd}|jj|||j||d}|r||vs%|r'||vr'dSd}tfdddD} dvrA| dg} ddurtd} t| tjj r]t j | dd } nt| t j sot j t ddd } | | d vrt jdid } | | d vrt jdid } | | d vr|| t j||g| Ri| ||<} | j|jvrd| _|j| dd dS)NrOrkc3s$|] }|vr||fVqdSrrrxrrrr\s  z,Inspector._reflect_column..)ZnullableZ autoincrementquoteinfor#commentdialect_optionsdefaultT)Z _reflectedcomputedidentitysequence)Zreplace_existingr)metadatadispatchZcolumn_reflectr{r^rrr elementsZ TextClause sa_schemaZ DefaultClauseZ FetchedValuetextappendZComputedZIdentity_reflect_col_sequenceColumnr# primary_key append_column)rrzrrrrZ orig_namerOrmZcol_kwcolargsrrcolrrrrIsX         zInspector._reflect_columncCsXd|vr*|d}t|ddd}d|vr|d|_d|vr#|d|_||dSdS)NrrOrstart increment)rSequencerrr)rrrseqrrrrrs  zInspector._reflect_col_sequencecsT|j||fi|j}|r(fdd|dD}|d|j_|j|dSdS)Ncs$g|]}|vr|vr|qSrr)rpkrrrrrPsz)Inspector._reflect_pk..constrained_columnsrO)rorwrrrOZ_reload)rrMr rzrrZpk_consZpk_colsrrrrs zInspector._reflect_pkc  sL|j||fi|j} | D]} | d} fdd| dD} |r't| |s0|r1t| |r1q | d}| d}| d}g}|durf|rUtj||jf||j|d| |D] }| d |||gqWn"|rytj||jf|jtj |d | |D] }| d ||gq{d | vr| d }ni}| tj | || fd d i|q dS)NrOcs"g|] }|vr |jn|qSr)r#)rcrrrrPsz)Inspector._reflect_fk..rreferred_schemarQreferred_columns)r autoload_withr.)rr roptionsZ link_to_nameT)rXrwrW intersectionrSrTablerr)rjoinZ BLANK_SCHEMAappend_constraintZForeignKeyConstraint)rrMr rzrrrrrr|r_Zfkey_dconnamerrrQrZrefspeccolumnrrrrrs     zInspector._reflect_fkascdescZ nulls_firstZ nulls_lastc 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)NrO column_namescolumn_sortinguniquerkindexrZduplicates_constraintz5Omitting %s key for (%s), key covers omitted columns., z5%s key '%s' was not located in columns for table '%s'r_table)rprrWissubsetr warnrrKeyError_index_sort_exprsrrIndexr{rZr)rrMr rzrrrr|ZindexesZindex_drOcolumnsrrZflavorr duplicatesZidx_colsrZidx_colZ c_sortingroprrrrsb          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)NrOrZduplicates_indexzDOmitting unique constraint key for (%s), key covers omitted columns.rzDunique constraint key '%s' was not located in columns for table '%s')rqNotImplementedErrorrrWrr rrrrrrrZUniqueConstraint)rrMr rzrrrr| constraintsconst_drrrZconstrained_colsrZconstrained_colrrrr:sJ      z%Inspector._reflect_unique_constraintsc CsJz|||}Wn tyYdSw|D] } |tjdi| qdS)Nr)rsrrrZCheckConstraint) rrMr rzrrrr|rrrrrrms  z$Inspector._reflect_check_constraintscCs8z|||}Wn tyYdSw|dd|_dS)Nr)rrrrr)rrMr rzr|Z comment_dictrrrrs  z Inspector._reflect_table_commentr)rTN)>r __module__ __qualname____doc__r deprecatedr* classmethodr1r'r3r2r9rZ _inspectsrr<rr=rr? contextlibcontextmanagerrBrDpropertyrErFrIrLrNrarcrdrergrirjrlrorXrprqrrrsZ deprecated_20rvrtrrrrr Zasc_opZdesc_opZnulls_first_opZ nulls_last_oprrrrrrrrrr&<s             7   A  $ )  "   B P:3 r&)rrbaserrrrrr r r r rZ sql.type_apir r decoratorr%Z_self_inspectsobjectr&rrrrs"