Participer au site avec un Tip
Rechercher
 

Bug Suggérer des Améliorations / Corrections

Links Mon profile Linkedin Notre chaîne YouTube Notre discord

Améliorations / Corrections

Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.

Emplacement :

Description des améliorations :

Vous êtes un professionnel et vous avez besoin d'une formation ? Programmation Python
Les fondamentaux Voir le programme détaillé
Module « sqlalchemy »

Classe « Dialect »

Informations générales

Héritage

builtins.object
    EventTarget
        Dialect

Définition

class Dialect(EventTarget):

help(Dialect)

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.

Constructeur(s)

Signature du constructeur Description
__init__(self, /, *args, **kwargs) Initialize self. See help(type(self)) for accurate signature. [extrait de __init__.__doc__]

Liste des attributs statiques

Nom de l'attribut Valeur
bind_typingBindTyping.NONE
CACHE_HITCacheStats.CACHE_HIT
CACHE_MISSCacheStats.CACHE_MISS
CACHING_DISABLEDCacheStats.CACHING_DISABLED
construct_argumentsNone
dbapi_exception_translation_mapimmutabledict({})
default_metavalue_tokenDEFAULT
dispatch<sqlalchemy.event.base.DialectEventsDispatch object at 0x0000020DA0CA7AD0>
loaded_dbapi<sqlalchemy.util.langhelpers._non_memoized_property object at 0x0000020DA0BDE030>
NO_CACHE_KEYCacheStats.NO_CACHE_KEY
NO_DIALECT_SUPPORTCacheStats.NO_DIALECT_SUPPORT
reflection_options()
supports_statement_cacheTrue

Liste des opérateurs

Opérateurs hérités de la classe object

__eq__, __ge__, __gt__, __le__, __lt__, __ne__

Liste des méthodes

