U
|
¸ý°dÆ ã
|
@ s d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z ddlm
|
Z
|
ddlm Z dd lm Z dd
|
lm Z dd lmZ dd lmZ dd lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z 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+ dd$l(m,Z, erÎd%d&l-m.Z. d%d'l-m/Z/ d%d(l0m1Z1 d%d)l2m3Z3 dd*l m4Z4 dd+l m5Z5 dd,l6m7Z7 dd-l8m9Z9 dd.l"m:Z: dd/l"m;Z; dd0l"m<Z< dd1l"m=Z= dd2l"m>Z> dd3l"m?Z? dd4l@mAZA dd5l@mBZB dd6lCmDZD dd7lCmEZE dd8lCmFZF ddlCmZG dd9lHmIZI dd:lJmKZK dd;lJmLZL eeeM eeMef f ZNed<d=d>ZOG d?d@ d@eZPG dAdB dBeZQG dCdD dDe+ZRG dEdF dFe+ZSG dGdH dHe+ZTeeMef ZUeeMef ZVeeU ZWeeWeUf ZXeee eUf ZYeeee eWf ZZeeZeYf Z[eeeMdFee\ ee\ ee\ ee\ ee] f Z^eYZ_eZZ`e[ZaeedIf ZbeeeM eeM f Zce%eMef Zde)dJ ZeeeeMedKf Zfe)dL ZgG dMdN dNe,dOdPZhe%eMef ZieeheeMef f ZjG dQdR dRe,ZkG dSdT dTe,ZlG dUdV dVe,ZmG dWdX dXe,ZnG dYdZ dZenZoG d[d\ d\enZpG d]d^ d^enZqG d_d` d`enZrG dadb dbe,ZsG dcdd dde,ZtG dedf dfeZueee\eMf dgf ZveeeM eMf ZwG dhdi die ZxG djdk dkZyG dldm dmZzG dndo doe Z{e{Z|G dpdq dqZ}G drds dsZ~dtS )uz1Define core interfaces used by the engine system.é )Ú annotations)ÚEnum)Ú
|
ModuleType)ÚAny)Ú Awaitable)ÚCallable)ÚClassVar)Ú
|
Collection)ÚDict)ÚIterable)ÚIterator)ÚList)ÚMapping)ÚMutableMapping)ÚOptional)ÚSequence)ÚSet)ÚTuple)ÚType)Ú TYPE_CHECKING)ÚTypeVar)ÚUnioné )Úutil)Ú EventTarget)ÚPool)ÚPoolProxiedConnection)ÚCompiled)Ú TypeCompiler)Ú immutabledict)Ú
|
await_only)ÚLiteral)Ú NotRequired)ÚProtocol)Ú TypedDicté )Ú
|
Connection)ÚEngine)Ú CursorResult)ÚURL)Ú_ListenerFnType)Ú
|
dispatcher)ÚStatementError)Ú
|
Executable)Ú_InsertManyValuesBatch)Ú DDLCompiler)ÚIdentifierPreparer)Ú InsertmanyvaluesSentinelOpts)ÚLinting)Ú SQLCompiler)Ú BindParameter)Ú ClauseElement)ÚColumn)ÚDefaultGenerator)Ú
|
SchemaItem)ÚInteger)Ú _TypeMemoDict)Ú
|
TypeEngineÚ_Tr )Úboundc @ s e Zd ZdZdZdZdZdZdS )Ú
|
CacheStatsr r% r é é N)Ú__name__Ú
|
__module__Ú __qualname__Ú CACHE_HITÚ
|
CACHE_MISSÚCACHING_DISABLEDÚ NO_CACHE_KEYÚNO_DIALECT_SUPPORT© rI rI úSd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/engine/interfaces.pyr> O s
|
r> c @ s e Zd ZdZdZdZdZdS )Ú ExecuteStylezVindicates the :term:`DBAPI` cursor method that will be used to invoke
|
a statement.r r% r N)rA rB rC Ú__doc__ZEXECUTEZ EXECUTEMANYZINSERTMANYVALUESrI rI rI rJ rK W s
|
rK c @ sR e Zd ZU dZddddZddddZddd d
|
Zddd d Zd ed< dS )ÚDBAPIConnectionzàprotocol representing a :pep:`249` database connection.
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
`Connection Objects <https://www.python.org/dev/peps/pep-0249/#connection-objects>`_
|
- in :pep:`249`
|
|
ÚNone©Úreturnc C s d S ©NrI ©ÚselfrI rI rJ Úclosey s zDBAPIConnection.closec C s d S rQ rI rR rI rI rJ Úcommit| s zDBAPIConnection.commitÚ DBAPICursorc C s d S rQ rI rR rI rI rJ Úcursor s zDBAPIConnection.cursorc C s d S rQ rI rR rI rI rJ Úrollback s zDBAPIConnection.rollbackÚboolZ
|
autocommitN) rA rB rC rL rT rU rW rX Ú__annotations__rI rI rI rJ rM m s
|
rM c @ s e Zd ZdZdS )Ú DBAPITypezÎprotocol representing a :pep:`249` database type.
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
`Type Objects <https://www.python.org/dev/peps/pep-0249/#type-objects>`_
|
- in :pep:`249`
|
|
N)rA rB rC rL rI rI rI rJ r[ s r[ c @ sü e Zd ZU dZeddddZeddddZded < ded
|
< d dd d Zd1ddddddZ ddddddZ
|
ddddZ d2ddd d d Z ddd d Z dd d!d"d#Zddd d$d%d&Zd3d'ddd(d)d*Zd+dd,d-Zd'dd.d/d0ZdS )4rV zÔprotocol representing a :pep:`249` database cursor.
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
`Cursor Objects <https://www.python.org/dev/peps/pep-0249/#cursor-objects>`_
|
- in :pep:`249`
|
|
Ú_DBAPICursorDescriptionrO c C s dS )zÀThe description attribute of the Cursor.
|
|
.. seealso::
|
|
`cursor.description <https://www.python.org/dev/peps/pep-0249/#description>`_
|
- in :pep:`249`
|
|
|
NrI rR rI rI rJ Ú description¡ s zDBAPICursor.descriptionÚintc C s d S rQ rI rR rI rI rJ Úrowcount° s zDBAPICursor.rowcountZ arraysizeZ lastrowidrN c C s d S rQ rI rR rI rI rJ rT ¸ s zDBAPICursor.closeNr ú#Optional[_DBAPISingleExecuteParams])Ú operationÚ
|
parametersrP c C s d S rQ rI ©rS ra rb rI rI rJ Úexecute» s zDBAPICursor.executez"Sequence[_DBAPIMultiExecuteParams]c C s d S rQ rI rc rI rI rJ Ú executemany s zDBAPICursor.executemanyz Optional[Any]c C s d S rQ rI rR rI rI rJ ÚfetchoneÉ s zDBAPICursor.fetchone.ú Sequence[Any])ÚsizerP c C s d S rQ rI )rS rh rI rI rJ Ú fetchmanyÌ s zDBAPICursor.fetchmanyc C s d S rQ rI rR rI rI rJ ÚfetchallÏ s zDBAPICursor.fetchall)ÚsizesrP c C s d S rQ rI )rS rk rI rI rJ Ú setinputsizesÒ s zDBAPICursor.setinputsizes)rh ÚcolumnrP c C s d S rQ rI )rS rh rm rI rI rJ Ú setoutputsizeÕ s zDBAPICursor.setoutputsizeÚstr)Úprocnamerb rP c C s d S rQ rI )rS rp rb rI rI rJ ÚcallprocØ s zDBAPICursor.callproczOptional[bool]c C s d S rQ rI rR rI rI rJ ÚnextsetÛ s zDBAPICursor.nextset)ÚkeyrP c C s d S rQ rI )rS rs rI rI rJ Ú __getattr__Þ s zDBAPICursor.__getattr__)N).).)rA rB rC rL Úpropertyr] r_ rZ rT rd re rf ri rj rl rn rq rr rt rI rI rI rJ rV s&
|
ýrV r )ZqmarkÚnumericÚnamedÚformatZpyformatZnumeric_dollarúTypeEngine[Any])Z SERIALIZABLEzREPEATABLE READzREAD COMMITTEDzREAD UNCOMMITTEDZ
|
AUTOCOMMITc @ sV e Zd ZU ded< ded< ded< ded< ded < d
|
ed < d
|
ed < d
|
ed < ded< dS )Ú_CoreKnownExecutionOptionszOptional[CompiledCacheType]Zcompiled_cachero Z logging_tokenÚIsolationLevelZisolation_levelrY Ú no_parametersZstream_resultsr^ Zmax_row_bufferZ yield_perÚinsertmanyvalues_page_sizez Optional[SchemaTranslateMapType]Zschema_translate_mapN)rA rB rC rZ rI rI rI rJ rz s
|
rz F)Útotalc @ sj e Zd ZU dZded< ded< ded< ded< ded< ded < ded
|
< ded < ded < d ed< ded< dS )ÚReflectedIdentitya& represent the reflected IDENTITY structure of a column, corresponding
|
to the :class:`_schema.Identity` construct.
|
|
The :class:`.ReflectedIdentity` structure is part of the
|
:class:`.ReflectedColumn` structure, which is returned by the
|
:meth:`.Inspector.get_columns` method.
|
|
rY ÚalwaysZon_nullr^ ÚstartÚ incrementZminvalueZmaxvalueZ
|
nominvalueZ
|
nomaxvalueÚcycleú Optional[int]ÚcacheÚorderN©rA rB rC rL rZ rI rI rI rJ r ' s
|
r c @ s" e Zd ZU dZded< ded< dS )ÚReflectedComputeda% Represent the reflected elements of a computed column, corresponding
|
to the :class:`_schema.Computed` construct.
|
|
The :class:`.ReflectedComputed` structure is part of the
|
:class:`.ReflectedColumn` structure, which is returned by the
|
:meth:`.Inspector.get_columns` method.
|
|
ro ÚsqltextúNotRequired[bool]Z persistedNr rI rI rI rJ r U s
|
r c @ sZ e Zd ZU dZded< ded< ded< ded < d
|
ed < d ed < ded< ded< ded< dS )ÚReflectedColumnz×Dictionary representing the reflected elements corresponding to
|
a :class:`_schema.Column` object.
|
|
The :class:`.ReflectedColumn` structure is returned by the
|
:class:`.Inspector.get_columns` method.
|
|
ro Únamery ÚtyperY Znullableú Optional[str]Údefaultr Z autoincrementúNotRequired[Optional[str]]Úcommentz NotRequired[ReflectedComputed]Zcomputedz NotRequired[ReflectedIdentity]ÚidentityúNotRequired[Dict[str, Any]]Údialect_optionsNr rI rI rI rJ r g s
|
r c @ s" e Zd ZU dZded< ded< dS )ÚReflectedConstraintzDictionary representing the reflected elements corresponding to
|
:class:`.Constraint`
|
|
A base class for all constraints
|
r r r r Nr rI rI rI rJ r ¡ s
|
r c @ s" e Zd ZU dZded< ded< dS )ÚReflectedCheckConstraintzâDictionary representing the reflected elements corresponding to
|
:class:`.CheckConstraint`.
|
|
The :class:`.ReflectedCheckConstraint` structure is returned by the
|
:meth:`.Inspector.get_check_constraints` method.
|
|
ro r r r Nr rI rI rI rJ r ¯ s
|
r c @ s* e Zd ZU dZded< ded< ded< dS ) ÚReflectedUniqueConstraintzåDictionary representing the reflected elements corresponding to
|
:class:`.UniqueConstraint`.
|
|
The :class:`.ReflectedUniqueConstraint` structure is returned by the
|
:meth:`.Inspector.get_unique_constraints` method.
|
|
ú List[str]Ú column_namesr Zduplicates_indexr r Nr rI rI rI rJ r  s
|
|
r c @ s" e Zd ZU dZded< ded< dS )Ú ReflectedPrimaryKeyConstraintzèDictionary representing the reflected elements corresponding to
|
:class:`.PrimaryKeyConstraint`.
|
|
The :class:`.ReflectedPrimaryKeyConstraint` structure is returned by the
|
:meth:`.Inspector.get_pk_constraint` method.
|
|
r Úconstrained_columnsr r Nr rI rI rI rJ r Ö s
|
r c @ s: e Zd ZU dZded< ded< ded< ded< d ed
|
< d S ) Ú ReflectedForeignKeyConstraintzçDictionary representing the reflected elements corresponding to
|
:class:`.ForeignKeyConstraint`.
|
|
The :class:`.ReflectedForeignKeyConstraint` structure is returned by
|
the :meth:`.Inspector.get_foreign_keys` method.
|
|
r r r Zreferred_schemaro Zreferred_tableZreferred_columnsr ÚoptionsNr rI rI rI rJ r æ s
|
r c @ sR e Zd ZU dZded< ded< ded< ded < d
|
ed < ded < d ed< ded< dS )ÚReflectedIndexzÄDictionary representing the reflected elements corresponding to
|
:class:`.Index`.
|
|
The :class:`.ReflectedIndex` structure is returned by the
|
:meth:`.Inspector.get_indexes` method.
|
|
r r zList[Optional[str]]r zNotRequired[List[str]]Z expressionsrY Úuniquer Zduplicates_constraintZinclude_columnsz"NotRequired[Dict[str, Tuple[str]]]Zcolumn_sortingr r Nr rI rI rI rJ r ÿ s
|
|
r c @ s e Zd ZU dZded< dS )ÚReflectedTableCommentzìDictionary representing the reflected comment corresponding to
|
the :attr:`_schema.Table.comment` attribute.
|
|
The :class:`.ReflectedTableComment` structure is returned by the
|
:meth:`.Inspector.get_table_comment` method.
|
|
r ÚtextNr rI rI rI rJ r 3 s
|
r c @ s e Zd ZdZdZdZdZdS )Ú
|
BindTypingzDefine different methods of passing typing information for
|
bound parameters in a statement to the database driver.
|
|
.. versionadded:: 2.0
|
|
r% r r? N)rA rB rC rL ÚNONEZ SETINPUTSIZESZ RENDER_CASTSrI rI rI rJ r¢ @ s
|
r¢ .c @ sØ e Zd ZU dZejZejZejZejZej Z de
|
d< de
|
d< de
|
d< de
|
d< de
|
d < e j d
|
d d d Z de
|
d< de
|
d< de
|
d< de
|
d< de
|
d< de
|
d< de
|
d< de
|
d < d e
|
d < d e
|
d < d!e
|
d"< d#e
|
d$< d%e
|
d&< d%e
|
d'< d(e
|
d)< d*e
|
d+< de
|
d,< d-e
|
d.< de
|
d/< de
|
d0< de
|
d1< de
|
d2< de
|
d3< de
|
d4< de
|
d5< d6Zde
|
d7< de
|
d8< de
|
d9< de
|
d:< de
|
d;< de
|
d<< de
|
d=< de
|
d>< d?e
|
d@< d-e
|
dA< d-e
|
dB< de
|
dC< de
|
dD< de
|
dE< de
|
dF< de
|
dG< de
|
dH< de
|
dI< de
|
dJ< de
|
dK< dLe
|
dM< de
|
dN< de
|
dO< d-e
|
dP< de
|
dQ< de
|
dR< de
|
dS< de
|
dT< de
|
dU< dVZdWe
|
dX< dYZdZe
|
d[< e jZd\e
|
d]< de
|
d^< de
|
d_< de
|
d`< daZdbZde
|
dc< de
|
dd< ejZde
|
de< de
|
df< dge
|
dh< die
|
dj< dke
|
dl< dke
|
dm< de
|
dn< de
|
do< de
|
dp< de
|
dq< dre
|
ds< dtd dudvZdwdxdydzd{Zed
|
d d|d}Zed~d~dddZ dddd
dZ e r:dddddZ dXddd#dddddZ dYdd#ddddddZ!dZddd#dddddZ"d[dd#ddddddZ#d\ddd#dddddZ$d]dd#ddddddZ%d^dd#ddd d¡d¢Z&d_dd#ddd d£d¤Z'd`dd#ddd d¥d¦Z(dadd#ddd d§d¨Z)dbdd#ddd d©dªZ*dcdd#ddd d«d¬Z+ddddd®d¯Z,ddddd#ddd°d±d²Z-deddd#dd³dd´dµZ.dfdd#ddd¶dd·d¸Z/dgddd#dd¹ddºd»Z0dhdd#ddd¼dd½d¾Z1diddd#dd¿ddÀdÁZ2djdd#dddÂddÃdÄZ3dkddd#ddÅddÆdÇZ4dldd#dddÈddÉdÊZ5dmddd#ddËddÌdÍZ6dndd#dddÎddÏdÐZ7dddÑdÒdÓZ8dddÑdÔdÕZ9doddd#ddddÖd×Z:dpdddd#dddØdÙdÚZ;dqddd#dddÛdÜdÝZ<dddddÞdßdàZ=ddddádâZ>ddddãdäZ?dåddædçdèZ@dåddædédêZAdåddædëdìZBdíddædîdïZCdíddædðdñZDdíddædòdóZEdíddædôdõZFdöd÷døddùdúdûZGdd düdýZHddddþdÿd ZIddddþddZJddddþddZKddddddZLdddddd ZMdrdddddd
|
d d ZNdsdddddd
|
d dZOdddddZPdöddddøddddZQdtdödddddddZRdudödd dddd d ZSdvdödddd d d!ZTd"d#d$dd%d&d'ZUdddíd(d)d*ZVdwd+dyd,d-ZWd+d d.d/ZXdíddæd0d1ZYdíd2dd3d4d5ZZdíd2dæd6d7Z[díd2d8d9d:Z\díd;d8d<d=Z]díd2dd>d?d@Z^edwdAdydBdCZ_edwdAdydDdEZ`edd dFdGZaedHddIdJdKZbdídddLdMZcdHdNddOdPdQZdddNddRdSdTZedwdUdydVdWZfdVS (w ÚDialectae Define the behavior of a specific database and DB-API combination.
|
|
Any aspect of metadata definition, SQL query generation,
|
execution, result-set handling, or anything else which varies
|
between databases is defined under the general category of the
|
Dialect. The Dialect acts as a factory for other
|
database-specific object implementations including
|
ExecutionContext, Compiled, DefaultGenerator, and TypeEngine.
|
|
.. note:: Third party dialects should not subclass :class:`.Dialect`
|
directly. Instead, subclass :class:`.default.DefaultDialect` or
|
descendant class.
|
|
zdispatcher[Dialect]Údispatchro r ZdriverZdialect_descriptionzOptional[ModuleType]Zdbapir rO c C s
|
t dS )zsame as .dbapi, but is never None; will raise an error if no
|
DBAPI was set up.
|
|
.. versionadded:: 2.0
|
|
N©ÚNotImplementedErrorrR rI rI rJ Ú loaded_dbapi¹ s zDialect.loaded_dbapirY Ú
|
positionalZ
|
paramstyler2 Zcompiler_lintingzType[SQLCompiler]Zstatement_compilerzType[DDLCompiler]Z ddl_compilerz ClassVar[Type[TypeCompiler]]Ztype_compiler_clsr Ztype_compiler_instancer Z type_compilerzType[IdentifierPreparer]Úpreparerr0 Zidentifier_preparerzOptional[Tuple[Any, ...]]Zserver_version_infor Zdefault_schema_namezOptional[IsolationLevel]Zdefault_isolation_levelZ_on_connect_isolation_levelzType[ExecutionContext]Zexecution_ctx_clsz4Union[Type[Tuple[Any, ...]], Type[Tuple[List[Any]]]]Zexecute_sequence_formatZsupports_alterr^ Zmax_identifier_lengthZ supports_server_side_cursorsZserver_side_cursorsZsupports_sane_rowcountZ supports_sane_multi_rowcountZsupports_empty_insertZsupports_default_valuesZsupports_default_metavalueÚDEFAULTÚdefault_metavalue_tokenZsupports_multivalues_insertZ insert_executemany_returningZ4insert_executemany_returning_sort_by_parameter_orderZ update_executemany_returningZ delete_executemany_returningZuse_insertmanyvaluesZ!use_insertmanyvalues_wo_returningr1 Z"insertmanyvalues_implicit_sentinelr} Z insertmanyvalues_max_parametersZ"preexecute_autoincrement_sequencesZinsert_returningZupdate_returningZupdate_returning_multifromZdelete_returningZdelete_returning_multifromZ favor_returning_over_lastrowidZsupports_identity_columnsZcte_follows_insertz<MutableMapping[Type[TypeEngine[Any]], Type[TypeEngine[Any]]]ZcolspecsZsupports_sequencesZsequences_optionalZdefault_sequence_baseZsupports_native_enumZsupports_native_booleanZsupports_native_decimalZsupports_native_uuidZreturns_native_bytesNzPOptional[List[Tuple[Type[Union[SchemaItem, ClauseElement]], Mapping[str, Any]]]]Úconstruct_argumentsrI ú Sequence[str]Úreflection_optionszMapping[str, str]Ú dbapi_exception_translation_mapZsupports_commentsZinline_commentsZ supports_constraint_commentsFTÚsupports_statement_cacheZ_supports_statement_cacheZis_asyncZ has_terminatezMapping[str, Any]Zengine_config_typesr Z label_lengthzOptional[Set[Any]]Zinclude_set_input_sizesZexclude_set_input_sizesZ supports_simple_order_by_labelZdiv_is_floordivZtuple_in_valuesZ_bind_typing_render_castsz.MutableMapping[TypeEngine[Any], _TypeMemoDict]Z _type_memoszOptional[_ListenerFnType]c C s
|
t d S rQ r¦ rR rI rI rJ Ú_builtin_onconnect¿ s zDialect._builtin_onconnectr) ÚConnectArgsType©ÚurlrP c C s
|
t dS )a Build DB-API compatible connection arguments.
|
|
Given a :class:`.URL` object, returns a tuple
|
consisting of a ``(*args, **kwargs)`` suitable to send directly
|
to the dbapi's connect function. The arguments are sent to the
|
:meth:`.Dialect.connect` method which then runs the DBAPI-level
|
``connect()`` function.
|
|
The method typically makes use of the
|
:meth:`.URL.translate_connect_args`
|
method in order to generate a dictionary of options.
|
|
The default implementation is::
|
|
def create_connect_args(self, url):
|
opts = url.translate_connect_args()
|
opts.update(url.query)
|
return [[], opts]
|
|
:param url: a :class:`.URL` object
|
|
:return: a tuple of ``(*args, **kwargs)`` which will be passed to the
|
:meth:`.Dialect.connect` method.
|
|
.. seealso::
|
|
:meth:`.URL.translate_connect_args`
|
|
Nr¦ ©rS rµ rI rI rJ Úcreate_connect_args s zDialect.create_connect_argsc C s
|
t dS )a¦ Import the DBAPI module that is used by this dialect.
|
|
The Python module object returned here will be assigned as an
|
instance variable to a constructed dialect under the name
|
``.dbapi``.
|
|
.. versionchanged:: 2.0 The :meth:`.Dialect.import_dbapi` class
|
method is renamed from the previous method ``.Dialect.dbapi()``,
|
which would be replaced at dialect instantiation time by the
|
DBAPI module itself, thus using the same name in two different ways.
|
If a ``.Dialect.dbapi()`` classmethod is present on a third-party
|
dialect, it will be used and a deprecation warning will be emitted.
|
|
Nr¦ ©ÚclsrI rI rJ Ú import_dbapiã s zDialect.import_dbapizTypeEngine[_T])ÚtypeobjrP c C s
|
t dS )a4 Transform a generic type to a dialect-specific type.
|
|
Dialect classes will usually use the
|
:func:`_types.adapt_type` function in the types module to
|
accomplish this.
|
|
The returned result is cached *per dialect class* so can
|
contain no dialect-instance state.
|
|
Nr¦ )r¹ r» rI rI rJ Útype_descriptorõ s zDialect.type_descriptorr& rN )Ú
|
connectionrP c C s dS )a Called during strategized creation of the dialect with a
|
connection.
|
|
Allows dialects to configure options based on server version info or
|
other properties.
|
|
The connection passed here is a SQLAlchemy Connection object,
|
with full capabilities.
|
|
The initialize() method of the base dialect should be called via
|
super().
|
|
.. note:: as of SQLAlchemy 1.4, this method is called **before**
|
any :meth:`_engine.Dialect.on_connect` hooks are called.
|
|
NrI ©rS r½ rI rI rJ Ú
|
initialize s zDialect.initialize)Ú method_namerP c C s d S rQ rI )rS rÀ rI rI rJ Ú_overrides_default s zDialect._overrides_defaultzList[ReflectedColumn])r½ Ú
|
table_nameÚschemaÚkwrP c K s
|
t dS )a Return information about columns in ``table_name``.
|
|
Given a :class:`_engine.Connection`, a string
|
``table_name``, and an optional string ``schema``, return column
|
information as a list of dictionaries
|
corresponding to the :class:`.ReflectedColumn` dictionary.
|
|
This is an internal dialect method. Applications should use
|
:meth:`.Inspector.get_columns`.
|
|
Nr¦ ©rS r½ r rà rÄ rI rI rJ Ú get_columns s zDialect.get_columnszOptional[Collection[str]]z0Iterable[Tuple[TableKey, List[ReflectedColumn]]])r½ rÃ Ú filter_namesrÄ rP c K s
|
t dS )aª Return information about columns in all tables in the
|
given ``schema``.
|
|
This is an internal dialect method. Applications should use
|
:meth:`.Inspector.get_multi_columns`.
|
|
.. note:: The :class:`_engine.DefaultDialect` provides a default
|
implementation that will call the single table method for
|
each object returned by :meth:`Dialect.get_table_names`,
|
:meth:`Dialect.get_view_names` or
|
:meth:`Dialect.get_materialized_view_names` depending on the
|
provided ``kind``. Dialects that want to support a faster
|
implementation should implement this method.
|
|
.. versionadded:: 2.0
|
|
Nr¦ ©rS r½ rà rÇ rÄ rI rI rJ Úget_multi_columns2 s zDialect.get_multi_columnsr c K s
|
t dS )a Return information about the primary key constraint on
|
table_name`.
|
|
Given a :class:`_engine.Connection`, a string
|
``table_name``, and an optional string ``schema``, return primary
|
key information as a dictionary corresponding to the
|
:class:`.ReflectedPrimaryKeyConstraint` dictionary.
|
|
This is an internal dialect method. Applications should use
|
:meth:`.Inspector.get_pk_constraint`.
|
|
Nr¦ rÅ rI rI rJ Úget_pk_constraintM s zDialect.get_pk_constraintz8Iterable[Tuple[TableKey, ReflectedPrimaryKeyConstraint]]c K s
|
t dS )aÀ Return information about primary key constraints in
|
all tables in the given ``schema``.
|
|
This is an internal dialect method. Applications should use
|
:meth:`.Inspector.get_multi_pk_constraint`.
|
|
.. note:: The :class:`_engine.DefaultDialect` provides a default
|
implementation that will call the single table method for
|
each object returned by :meth:`Dialect.get_table_names`,
|
:meth:`Dialect.get_view_names` or
|
:meth:`Dialect.get_materialized_view_names` depending on the
|
provided ``kind``. Dialects that want to support a faster
|
implementation should implement this method.
|
|
.. versionadded:: 2.0
|
|
Nr¦ rÈ rI rI rJ Úget_multi_pk_constraintb s z Dialect.get_multi_pk_constraintz#List[ReflectedForeignKeyConstraint]c K s
|
t dS )a· Return information about foreign_keys in ``table_name``.
|
|
Given a :class:`_engine.Connection`, a string
|
``table_name``, and an optional string ``schema``, return foreign
|
key information as a list of dicts corresponding to the
|
:class:`.ReflectedForeignKeyConstraint` dictionary.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.get_foreign_keys`.
|
Nr¦ rÅ rI rI rJ Úget_foreign_keys| s zDialect.get_foreign_keysz>Iterable[Tuple[TableKey, List[ReflectedForeignKeyConstraint]]]c K s
|
t dS )a» Return information about foreign_keys in all tables
|
in the given ``schema``.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.get_multi_foreign_keys`.
|
|
.. note:: The :class:`_engine.DefaultDialect` provides a default
|
implementation that will call the single table method for
|
each object returned by :meth:`Dialect.get_table_names`,
|
:meth:`Dialect.get_view_names` or
|
:meth:`Dialect.get_materialized_view_names` depending on the
|
provided ``kind``. Dialects that want to support a faster
|
implementation should implement this method.
|
|
.. versionadded:: 2.0
|
|
Nr¦ rÈ rI rI rJ Úget_multi_foreign_keys s z Dialect.get_multi_foreign_keysr )r½ rà rÄ rP c K s
|
t dS )z®Return a list of table names for ``schema``.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.get_table_names`.
|
|
Nr¦ ©rS r½ rà rÄ rI rI rJ Úget_table_names« s
|
zDialect.get_table_namesc K s
|
t dS )zöReturn a list of temporary table names on the given connection,
|
if supported by the underlying backend.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.get_temp_table_names`.
|
|
Nr¦ rÎ rI rI rJ Úget_temp_table_names· s z Dialect.get_temp_table_namesc K s
|
t dS )a Return a list of all non-materialized view names available in the
|
database.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.get_view_names`.
|
|
:param schema: schema name to query, if not the default schema.
|
|
Nr¦ rÎ rI rI rJ Úget_view_namesÄ s zDialect.get_view_namesc K s
|
t dS )aF Return a list of all materialized view names available in the
|
database.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.get_materialized_view_names`.
|
|
:param schema: schema name to query, if not the default schema.
|
|
.. versionadded:: 2.0
|
|
Nr¦ rÎ rI rI rJ Úget_materialized_view_namesÓ s z#Dialect.get_materialized_view_namesc K s
|
t dS )a* Return a list of all sequence names available in the database.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.get_sequence_names`.
|
|
:param schema: schema name to query, if not the default schema.
|
|
.. versionadded:: 1.4
|
Nr¦ rÎ rI rI rJ Úget_sequence_namesä s zDialect.get_sequence_namesc K s
|
t dS )zôReturn a list of temporary view names on the given connection,
|
if supported by the underlying backend.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.get_temp_view_names`.
|
|
Nr¦ rÎ rI rI rJ Úget_temp_view_namesó s zDialect.get_temp_view_names)r½ rÄ rP c K s
|
t dS )z¾Return a list of all schema names available in the database.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.get_schema_names`.
|
Nr¦ )rS r½ rÄ rI rI rJ Úget_schema_names s zDialect.get_schema_names)r½ Ú view_namerà rÄ rP c K s
|
t dS )aG Return plain or materialized view definition.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.get_view_definition`.
|
|
Given a :class:`_engine.Connection`, a string
|
``view_name``, and an optional string ``schema``, return the view
|
definition.
|
Nr¦ )rS r½ rÖ rà rÄ rI rI rJ Úget_view_definition s zDialect.get_view_definitionzList[ReflectedIndex]c K s
|
t dS )a Return information about indexes in ``table_name``.
|
|
Given a :class:`_engine.Connection`, a string
|
``table_name`` and an optional string ``schema``, return index
|
information as a list of dictionaries corresponding to the
|
:class:`.ReflectedIndex` dictionary.
|
|
This is an internal dialect method. Applications should use
|
:meth:`.Inspector.get_indexes`.
|
Nr¦ rÅ rI rI rJ Ú get_indexes s zDialect.get_indexesz/Iterable[Tuple[TableKey, List[ReflectedIndex]]]c K s
|
t dS )a Return information about indexes in in all tables
|
in the given ``schema``.
|
|
This is an internal dialect method. Applications should use
|
:meth:`.Inspector.get_multi_indexes`.
|
|
.. note:: The :class:`_engine.DefaultDialect` provides a default
|
implementation that will call the single table method for
|
each object returned by :meth:`Dialect.get_table_names`,
|
:meth:`Dialect.get_view_names` or
|
:meth:`Dialect.get_materialized_view_names` depending on the
|
provided ``kind``. Dialects that want to support a faster
|
implementation should implement this method.
|
|
.. versionadded:: 2.0
|
|
Nr¦ rÈ rI rI rJ Úget_multi_indexes/ s zDialect.get_multi_indexesz List[ReflectedUniqueConstraint]c K s
|
t 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 dicts corresponding
|
to the :class:`.ReflectedUniqueConstraint` dictionary.
|
|
This is an internal dialect method. Applications should use
|
:meth:`.Inspector.get_unique_constraints`.
|
Nr¦ rÅ rI rI rJ Úget_unique_constraintsJ s z Dialect.get_unique_constraintsz:Iterable[Tuple[TableKey, List[ReflectedUniqueConstraint]]]c K s
|
t dS )aÀ Return information about unique constraints in all tables
|
in the given ``schema``.
|
|
This is an internal dialect method. Applications should use
|
:meth:`.Inspector.get_multi_unique_constraints`.
|
|
.. note:: The :class:`_engine.DefaultDialect` provides a default
|
implementation that will call the single table method for
|
each object returned by :meth:`Dialect.get_table_names`,
|
:meth:`Dialect.get_view_names` or
|
:meth:`Dialect.get_materialized_view_names` depending on the
|
provided ``kind``. Dialects that want to support a faster
|
implementation should implement this method.
|
|
.. versionadded:: 2.0
|
|
Nr¦ rÈ rI rI rJ Ú get_multi_unique_constraints] s z$Dialect.get_multi_unique_constraintsz List[ReflectedCheckConstraint]c K s
|
t dS )a 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 dicts corresponding
|
to the :class:`.ReflectedCheckConstraint` dictionary.
|
|
This is an internal dialect method. Applications should use
|
:meth:`.Inspector.get_check_constraints`.
|
|
Nr¦ rÅ rI rI rJ Úget_check_constraintsx s z Dialect.get_check_constraintsz9Iterable[Tuple[TableKey, List[ReflectedCheckConstraint]]]c K s
|
t dS )a¾ Return information about check constraints in all tables
|
in the given ``schema``.
|
|
This is an internal dialect method. Applications should use
|
:meth:`.Inspector.get_multi_check_constraints`.
|
|
.. note:: The :class:`_engine.DefaultDialect` provides a default
|
implementation that will call the single table method for
|
each object returned by :meth:`Dialect.get_table_names`,
|
:meth:`Dialect.get_view_names` or
|
:meth:`Dialect.get_materialized_view_names` depending on the
|
provided ``kind``. Dialects that want to support a faster
|
implementation should implement this method.
|
|
.. versionadded:: 2.0
|
|
Nr¦ rÈ rI rI rJ Úget_multi_check_constraints s z#Dialect.get_multi_check_constraintsúDict[str, Any]c K s
|
t dS )zÔReturn a dictionary of options specified when ``table_name``
|
was created.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.get_table_options`.
|
Nr¦ rÅ rI rI rJ Úget_table_options§ s zDialect.get_table_optionsz)Iterable[Tuple[TableKey, Dict[str, Any]]]c K s
|
t dS )aÊ Return a dictionary of options specified when the tables in the
|
given schema were created.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.get_multi_table_options`.
|
|
.. note:: The :class:`_engine.DefaultDialect` provides a default
|
implementation that will call the single table method for
|
each object returned by :meth:`Dialect.get_table_names`,
|
:meth:`Dialect.get_view_names` or
|
:meth:`Dialect.get_materialized_view_names` depending on the
|
provided ``kind``. Dialects that want to support a faster
|
implementation should implement this method.
|
|
.. versionadded:: 2.0
|
|
Nr¦ rÈ rI rI rJ Úget_multi_table_options¶ s z Dialect.get_multi_table_optionsr c K s
|
t dS )a Return the "comment" for the table identified by ``table_name``.
|
|
Given a string ``table_name`` and an optional string ``schema``, return
|
table comment information as a dictionary corresponding to the
|
:class:`.ReflectedTableComment` dictionary.
|
|
This is an internal dialect method. Applications should use
|
:meth:`.Inspector.get_table_comment`.
|
|
:raise: ``NotImplementedError`` for dialects that don't support
|
comments.
|
|
.. versionadded:: 1.2
|
|
Nr¦ rÅ rI rI rJ Úget_table_commentÐ s zDialect.get_table_commentz0Iterable[Tuple[TableKey, ReflectedTableComment]]c K s
|
t dS )aÁ Return information about the table comment in all tables
|
in the given ``schema``.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.get_multi_table_comment`.
|
|
.. note:: The :class:`_engine.DefaultDialect` provides a default
|
implementation that will call the single table method for
|
each object returned by :meth:`Dialect.get_table_names`,
|
:meth:`Dialect.get_view_names` or
|
:meth:`Dialect.get_materialized_view_names` depending on the
|
provided ``kind``. Dialects that want to support a faster
|
implementation should implement this method.
|
|
.. versionadded:: 2.0
|
|
Nr¦ rÈ rI rI rJ Úget_multi_table_commenté s z Dialect.get_multi_table_comment)r rP c C s
|
t dS )z»convert the given name to lowercase if it is detected as
|
case insensitive.
|
|
This method is only used if the dialect defines
|
requires_name_normalize=True.
|
|
Nr¦ ©rS r rI rI rJ Únormalize_name s zDialect.normalize_namec C s
|
t dS )zØconvert the given name to a case insensitive identifier
|
for the backend if it is an all-lowercase name.
|
|
This method is only used if the dialect defines
|
requires_name_normalize=True.
|
|
Nr¦ rã rI rI rJ Údenormalize_name s zDialect.denormalize_namec K s
|
t dS )a For internal dialect use, check the existence of a particular table
|
or view in the database.
|
|
Given a :class:`_engine.Connection` object, a string table_name and
|
optional schema name, return True if the given table exists in the
|
database, False otherwise.
|
|
This method serves as the underlying implementation of the
|
public facing :meth:`.Inspector.has_table` method, and is also used
|
internally to implement the "checkfirst" behavior for methods like
|
:meth:`_schema.Table.create` and :meth:`_schema.MetaData.create_all`.
|
|
.. note:: This method is used internally by SQLAlchemy, and is
|
published so that third-party dialects may provide an
|
implementation. It is **not** the public API for checking for table
|
presence. Please use the :meth:`.Inspector.has_table` method.
|
|
.. versionchanged:: 2.0:: :meth:`_engine.Dialect.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 dialects to the degree that the backing database supports views
|
or temporary tables should seek to support locating these objects
|
for full compliance.
|
|
Nr¦ rÅ rI rI rJ Ú has_table s 'zDialect.has_table)r½ r Ú
|
index_namerà rÄ rP c K s
|
t dS )a Check the existence of a particular index name in the database.
|
|
Given a :class:`_engine.Connection` object, a string
|
``table_name`` and string index name, return ``True`` if an index of
|
the given name on the given table exists, ``False`` otherwise.
|
|
The :class:`.DefaultDialect` implements this in terms of the
|
:meth:`.Dialect.has_table` and :meth:`.Dialect.get_indexes` methods,
|
however dialects can implement a more performant version.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.has_index`.
|
|
.. versionadded:: 1.4
|
|
Nr¦ )rS r½ r rç rà rÄ rI rI rJ Ú has_indexA s zDialect.has_index)r½ Ú sequence_namerà rÄ rP c K s
|
t dS )ap Check the existence of a particular sequence in the database.
|
|
Given a :class:`_engine.Connection` object and a string
|
`sequence_name`, return ``True`` if the given sequence exists in
|
the database, ``False`` otherwise.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.has_sequence`.
|
Nr¦ )rS r½ ré rà rÄ rI rI rJ Ú has_sequence\ s zDialect.has_sequence)r½ Ú schema_namerÄ rP c K s
|
t dS )av Check the existence of a particular schema name in the database.
|
|
Given a :class:`_engine.Connection` object, a string
|
``schema_name``, return ``True`` if a schema of the
|
given exists, ``False`` otherwise.
|
|
The :class:`.DefaultDialect` implements this by checking
|
the presence of ``schema_name`` among the schemas returned by
|
:meth:`.Dialect.get_schema_names`,
|
however dialects can implement a more performant version.
|
|
This is an internal dialect method. Applications should use
|
:meth:`_engine.Inspector.has_schema`.
|
|
.. versionadded:: 2.0
|
|
Nr¦ )rS r½ rë rÄ rI rI rJ Ú
|
has_schemao s zDialect.has_schemac C s
|
t dS )zèRetrieve the server version info from the given connection.
|
|
This is used by the default implementation to populate the
|
"server_version_info" attribute and is called exactly
|
once upon first connect.
|
|
Nr¦ r¾ rI rI rJ Ú_get_server_version_info s z Dialect._get_server_version_infoc C s
|
t dS )a Return the string name of the currently selected schema from
|
the given connection.
|
|
This is used by the default implementation to populate the
|
"default_schema_name" attribute and is called exactly
|
once upon first connect.
|
|
Nr¦ r¾ rI rI rJ Ú_get_default_schema_name s
|
z Dialect._get_default_schema_namer )Údbapi_connectionrP c C s
|
t dS )a¢ Provide an implementation of ``connection.begin()``, given a
|
DB-API connection.
|
|
The DBAPI has no dedicated "begin" method and it is expected
|
that transactions are implicit. This hook is provided for those
|
DBAPIs that might need additional help in this area.
|
|
:param dbapi_connection: a DBAPI connection, typically
|
proxied within a :class:`.ConnectionFairy`.
|
|
Nr¦ ©rS rï rI rI rJ Údo_begin s zDialect.do_beginc C s
|
t dS )zÙProvide an implementation of ``connection.rollback()``, given
|
a DB-API connection.
|
|
:param dbapi_connection: a DBAPI connection, typically
|
proxied within a :class:`.ConnectionFairy`.
|
|
Nr¦ rð rI rI rJ Ú do_rollback¬ s zDialect.do_rollbackc C s
|
t dS )z×Provide an implementation of ``connection.commit()``, given a
|
DB-API connection.
|
|
:param dbapi_connection: a DBAPI connection, typically
|
proxied within a :class:`.ConnectionFairy`.
|
|
Nr¦ rð rI rI rJ Ú do_commit· s zDialect.do_commitrM c C s
|
t dS )aÄ Provide an implementation of ``connection.close()`` that tries as
|
much as possible to not block, given a DBAPI
|
connection.
|
|
In the vast majority of cases this just calls .close(), however
|
for some asyncio dialects may call upon different API features.
|
|
This hook is called by the :class:`_pool.Pool`
|
when a connection is being recycled or has been invalidated.
|
|
.. versionadded:: 1.4.41
|
|
Nr¦ rð rI rI rJ Ú do_terminate s zDialect.do_terminatec C s
|
t dS )a Provide an implementation of ``connection.close()``, given a DBAPI
|
connection.
|
|
This hook is called by the :class:`_pool.Pool`
|
when a connection has been
|
detached from the pool, or is being returned beyond the normal
|
capacity of the pool.
|
|
Nr¦ rð rI rI rJ Údo_closeÓ s zDialect.do_closec C s
|
t d S rQ r¦ rð rI rI rJ Ú_do_ping_w_eventà s zDialect._do_ping_w_eventc C s
|
t dS )zNping the DBAPI connection and return True if the connection is
|
usable.Nr¦ rð rI rI rJ Údo_pingã s zDialect.do_pingrV Ú_GenericSetInputSizesTypeÚExecutionContext)rW Úlist_of_tuplesÚcontextrP c C s
|
t dS )aJ invoke the cursor.setinputsizes() method with appropriate arguments
|
|
This hook is called if the :attr:`.Dialect.bind_typing` attribute is
|
set to the
|
:attr:`.BindTyping.SETINPUTSIZES` value.
|
Parameter data is passed in a list of tuples (paramname, dbtype,
|
sqltype), where ``paramname`` is the key of the parameter in the
|
statement, ``dbtype`` is the DBAPI datatype and ``sqltype`` is the
|
SQLAlchemy type. The order of tuples is in the correct parameter order.
|
|
.. versionadded:: 1.4
|
|
.. versionchanged:: 2.0 - setinputsizes mode is now enabled by
|
setting :attr:`.Dialect.bind_typing` to
|
:attr:`.BindTyping.SETINPUTSIZES`. Dialects which accept
|
a ``use_setinputsizes`` parameter should set this value
|
appropriately.
|
|
|
Nr¦ )rS rW rú rû rI rI rJ Údo_set_input_sizesè s zDialect.do_set_input_sizesc C s
|
t dS )z½Create a two-phase transaction ID.
|
|
This id will be passed to do_begin_twophase(),
|
do_rollback_twophase(), do_commit_twophase(). Its format is
|
unspecified.
|
Nr¦ rR rI rI rJ Ú
|
create_xid s zDialect.create_xid)r½ r rP c C s
|
t dS )zCreate a savepoint with the given name.
|
|
:param connection: a :class:`_engine.Connection`.
|
:param name: savepoint name.
|
|
Nr¦ ©rS r½ r rI rI rJ Ú do_savepoint s zDialect.do_savepointc C s
|
t dS )zRollback a connection to the named savepoint.
|
|
:param connection: a :class:`_engine.Connection`.
|
:param name: savepoint name.
|
|
Nr¦ rþ rI rI rJ Údo_rollback_to_savepoint s
|
z Dialect.do_rollback_to_savepointc C s
|
t dS )zRelease the named savepoint on a connection.
|
|
:param connection: a :class:`_engine.Connection`.
|
:param name: savepoint name.
|
Nr¦ rþ rI rI rJ Údo_release_savepoint$ s z Dialect.do_release_savepoint)r½ ÚxidrP c C s
|
t dS )zBegin a two phase transaction on the given connection.
|
|
:param connection: a :class:`_engine.Connection`.
|
:param xid: xid
|
|
Nr¦ ©rS r½ r rI rI rJ Údo_begin_twophase- s zDialect.do_begin_twophasec C s
|
t dS )zPrepare a two phase transaction on the given connection.
|
|
:param connection: a :class:`_engine.Connection`.
|
:param xid: xid
|
|
Nr¦ r rI rI rJ Údo_prepare_twophase7 s zDialect.do_prepare_twophase)r½ r Ú is_preparedÚrecoverrP c C s
|
t dS )a3 Rollback a two phase transaction on the given connection.
|
|
:param connection: a :class:`_engine.Connection`.
|
:param xid: xid
|
:param is_prepared: whether or not
|
:meth:`.TwoPhaseTransaction.prepare` was called.
|
:param recover: if the recover flag was passed.
|
|
Nr¦ ©rS r½ r r r rI rI rJ Údo_rollback_twophaseA s z Dialect.do_rollback_twophasec C s
|
t dS )a2 Commit a two phase transaction on the given connection.
|
|
|
:param connection: a :class:`_engine.Connection`.
|
:param xid: xid
|
:param is_prepared: whether or not
|
:meth:`.TwoPhaseTransaction.prepare` was called.
|
:param recover: if the recover flag was passed.
|
|
Nr¦ r rI rI rJ Údo_commit_twophaseT s zDialect.do_commit_twophasez List[Any]c C s
|
t dS )z¬Recover list of uncommitted prepared two phase transaction
|
identifiers on the given connection.
|
|
:param connection: a :class:`_engine.Connection`.
|
|
Nr¦ r¾ rI rI rJ Údo_recover_twophaseh s zDialect.do_recover_twophaseÚ_DBAPIMultiExecuteParamsz#Optional[_GenericSetInputSizesType]z Iterator[_InsertManyValuesBatch])rW Ú statementrb Úgeneric_setinputsizesrû rP c C s
|
t dS )z¡convert executemany parameters for an INSERT into an iterator
|
of statement/single execute values, used by the insertmanyvalues
|
feature.
|
|
Nr¦ )rS rW r rb r rû rI rI rJ Ú!_deliver_insertmanyvalues_batchesr s z)Dialect._deliver_insertmanyvalues_batchesúOptional[ExecutionContext])rW r rb rû rP c C s
|
t dS )zSProvide an implementation of ``cursor.executemany(statement,
|
parameters)``.Nr¦ ©rS rW r rb rû rI rI rJ Údo_executemany s
|
zDialect.do_executemanyr` c C s
|
t dS )zOProvide an implementation of ``cursor.execute(statement,
|
parameters)``.Nr¦ r rI rI rJ Ú
|
do_execute s
|
zDialect.do_execute)rW r rû rP c C s
|
t dS )z{Provide an implementation of ``cursor.execute(statement)``.
|
|
The parameter collection should not be sent.
|
|
Nr¦ )rS rW r rû rI rI rJ Údo_execute_no_params s z Dialect.do_execute_no_paramsÚ Exceptionz7Optional[Union[PoolProxiedConnection, DBAPIConnection]]úOptional[DBAPICursor])Úer½ rW rP c C s
|
t dS )zMReturn True if the given DB-API error indicates an invalid
|
connectionNr¦ )rS r r½ rW rI rI rJ Ú is_disconnect§ s zDialect.is_disconnect)ÚcargsÚcparamsrP c O s
|
t dS )aì Establish a connection using this dialect's DBAPI.
|
|
The default implementation of this method is::
|
|
def connect(self, *cargs, **cparams):
|
return self.dbapi.connect(*cargs, **cparams)
|
|
The ``*cargs, **cparams`` parameters are generated directly
|
from this dialect's :meth:`.Dialect.create_connect_args` method.
|
|
This method may be used for dialects that need to perform programmatic
|
per-connection steps when a new connection is procured from the
|
DBAPI.
|
|
|
:param \*cargs: positional parameters returned from the
|
:meth:`.Dialect.create_connect_args` method
|
|
:param \*\*cparams: keyword parameters returned from the
|
:meth:`.Dialect.create_connect_args` method.
|
|
:return: a DBAPI connection, typically from the :pep:`249` module
|
level ``.connect()`` function.
|
|
.. seealso::
|
|
:meth:`.Dialect.create_connect_args`
|
|
:meth:`.Dialect.on_connect`
|
|
Nr¦ )rS r r rI rI rJ Úconnect² s zDialect.connectz Optional[Callable[[Any], Any]]c C s | ¡ S )a& return a callable which sets up a newly created DBAPI connection.
|
|
This method is a new hook that supersedes the
|
:meth:`_engine.Dialect.on_connect` method when implemented by a
|
dialect. When not implemented by a dialect, it invokes the
|
:meth:`_engine.Dialect.on_connect` method directly to maintain
|
compatibility with existing dialects. There is no deprecation
|
for :meth:`_engine.Dialect.on_connect` expected.
|
|
The callable should accept a single argument "conn" which is the
|
DBAPI connection itself. The inner callable has no
|
return value.
|
|
E.g.::
|
|
class MyDialect(default.DefaultDialect):
|
# ...
|
|
def on_connect_url(self, url):
|
def do_on_connect(connection):
|
connection.execute("SET SPECIAL FLAGS etc")
|
|
return do_on_connect
|
|
This is used to set dialect-wide per-connection options such as
|
isolation modes, Unicode modes, etc.
|
|
This method differs from :meth:`_engine.Dialect.on_connect` in that
|
it is passed the :class:`_engine.URL` object that's relevant to the
|
connect args. Normally the only way to get this is from the
|
:meth:`_engine.Dialect.on_connect` hook is to look on the
|
:class:`_engine.Engine` itself, however this URL object may have been
|
replaced by plugins.
|
|
.. note::
|
|
The default implementation of
|
:meth:`_engine.Dialect.on_connect_url` is to invoke the
|
:meth:`_engine.Dialect.on_connect` method. Therefore if a dialect
|
implements this method, the :meth:`_engine.Dialect.on_connect`
|
method **will not be called** unless the overriding dialect calls
|
it directly from here.
|
|
.. versionadded:: 1.4.3 added :meth:`_engine.Dialect.on_connect_url`
|
which normally calls into :meth:`_engine.Dialect.on_connect`.
|
|
:param url: a :class:`_engine.URL` object representing the
|
:class:`_engine.URL` that was passed to the
|
:meth:`_engine.Dialect.create_connect_args` method.
|
|
:return: a callable that accepts a single DBAPI connection as an
|
argument, or None.
|
|
.. seealso::
|
|
:meth:`_engine.Dialect.on_connect`
|
|
)Ú
|
on_connectr¶ rI rI rJ Úon_connect_urlÔ s ;zDialect.on_connect_urlc C s dS )a return a callable which sets up a newly created DBAPI connection.
|
|
The callable should accept a single argument "conn" which is the
|
DBAPI connection itself. The inner callable has no
|
return value.
|
|
E.g.::
|
|
class MyDialect(default.DefaultDialect):
|
# ...
|
|
def on_connect(self):
|
def do_on_connect(connection):
|
connection.execute("SET SPECIAL FLAGS etc")
|
|
return do_on_connect
|
|
This is used to set dialect-wide per-connection options such as
|
isolation modes, Unicode modes, etc.
|
|
The "do_on_connect" callable is invoked by using the
|
:meth:`_events.PoolEvents.connect` event
|
hook, then unwrapping the DBAPI connection and passing it into the
|
callable.
|
|
.. versionchanged:: 1.4 the on_connect hook is no longer called twice
|
for the first connection of a dialect. The on_connect hook is still
|
called before the :meth:`_engine.Dialect.initialize` method however.
|
|
.. versionchanged:: 1.4.3 the on_connect hook is invoked from a new
|
method on_connect_url that passes the URL that was used to create
|
the connect args. Dialects can implement on_connect_url instead
|
of on_connect if they need the URL object that was used for the
|
connection in order to get additional context.
|
|
If None is returned, no event listener is generated.
|
|
:return: a callable that accepts a single DBAPI connection as an
|
argument, or None.
|
|
.. seealso::
|
|
:meth:`.Dialect.connect` - allows the DBAPI ``connect()`` sequence
|
itself to be controlled.
|
|
:meth:`.Dialect.on_connect_url` - supersedes
|
:meth:`.Dialect.on_connect` to also receive the
|
:class:`_engine.URL` object in context.
|
|
NrI rR rI rI rJ r s 3zDialect.on_connectc C s
|
t dS )a2 Given a DBAPI connection, revert its isolation to the default.
|
|
Note that this is a dialect-level method which is used as part
|
of the implementation of the :class:`_engine.Connection` and
|
:class:`_engine.Engine`
|
isolation level facilities; these APIs should be preferred for
|
most typical use cases.
|
|
.. seealso::
|
|
:meth:`_engine.Connection.get_isolation_level`
|
- view current level
|
|
:attr:`_engine.Connection.default_isolation_level`
|
- view default level
|
|
:paramref:`.Connection.execution_options.isolation_level` -
|
set per :class:`_engine.Connection` isolation level
|
|
:paramref:`_sa.create_engine.isolation_level` -
|
set per :class:`_engine.Engine` isolation level
|
|
Nr¦ rð rI rI rJ Úreset_isolation_levelF s z Dialect.reset_isolation_levelr{ )rï ÚlevelrP c C s
|
t dS )a2 Given a DBAPI connection, set its isolation level.
|
|
Note that this is a dialect-level method which is used as part
|
of the implementation of the :class:`_engine.Connection` and
|
:class:`_engine.Engine`
|
isolation level facilities; these APIs should be preferred for
|
most typical use cases.
|
|
If the dialect also implements the
|
:meth:`.Dialect.get_isolation_level_values` method, then the given
|
level is guaranteed to be one of the string names within that sequence,
|
and the method will not need to anticipate a lookup failure.
|
|
.. seealso::
|
|
:meth:`_engine.Connection.get_isolation_level`
|
- view current level
|
|
:attr:`_engine.Connection.default_isolation_level`
|
- view default level
|
|
:paramref:`.Connection.execution_options.isolation_level` -
|
set per :class:`_engine.Connection` isolation level
|
|
:paramref:`_sa.create_engine.isolation_level` -
|
set per :class:`_engine.Engine` isolation level
|
|
Nr¦ )rS rï r rI rI rJ Úset_isolation_levela s zDialect.set_isolation_levelc C s
|
t dS )aé Given a DBAPI connection, return its isolation level.
|
|
When working with a :class:`_engine.Connection` object,
|
the corresponding
|
DBAPI connection may be procured using the
|
:attr:`_engine.Connection.connection` accessor.
|
|
Note that this is a dialect-level method which is used as part
|
of the implementation of the :class:`_engine.Connection` and
|
:class:`_engine.Engine` isolation level facilities;
|
these APIs should be preferred for most typical use cases.
|
|
|
.. seealso::
|
|
:meth:`_engine.Connection.get_isolation_level`
|
- view current level
|
|
:attr:`_engine.Connection.default_isolation_level`
|
- view default level
|
|
:paramref:`.Connection.execution_options.isolation_level` -
|
set per :class:`_engine.Connection` isolation level
|
|
:paramref:`_sa.create_engine.isolation_level` -
|
set per :class:`_engine.Engine` isolation level
|
|
|
Nr¦ rð rI rI rJ Úget_isolation_level s !zDialect.get_isolation_level)Ú
|
dbapi_connrP c C s
|
t dS )a Given a DBAPI connection, return its isolation level, or
|
a default isolation level if one cannot be retrieved.
|
|
This method may only raise NotImplementedError and
|
**must not raise any other exception**, as it is used implicitly upon
|
first connect.
|
|
The method **must return a value** for a dialect that supports
|
isolation level settings, as this level is what will be reverted
|
towards when a per-connection isolation level change is made.
|
|
The method defaults to using the :meth:`.Dialect.get_isolation_level`
|
method unless overridden by a dialect.
|
|
.. versionadded:: 1.3.22
|
|
Nr¦ ©rS r" rI rI rJ Úget_default_isolation_level¦ s z#Dialect.get_default_isolation_levelzList[IsolationLevel]c C s
|
t dS )a return a sequence of string isolation level names that are accepted
|
by this dialect.
|
|
The available names should use the following conventions:
|
|
* use UPPERCASE names. isolation level methods will accept lowercase
|
names but these are normalized into UPPERCASE before being passed
|
along to the dialect.
|
* separate words should be separated by spaces, not underscores, e.g.
|
``REPEATABLE READ``. isolation level names will have underscores
|
converted to spaces before being passed along to the dialect.
|
* The names for the four standard isolation names to the extent that
|
they are supported by the backend should be ``READ UNCOMMITTED``
|
``READ COMMITTED``, ``REPEATABLE READ``, ``SERIALIZABLE``
|
* if the dialect supports an autocommit option it should be provided
|
using the isolation level name ``AUTOCOMMIT``.
|
* Other isolation modes may also be present, provided that they
|
are named in UPPERCASE and use spaces not underscores.
|
|
This function is used so that the default dialect can check that
|
a given isolation level parameter is valid, else raises an
|
:class:`_exc.ArgumentError`.
|
|
A DBAPI connection is passed to the method, in the unlikely event that
|
the dialect needs to interrogate the connection itself to determine
|
this list, however it is expected that most backends will return
|
a hardcoded list of values. If the dialect supports "AUTOCOMMIT",
|
that value should also be present in the sequence returned.
|
|
The method raises ``NotImplementedError`` by default. If a dialect
|
does not implement this method, then the default dialect will not
|
perform any checking on a given isolation level value before passing
|
it onto the :meth:`.Dialect.set_isolation_level` method. This is
|
to allow backwards-compatibility with third party dialects that may
|
not yet be implementing this method.
|
|
.. versionadded:: 2.0
|
|
Nr¦ r# rI rI rJ Úget_isolation_level_values¼ s *z"Dialect.get_isolation_level_values)r" r rP c C s
|
t d S rQ r¦ )rS r" r rI rI rJ Ú _assert_and_set_isolation_levelè s z'Dialect._assert_and_set_isolation_levelú Type[Dialect]c C s | S )a} Given a URL, return the :class:`.Dialect` that will be used.
|
|
This is a hook that allows an external plugin to provide functionality
|
around an existing dialect, by allowing the plugin to be loaded
|
from the url based on an entrypoint, and then the plugin returns
|
the actual dialect to be used.
|
|
By default this just returns the cls.
|
|
rI ©r¹ rµ rI rI rJ Úget_dialect_clsí s zDialect.get_dialect_clsc C s
|
| |¡S )a² Given a URL, return the :class:`.Dialect` that will be used by
|
an async engine.
|
|
By default this is an alias of :meth:`.Dialect.get_dialect_cls` and
|
just returns the cls. It may be used if a dialect provides
|
both a sync and async version under the same name, like the
|
``psycopg`` driver.
|
|
.. versionadded:: 2
|
|
.. seealso::
|
|
:meth:`.Dialect.get_dialect_cls`
|
|
)r) r( rI rI rJ Úget_async_dialect_clsû s z Dialect.get_async_dialect_clsc C s dS )aJ set up the provision.py module for this dialect.
|
|
For dialects that include a provision.py module that sets up
|
provisioning followers, this method should initiate that process.
|
|
A typical implementation would be::
|
|
@classmethod
|
def load_provisioning(cls):
|
__import__("mydialect.provision")
|
|
The default method assumes a module named ``provision.py`` inside
|
the owning package of the current dialect, based on the ``__module__``
|
attribute::
|
|
@classmethod
|
def load_provisioning(cls):
|
package = ".".join(cls.__module__.split(".")[0:-1])
|
try:
|
__import__(package + ".provision")
|
except ImportError:
|
pass
|
|
.. versionadded:: 1.3.14
|
|
NrI r¸ rI rI rJ Úload_provisioning
|
s zDialect.load_provisioningr' ©ÚenginerP c C s dS )a_ A convenience hook called before returning the final
|
:class:`_engine.Engine`.
|
|
If the dialect returned a different class from the
|
:meth:`.get_dialect_cls`
|
method, then the hook is called on both classes, first on
|
the dialect class returned by the :meth:`.get_dialect_cls` method and
|
then on the class on which the method was called.
|
|
The hook should be used by dialects and/or wrappers to apply special
|
events to the engine or its components. In particular, it allows
|
a dialect-wrapping class to apply dialect-level events.
|
|
NrI )r¹ r- rI rI rJ Úengine_created+
|
s zDialect.engine_createdc C s
|
t dS )aÎ Returns the connection object as returned by the external driver
|
package.
|
|
For normal dialects that use a DBAPI compliant driver this call
|
will just return the ``connection`` passed as argument.
|
For dialects that instead adapt a non DBAPI compliant driver, like
|
when adapting an asyncio driver, this call will return the
|
connection-like object as returned by the driver.
|
|
.. versionadded:: 1.4.24
|
|
Nr¦ r¾ rI rI rJ Úget_driver_connection<
|
s z Dialect.get_driver_connectionÚCoreExecuteOptionsParameter)r- ÚoptsrP c C s
|
t dS )aa Establish execution options for a given engine.
|
|
This is implemented by :class:`.DefaultDialect` to establish
|
event hooks for new :class:`.Connection` instances created
|
by the given :class:`.Engine` which will then invoke the
|
:meth:`.Dialect.set_connection_execution_options` method for that
|
connection.
|
|
Nr¦ )rS r- r1 rI rI rJ Ú set_engine_execution_optionsK
|
s z$Dialect.set_engine_execution_options)r½ r1 rP c C s
|
t dS )a Establish execution options for a given connection.
|
|
This is implemented by :class:`.DefaultDialect` in order to implement
|
the :paramref:`_engine.Connection.execution_options.isolation_level`
|
execution option. Dialects can intercept various execution options
|
which may need to modify state on a particular DBAPI connection.
|
|
.. versionadded:: 1.4
|
|
Nr¦ )rS r½ r1 rI rI rJ Ú set_connection_execution_optionsY
|
s z(Dialect.set_connection_execution_optionsú
|
Type[Pool]c C s
|
t dS )z*return a Pool class to use for a given URLNr¦ r¶ rI rI rJ Úget_dialect_pool_classh
|
s z Dialect.get_dialect_pool_class)N)NN)N)NN)N)NN)N)N)N)N)N)N)N)N)NN)N)NN)N)NN)N)NN)N)NN)N)N)N)TF)TF)N)N)N)grA rB rC rL r> rD rE rF rG rH rZ r Znon_memoized_propertyr¨ r¬ r r¯ Ú
|
EMPTY_DICTr° Z _has_eventsr± r¢ r£ Z bind_typingr² r· Ú classmethodrº 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ß 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 r r
|
r r r r r r r r r r r r! r$ r% r& r) r* r+ r. r/ r2 r3 r5 rI rI rI rJ r¤ s¬
|
|
|
|
þ
|
%
|
!ü ü ü ü ü ü ÿ ÿÿÿÿÿ üü ü ü ü ü ü ü ü ü ü
|
ü.û ü
|
|
|
û û
|
$û"û"ü "=5"#, r¤ c @ sd e Zd ZdZdddddZddddd Zd
|
dd d d dZddd dddZdd dddZdS )ÚCreateEnginePlugina A set of hooks intended to augment the construction of an
|
:class:`_engine.Engine` object based on entrypoint names in a URL.
|
|
The purpose of :class:`_engine.CreateEnginePlugin` is to allow third-party
|
systems to apply engine, pool and dialect level event listeners without
|
the need for the target application to be modified; instead, the plugin
|
names can be added to the database URL. Target applications for
|
:class:`_engine.CreateEnginePlugin` include:
|
|
* connection and SQL performance tools, e.g. which use events to track
|
number of checkouts and/or time spent with statements
|
|
* connectivity plugins such as proxies
|
|
A rudimentary :class:`_engine.CreateEnginePlugin` that attaches a logger
|
to an :class:`_engine.Engine` object might look like::
|
|
|
import logging
|
|
from sqlalchemy.engine import CreateEnginePlugin
|
from sqlalchemy import event
|
|
class LogCursorEventsPlugin(CreateEnginePlugin):
|
def __init__(self, url, kwargs):
|
# consume the parameter "log_cursor_logging_name" from the
|
# URL query
|
logging_name = url.query.get("log_cursor_logging_name", "log_cursor")
|
|
self.log = logging.getLogger(logging_name)
|
|
def update_url(self, url):
|
"update the URL to one that no longer includes our parameters"
|
return url.difference_update_query(["log_cursor_logging_name"])
|
|
def engine_created(self, engine):
|
"attach an event listener after the new Engine is constructed"
|
event.listen(engine, "before_cursor_execute", self._log_event)
|
|
|
def _log_event(
|
self,
|
conn,
|
cursor,
|
statement,
|
parameters,
|
context,
|
executemany):
|
|
self.log.info("Plugin logged cursor event: %s", statement)
|
|
|
|
Plugins are registered using entry points in a similar way as that
|
of dialects::
|
|
entry_points={
|
'sqlalchemy.plugins': [
|
'log_cursor_plugin = myapp.plugins:LogCursorEventsPlugin'
|
]
|
|
A plugin that uses the above names would be invoked from a database
|
URL as in::
|
|
from sqlalchemy import create_engine
|
|
engine = create_engine(
|
"mysql+pymysql://scott:tiger@localhost/test?"
|
"plugin=log_cursor_plugin&log_cursor_logging_name=mylogger"
|
)
|
|
The ``plugin`` URL parameter supports multiple instances, so that a URL
|
may specify multiple plugins; they are loaded in the order stated
|
in the URL::
|
|
engine = create_engine(
|
"mysql+pymysql://scott:tiger@localhost/test?"
|
"plugin=plugin_one&plugin=plugin_twp&plugin=plugin_three")
|
|
The plugin names may also be passed directly to :func:`_sa.create_engine`
|
using the :paramref:`_sa.create_engine.plugins` argument::
|
|
engine = create_engine(
|
"mysql+pymysql://scott:tiger@localhost/test",
|
plugins=["myplugin"])
|
|
.. versionadded:: 1.2.3 plugin names can also be specified
|
to :func:`_sa.create_engine` as a list
|
|
A plugin may consume plugin-specific arguments from the
|
:class:`_engine.URL` object as well as the ``kwargs`` dictionary, which is
|
the dictionary of arguments passed to the :func:`_sa.create_engine`
|
call. "Consuming" these arguments includes that they must be removed
|
when the plugin initializes, so that the arguments are not passed along
|
to the :class:`_engine.Dialect` constructor, where they will raise an
|
:class:`_exc.ArgumentError` because they are not known by the dialect.
|
|
As of version 1.4 of SQLAlchemy, arguments should continue to be consumed
|
from the ``kwargs`` dictionary directly, by removing the values with a
|
method such as ``dict.pop``. Arguments from the :class:`_engine.URL` object
|
should be consumed by implementing the
|
:meth:`_engine.CreateEnginePlugin.update_url` method, returning a new copy
|
of the :class:`_engine.URL` with plugin-specific parameters removed::
|
|
class MyPlugin(CreateEnginePlugin):
|
def __init__(self, url, kwargs):
|
self.my_argument_one = url.query['my_argument_one']
|
self.my_argument_two = url.query['my_argument_two']
|
self.my_argument_three = kwargs.pop('my_argument_three', None)
|
|
def update_url(self, url):
|
return url.difference_update_query(
|
["my_argument_one", "my_argument_two"]
|
)
|
|
Arguments like those illustrated above would be consumed from a
|
:func:`_sa.create_engine` call such as::
|
|
from sqlalchemy import create_engine
|
|
engine = create_engine(
|
"mysql+pymysql://scott:tiger@localhost/test?"
|
"plugin=myplugin&my_argument_one=foo&my_argument_two=bar",
|
my_argument_three='bat'
|
)
|
|
.. versionchanged:: 1.4
|
|
The :class:`_engine.URL` object is now immutable; a
|
:class:`_engine.CreateEnginePlugin` that needs to alter the
|
:class:`_engine.URL` should implement the newly added
|
:meth:`_engine.CreateEnginePlugin.update_url` method, which
|
is invoked after the plugin is constructed.
|
|
For migration, construct the plugin in the following way, checking
|
for the existence of the :meth:`_engine.CreateEnginePlugin.update_url`
|
method to detect which version is running::
|
|
class MyPlugin(CreateEnginePlugin):
|
def __init__(self, url, kwargs):
|
if hasattr(CreateEnginePlugin, "update_url"):
|
# detect the 1.4 API
|
self.my_argument_one = url.query['my_argument_one']
|
self.my_argument_two = url.query['my_argument_two']
|
else:
|
# detect the 1.3 and earlier API - mutate the
|
# URL directly
|
self.my_argument_one = url.query.pop('my_argument_one')
|
self.my_argument_two = url.query.pop('my_argument_two')
|
|
self.my_argument_three = kwargs.pop('my_argument_three', None)
|
|
def update_url(self, url):
|
# this method is only called in the 1.4 version
|
return url.difference_update_query(
|
["my_argument_one", "my_argument_two"]
|
)
|
|
.. seealso::
|
|
:ref:`change_5526` - overview of the :class:`_engine.URL` change which
|
also includes notes regarding :class:`_engine.CreateEnginePlugin`.
|
|
|
When the engine creation process completes and produces the
|
:class:`_engine.Engine` object, it is again passed to the plugin via the
|
:meth:`_engine.CreateEnginePlugin.engine_created` hook. In this hook, additional
|
changes can be made to the engine, most typically involving setup of
|
events (e.g. those defined in :ref:`core_event_toplevel`).
|
|
r) rÞ )rµ Úkwargsc C s
|
|| _ dS )aù Construct a new :class:`.CreateEnginePlugin`.
|
|
The plugin object is instantiated individually for each call
|
to :func:`_sa.create_engine`. A single :class:`_engine.
|
Engine` will be
|
passed to the :meth:`.CreateEnginePlugin.engine_created` method
|
corresponding to this URL.
|
|
:param url: the :class:`_engine.URL` object. The plugin may inspect
|
the :class:`_engine.URL` for arguments. Arguments used by the
|
plugin should be removed, by returning an updated :class:`_engine.URL`
|
from the :meth:`_engine.CreateEnginePlugin.update_url` method.
|
|
.. versionchanged:: 1.4
|
|
The :class:`_engine.URL` object is now immutable, so a
|
:class:`_engine.CreateEnginePlugin` that needs to alter the
|
:class:`_engine.URL` object should implement the
|
:meth:`_engine.CreateEnginePlugin.update_url` method.
|
|
:param kwargs: The keyword arguments passed to
|
:func:`_sa.create_engine`.
|
|
N)rµ )rS rµ r9 rI rI rJ Ú__init__ s zCreateEnginePlugin.__init__r´ c C s
|
t dS )a Update the :class:`_engine.URL`.
|
|
A new :class:`_engine.URL` should be returned. This method is
|
typically used to consume configuration arguments from the
|
:class:`_engine.URL` which must be removed, as they will not be
|
recognized by the dialect. The
|
:meth:`_engine.URL.difference_update_query` method is available
|
to remove these arguments. See the docstring at
|
:class:`_engine.CreateEnginePlugin` for an example.
|
|
|
.. versionadded:: 1.4
|
|
Nr¦ r¶ rI rI rJ Ú
|
update_url5 s z CreateEnginePlugin.update_urlr' rN )Ú dialect_clsÚ dialect_argsrP c C s dS )z parse and modify dialect kwargsNrI )rS r< r= rI rI rJ Úhandle_dialect_kwargsF s z(CreateEnginePlugin.handle_dialect_kwargsr4 )Úpool_clsÚ pool_argsrP c C s dS )z parse and modify pool kwargsNrI )rS r? r@ rI rI rJ Úhandle_pool_kwargsK s z%CreateEnginePlugin.handle_pool_kwargsr' r, c C s dS )z×Receive the :class:`_engine.Engine`
|
object when it is fully constructed.
|
|
The plugin may make additional changes to the engine, such as
|
registering engine or connection pool events.
|
|
NrI )rS r- rI rI rJ r. P s z!CreateEnginePlugin.engine_createdN) rA rB rC rL r: r; r> rA r. rI rI rI rJ r8 m
|
s -r8 c @ sÖ e Zd ZU dZded< ded< ded< ded< d ed
|
< d ed < d ed< ded< ded< ded< ded< ded< ded< ded< ded< ded < eddd d d d d d!d"Zeejfddd d d#d$d%d&d'd d(
|
d)d*Z eddd d d d+d d,d-d.Z
|
eddd d d d/d0d1Z d2d3d4d5d6d7d8Z d9d:d;d<Z d d:d=d>Zd?d:d@dAZdBdCdDdEdFdGZd d:dHdIZdJd:dKdLZdMdNdOdPdQZdJd:dRdSZdTdJdUdVdWZdd:dXdYZdZd:d[d\Zd dNd]d^d_Zd`S )arù zRA messenger object for a Dialect that corresponds to a single
|
execution.
|
|
r' r- r& r½ Zroot_connectionr¤ ÚdialectrV rW zOptional[Compiled]Úcompiledro r zOptional[Executable]Úinvoked_statementÚ_AnyMultiExecuteParamsrb rY r| ZisinsertZisupdaterK Z execute_stylere z;util.generic_fn_descriptor[Optional[Sequence[Column[Any]]]]Z prefetch_colsZpostfetch_colsr Ú_ExecuteOptionsr/ )rB r½ rï Úexecution_optionsÚ compiled_ddlrP c C s
|
t d S rQ r¦ )r¹ rB r½ rï rG rH rI rI rJ Ú _init_ddl³ s zExecutionContext._init_ddlr3 Ú_CoreMultiExecuteParamsr- z&Optional[Sequence[BindParameter[Any]]]r> )
|
rB r½ rï rG rC rb rD Úextracted_parametersÚ cache_hitrP c
|
|
C s
|
t d S rQ r¦ )
|
r¹ rB r½ rï rG rC rb rD rK rL rI rI rJ Ú_init_compiled¾ s z ExecutionContext._init_compiledr )rB r½ rï rG r rb rP c C s
|
t d S rQ r¦ )r¹ rB r½ rï rG r rb rI rI rJ Ú_init_statementÍ s
|
z ExecutionContext._init_statement)rB r½ rï rG rP c C s
|
t d S rQ r¦ )r¹ rB r½ rï rG rI rI rJ Ú _init_defaultÙ s z ExecutionContext._init_defaultzOptional[Column[Any]]r7 zOptional[TypeEngine[Any]]r )rm r Útype_rP c C s
|
t d S rQ r¦ )rS rm r rP rI rI rJ Ú _exec_defaultã s z ExecutionContext._exec_defaultz0Optional[List[Tuple[str, Any, TypeEngine[Any]]]]rO c C s
|
t d S rQ r¦ rR rI rI rJ Ú_prepare_set_input_sizesë s z)ExecutionContext._prepare_set_input_sizesc C s
|
t d S rQ r¦ rR rI rI rJ Ú_get_cache_statsð s z!ExecutionContext._get_cache_statszCursorResult[Any]c C s
|
t d S rQ r¦ rR rI rI rJ Ú_setup_result_proxyó s z$ExecutionContext._setup_result_proxyÚSequence_SchemaItemr9 r^ )ÚseqrP rP c C s
|
t dS )zKgiven a :class:`.Sequence`, invoke it and return the next int
|
valueNr¦ )rS rV rP rI rI rJ Ú fire_sequenceö s z ExecutionContext.fire_sequencec C s
|
t dS )zõReturn a new cursor generated from this ExecutionContext's
|
connection.
|
|
Some dialects may wish to change the behavior of
|
connection.cursor(), such as postgresql which may return a PG
|
"server side" cursor.
|
Nr¦ rR rI rI rJ Ú create_cursorû s z ExecutionContext.create_cursorrN c C s
|
t dS )zõCalled before an execution of a compiled statement.
|
|
If a compiled statement was passed to this ExecutionContext,
|
the `statement` and `parameters` datamembers must be
|
initialized after this statement is complete.
|
Nr¦ rR rI rI rJ Úpre_exec s zExecutionContext.pre_execr® rg )Úout_param_namesrP c C s
|
t dS )a! Return a sequence of OUT parameter values from a cursor.
|
|
For dialects that support OUT parameters, this method will be called
|
when there is a :class:`.SQLCompiler` object which has the
|
:attr:`.SQLCompiler.has_out_parameters` flag set. This flag in turn
|
will be set to True if the statement itself has :class:`.BindParameter`
|
objects that have the ``.isoutparam`` flag set which are consumed by
|
the :meth:`.SQLCompiler.visit_bindparam` method. If the dialect
|
compiler produces :class:`.BindParameter` objects with ``.isoutparam``
|
set which are not handled by :meth:`.SQLCompiler.visit_bindparam`, it
|
should set this flag explicitly.
|
|
The list of names that were rendered for each bound parameter
|
is passed to the method. The method should then return a sequence of
|
values corresponding to the list of parameter objects. Unlike in
|
previous SQLAlchemy versions, the values can be the **raw values** from
|
the DBAPI; the execution context will apply the appropriate type
|
handler based on what's present in self.compiled.binds and update the
|
values. The processed dictionary will then be made available via the
|
``.out_parameters`` collection on the result object. Note that
|
SQLAlchemy 1.4 has multiple kinds of result object as part of the 2.0
|
transition.
|
|
.. versionadded:: 1.4 - added
|
:meth:`.ExecutionContext.get_out_parameter_values`, which is invoked
|
automatically by the :class:`.DefaultExecutionContext` when there
|
are :class:`.BindParameter` objects with the ``.isoutparam`` flag
|
set. This replaces the practice of setting out parameters within
|
the now-removed ``get_result_proxy()`` method.
|
|
Nr¦ )rS rZ rI rI rJ Úget_out_parameter_values s "z)ExecutionContext.get_out_parameter_valuesc C s
|
t dS )a Called after the execution of a compiled statement.
|
|
If a compiled statement was passed to this ExecutionContext,
|
the `last_insert_ids`, `last_inserted_params`, etc.
|
datamembers should be available after this method completes.
|
Nr¦ rR rI rI rJ Ú post_exec4 s zExecutionContext.post_execÚ BaseException)r rP c C s
|
t dS )zQReceive a DBAPI exception which occurred upon execute, result
|
fetch, etc.Nr¦ )rS r rI rI rJ Úhandle_dbapi_exception> s z'ExecutionContext.handle_dbapi_exceptionc C s
|
t dS )zjReturn True if the last INSERT or UPDATE row contained
|
inlined or database-side defaults.
|
Nr¦ rR rI rI rJ Úlastrow_has_defaultsD s z%ExecutionContext.lastrow_has_defaultsr c C s
|
t dS )z¬Return the DBAPI ``cursor.rowcount`` value, or in some
|
cases an interpreted value.
|
|
See :attr:`_engine.CursorResult.rowcount` for details on this.
|
|
Nr¦ rR rI rI rJ Ú get_rowcountK s z ExecutionContext.get_rowcount)rW rP c C s
|
t dS )a For a RETURNING result, deliver cursor.fetchall() from the
|
DBAPI cursor.
|
|
This is a dialect-specific hook for dialects that have special
|
considerations when calling upon the rows delivered for a
|
"RETURNING" statement. Default implementation is
|
``cursor.fetchall()``.
|
|
This hook is currently used only by the :term:`insertmanyvalues`
|
feature. Dialects that don't set ``use_insertmanyvalues=True``
|
don't need to consider this hook.
|
|
.. versionadded:: 2.0.10
|
|
Nr¦ )rS rW rI rI rJ Úfetchall_for_returningU s z'ExecutionContext.fetchall_for_returningN)rA rB rC rL rZ r7 rI r> rF rM rN rO rQ rR rS rT rW rX rY r[ r\ r^ r_ r` ra rI rI rI rJ rù Z sN
|
|
|
ö$
|
$
|
|
rù c @ s e Zd ZU dZded< dS )ÚConnectionEventsTargetzªAn object which can accept events from :class:`.ConnectionEvents`.
|
|
Includes :class:`_engine.Connection` and :class:`_engine.Engine`.
|
|
.. versionadded:: 2.0
|
|
z"dispatcher[ConnectionEventsTarget]r¥ Nr rI rI rI rJ rb h s
|
rb c @ s~ e Zd ZU dZdZded< ded< ded< d ed
|
< d ed < d ed< ded< ded< ded< ded< ded< ded< ded< dS ) ÚExceptionContexta Encapsulate information about an error condition in progress.
|
|
This object exists solely to be passed to the
|
:meth:`_events.DialectEvents.handle_error` event,
|
supporting an interface that
|
can be extended without backwards-incompatibility.
|
|
|
rI r¤ rB zOptional[Connection]r½ zOptional[Engine]r- r rW r r z Optional[_DBAPIAnyExecuteParams]rb r] Zoriginal_exceptionzOptional[StatementError]Zsqlalchemy_exceptionzOptional[BaseException]Zchained_exceptionr Zexecution_contextrY r Z invalidate_pool_on_disconnectZ is_pre_pingN)rA rB rC rL Ú __slots__rZ rI rI rI rJ rc w s
|
|
|
rc c @ sN e Zd ZU dZdZded< eddddZdd d
|
d d Zd dddZ dS )ÚAdaptedConnectionzùInterface of an adapted connection object to support the DBAPI protocol.
|
|
Used by asyncio dialects to provide a sync-style pep-249 facade on top
|
of the asyncio connection/cursor API provided by the driver.
|
|
.. versionadded:: 1.4.24
|
|
©Ú _connectionr rg rO c C s | j S )z@The connection object as returned by the driver after a connect.rf rR rI rI rJ Údriver_connection+ s z#AdaptedConnection.driver_connectionz Callable[[Any], Awaitable[_T]]r< )ÚfnrP c C s t || jS )a Run the awaitable returned by the given function, which is passed
|
the raw asyncio driver connection.
|
|
This is used to invoke awaitable-only methods on the driver connection
|
within the context of a "synchronous" method, like a connection
|
pool event handler.
|
|
E.g.::
|
|
engine = create_async_engine(...)
|
|
@event.listens_for(engine.sync_engine, "connect")
|
def register_custom_types(dbapi_connection, ...):
|
dbapi_connection.run_async(
|
lambda connection: connection.set_type_codec(
|
'MyCustomType', encoder, decoder, ...
|
)
|
)
|
|
.. versionadded:: 1.4.30
|
|
.. seealso::
|
|
:ref:`asyncio_events_run_async`
|
|
)r rg )rS ri rI rI rJ Ú run_async0 s zAdaptedConnection.run_asyncro c C s
|
d| j S )Nz<AdaptedConnection %s>rf rR rI rI rJ Ú__repr__M s zAdaptedConnection.__repr__N)
|
rA rB rC rL rd rZ ru rh rj rk rI rI rI rJ re s
|
re N)rL Ú
|
__future__r Úenumr Útypesr Útypingr r r r r r
|
r r r r r r r r r r r r r Ú r Úeventr Úpoolr r Z sql.compilerr r r Zutil.concurrencyr Z util.typingr! r" r# r$ Úbaser& r' rW r( rµ r) r* r+ Úexcr, Zsqlr- r. r/ r0 r1 r2 r3 Z sql.elementsr4 r5 Z
|
sql.schemar6 r7 r8 rU Z sql.sqltypesr9 Z sql.type_apir: r; ro r³ r< r> rK rM r[ rV Z_CoreSingleExecuteParamsZ _MutableCoreSingleExecuteParamsrJ Z_CoreAnyExecuteParamsZ_DBAPISingleExecuteParamsr Z_DBAPIAnyExecuteParamsr^ rY r\ Z_AnySingleExecuteParamsrE Z_AnyExecuteParamsZCompiledCacheTypeZSchemaTranslateMapTypeZ_ImmutableExecuteOptionsZ _ParamStylerø r{ rz rF r0 r r r r r r r r r r r¢ ZVersionInfoTypeZTableKeyr¤ r8 rù rb Z Connectablerc re rI rI rI rJ Ú<module> s* M ÿÿÿúÿÿ ÿÿ ÿ.:4 < | n '
|
