Classe « URL »

Informations générales

Héritage

builtins.object
    builtins.tuple
        URL

Définition

class URL(builtins.tuple):

help(URL)

Represent the components of a URL used to connect to a database.

URLs are typically constructed from a fully formatted URL string, where the
:func:`.make_url` function is used internally by the
:func:`_sa.create_engine` function in order to parse the URL string into
its individual components, which are then used to construct a new
:class:`.URL` object. When parsing from a formatted URL string, the parsing
format generally follows
`RFC-1738 <https://www.ietf.org/rfc/rfc1738.txt>`_, with some exceptions.

A :class:`_engine.URL` object may also be produced directly, either by
using the :func:`.make_url` function with a fully formed URL string, or
by using the :meth:`_engine.URL.create` constructor in order
to construct a :class:`_engine.URL` programmatically given individual
fields. The resulting :class:`.URL` object may be passed directly to
:func:`_sa.create_engine` in place of a string argument, which will bypass
the usage of :func:`.make_url` within the engine's creation process.

.. versionchanged:: 1.4

    The :class:`_engine.URL` object is now an immutable object.  To
    create a URL, use the :func:`_engine.make_url` or
    :meth:`_engine.URL.create` function / method.  To modify
    a :class:`_engine.URL`, use methods like
    :meth:`_engine.URL.set` and
    :meth:`_engine.URL.update_query_dict` to return a new
    :class:`_engine.URL` object with modifications.   See notes for this
    change at :ref:`change_5526`.

.. seealso::

    :ref:`database_urls`

:class:`_engine.URL` contains the following attributes:

* :attr:`_engine.URL.drivername`: database backend and driver name, such as
  ``postgresql+psycopg2``
* :attr:`_engine.URL.username`: username string
* :attr:`_engine.URL.password`: password string
* :attr:`_engine.URL.host`: string hostname
* :attr:`_engine.URL.port`: integer port number
* :attr:`_engine.URL.database`: string database name
* :attr:`_engine.URL.query`: an immutable mapping representing the query
  string.  contains strings for keys and either strings or tuples of
  strings for values.

Constructeur(s)

Signature du constructeur	Description
__new__(_cls, drivername: ForwardRef('str'), username: ForwardRef('Optional[str]'), password: ForwardRef('Optional[str]'), host: ForwardRef('Optional[str]'), port: ForwardRef('Optional[int]'), database: ForwardRef('Optional[str]'), query: ForwardRef('util.immutabledict[str, Union[Tuple[str, ...], str]]'))	Create new instance of URL(drivername, username, password, host, port, database, query) _{[extrait de __new__.__doc__]}
__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
database	_tuplegetter(5, 'Alias for field number 5')
drivername	_tuplegetter(0, 'Alias for field number 0')
host	_tuplegetter(3, 'Alias for field number 3')
password	_tuplegetter(2, 'Alias for field number 2')
port	_tuplegetter(4, 'Alias for field number 4')
query	_tuplegetter(6, 'Alias for field number 6')
username	_tuplegetter(1, 'Alias for field number 1')

Liste des propriétés

Nom de la propriété	Description
normalized_query	Return the :attr:`_engine.URL.query` dictionary with values normalized _{[extrait de normalized_query.__doc__]}

Liste des opérateurs

Signature de l'opérateur	Description
__eq__(self, other: 'Any') -> 'bool'
__ne__(self, other: 'Any') -> 'bool'

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

__add__, __contains__, __ge__, __getitem__, __gt__, __le__, __lt__, __mul__, __rmul__

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

__ge__, __gt__, __le__, __lt__

Liste des méthodes

Toutes les méthodes Méthodes d'instance Méthodes statiques

Signature de la méthode	Description
__class_getitem__(object)	See PEP 585 _{[extrait de __class_getitem__.__doc__]}
__copy__(self) -> 'URL'
__deepcopy__(self, memo: 'Any') -> 'URL'
__getnewargs__(self)	Return self as a plain tuple. Used by copy and pickle. _{[extrait de __getnewargs__.__doc__]}
__hash__(self) -> 'int'
__replace__(self, /, **kwds)	Return a new URL object replacing specified fields with new values _{[extrait de _replace.__doc__]}
__repr__(self) -> 'str'
__to_string__(self, hide_password: 'bool' = True) -> 'str'	Render this :class:`_engine.URL` object as a string. _{[extrait de __to_string__.__doc__]}
create(drivername: 'str', username: 'Optional[str]' = None, password: 'Optional[str]' = None, host: 'Optional[str]' = None, port: 'Optional[int]' = None, database: 'Optional[str]' = None, query: 'Mapping[str, Union[Sequence[str], str]]' = immutabledict({})) -> 'URL'	Create a new :class:`_engine.URL` object. _{[extrait de create.__doc__]}
difference_update_query(self, names: 'Iterable[str]') -> 'URL'
get_backend_name(self) -> 'str'	Return the backend name. _{[extrait de get_backend_name.__doc__]}
get_dialect(self, _is_async: 'bool' = False) -> 'Type[Dialect]'	Return the SQLAlchemy :class:`_engine.Dialect` class corresponding _{[extrait de get_dialect.__doc__]}
get_driver_name(self) -> 'str'	Return the backend name. _{[extrait de get_driver_name.__doc__]}
render_as_string(self, hide_password: 'bool' = True) -> 'str'	Render this :class:`_engine.URL` object as a string. _{[extrait de render_as_string.__doc__]}
set(self, drivername: 'Optional[str]' = None, username: 'Optional[str]' = None, password: 'Optional[str]' = None, host: 'Optional[str]' = None, port: 'Optional[int]' = None, database: 'Optional[str]' = None, query: 'Optional[Mapping[str, Union[Sequence[str], str]]]' = None) -> 'URL'	return a new :class:`_engine.URL` object with modifications. _{[extrait de set.__doc__]}
translate_connect_args(self, names: 'Optional[List[str]]' = None, **kw: 'Any') -> 'Dict[str, Any]'	Translate url attributes into a dictionary of connection arguments. _{[extrait de translate_connect_args.__doc__]}
update_query_dict(self, query_parameters: 'Mapping[str, Union[str, List[str]]]', append: 'bool' = False) -> 'URL'	Return a new :class:`_engine.URL` object with the _{[extrait de update_query_dict.__doc__]}
update_query_pairs(self, key_value_pairs: 'Iterable[Tuple[str, Union[str, List[str]]]]', append: 'bool' = False) -> 'URL'	Return a new :class:`_engine.URL` object with the _{[extrait de update_query_pairs.__doc__]}
update_query_string(self, query_string: 'str', append: 'bool' = False) -> 'URL'	Return a new :class:`_engine.URL` object with the :attr:`_engine.URL.query` _{[extrait de update_query_string.__doc__]}