Toutes les méthodes Méthodes d'instance Méthodes statiques Méthodes dépréciées
Signature de la méthodeDescription
connect(self, *cargs: 'Any', **cparams: 'Any') -> 'DBAPIConnection' Establish a connection using this dialect's DBAPI. [extrait de connect.__doc__]
create_connect_args(self, url: 'URL') -> 'ConnectArgsType' Build DB-API compatible connection arguments. [extrait de create_connect_args.__doc__]
create_xid(self) -> 'Any' Create a two-phase transaction ID. [extrait de create_xid.__doc__]
denormalize_name(self, name: 'str') -> 'str' convert the given name to a case insensitive identifier [extrait de denormalize_name.__doc__]
do_begin(self, dbapi_connection: 'PoolProxiedConnection') -> 'None' Provide an implementation of ``connection.begin()``, given a [extrait de do_begin.__doc__]
do_begin_twophase(self, connection: 'Connection', xid: 'Any') -> 'None' Begin a two phase transaction on the given connection. [extrait de do_begin_twophase.__doc__]
do_close(self, dbapi_connection: 'DBAPIConnection') -> 'None' Provide an implementation of ``connection.close()``, given a DBAPI [extrait de do_close.__doc__]
do_commit(self, dbapi_connection: 'PoolProxiedConnection') -> 'None' Provide an implementation of ``connection.commit()``, given a [extrait de do_commit.__doc__]
do_commit_twophase(self, connection: 'Connection', xid: 'Any', is_prepared: 'bool' = True, recover: 'bool' = False) -> 'None' Commit a two phase transaction on the given connection. [extrait de do_commit_twophase.__doc__]
do_execute(self, cursor: 'DBAPICursor', statement: 'str', parameters: 'Optional[_DBAPISingleExecuteParams]', context: 'Optional[ExecutionContext]' = None) -> 'None' Provide an implementation of ``cursor.execute(statement, [extrait de do_execute.__doc__]
do_execute_no_params(self, cursor: 'DBAPICursor', statement: 'str', context: 'Optional[ExecutionContext]' = None) -> 'None' Provide an implementation of ``cursor.execute(statement)``. [extrait de do_execute_no_params.__doc__]
do_executemany(self, cursor: 'DBAPICursor', statement: 'str', parameters: '_DBAPIMultiExecuteParams', context: 'Optional[ExecutionContext]' = None) -> 'None' Provide an implementation of ``cursor.executemany(statement, [extrait de do_executemany.__doc__]
do_ping(self, dbapi_connection: 'DBAPIConnection') -> 'bool' ping the DBAPI connection and return True if the connection is [extrait de do_ping.__doc__]
do_prepare_twophase(self, connection: 'Connection', xid: 'Any') -> 'None' Prepare a two phase transaction on the given connection. [extrait de do_prepare_twophase.__doc__]
do_recover_twophase(self, connection: 'Connection') -> 'List[Any]' Recover list of uncommitted prepared two phase transaction [extrait de do_recover_twophase.__doc__]
do_release_savepoint(self, connection: 'Connection', name: 'str') -> 'None' Release the named savepoint on a connection. [extrait de do_release_savepoint.__doc__]
do_rollback(self, dbapi_connection: 'PoolProxiedConnection') -> 'None' Provide an implementation of ``connection.rollback()``, given [extrait de do_rollback.__doc__]
do_rollback_to_savepoint(self, connection: 'Connection', name: 'str') -> 'None' Rollback a connection to the named savepoint. [extrait de do_rollback_to_savepoint.__doc__]
do_rollback_twophase(self, connection: 'Connection', xid: 'Any', is_prepared: 'bool' = True, recover: 'bool' = False) -> 'None' Rollback a two phase transaction on the given connection. [extrait de do_rollback_twophase.__doc__]
do_savepoint(self, connection: 'Connection', name: 'str') -> 'None' Create a savepoint with the given name. [extrait de do_savepoint.__doc__]
do_set_input_sizes(self, cursor: 'DBAPICursor', list_of_tuples: '_GenericSetInputSizesType', context: 'ExecutionContext') -> 'Any' invoke the cursor.setinputsizes() method with appropriate arguments [extrait de do_set_input_sizes.__doc__]
do_terminate(self, dbapi_connection: 'DBAPIConnection') -> 'None' Provide an implementation of ``connection.close()`` that tries as [extrait de do_terminate.__doc__]
engine_created(engine: 'Engine') -> 'None' A convenience hook called before returning the final [extrait de engine_created.__doc__]
get_async_dialect_cls(url: 'URL') -> 'Type[Dialect]' Given a URL, return the :class:`.Dialect` that will be used by [extrait de get_async_dialect_cls.__doc__]
get_check_constraints(self, connection: 'Connection', table_name: 'str', schema: 'Optional[str]' = None, **kw: 'Any') -> 'List[ReflectedCheckConstraint]' Return information about check constraints in ``table_name``. [extrait de get_check_constraints.__doc__]
get_columns(self, connection: 'Connection', table_name: 'str', schema: 'Optional[str]' = None, **kw: 'Any') -> 'List[ReflectedColumn]' Return information about columns in ``table_name``. [extrait de get_columns.__doc__]
get_default_isolation_level(self, dbapi_conn: 'DBAPIConnection') -> 'IsolationLevel' Given a DBAPI connection, return its isolation level, or [extrait de get_default_isolation_level.__doc__]
get_dialect_cls(url: 'URL') -> 'Type[Dialect]' Given a URL, return the :class:`.Dialect` that will be used. [extrait de get_dialect_cls.__doc__]
get_dialect_pool_class(self, url: 'URL') -> 'Type[Pool]' return a Pool class to use for a given URL [extrait de get_dialect_pool_class.__doc__]
get_driver_connection(self, connection: 'DBAPIConnection') -> 'Any' Returns the connection object as returned by the external driver [extrait de get_driver_connection.__doc__]
get_foreign_keys(self, connection: 'Connection', table_name: 'str', schema: 'Optional[str]' = None, **kw: 'Any') -> 'List[ReflectedForeignKeyConstraint]' Return information about foreign_keys in ``table_name``. [extrait de get_foreign_keys.__doc__]
get_indexes(self, connection: 'Connection', table_name: 'str', schema: 'Optional[str]' = None, **kw: 'Any') -> 'List[ReflectedIndex]' Return information about indexes in ``table_name``. [extrait de get_indexes.__doc__]
get_isolation_level(self, dbapi_connection: 'DBAPIConnection') -> 'IsolationLevel' Given a DBAPI connection, return its isolation level. [extrait de get_isolation_level.__doc__]
get_isolation_level_values(self, dbapi_conn: 'DBAPIConnection') -> 'List[IsolationLevel]' return a sequence of string isolation level names that are accepted [extrait de get_isolation_level_values.__doc__]
get_materialized_view_names(self, connection: 'Connection', schema: 'Optional[str]' = None, **kw: 'Any') -> 'List[str]' Return a list of all materialized view names available in the [extrait de get_materialized_view_names.__doc__]
get_multi_check_constraints(self, connection: 'Connection', *, schema: 'Optional[str]' = None, filter_names: 'Optional[Collection[str]]' = None, **kw: 'Any') -> 'Iterable[Tuple[TableKey, List[ReflectedCheckConstraint]]]' Return information about check constraints in all tables [extrait de get_multi_check_constraints.__doc__]
get_multi_columns(self, connection: 'Connection', *, schema: 'Optional[str]' = None, filter_names: 'Optional[Collection[str]]' = None, **kw: 'Any') -> 'Iterable[Tuple[TableKey, List[ReflectedColumn]]]' Return information about columns in all tables in the [extrait de get_multi_columns.__doc__]
get_multi_foreign_keys(self, connection: 'Connection', *, schema: 'Optional[str]' = None, filter_names: 'Optional[Collection[str]]' = None, **kw: 'Any') -> 'Iterable[Tuple[TableKey, List[ReflectedForeignKeyConstraint]]]' Return information about foreign_keys in all tables [extrait de get_multi_foreign_keys.__doc__]
get_multi_indexes(self, connection: 'Connection', *, schema: 'Optional[str]' = None, filter_names: 'Optional[Collection[str]]' = None, **kw: 'Any') -> 'Iterable[Tuple[TableKey, List[ReflectedIndex]]]' Return information about indexes in in all tables [extrait de get_multi_indexes.__doc__]
get_multi_pk_constraint(self, connection: 'Connection', *, schema: 'Optional[str]' = None, filter_names: 'Optional[Collection[str]]' = None, **kw: 'Any') -> 'Iterable[Tuple[TableKey, ReflectedPrimaryKeyConstraint]]' Return information about primary key constraints in [extrait de get_multi_pk_constraint.__doc__]
get_multi_table_comment(self, connection: 'Connection', *, schema: 'Optional[str]' = None, filter_names: 'Optional[Collection[str]]' = None, **kw: 'Any') -> 'Iterable[Tuple[TableKey, ReflectedTableComment]]' Return information about the table comment in all tables [extrait de get_multi_table_comment.__doc__]
get_multi_table_options(self, connection: 'Connection', *, schema: 'Optional[str]' = None, filter_names: 'Optional[Collection[str]]' = None, **kw: 'Any') -> 'Iterable[Tuple[TableKey, Dict[str, Any]]]' Return a dictionary of options specified when the tables in the [extrait de get_multi_table_options.__doc__]
get_multi_unique_constraints(self, connection: 'Connection', *, schema: 'Optional[str]' = None, filter_names: 'Optional[Collection[str]]' = None, **kw: 'Any') -> 'Iterable[Tuple[TableKey, List[ReflectedUniqueConstraint]]]' Return information about unique constraints in all tables [extrait de get_multi_unique_constraints.__doc__]
get_pk_constraint(self, connection: 'Connection', table_name: 'str', schema: 'Optional[str]' = None, **kw: 'Any') -> 'ReflectedPrimaryKeyConstraint' Return information about the primary key constraint on [extrait de get_pk_constraint.__doc__]
get_schema_names(self, connection: 'Connection', **kw: 'Any') -> 'List[str]' Return a list of all schema names available in the database. [extrait de get_schema_names.__doc__]
get_sequence_names(self, connection: 'Connection', schema: 'Optional[str]' = None, **kw: 'Any') -> 'List[str]' Return a list of all sequence names available in the database. [extrait de get_sequence_names.__doc__]
get_table_comment(self, connection: 'Connection', table_name: 'str', schema: 'Optional[str]' = None, **kw: 'Any') -> 'ReflectedTableComment' Return the "comment" for the table identified by ``table_name``. [extrait de get_table_comment.__doc__]
get_table_names(self, connection: 'Connection', schema: 'Optional[str]' = None, **kw: 'Any') -> 'List[str]' Return a list of table names for ``schema``. [extrait de get_table_names.__doc__]
get_table_options(self, connection: 'Connection', table_name: 'str', schema: 'Optional[str]' = None, **kw: 'Any') -> 'Dict[str, Any]' Return a dictionary of options specified when ``table_name`` [extrait de get_table_options.__doc__]
get_temp_table_names(self, connection: 'Connection', schema: 'Optional[str]' = None, **kw: 'Any') -> 'List[str]' Return a list of temporary table names on the given connection, [extrait de get_temp_table_names.__doc__]
get_temp_view_names(self, connection: 'Connection', schema: 'Optional[str]' = None, **kw: 'Any') -> 'List[str]' Return a list of temporary view names on the given connection, [extrait de get_temp_view_names.__doc__]
get_unique_constraints(self, connection: 'Connection', table_name: 'str', schema: 'Optional[str]' = None, **kw: 'Any') -> 'List[ReflectedUniqueConstraint]' Return information about unique constraints in ``table_name``. [extrait de get_unique_constraints.__doc__]
get_view_definition(self, connection: 'Connection', view_name: 'str', schema: 'Optional[str]' = None, **kw: 'Any') -> 'str' Return plain or materialized view definition. [extrait de get_view_definition.__doc__]
get_view_names(self, connection: 'Connection', schema: 'Optional[str]' = None, **kw: 'Any') -> 'List[str]' Return a list of all non-materialized view names available in the [extrait de get_view_names.__doc__]
has_index(self, connection: 'Connection', table_name: 'str', index_name: 'str', schema: 'Optional[str]' = None, **kw: 'Any') -> 'bool' Check the existence of a particular index name in the database. [extrait de has_index.__doc__]
has_schema(self, connection: 'Connection', schema_name: 'str', **kw: 'Any') -> 'bool' Check the existence of a particular schema name in the database. [extrait de has_schema.__doc__]
has_sequence(self, connection: 'Connection', sequence_name: 'str', schema: 'Optional[str]' = None, **kw: 'Any') -> 'bool' Check the existence of a particular sequence in the database. [extrait de has_sequence.__doc__]
has_table(self, connection: 'Connection', table_name: 'str', schema: 'Optional[str]' = None, **kw: 'Any') -> 'bool' For internal dialect use, check the existence of a particular table [extrait de has_table.__doc__]
import_dbapi() -> 'ModuleType' Import the DBAPI module that is used by this dialect. [extrait de import_dbapi.__doc__]
initialize(self, connection: 'Connection') -> 'None' Called during strategized creation of the dialect with a [extrait de initialize.__doc__]
is_disconnect(self, e: 'Exception', connection: 'Optional[Union[PoolProxiedConnection, DBAPIConnection]]', cursor: 'Optional[DBAPICursor]') -> 'bool' Return True if the given DB-API error indicates an invalid [extrait de is_disconnect.__doc__]
load_provisioning() -> 'None' set up the provision.py module for this dialect. [extrait de load_provisioning.__doc__]
normalize_name(self, name: 'str') -> 'str' convert the given name to lowercase if it is detected as [extrait de normalize_name.__doc__]
on_connect(self) -> 'Optional[Callable[[Any], Any]]' return a callable which sets up a newly created DBAPI connection. [extrait de on_connect.__doc__]
on_connect_url(self, url: 'URL') -> 'Optional[Callable[[Any], Any]]' return a callable which sets up a newly created DBAPI connection. [extrait de on_connect_url.__doc__]
reset_isolation_level(self, dbapi_connection: 'DBAPIConnection') -> 'None' Given a DBAPI connection, revert its isolation to the default. [extrait de reset_isolation_level.__doc__]
set_connection_execution_options(self, connection: 'Connection', opts: 'CoreExecuteOptionsParameter') -> 'None' Establish execution options for a given connection. [extrait de set_connection_execution_options.__doc__]
set_engine_execution_options(self, engine: 'Engine', opts: 'CoreExecuteOptionsParameter') -> 'None' Establish execution options for a given engine. [extrait de set_engine_execution_options.__doc__]
set_isolation_level(self, dbapi_connection: 'DBAPIConnection', level: 'IsolationLevel') -> 'None' Given a DBAPI connection, set its isolation level. [extrait de set_isolation_level.__doc__]
type_descriptor(self, typeobj: 'TypeEngine[_T]') -> 'TypeEngine[_T]' Transform a generic type to a dialect-specific type. [extrait de type_descriptor.__doc__]

Méthodes héritées de la classe EventTarget

__init_subclass__, __subclasshook__

Méthodes héritées de la classe object

__delattr__, __dir__, __format__, __getattribute__, __getstate__, __hash__, __reduce__, __reduce_ex__, __repr__, __setattr__, __sizeof__, __str__

Vous êtes un professionnel et vous avez besoin d'une formation ? RAG (Retrieval-Augmented Generation)
et Fine Tuning d'un LLM Voir le programme détaillé



Le tutoriel Python complet (Text+Vidéos)
Le tutoriel Python en vidéos
Evaluez vos compétences en Python