-hSrSSKrSSKJr SSKJr SSKJr SSKJr SS KJr SS KJ r SS KJ r SS K J r SS K J r SSKJr SSK Jr \ R"S5r\R&"SS\55rg)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) topologicalc URSS5nUc U"X/UQ70UD6$UR[SU55[SUR5554nURU5nUcU"X/UQ70UD6nXuU'U$)N info_cachec3h# UH(n[U[R5(dM$Uv M* g7fN) isinstancer string_types).0as qC:\Users\ROHAN GUPTA\OneDrive\Desktop\mathbuddy-assessment\venv\Lib\site-packages\sqlalchemy/engine/reflection.py cache..2s! BAAt/@/@!Aaas#2 2c3<# UHupUS:wdM X4v M g7f)rN)rkvs rrr3s AqL/@fqfs  )get__name__tupleitems)fnselfconargskwrkeyrets rcacher*+s d+J$)d)b))  B BB A AA C .. C {(T(R(3 Jc\rSrSrSr\R "SS5S5r\S5r Sr Sr S r \\R "SS 5S 55r \R"\5S 5r\R"\5S 5r\R"\5S5r\R.S5r\R.S5r\S5rSrS6SjrS6SjrS6SjrS6Sjr Sr!Sr"S6Sjr#S6Sjr$S6Sjr%S6Sjr&S6Sjr'S6Sjr(S6S jr)S6S!jr*S6S"jr+S6S#jr,S6S$jr-\R\"S%S&5S'5r/S7S(jr0S)r1S*r2S+r3S,r4S-\5Rl4S.\5Rn4S/\5Rp4S0\5Rr4/r:S1r;S2rS5r?g)8 Inspector<aPerforms 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. z1.4aThe __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`.c$URU5$)aSInitialize 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` ) _init_legacyr$binds r__init__Inspector.__init__Us.  &&r+c[URS5(aURRnURU5nU"X25 U$)N inspector)hasattrdialectr6__new__)clsinitr2r$s r _constructInspector._constructns? 4<< - -,,((C{{3 T r+cl[US5(aURU5 gURU5 g)Nexec_driver_sql)r7_init_connection _init_enginer1s rr0Inspector._init_legacyxs, 4* + +  ! !$ '   d #r+cU=UlUlUR5R5 SUlURR Ul0Ulg)NT)r2engineconnectclose_op_context_requires_connectr8r)r$rDs rrAInspector._init_engine~sC"(( DK ,0){{** r+cXlURUlSUlURRUl0Ulg)NF)r2rDrGr8r)r$ connections rr@Inspector._init_connections4  '' ,1){{** r+aThe 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:URURU5$)aRConstruct 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`. )r<r0)r:r2s r from_engineInspector.from_engines>~~c..55r+cJ[R[RU5$r)r-r<r0r2s r_connectable_inspInspector._connectable_insps ##I$:$:DAAr+cJ[R[RU5$r)r-r<rArPs r _engine_inspInspector._engine_insps##I$:$:DAAr+cJ[R[RU5$r)r-r<r@rPs r_connection_inspInspector._connection_insps##I$>$>EEr+c## UR(aURR5nO URnUv UR(aUR5 gg!UR(aUR5 ff=f7f)zReturn 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)rGr2rErFr$conns r_operation_contextInspector._operation_contextsc  , ,99$$&D99D J00 1t00 1s9B A##B #$BB c## UR5nURURRU5nURUlUv SSS5 g!,(df  g=f7f)zmReturn an :class:`_reflection.Inspector` from this one that will run all operations on a single connection. N)r\r< __class__r@r)r$r[sub_insps r_inspection_contextInspector._inspection_contextsK $ $ &$t~~'F'FMH"&//H N' & &sA). $ $ &$<<//0' & & $? A cUR5nURRX1U5sSSS5 $!,(df  g=f)a%Return 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)r\r8 has_table)r$ table_namer r[s rrpInspector.has_tables2 $ $ &$<<))$FC' & & 7 AcUR5nURRX1U5sSSS5 $!,(df  g=f)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)r\r8 has_sequence)r$ sequence_namer r[s rruInspector.has_sequences2 $ $ &$<<,,T&I' & &rscZ^ UR5nURRX!URS9nSSS5 [ 5n[ 5n0nWH]nUR Xq5n[ UV s/sHoSPM sn 5Xg'UH#n XzS:wdM UR U SU45 M% M_ [[R"XC55n U Vs/sHnXvURU54PM snS[U54/-$!,(df  N=fs sn f![Rann U RH5m URT 5 URU 4SjUT S55 M7 [[R"XC55n Sn A NSn A ff=fs snf)a 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. .. 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`. rhNnamereferred_tablec32># UH nTSU4v M g7f)rNr)rfkcedges rr;Inspector.get_sorted_table_and_fkc_names..Ws&.HsT!WcN.Hsr)r\r8rkrsetget_foreign_keysaddlistrsortrCircularDependencyErroredgesremoveupdate difference)r$r r[tnamestuplesremaining_fkcsfknames_for_tabletnamefkeysfkfkeycandidate_sorterrr}s @rget_sorted_table_and_fkc_names(Inspector.get_sorted_table_and_fkc_names*s2 $ $ &$\\112F' E))%8E'*+G2vJ+G'H  $!122JJ%5 6>? D!+"2"26"BCN( 'e,77G H' D( ) *+ +3' &,H ** D  d#%%&.?Q.H&" "+"2"26"BCN D s0%D 4D 9D#F( D#F%7A$F  F%cUR5nURRXRS9sSSS5 $!,(df  g=f)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 rhN)r\r8get_temp_table_namesrrZs rrInspector.get_temp_table_namesas< $ $ &$<<445' & & #> A cUR5nURRXRS9sSSS5 $!,(df  g=f)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 rhN)r\r8get_temp_view_namesrrZs rrInspector.get_temp_view_namesps< $ $ &$<<334' & &rc [URS5(aDUR5nURR"XAU4SUR0UD6sSSS5 $0$!,(df  0$=f)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)r7r8r\rrr$rqr r'r[s rrInspector.get_table_options~sn 4< $ $ &$<<../' & &rncUR5nURRX!URS9sSSS5 $!,(df  g=f)zReturn all sequence names in `schema`. :param schema: Optional, retrieve names from a non-default schema. For special quoting, use :class:`.quoted_name`. rhN)r\r8get_sequence_namesrrls rrInspector.get_sequence_namess> $ $ &$<<223' & &rncUR5nURRX1X RS9sSSS5 $!,(df  g=f)zReturn definition for `view_name`. :param schema: Optional, retrieve names from a non-default schema. For special quoting, use :class:`.quoted_name`. rhN)r\r8get_view_definitionr)r$ view_namer r[s rrInspector.get_view_definitions> $ $ &$<<33OO4' & &rnc UR5nURR"XAU4SUR0UD6nSSS5 WH)nUSn[ U[ 5(aMU"5US'M+ U$!,(df  N?=f)a Return 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)r\r8 get_columnsrrr)r$rqr r'r[col_defscol_defcoltypes rrInspector.get_columnssl $ $ &$||//&59__HJH' GfoGgz22"))  ' &s +A55 Bc UR5nURR"XAU4SUR0UD6sSSS5 $!,(df  g=f)aHReturn 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)r\r8get_pk_constraintrrs rrInspector.get_pk_constraintsI( $ $ &$<<11&59__HJ' & & *A Ac UR5nURR"XAU4SUR0UD6sSSS5 $!,(df  g=f)a'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 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)r\r8rrrs rrInspector.get_foreign_keyssI> $ $ &$<<00&59__HJ' & &rc UR5nURR"XAU4SUR0UD6sSSS5 $!,(df  g=f)aWReturn 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)r\r8 get_indexesrrs rrInspector.get_indexes8sJH $ $ &$<<++&59__HJ' & &rc UR5nURR"XAU4SUR0UD6sSSS5 $!,(df  g=f)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)r\r8get_unique_constraintsrrs rr Inspector.get_unique_constraintsasI* $ $ &$<<66&59__HJ' & &rc UR5nURR"XAU4SUR0UD6sSSS5 $!,(df  g=f)aPReturn 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)r\r8get_table_commentrrs rrInspector.get_table_comment{sI  $ $ &$<<11&59__HJ' & &rc UR5nURR"XAU4SUR0UD6sSSS5 $!,(df  g=f)aReturn 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)r\r8get_check_constraintsrrs rrInspector.get_check_constraintssI: $ $ &$<<55&59__HJ' & &rz*: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.c&UR"U0UD6$)z1See reflect_table. This method name is deprecated) reflect_table)r$r&kwargss r reflecttableInspector.reflecttables!!42622r+c x^UbTU;agURT5 URRnUR5nUR T5nSSS5 TR n [ U4SjUR55n UR"U W40TRD6n U (aTRU 5 [R(a`[U[5(aURUR 5n[U [5(aU RUR 5n Sn 0n UR""X40TRD6HnSn UR%TUUUU 5 M U (d,UR'X5(d[(R*"U 5eUR-XTX5 UR/U UTU UUUUU 5 UR1U UTU UUU 5 UR3U UTU UUU 5 UR5U UTU UUU 5 UR7XTU 5 g!,(df  GN=f)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 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. Nc3># UH4nUTR;dMUTRRU54v M6 g7fr)dialect_kwargsr)rrtables rr*Inspector.reflect_table..s>" /E((( -Q$$((+ ,/s?$?FT)rr2r8r\schema_for_objectrydictreflection_optionsrr_validate_dialect_kwargsr py2krstrdecodeencodingr_reflect_columnrprNoSuchTableError _reflect_pk _reflect_fk_reflect_indexes_reflect_unique_constraints_reflect_check_constraints_reflect_table_comment)r$rinclude_columnsexclude_columns resolve_fks _extend_onr8r[r rqrtbl_opts found_tablecols_by_orig_namecol_ds ` rrInspector.reflect_tablesP@  ! "u%))##  $ $ &$++E2F'ZZ "" //"  ))  "'"6"6    * *8 4 99&#&&w'7'78*c**'..w/?/?@  %%  "'"6"6 EK  !    4>>*#E#E&&z2 2  '8                      ((         ''         ## '9 A' &s H** H9c.^TSnURRRXT5 URRXT5 TSnU(aXs;d U(aXt;agTSn[U4SjS55n ST;aU R TS5 /n TR S5bTSn [ U [RR5(a[R"U SS9n OK[ U [R5(d,[R"[R"TS5SS9n U RU 5 S T;a*[R"S 0TS D6n U RU 5 S T;a*[R "S 0TS D6n U RU 5 S T;aUR#TU 5 [R$"Xx/U Q70U D6=XV'n U R&UR(;aSU lUR+U SS 9 g)Nryrc3B># UHnUT;dM UTU4v M g7frr)rrrs rr,Inspector._reflect_column..\s/  Ez QaMs )nullable autoincrementquoteinfor(commentdialect_optionsdefaultT) _reflectedcomputedidentitysequence)replace_existingr)metadatadispatchcolumn_reflectrrrrr elements TextClause sa_schema DefaultClause FetchedValuetextappendComputedIdentity_reflect_col_sequenceColumnr( primary_key append_column)r$rrrrr orig_nameryrcol_kwcolargsrrcols ` rrInspector._reflect_columnIs&M  ..tEB %%d59V}  ;  7 -       % MM% 12 3 99Y  +I&G'3<<#:#:;;#11'dK)?)?@@#11HHU9-.4 NN7 #   ))>E*,=>H NN8 $   ))>E*,=>H NN8 $    & &ug 6-6-=-= . #. '-.  $s 77e'' '"CO C$7r+cSU;aRUSn[R"USSS5nSU;a USUlSU;a USUlUR U5 gg)Nrryrstart increment)rSequencer r r)r$rrseqrs rrInspector._reflect_col_sequencesd   #C ))#f+q![ R"UUR4UR[ RUS.U D6 UH%nURSRUU/55 M' S U ;aU S nO0nUR[ R"UUU 4S S 0UD65 GM gs sn f) Nryrreferred_schemarzreferred_columns)r autoload_withr.)rr roptions link_to_nameT)rrr(r intersectionrrTablerr2rjoin BLANK_SCHEMAappend_constraintForeignKeyConstraint)r$rqr rrrrrrrrfkey_dconnamecrrrzrrefspeccolumnrs rrInspector._reflect_fks%%  "'"6"6 FVnG  56#6A-.,B!$((I6 #  +,99/JJ#/0;;OLL$%67O#$45N%&89 G*OO& /&*ii#-  - /FNN/>6!JK/ OO&'+ii(55#-  - /FNN388^V,D#EF/F" +  # #..'"&    m#sGascdesc nulls_first nulls_lastc nURX5nUGHjn U Sn U Sn U RS05n U Sn U RSS5nU RS05nU RS5nU(aO[U 5RU5(d0[R "S U<S S R U 5<S 35 MU(aM/nU HgnUU;aUUOURUnU RUS5nURHunnUU;dMU"U5nM URU5 Mi [R"U /UQ7SU0[[UR55SU 4/-5D6 GMm g![a& [R "U<S U<SU<S35 Mf=f)Nry column_namescolumn_sortinguniquerindexrduplicates_constraintz Omitting z key for (, z), key covers omitted columns.z key '(' was not located in columns for table ''r_table)rrrissubsetr warnr r&KeyError_index_sort_exprsrrIndexrrr")r$rqr rrrrrindexesindex_drycolumnsr0r1flavorr duplicatesidx_colsr&idx_col c_sortingrops rrInspector._reflect_indexess"":6G6?Dn-G$[[)92>NX&F[[1F%kk*;R@O %<=Js7|'<'<_'M'M tyy13H  11*!,"WWQZ+..q"5 !33EArI~"$W+4(#& OO   tO113468J7KKL  O6 II4:AzK sF,F43F4c VURX5nUHn U Sn U Sn U RS5n U(aI[U 5R U5(d*[ R "SSRU 5-5 MnU (aMw/n U H-nX;aXNOURUnU RU5 M/ UR[R"U SU 065 M g![a gf=f![a# [ R "SU<SU<S35 Mf=f) Nryr/duplicates_indexzDOmitting unique constraint key for (%s), key covers omitted columns.r4zunique constraint key 'r5r6)rNotImplementedErrorrrr8r r9r r&rr:r"rUniqueConstraint)r$rqr rrrrr constraintsconst_dr%r?rAconstrained_colsr&constrained_cols rr%Inspector._reflect_unique_constraints:s0 55jIK #GfoGn-G %78Js7|'<'<_'M'M 248IIg4FG "  =1*,"WWQZ$%++O<  # #**,<K7K ;# #   4 II45zCs#C+C;+ C87C8;)D('D(cURX5nUH(n UR[R"S0U D65 M* g![a gf=f)Nr)rrIr"rCheckConstraint) r$rqr rrrrrrKrLs rr$Inspector._reflect_check_constraintsmsS 44ZHK #G  # #I$=$=$H$H I# #   sA AAcvURX5nURSS5Ulg![a gf=f)Nr)rrrrI)r$rqr rr comment_dicts rr Inspector._reflect_table_commentsA ;11*EL),,VT:EM#   s + 88)rGr2r8rDrr)rTN)@r __module__ __qualname____firstlineno____doc__r deprecatedr3 classmethodr<r0rAr@rMr _inspectsrrQrrTrrW contextlibcontextmanagerr\rapropertyrdrgrkrprurrrrrrrrrrrrrr deprecated_20rrrrrrr asc_opdesc_opnulls_first_op nulls_last_opr;rrrr__static_attributes__rr+rr-r-<s2. __  5  '  '$  __  5 6 6*+&B'B &!B"B*%F&F&  008 D J5+n  *   ?B2"H'R4* D 4 /33 J X@8D %/(M`    ! ""#  001 y../ 8t1fJ&;r+r-)rYr]baserrrrr r r r r r sql.type_apirr decoratorr*_self_inspectsobjectr-rr+rrlsl(%%    K;K;K;r+