U
|
¸ý°dù ã @ sp U d Z ddlmZ ddlmZ ddlZddlZddl Z ddl
|
Z
|
ddl Z ddl m Z ddl mZ ddl mZ ddl mZ ddl mZ dd l mZ dd
|
l mZ dd l mZ dd l mZ dd l mZ ddl mZ ddl mZ ddl mZ ddlmZ ddl m Z ddl m Z ddl m Z ddl m!Z! ddl m"Z" ddl#m$Z$ ddl#m%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"m0Z0 dd#l"m1Z1 dd$l"m2Z2 dd%l"m3Z3 dd&l4m5Z5 d'd(l m6Z6 d'd)l m7Z7 d'd*l m8Z8 d'd+l m9Z9 d'd,l:m;Z; d'd-l9m<Z< d'd.l9m=Z= d'd/l>m?Z? d'd0l>m@Z@ d'd1l>mAZA erÈdd2lBmCZC dd3lBmDZD dd4l mEZE dd5lFmGZG dd6l"mHZH dd7l"mIZI dd8l"mJZJ dd9l"mKZK d'd:lLmMZM ed;d<d=ZNed>e d=ZOed?d@d=ZPG dAdB dBe2ZQG dCdD dDe2ZRG dEdF dFe2ZSG dGdH dHeRe1eT ZUG dIdJ dJeUZVG dKdL dLeUZWG dMdN dNeVZXG dOdP dPeQe1eY ZZG dQdR dReZZ[G dSdT dTeZZ\edUeej]e^f d=Z_G dVdW dWeQe1e_ Z`G dXdY dYe`e_ ZaG dZd[ d[eae_ ZbG d\d] d]ZcG d^d_ d_eceQe1ej ZdG d`da daeceQe1eje ZfG dbdc dceceQe1ejg ZhG ddde dee1ei ZjG dfdg dgejZkG dhdi die&e2ZlG djdk dkeUele-e1eeTe jmf ZmG dldm dme0en ZoG dndo doele-e1ep ZqG dpdq dqeQe1ejr ZsG drds dse-ese0ejr ZtG dtdu dueSe1e ZuG dvdw dwe&eSeRe1ee ZvG dxdy dye1ee dzf ZwG d{d| d|eae_ ZxG d}d~ d~eae_ ZyG dd debe_ ZzG dd debe_ Z{G dd de`e_ Z|G d
d de`e_ Z}G dd deZZ~e~ZG dd de[ZG dd de\ZG dd dedZG dd dedZG dd defZG dd dehZ
G dd deVZG dd deVZG dd deUZG dd deWZG dd deUZG dd d eWZG d¡d¢ d¢ekZG d£d¤ d¤ejZG d¥d¦ d¦ejZG d§d¨ d¨eqZG d©dª dªe1d ZG d«d¬ d¬e(e1e ZG dd® d®eqZed¯eTe ZG d°d± d±e1e ZG d²d³ d³ee Ze Zeq ZeU ZeZ Ze` Zd´edµ< e Ze Zedd¶d·Zehd¶d·Ze\ Zed Z eh Z¡eU Z¢eW Z£eYeZ e^ea epee e ej]e` ejeef eje ejge¡ejret e¤deeiek eTe¢e jmeme jme@eme jmiZ¥d¸ed¹< e¥j¦Z§d<d@dºd»d¼Z¨ee"_ee"_ee"_ee"_ee"_ee"_eS e"_©Z©ee"_e¨e"_¨dS )½zSQL specific types.
|
|
é )Ú annotationsN)ÚAny)ÚCallable)Úcast)ÚDict)ÚList)ÚOptional)Úoverload)ÚSequence)ÚTuple)ÚType)Ú TYPE_CHECKING)ÚTypeVar)ÚUnion)ÚUUIDé )Ú coercions©Úelements)Ú operators)Úroles)Útype_api)Ú
|
_NONE_NAME)ÚNO_ARG)ÚSchemaEventTarget)Ú HasCacheKey)Ú quoted_name)ÚSlice)Ú
|
TypeCoerce)ÚEmulated)ÚNativeForEmulated)Ú to_instance)Ú TypeDecorator)Ú
|
TypeEngine)ÚTypeEngineMixin)ÚVariant)ÚInternalTraversalé )Úevent)Úexc)Ú
|
inspection)Úutil)Ú
|
processors)Ú langhelpers)Ú OrderedDict)Ú
|
is_literal)ÚLiteral)Útyping_get_args)Ú_ColumnExpressionArgument)Ú_TypeEngineArgument)Ú OperatorType)ÚMetaData)Ú_BindProcessorType)Ú_ComparatorFactory)Ú_MatchedOnType)Ú_ResultProcessorType)ÚDialectÚ_Tr )ÚboundÚ_CTÚ_TEúTypeEngine[Any]c @ s@ e Zd ZU dZedd ZG dd deje ZeZ de
|
d< dS ) ÚHasExpressionLookupz¾Mixin expression adaptations based on lookup tables.
|
|
These rules are currently used by the numeric, integer and date types
|
which have detailed cross-expression coercion rules.
|
|
c C s
|
t d S ©N©ÚNotImplementedError©Úself© rF úNd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/sql/sqltypes.pyÚ_expression_adaptations[ s z+HasExpressionLookup._expression_adaptationsc @ s( e Zd ZdZejZddddddZdS ) z HasExpressionLookup.ComparatorrF r4 úTypeEngine.Comparator[Any]ú$Tuple[OperatorType, TypeEngine[Any]]©ÚopÚother_comparatorÚreturnc C sp |j j}tr t| j ts t| j j || j¡ || j ¡}||krJ||j fS || j jkr`|| j fS |t |fS d S rA )
|
ÚtypeÚ_type_affinityr Ú
|
isinstancer@ ÚAssertionErrorrH ÚgetÚ _blank_dictr! )rE rL rM Z othertypeÚlookuprF rF rG Ú_adapt_expressiond s ÿ þ
|
|
z0HasExpressionLookup.Comparator._adapt_expressionN)Ú__name__Ú
|
__module__Ú __qualname__Ú __slots__r+ Ú
|
EMPTY_DICTrT rV rF rF rF rG Ú
|
Comparator_ s r\ ú_ComparatorFactory[Any]Úcomparator_factoryN) rW rX rY Ú__doc__ÚpropertyrH r# r\ r= r^ Ú__annotations__rF rF rF rG r@ R s
|
|
|
r@ c @ s4 e Zd ZU dZG dd deje ZeZded< dS )Ú ConcatenablezOA mixin that marks a type as supporting 'concatenation',
|
typically strings.c s* e Zd ZdZdddd fdd Z ZS )zConcatenable.ComparatorrF r4 rI rJ rK c s< |t jkr*t|tjtjfr*t j| jjfS t
|
||¡S d S rA ) r ÚaddrQ rb r\ ÚNullTypeÚ concat_opÚexprrO ÚsuperrV ©rE rL rM ©Ú __class__rF rG rV s
|
þz)Concatenable.Comparator._adapt_expression)rW rX rY rZ rV Ú __classcell__rF rF ri rG r\ ~ s r\ r] r^ N© rW rX rY r_ r# r\ r; r^ ra rF rF rF rG rb y s
|
rb c @ s4 e Zd ZU dZG dd deje ZeZded< dS )Ú IndexablezhA mixin that marks a type as supporting indexing operations,
|
such as array or JSON structures.
|
|
c @ s e Zd ZdZdd Zdd ZdS )zIndexable.ComparatorrF c C s
|
t d S rA rB )rE ÚindexrF rF rG Ú_setup_getitem s z#Indexable.Comparator._setup_getitemc C s | |¡\}}}| j|||dS )N)Ú result_type)ro Zoperate)rE rn Z adjusted_opZadjusted_right_exprrp rF rF rG Ú __getitem__ s ü ÿz Indexable.Comparator.__getitem__N)rW rX rY rZ ro rq rF rF rF rG r\ s r\ r] r^ Nrl rF rF rF rG rm s
|
rm c @ sZ e Zd ZdZdZddddddZd d
|
Zd d Zd d Zdd Z e
|
dd Z dd Z dS )ÚStringzûThe base for all string and character types.
|
|
In SQL, corresponds to VARCHAR.
|
|
The `length` field is usually required when the `String` type is
|
used within a CREATE TABLE statement, as VARCHAR requires a length
|
on most databases.
|
|
ÚstringNú Optional[int]ú Optional[str]©ÚlengthÚ collationc C s || _ || _dS )a
|
Create a string-holding type.
|
|
:param length: optional, a length for the column for use in
|
DDL and CAST expressions. May be safely omitted if no ``CREATE
|
TABLE`` will be issued. Certain databases may require a
|
``length`` for use in DDL, and will raise an exception when
|
the ``CREATE TABLE`` DDL is issued if a ``VARCHAR``
|
with no length is included. Whether the value is
|
interpreted as bytes or characters is database specific.
|
|
:param collation: Optional, a column-level collation for
|
use in DDL and CAST expressions. Renders using the
|
COLLATE keyword supported by SQLite, MySQL, and PostgreSQL.
|
E.g.:
|
|
.. sourcecode:: pycon+sql
|
|
>>> from sqlalchemy import cast, select, String
|
>>> print(select(cast('some string', String(collation='utf8'))))
|
{printsql}SELECT CAST(:param_1 AS VARCHAR COLLATE utf8) AS anon_1
|
|
.. note::
|
|
In most cases, the :class:`.Unicode` or :class:`.UnicodeText`
|
datatypes should be used for a :class:`_schema.Column` that expects
|
to store non-ascii data. These datatypes will ensure that the
|
correct types are used on the database.
|
|
Nrv )rE rw rx rF rF rG Ú__init__¸ s $zString.__init__c C s | ¡ r tS tS d S rA )ÚisasciiÚ_STRINGÚ_UNICODE©rE ÚvaluerF rF rG Ú_resolve_for_literalß s zString._resolve_for_literalc s fdd}|S )Nc s( | dd¡} jjr | dd¡} d| S )Nú'ú''ú%z%%ú'%s')ÚreplaceZidentifier_preparerZ_double_percents©r~ ©ÚdialectrF rG Úprocessé s z)String.literal_processor.<locals>.processrF ©rE r r rF r rG Úliteral_processorè s zString.literal_processorc C s d S rA rF ©rE r rF rF rG Úbind_processoró s zString.bind_processorc C s d S rA rF ©rE r ÚcoltyperF rF rG Úresult_processorö s zString.result_processorc C s t S rA ©ÚstrrD rF rF rG Ú python_typeù s zString.python_typec C s |j S rA )ÚSTRING©rE ÚdbapirF rF rG Úget_dbapi_typeý s zString.get_dbapi_type)NN) rW rX rY r_ Ú__visit_name__ry r r r r r` r r rF rF rF rG rr ª s
|
ý'
|
rr c @ s e Zd ZdZdZdS )ÚTextzåA variably sized string type.
|
|
In SQL, usually corresponds to CLOB or TEXT. In general, TEXT objects
|
do not have a length; while some databases will accept a length
|
argument here, it will be rejected by others.
|
|
ÚtextN©rW rX rY r_ r rF rF rF rG r s r c s& e Zd ZdZdZd fdd Z ZS )ÚUnicodea A variable length Unicode string type.
|
|
The :class:`.Unicode` type is a :class:`.String` subclass that assumes
|
input and output strings that may contain non-ASCII characters, and for
|
some backends implies an underlying column type that is explicitly
|
supporting of non-ASCII data, such as ``NVARCHAR`` on Oracle and SQL
|
Server. This will impact the output of ``CREATE TABLE`` statements and
|
``CAST`` functions at the dialect level.
|
|
The character encoding used by the :class:`.Unicode` type that is used to
|
transmit and receive data to the database is usually determined by the
|
DBAPI itself. All modern DBAPIs accommodate non-ASCII strings but may have
|
different methods of managing database encodings; if necessary, this
|
encoding should be configured as detailed in the notes for the target DBAPI
|
in the :ref:`dialect_toplevel` section.
|
|
In modern SQLAlchemy, use of the :class:`.Unicode` datatype does not
|
imply any encoding/decoding behavior within SQLAlchemy itself. In Python
|
3, all string objects are inherently Unicode capable, and SQLAlchemy
|
does not produce bytestring objects nor does it accommodate a DBAPI that
|
does not return Python Unicode objects in result sets for string values.
|
|
.. warning:: Some database backends, particularly SQL Server with pyodbc,
|
are known to have undesirable behaviors regarding data that is noted
|
as being of ``NVARCHAR`` type as opposed to ``VARCHAR``, including
|
datatype mismatch errors and non-use of indexes. See the section
|
on :meth:`.DialectEvents.do_setinputsizes` for background on working
|
around unicode character issues for backends like SQL Server with
|
pyodbc as well as cx_Oracle.
|
|
.. seealso::
|
|
:class:`.UnicodeText` - unlengthed textual counterpart
|
to :class:`.Unicode`.
|
|
:meth:`.DialectEvents.do_setinputsizes`
|
|
|
ÚunicodeNc s t jf d|i| dS )zs
|
Create a :class:`.Unicode` object.
|
|
Parameters are the same as that of :class:`.String`.
|
|
rw N©rg ry ©rE rw Úkwargsri rF rG ry : s zUnicode.__init__)N©rW rX rY r_ r ry rk rF rF ri rG r s (r c s& e Zd ZdZdZd fdd Z ZS )Ú UnicodeTexta# An unbounded-length Unicode string type.
|
|
See :class:`.Unicode` for details on the unicode
|
behavior of this object.
|
|
Like :class:`.Unicode`, usage the :class:`.UnicodeText` type implies a
|
unicode-capable type being used on the backend, such as
|
``NCLOB``, ``NTEXT``.
|
|
Z unicode_textNc s t jf d|i| dS )z
|
Create a Unicode-converting Text type.
|
|
Parameters are the same as that of :class:`_expression.TextClause`.
|
|
rw Nr r ri rF rG ry S s zUnicodeText.__init__)Nr rF rF ri rG r¡ D s r¡ c @ s^ e Zd ZdZdZer(ejddddZdd Z e
|
d d
|
Z d d Z d d Z ejdd ZdS )ÚIntegerz A type for ``int`` integers.Úintegerz Type[Integer]©rN c C s d S rA rF rD rF rF rG rP e s zInteger._type_affinityc C s |j S rA ©ÚNUMBERr rF rF rG r i s zInteger.get_dbapi_typec C s t S rA )ÚintrD rF rF rG r l s zInteger.python_typec C s | ¡ dkrtS | S d S )Né )Ú
|
bit_lengthÚ _BIGINTEGERr} rF rF rG r p s z Integer._resolve_for_literalc C s dd }|S )Nc S s t t| S rA )r r§ r
rF rF rG r w s z*Integer.literal_processor.<locals>.processrF r rF rF rG r v s zInteger.literal_processorc C sZ t jttt| jttit jttt| jttit jttttit j t| jttit j
|
t| jttiiS rA ) r rc ÚDater¢ rj ÚNumericÚmulÚIntervalÚtruedivÚfloordivÚsubrD rF rF rG rH | s. ý ý
|
óz Integer._expression_adaptationsN)rW rX rY r_ r r r+ Úro_memoized_propertyrP r r` r r r Úmemoized_propertyrH rF rF rF rG r¢ ] s
|
r¢ c @ s e Zd ZdZdZdS )Ú SmallIntegerz¥A type for smaller ``int`` integers.
|
|
Typically generates a ``SMALLINT`` in DDL, and otherwise acts like
|
a normal :class:`.Integer` on the Python side.
|
|
Z small_integerNr rF rF rF rG r´ s r´ c @ s e Zd ZdZdZdS )Ú
|
BigIntegerz¢A type for bigger ``int`` integers.
|
|
Typically generates a ``BIGINT`` in DDL, and otherwise acts like
|
a normal :class:`.Integer` on the Python side.
|
|
Z big_integerNr rF rF rF rG rµ s rµ Ú_Nc @ sÄ e Zd ZdZdZer(ejddddZdZ e
|
d%d d
|
d
|
d
|
d d d dZ e
|
d&dd
|
d
|
d
|
dd ddZ d'd
|
d
|
d
|
ddddZ e dd Z dd Zdd Ze d d Zd d Zd!d" Zejd#d$ ZdS )(r¬ aê Base for non-integer numeric types, such as
|
``NUMERIC``, ``FLOAT``, ``DECIMAL``, and other variants.
|
|
The :class:`.Numeric` datatype when used directly will render DDL
|
corresponding to precision numerics if available, such as
|
``NUMERIC(precision, scale)``. The :class:`.Float` subclass will
|
attempt to render a floating-point datatype such as ``FLOAT(precision)``.
|
|
:class:`.Numeric` returns Python ``decimal.Decimal`` objects by default,
|
based on the default value of ``True`` for the
|
:paramref:`.Numeric.asdecimal` parameter. If this parameter is set to
|
False, returned values are coerced to Python ``float`` objects.
|
|
The :class:`.Float` subtype, being more specific to floating point,
|
defaults the :paramref:`.Float.asdecimal` flag to False so that the
|
default Python datatype is ``float``.
|
|
.. note::
|
|
When using a :class:`.Numeric` datatype against a database type that
|
returns Python floating point values to the driver, the accuracy of the
|
decimal conversion indicated by :paramref:`.Numeric.asdecimal` may be
|
limited. The behavior of specific numeric/floating point datatypes
|
is a product of the SQL datatype in use, the Python :term:`DBAPI`
|
in use, as well as strategies that may be present within
|
the SQLAlchemy dialect in use. Users requiring specific precision/
|
scale are encouraged to experiment with the available datatypes
|
in order to determine the best results.
|
|
ÚnumericzType[Numeric[_N]]r¤ c C s d S rA rF rD rF rF rG rP Ï s zNumeric._type_affinityé
|
.úNumeric[decimal.Decimal]rt ú Literal[True]©rE Ú precisionÚscaleÚdecimal_return_scaleÚ asdecimalc C s d S rA rF r» rF rF rG ry Õ s zNumeric.__init__zNumeric[float]úLiteral[False]c C s d S rA rF r» rF rF rG ry ß s NTÚbool©r¼ r½ r¾ r¿ c C s || _ || _|| _|| _dS )aw
|
Construct a Numeric.
|
|
:param precision: the numeric precision for use in DDL ``CREATE
|
TABLE``.
|
|
:param scale: the numeric scale for use in DDL ``CREATE TABLE``.
|
|
:param asdecimal: default True. Return whether or not
|
values should be sent as Python Decimal objects, or
|
as floats. Different DBAPIs send one or the other based on
|
datatypes - the Numeric type will ensure that return values
|
are one or the other across DBAPIs consistently.
|
|
:param decimal_return_scale: Default scale to use when converting
|
from floats to Python decimals. Floating point values will typically
|
be much longer due to decimal inaccuracy, and most floating point
|
database types don't have a notion of "scale", so by default the
|
float type looks for the first ten decimal places when converting.
|
Specifying this value will override that length. Types which
|
do include an explicit ".scale" value, such as the base
|
:class:`.Numeric` as well as the MySQL float types, will use the
|
value of ".scale" as the default for decimal_return_scale, if not
|
otherwise specified.
|
|
When using the ``Numeric`` type, care should be taken to ensure
|
that the asdecimal setting is appropriate for the DBAPI in use -
|
when Numeric applies a conversion from Decimal->float or float->
|
Decimal, this conversion incurs an additional performance overhead
|
for all result columns received.
|
|
DBAPIs that return Decimal natively (e.g. psycopg2) will have
|
better accuracy and higher performance with a setting of ``True``,
|
as the native translation to Decimal reduces the amount of floating-
|
point issues at play, and the Numeric type itself doesn't need
|
to apply any further conversions. However, another DBAPI which
|
returns floats natively *will* incur an additional conversion
|
overhead, and is still subject to floating point data loss - in
|
which case ``asdecimal=False`` will at least remove the extra
|
conversion overhead.
|
|
Nr r» rF rF rG ry é s 1c C s0 | j d k r| j S t| dd d k r&| jS | jS d S )Nr½ )r¾ Úgetattrr½ Ú _default_decimal_return_scalerD rF rF rG Ú _effective_decimal_return_scale s
|
|
z'Numeric._effective_decimal_return_scalec C s |j S rA r¥ r rF rF rG r ( s zNumeric.get_dbapi_typec C s dd }|S )Nc S s t | S rA r r
rF rF rG r , s z*Numeric.literal_processor.<locals>.processrF r rF rF rG r + s zNumeric.literal_processorc C s | j r tjS tS d S rA )r¿ ÚdecimalÚDecimalÚfloatrD rF rF rG r 1 s zNumeric.python_typec C s |j r
|
d S tjS d S rA )Úsupports_native_decimalr, Úto_floatr rF rF rG r 8 s zNumeric.bind_processorc C sF | j r2|jrd S t tj| jd k r(| jn| j¡S n|jr>tjS d S d S rA ) r¿ rÉ r, Ú to_decimal_processor_factoryrÆ rÇ r½ rÄ rÊ r rF rF rG r > s ÿüzNumeric.result_processorc C sP t jttt| jt| jit jt| jt| jit jt| jt| jit jt| jt| jiiS rA ) r r r® r¬ rj r¢ r¯ rc r± rD rF rF rG rH Q s& ý þ õz Numeric._expression_adaptations)....)....)NNNT)rW rX rY r_ r r r+ r² rP rÄ r ry r` rÅ r r r r r r³ rH rF rF rF rG r¬ ª sB û û û6
|
|
r¬ c @ sj e Zd ZdZdZdZeddddddd d
|
Zedd dd ddd d
|
Zdddddddd
|
Zdd ZdS )ÚFloata Type representing floating point types, such as ``FLOAT`` or ``REAL``.
|
|
This type returns Python ``float`` objects by default, unless the
|
:paramref:`.Float.asdecimal` flag is set to True, in which case they
|
are coerced to ``decimal.Decimal`` objects.
|
|
|
rÈ N.z Float[float]rt rÀ ©rE r¼ r¿ r¾ c C s d S rA rF rÍ rF rF rG ry q s zFloat.__init__zFloat[decimal.Decimal]rº c C s d S rA rF rÍ rF rF rG ry z s Fz Float[_N]rÁ c C s || _ || _|| _dS )a<
|
Construct a Float.
|
|
:param precision: the numeric precision for use in DDL ``CREATE
|
TABLE``. Backends **should** attempt to ensure this precision
|
indicates a number of digits for the generic
|
:class:`_sqltypes.Float` datatype.
|
|
.. note:: For the Oracle backend, the
|
:paramref:`_sqltypes.Float.precision` parameter is not accepted
|
when rendering DDL, as Oracle does not support float precision
|
specified as a number of decimal places. Instead, use the
|
Oracle-specific :class:`_oracle.FLOAT` datatype and specify the
|
:paramref:`_oracle.FLOAT.binary_precision` parameter. This is new
|
in version 2.0 of SQLAlchemy.
|
|
To create a database agnostic :class:`_types.Float` that
|
separately specifies binary precision for Oracle, use
|
:meth:`_types.TypeEngine.with_variant` as follows::
|
|
from sqlalchemy import Column
|
from sqlalchemy import Float
|
from sqlalchemy.dialects import oracle
|
|
Column(
|
"float_data",
|
Float(5).with_variant(oracle.FLOAT(binary_precision=16), "oracle")
|
)
|
|
:param asdecimal: the same flag as that of :class:`.Numeric`, but
|
defaults to ``False``. Note that setting this flag to ``True``
|
results in floating point conversion.
|
|
:param decimal_return_scale: Default scale to use when converting
|
from floats to Python decimals. Floating point values will typically
|
be much longer due to decimal inaccuracy, and most floating point
|
database types don't have a notion of "scale", so by default the
|
float type looks for the first ten decimal places when converting.
|
Specifying this value will override that length. Note that the
|
MySQL float types, which do include "scale", will use "scale"
|
as the default for decimal_return_scale, if not otherwise specified.
|
|
N)r¼ r¿ r¾ rÍ rF rF rG ry s 1c C s* | j rt tj| j¡S |jr"tjS d S d S rA )r¿ r, rË rÆ rÇ rÅ rÉ rÊ r rF rF rG r ¸ s ÿzFloat.result_processor)...)...)NFN) rW rX rY r_ r r½ r ry r rF rF rF rG rÌ b s$ ü ü
|
ü5rÌ c @ s e Zd ZdZdZdS )ÚDoublezåA type for double ``FLOAT`` floating point types.
|
|
Typically generates a ``DOUBLE`` or ``DOUBLE_PRECISION`` in DDL,
|
and otherwise acts like a normal :class:`.Float` on the Python
|
side.
|
|
.. versionadded:: 2.0
|
|
ÚdoubleNr rF rF rF rG rÎ Ã s
|
rÎ c @ s. e Zd Zdd Zdd Zdd Zd
|
dd ZdS ) Ú_RenderISO8601NoTc C s | |d ¡S rA ©Ú_literal_processor_portionr rF rF rG Ú_literal_processor_datetimeÒ s z-_RenderISO8601NoT._literal_processor_datetimec C s | |d¡S )Nr rÑ r rF rF rG Ú_literal_processor_dateÕ s z)_RenderISO8601NoT._literal_processor_datec C s | |d¡S )NéÿÿÿÿrÑ r rF rF rG Ú_literal_processor_timeØ s z)_RenderISO8601NoT._literal_processor_timeNc s. dks t d k r" fdd}ndd }|S )N)Nr rÕ c s& | d k r"d| ¡ d¡ d} | S )Nr ÚT)Ú isoformatÚsplitr
©Ú_portionrF rG r ß s z=_RenderISO8601NoT._literal_processor_portion.<locals>.processc S s$ | d k r d| ¡ dd¡ d} | S )Nr r× ú )rØ r r
rF rF rG r æ s )rR )rE r rÛ r rF rÚ rG rÒ Û s
|
z,_RenderISO8601NoT._literal_processor_portion)N)rW rX rY rÓ rÔ rÖ rÒ rF rF rF rG rÐ Ñ s rÐ c @ sV e Zd ZdZdZdddddZdd Zd
|
d Zd d Ze dd Z
|
e j dd Z dS )ÚDateTimeaÿ A type for ``datetime.datetime()`` objects.
|
|
Date and time types return objects from the Python ``datetime``
|
module. Most DBAPIs have built in support for the datetime
|
module, with the noted exception of SQLite. In the case of
|
SQLite, date and time types are stored as strings which are then
|
converted back to datetime objects when rows are returned.
|
|
For the time representation within the datetime type, some
|
backends include additional options, such as timezone support and
|
fractional seconds support. For fractional seconds, use the
|
dialect-specific datatype, such as :class:`.mysql.TIME`. For
|
timezone support, use at least the :class:`_types.TIMESTAMP` datatype,
|
if not the dialect-specific datatype object.
|
|
ÚdatetimeFrÁ ©Útimezonec C s
|
|| _ dS )aö Construct a new :class:`.DateTime`.
|
|
:param timezone: boolean. Indicates that the datetime type should
|
enable timezone support, if available on the
|
**base date/time-holding type only**. It is recommended
|
to make use of the :class:`_types.TIMESTAMP` datatype directly when
|
using this flag, as some databases include separate generic
|
date/time-holding types distinct from the timezone-capable
|
TIMESTAMP datatype, such as Oracle.
|
|
|
Nrß ©rE rà rF rF rG ry s zDateTime.__init__c C s |j S rA ©ÚDATETIMEr rF rF rG r s zDateTime.get_dbapi_typec C s |j d k }|r| jstS | S d S rA )Útzinforà ÚDATETIME_TIMEZONE©rE r~ Z with_timezonerF rF rG r s
|
|
z DateTime._resolve_for_literalc C s
|
| |¡S rA )rÓ r rF rF rG r s zDateTime.literal_processorc C s t jS rA )ÚdtrÞ rD rF rF rG r ! s zDateTime.python_typec C s t jt| jit jt| jttiiS rA )r rc r® rj r± rÝ rD rF rF rG rH % s
|
þz DateTime._expression_adaptationsN)F)rW rX rY r_ r ry r r r r` r r+ r³ rH rF rF rF rG rÝ î s
|
rÝ c @ s> e Zd ZdZdZdd Zedd Zdd Ze j
|
d d
|
Z d S ) r« z'A type for ``datetime.date()`` objects.Údatec C s |j S rA râ r rF rF rG r 7 s zDate.get_dbapi_typec C s t jS rA )rç rè rD rF rF rG r : s zDate.python_typec C s
|
| |¡S rA )rÔ r rF rF rG r > s zDate.literal_processorc C s0 t jt| jttttit jt| jttttttiiS rA ) r rc r¢ rj r® rÝ ÚTimer± r« rD rF rF rG rH A s& ý ÷úz Date._expression_adaptationsN) rW rX rY r_ r r r` r r r+ r³ rH rF rF rF rG r« 1 s
|
r« c @ sV e Zd ZdZdZdddddZdd Zed
|
d Zd d Z e
|
j dd Z dd Z dS )ré z'A type for ``datetime.time()`` objects.ÚtimeFrÁ rß c C s
|
|| _ d S rA rß rá rF rF rG ry ` s z Time.__init__c C s |j S rA râ r rF rF rG r c s zTime.get_dbapi_typec C s t jS rA )rç rê rD rF rF rG r f s zTime.python_typec C s |j d k }|r| jstS | S d S rA )rä rà Ú TIME_TIMEZONEræ rF rF rG r j s
|
|
zTime._resolve_for_literalc C s$ t jttt| jit jttt| jiiS rA )r rc r« rÝ r® rj r± ré rD rF rF rG rH q s
|
þz Time._expression_adaptationsc C s
|
| |¡S rA )rÖ r rF rF rG r { s zTime.literal_processorN)F)rW rX rY r_ r ry r r` r r r+ r³ rH r rF rF rF rG ré Z s
|
|
ré c s\ e Zd ZdZdddddZdd Zed d
|
Zd d Zd d Z fddZ
|
dd Z Z S )Ú_Binaryz&Define base behavior for binary types.Nrt ©rw c C s
|
|| _ d S rA rí ©rE rw rF rF rG ry s z_Binary.__init__c s fdd}|S )Nc s | j¡ dd¡} d| S )Nr r r )ÚdecodeZ$_legacy_binary_type_literal_encodingr r
r rF rG r s ÿ þz*_Binary.literal_processor.<locals>.processrF r rF r rG r s z_Binary.literal_processorc C s t S rA ©ÚbytesrD rF rF rG r s z_Binary.python_typec s& |j d krd S |j j fdd}|S )Nc s | d k r | S d S d S rA rF r
©Z DBAPIBinaryrF rG r s z'_Binary.bind_processor.<locals>.process)r ÚBinaryr rF rò rG r s
|
|
z_Binary.bind_processorc C s |j r
|
d S dd }|S )Nc S s | d k rt | } | S rA rð r
rF rF rG r ¬ s z)_Binary.result_processor.<locals>.process)Zreturns_native_bytes©rE r r r rF rF rG r ¨ s z_Binary.result_processorc s t |tr| S t ||¡S dS ©z@See :meth:`.TypeEngine.coerce_compared_value` for a description.N©rQ r rg Úcoerce_compared_value©rE rL r~ ri rF rG r÷ ³ s
|
z _Binary.coerce_compared_valuec C s |j S rA )ÚBINARYr rF rF rG r » s z_Binary.get_dbapi_type)N) rW rX rY r_ ry r r` r r r r÷ r rk rF rF ri rG rì s
|
rì c @ s$ e Zd ZdZdZdddddZdS ) Ú LargeBinarya A type for large binary byte data.
|
|
The :class:`.LargeBinary` type corresponds to a large and/or unlengthed
|
binary type for the target platform, such as BLOB on MySQL and BYTEA for
|
PostgreSQL. It also handles the necessary conversions for the DBAPI.
|
|
Z large_binaryNrt rí c C s t j| |d dS )zã
|
Construct a LargeBinary type.
|
|
:param length: optional, a length for the column for use in
|
DDL statements, for those binary types that accept a length,
|
such as the MySQL BLOB type.
|
|
rí N)rì ry rî rF rF rG ry Ë s zLargeBinary.__init__)N)rW rX rY r_ r ry rF rF rF rG rú ¿ s rú c sÜ e Zd ZU dZdZded< d/ddddd dd
|
d d d Zdd Zdd Zdd Z dd Z
|
e ddddddZ e d dd dd dZ d dd d fd d Z d0d!d"Z d1d#d$Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Z ZS )2Ú
|
SchemaTypea Add capabilities to a type which allow for schema-level DDL to be
|
associated with a type.
|
|
Supports types that must be explicitly created/dropped (i.e. PG ENUM type)
|
as well as types that are complimented by table or schema level
|
constraints, triggers, and other rules.
|
|
:class:`.SchemaType` classes can also be targets for the
|
:meth:`.DDLEvents.before_parent_attach` and
|
:meth:`.DDLEvents.after_parent_attach` events, where the events fire off
|
surrounding the association of the type object with a parent
|
:class:`_schema.Column`.
|
|
.. seealso::
|
|
:class:`.Enum`
|
|
:class:`.Boolean`
|
|
|
Tru ÚnameNFzOptional[MetaData]rÁ zOptional[bool]úOptional[SchemaType]©rü ÚschemaÚmetadataÚinherit_schemaÚquoteÚ_create_eventsÚ _adapted_fromc C s |d k rt ||| _nd | _|| _|| _|| _|| _|rn| jrnt | jdt | j
|
¡¡ t | jdt | j ¡¡ |r| j |j ¡| _ d S )NÚ before_createÚ
|
after_drop)r rü rÿ r r r r( Úlistenr+ Úportable_instancemethodÚ_on_metadata_createÚ_on_metadata_dropÚdispatchÚ_join)rE rü rÿ r r r r r rF rF rG ry ó s(
|
|
|
ý
|
ýzSchemaType.__init__c K s | t | j¡¡ d S rA )Z_on_table_attachr+ r Ú
|
_set_table)rE ÚcolumnÚkwrF rF rG Ú _set_parent s zSchemaType._set_parentc C s( |j jr t|j j}|j |d< nd }|S )NÚ_default)rO Z_variant_mappingÚdict)rE r Úvariant_mappingrF rF rG Ú _variant_mapping_for_set_table% s
|
z)SchemaType._variant_mapping_for_set_tablec C sÈ | j r|j| _n"| jr2| jd kr2| jjr2| jj| _| js<d S | |¡}t |dt | j d|i¡¡ t |dt | j
|
d|i¡¡ | jd krÄt |jdt | j d|i¡¡ t |jdt | j d|i¡¡ d S )Nr r r ) r rÿ r r r r( r r+ r Ú_on_table_createÚ_on_table_dropr r
|
)rE r Útabler rF rF rG r - sP
|
|
|
ÿý ÿý
|
þýþýzSchemaType._set_tablec K s | j td| jddS )NzType[TypeEngine[Any]]T)r )Úadaptr rj ©rE r rF rF rG Úcopy[ s
|
þzSchemaType.copyz Type[_TE]r r> )Úclsr rN c K s d S rA rF ©rE r r rF rF rG r a s zSchemaType.adaptzType[TypeEngineMixin]r? c K s d S rA rF r rF rF rG r e s z-Type[Union[TypeEngine[Any], TypeEngineMixin]]c s( | dd¡ | d| ¡ t j|f|S )Nr Fr )Ú
|
setdefaultrg r r ri rF rG r i s c C s4 | |j¡}t|tr0|j| jk r0|j||d dS )z.Issue CREATE DDL for this type, if applicable.©Ú
|
checkfirstN)Ú dialect_implr rQ rû rj Úcreate©rE Úbindr ÚtrF rF rG r! p s zSchemaType.createc C s4 | |j¡}t|tr0|j| jk r0|j||d dS )z,Issue DROP DDL for this type, if applicable.r N)r r rQ rû rj Údropr" rF rF rG r% w s zSchemaType.dropc K sH | |j|¡sd S | |j¡}t|trD|j| jk rD|j||f| d S rA )Ú_is_impl_for_variantr r rQ rû rj r ©rE Útargetr# r r$ rF rF rG r ~ s
|
zSchemaType._on_table_createc K sH | |j|¡sd S | |j¡}t|trD|j| jk rD|j||f| d S rA )r& r r rQ rû rj r r' rF rF rG r s
|
zSchemaType._on_table_dropc K sH | |j|¡sd S | |j¡}t|trD|j| jk rD|j||f| d S rA )r& r r rQ rû rj r r' rF rF rG r s
|
z SchemaType._on_metadata_createc K sH | |j|¡sd S | |j¡}t|trD|j| jk rD|j||f| d S rA )r& r r rQ rû rj r
|
r' rF rF rG r
|
s
|
z SchemaType._on_metadata_dropc sV | dd ¡}|sdS fdd}|j|kr<|||j r<dS |j|krR||d S d S )Nr Tc s | kpt | to| j kS rA )rQ ÚARRAYÚ item_type)ÚtyprD rF rG Ú_we_are_the_impl¯ s
|
ýz9SchemaType._is_impl_for_variant.<locals>._we_are_the_implr )Úpoprü )rE r r r r, rF rD rG r& s ÿ
|
z SchemaType._is_impl_for_variant)NNNFNTN)F)F)rW rX rY r_ Z_use_schema_mapra ry r r r r r r r! r% r r r r
|
r& rk rF rF ri rG rû × s6
|
ø ".
|
|
rû c s: e Zd ZdZdZdddddZedd Z fd
|
d Zd d Z dd dddZ
|
dddddddZ dd Z edd Z edd Zd d ZG d d d eje ZeZd!d" Zd#d$ Zd=d&d'Zd(d) Zd*d+ Z fd,d-Zd.d/ Ze d0¡d1d2 Z fd3d4Z fd5d6Z fd7d8Z d9d: Z!e fd;d<Z" Z#S )>ÚEnuma Generic Enum Type.
|
|
The :class:`.Enum` type provides a set of possible string values
|
which the column is constrained towards.
|
|
The :class:`.Enum` type will make use of the backend's native "ENUM"
|
type if one is available; otherwise, it uses a VARCHAR datatype.
|
An option also exists to automatically produce a CHECK constraint
|
when the VARCHAR (so called "non-native") variant is produced;
|
see the :paramref:`.Enum.create_constraint` flag.
|
|
The :class:`.Enum` type also provides in-Python validation of string
|
values during both read and write operations. When reading a value
|
from the database in a result set, the string value is always checked
|
against the list of possible values and a ``LookupError`` is raised
|
if no match is found. When passing a value to the database as a
|
plain string within a SQL statement, if the
|
:paramref:`.Enum.validate_strings` parameter is
|
set to True, a ``LookupError`` is raised for any string value that's
|
not located in the given list of possible values; note that this
|
impacts usage of LIKE expressions with enumerated values (an unusual
|
use case).
|
|
The source of enumerated values may be a list of string values, or
|
alternatively a PEP-435-compliant enumerated class. For the purposes
|
of the :class:`.Enum` datatype, this class need only provide a
|
``__members__`` method.
|
|
When using an enumerated class, the enumerated objects are used
|
both for input and output, rather than strings as is the case with
|
a plain-string enumerated type::
|
|
import enum
|
from sqlalchemy import Enum
|
|
class MyEnum(enum.Enum):
|
one = 1
|
two = 2
|
three = 3
|
|
t = Table(
|
'data', MetaData(),
|
Column('value', Enum(MyEnum))
|
)
|
|
connection.execute(t.insert(), {"value": MyEnum.two})
|
assert connection.scalar(t.select()) is MyEnum.two
|
|
Above, the string names of each element, e.g. "one", "two", "three",
|
are persisted to the database; the values of the Python Enum, here
|
indicated as integers, are **not** used; the value of each enum can
|
therefore be any kind of Python object whether or not it is persistable.
|
|
In order to persist the values and not the names, the
|
:paramref:`.Enum.values_callable` parameter may be used. The value of
|
this parameter is a user-supplied callable, which is intended to be used
|
with a PEP-435-compliant enumerated class and returns a list of string
|
values to be persisted. For a simple enumeration that uses string values,
|
a callable such as ``lambda x: [e.value for e in x]`` is sufficient.
|
|
.. seealso::
|
|
:ref:`orm_declarative_mapped_column_enums` - background on using
|
the :class:`_sqltypes.Enum` datatype with the ORM's
|
:ref:`ORM Annotated Declarative <orm_declarative_mapped_column>`
|
feature.
|
|
:class:`_postgresql.ENUM` - PostgreSQL-specific type,
|
which has additional functionality.
|
|
:class:`.mysql.ENUM` - MySQL-specific type
|
|
ÚenumÚobjectr )Úenumsr c O s | ||¡ dS )a¸ Construct an enum.
|
|
Keyword arguments which don't apply to a specific backend are ignored
|
by that backend.
|
|
:param \*enums: either exactly one PEP-435 compliant enumerated type
|
or one or more string labels.
|
|
:param create_constraint: defaults to False. When creating a
|
non-native enumerated type, also build a CHECK constraint on the
|
database against the valid values.
|
|
.. note:: it is strongly recommended that the CHECK constraint
|
have an explicit name in order to support schema-management
|
concerns. This can be established either by setting the
|
:paramref:`.Enum.name` parameter or by setting up an
|
appropriate naming convention; see
|
:ref:`constraint_naming_conventions` for background.
|
|
.. versionchanged:: 1.4 - this flag now defaults to False, meaning
|
no CHECK constraint is generated for a non-native enumerated
|
type.
|
|
:param metadata: Associate this type directly with a ``MetaData``
|
object. For types that exist on the target database as an
|
independent schema construct (PostgreSQL), this type will be
|
created and dropped within ``create_all()`` and ``drop_all()``
|
operations. If the type is not associated with any ``MetaData``
|
object, it will associate itself with each ``Table`` in which it is
|
used, and will be created when any of those individual tables are
|
created, after a check is performed for its existence. The type is
|
only dropped when ``drop_all()`` is called for that ``Table``
|
object's metadata, however.
|
|
The value of the :paramref:`_schema.MetaData.schema` parameter of
|
the :class:`_schema.MetaData` object, if set, will be used as the
|
default value of the :paramref:`_types.Enum.schema` on this object
|
if an explicit value is not otherwise supplied.
|
|
.. versionchanged:: 1.4.12 :class:`_types.Enum` inherits the
|
:paramref:`_schema.MetaData.schema` parameter of the
|
:class:`_schema.MetaData` object if present, when passed using
|
the :paramref:`_types.Enum.metadata` parameter.
|
|
:param name: The name of this type. This is required for PostgreSQL
|
and any future supported database which requires an explicitly
|
named type, or an explicitly named constraint in order to generate
|
the type and/or a table that uses it. If a PEP-435 enumerated
|
class was used, its name (converted to lower case) is used by
|
default.
|
|
:param native_enum: Use the database's native ENUM type when
|
available. Defaults to True. When False, uses VARCHAR + check
|
constraint for all backends. When False, the VARCHAR length can be
|
controlled with :paramref:`.Enum.length`; currently "length" is
|
ignored if native_enum=True.
|
|
:param length: Allows specifying a custom length for the VARCHAR
|
when a non-native enumeration datatype is used. By default it uses
|
the length of the longest value.
|
|
.. versionchanged:: 2.0.0 The :paramref:`.Enum.length` parameter
|
is used unconditionally for ``VARCHAR`` rendering regardless of
|
the :paramref:`.Enum.native_enum` parameter, for those backends
|
where ``VARCHAR`` is used for enumerated datatypes.
|
|
|
:param schema: Schema name of this type. For types that exist on the
|
target database as an independent schema construct (PostgreSQL),
|
this parameter specifies the named schema in which the type is
|
present.
|
|
If not present, the schema name will be taken from the
|
:class:`_schema.MetaData` collection if passed as
|
:paramref:`_types.Enum.metadata`, for a :class:`_schema.MetaData`
|
that includes the :paramref:`_schema.MetaData.schema` parameter.
|
|
.. versionchanged:: 1.4.12 :class:`_types.Enum` inherits the
|
:paramref:`_schema.MetaData.schema` parameter of the
|
:class:`_schema.MetaData` object if present, when passed using
|
the :paramref:`_types.Enum.metadata` parameter.
|
|
Otherwise, if the :paramref:`_types.Enum.inherit_schema` flag is set
|
to ``True``, the schema will be inherited from the associated
|
:class:`_schema.Table` object if any; when
|
:paramref:`_types.Enum.inherit_schema` is at its default of
|
``False``, the owning table's schema is **not** used.
|
|
|
:param quote: Set explicit quoting preferences for the type's name.
|
|
:param inherit_schema: When ``True``, the "schema" from the owning
|
:class:`_schema.Table`
|
will be copied to the "schema" attribute of this
|
:class:`.Enum`, replacing whatever value was passed for the
|
``schema`` attribute. This also takes effect when using the
|
:meth:`_schema.Table.to_metadata` operation.
|
|
:param validate_strings: when True, string values that are being
|
passed to the database in a SQL statement will be checked
|
for validity against the list of enumerated values. Unrecognized
|
values will result in a ``LookupError`` being raised.
|
|
:param values_callable: A callable which will be passed the PEP-435
|
compliant enumerated type, which should then return a list of string
|
values to be persisted. This allows for alternate usages such as
|
using the string value of an enum to be persisted to the database
|
instead of its name.
|
|
.. versionadded:: 1.2.3
|
|
:param sort_key_function: a Python callable which may be used as the
|
"key" argument in the Python ``sorted()`` built-in. The SQLAlchemy
|
ORM requires that primary key columns which are mapped must
|
be sortable in some way. When using an unsortable enumeration
|
object such as a Python 3 ``Enum`` object, this parameter may be
|
used to set a default sort key function for the objects. By
|
default, the database value of the enumeration is used as the
|
sorting function.
|
|
.. versionadded:: 1.3.8
|
|
:param omit_aliases: A boolean that when true will remove aliases from
|
pep 435 enums. defaults to ``True``.
|
|
.. versionchanged:: 2.0 This parameter now defaults to True.
|
|
N)Ú
|
_enum_init)rE r1 r rF rF rG ry s z Enum.__init__c C s | j d k r| j gS | jS d S rA )Ú
|
enum_classr1 rD rF rF rG Ú_enums_argument s
|
zEnum._enums_argumentc sr | dd¡| _| dd¡| _| dd¡| _| dt¡| _| dt¡}| d d¡| _| d
|
d¡}| ||¡\}}| |||¡ | d d¡| _ | j
|
r¬t d d | j
|
D | _ }n
|
d | _ }|tk rÞ|sÚ||k rÚt d||f |}d | jd< | jd< t j|d | jr | d| jj ¡ ¡ tj| | dd¡| dd¡| dd¡| dd¡| dd¡| dd¡| dd¡d dS )zéinternal init for :class:`.Enum` and subclasses.
|
|
friendly init helper used by subclasses to remove
|
all the Enum-specific keyword arguments from kw. Allows all
|
other arguments in kw to pass through.
|
|
Ú native_enumTÚcreate_constraintFÚvalues_callableNÚsort_key_functionrw Ú omit_aliasesÚ_disable_warningsÚvalidate_stringsc s s | ]}t |V qd S rA )Úlen©Ú.0ÚxrF rF rG Ú <genexpr>ª s z"Enum._enum_init.<locals>.<genexpr>r z`When provided, length must be larger or equal than the length of the longest enum value. %s < %srí rü rÿ r r r r r rþ )r- r5 r6 r7 r Ú_sort_key_functionÚ _omit_aliasesÚ_parse_into_valuesÚ_setup_for_valuesr; r1 ÚmaxÚ_default_lengthÚ
|
ValueErrorÚ _valid_lookupÚ_object_lookuprg ry r3 r rW Úlowerrû )rE r1 r Z
|
length_argr: ÚvaluesÚobjectsrw ri rF rG r2 sF
|
þÿ
|
|
|
|
|
|
|
øzEnum._enum_initc s° |sd|kr| d¡}t|dkrt|d dr|d | _| jj}| jdkrdtdd | ¡ D n| | jr|| | j¡}nt } fdd D }||fS d | _||fS d S )
|
NÚ_enumsr r Ú __members__Tc s s$ | ] \}}|j |kr||fV qd S rA )rü )r> ÚnÚvrF rF rG r@ Ó s
|
z*Enum._parse_into_values.<locals>.<genexpr>c s g | ] } | qS rF rF )r> Úk©ÚmembersrF rG Ú
|
<listcomp>Ü s z+Enum._parse_into_values.<locals>.<listcomp>)
|
r- r< Úhasattrr3 rN rB r. Úitemsr7 Úlist)rE r1 r Z_membersrK rL rF rR rG rC È s"
|
|
|
ÿ
|
zEnum._parse_into_values©r~ rN c C s& t |}| |||¡}|d k s"t|S rA )rO Ú_resolve_for_python_typerR )rE r~ Útvr+ rF rF rG r â s zEnum._resolve_for_literalz Type[Any]r8 zOptional[Enum])r Ú
|
matched_onÚmatched_on_flattenedrN c C sì | j tjgk}d }|s&||kr&| j }nnt|rpt|}dd |D }|rjt dd dd |D ¡ d¡d}n$t|t rt
|
|tjr|g}n| j }| i ¡}| d d ¡ |dkrºd|d
|
< | j d krÈtn| j |d < tt| jf d |i|S )Nc S s g | ]}t |ts|qS rF )rQ r )r> ÚargrF rF rG rT s
|
z1Enum._resolve_for_python_type.<locals>.<listcomp>z@Can't create string-based Enum datatype from non-string values: ú, c s s | ]}t |V qd S rA )Úreprr= rF rF rG r@ s z0Enum._resolve_for_python_type.<locals>.<genexpr>z@. Please provide an explicit Enum datatype for this Python typeFrü r5 r rw rM )r4 r/ r. r/ r1 r) Ú ArgumentErrorÚjoinrQ rO Ú
|
issubclassÚ _make_enum_kwr- rw r r Ú_generic_type_affinity) rE r r[ r\ Zwe_are_generic_formr5 Z enum_argsZbad_argsr rF rF rG rY è s6
|
ÿ ÿ
|
þz Enum._resolve_for_python_typec sP t | _ttt|t| _tt|| _ j fdd|D ¡ d S )Nc s g | ]}| j j| fqS rF )rH rI )r> r~ rD rF rG rT ( s ÿz*Enum._setup_for_values.<locals>.<listcomp>)rW r1 r ÚzipÚreversedrH rI Úupdate)rE rK rL r rF rD rG rD s
|
|
þÿzEnum._setup_for_valuesc C s | j tkr| jS | j S d S rA )rA r Ú_db_value_for_elemrD rF rF rG r8 . s
|
zEnum.sort_key_functionc C s | j S rA )r5 rD rF rF rG Únative5 s z Enum.nativec
|
C sn z | j | W S tk
|
rh } z>| js:t|tr:| W Y ¢$S td|| jt | j ¡f |W 5 d }~X Y nX d S ©NzM'%s' is not among the defined enum values. Enum name: %s. Possible values: %s)
|
rH ÚKeyErrorr; rQ r Ú LookupErrorrü r- Úrepr_tuple_namesr1 ©rE ÚelemÚerrrF rF rG rh 9 s
|
ýþÿøzEnum._db_value_for_elemc s4 e Zd ZU dZded< dddd fdd Z ZS )
|
zEnum.ComparatorrF rr rO r4 rI rJ rK c s0 t ||¡\}}|tjkr(t| jj}||fS rA )rg rV r re rr rO rw )rE rL rM r+ ri rF rG rV W s
|
z!Enum.Comparator._adapt_expression)rW rX rY rZ ra rV rk rF rF ri rG r\ R s
|
r\ c
|
C sR z | j | W S tk
|
rL } z"td|| jt | j¡f |W 5 d }~X Y nX d S rj )rI rk rl rü r- rm r1 rn rF rF rG Ú_object_value_for_elemc s
|
ýþÿøzEnum._object_value_for_elemc C s t j| ddd| jfgttgdS )N)r5 T)r6 Frw )Z additional_kwZ
|
to_inspect)r+ Z generic_reprrF r. rû rD rF rF rG Ú__repr__q s ýùz Enum.__repr__Fc C s4 t | dr| j}ntdtj| | jf|ddiS )Nr1 zpTypeEngine.as_generic() heuristic is undefined for types that inherit Enum but do not have an `enums` attribute.r: T)rU r1 rC r+ Zconstructor_copyrd )rE Zallow_nulltypeÚargsrF rF rG Ú
|
as_generic| s
|
ÿ ÿÿÿzEnum.as_genericc C s | d| j¡ | d| j¡ | d| j¡ | d| j¡ | d| j¡ | d| j¡ | d| j¡ | d| j¡ | d | j ¡ | d
|
| j
|
¡ |S ) Nr; rü rÿ r r r5 r7 r6 rw r9 ) r r; rü rÿ r r r5 r7 r6 rw rB r rF rF rG rc s zEnum._make_enum_kwc K s4 | |¡ d|d< | dd¡ d|ks*t|f |S )NTr: r FrM )rc r rR ©rE Zimpltyper rF rF rG Úadapt_to_emulated s
|
|
zEnum.adapt_to_emulatedc s" | j |d< d|d< t j|f|S )NrM Tr: )r4 rg r ru ri rF rG r s
|
z
|
Enum.adaptc K s$ | |j|¡sdS | j p"|jj S ©NF)r& r r5 Zsupports_native_enum©rE Úcompilerr rF rF rG Ú_should_create_constraint£ s ÿz Enum._should_create_constraintúsqlalchemy.sql.schemac C s| t jj}t | ||¡ | js d S | |¡}|jt|t
|
| j ¡| j d krNt n| j t | jd|i¡dd}|j|ksxtd S )Nr T©rü Z _create_ruleZ _type_bound)r+ Ú preloadedÚ
|
sql_schemarû r r6 r ÚCheckConstraintÚ type_coercerr Úin_r1 rü r r rz r rR ©rE r r rÿ r ÚerF rF rG r ª s
|
þù zEnum._set_tablec s t |¡ fdd}|S )Nc s | ¡} r | } | S rA ©rh r
©Zparent_processorrE rF rG r  s
|
z'Enum.literal_processor.<locals>.process)rg r r ri r
rG r ¿ s zEnum.literal_processorc s t |¡ fdd}|S )Nc s | ¡} r | } | S rA r r
r
rF rG r Í s
|
z$Enum.bind_processor.<locals>.process)rg r r ri r
rG r Ê s zEnum.bind_processorc s t ||¡ fdd}|S )Nc s r | } | ¡} | S rA )rq r
r
rF rG r Ø s
|
z&Enum.result_processor.<locals>.process)rg r rô ri r
rG r Õ s zEnum.result_processorc K s t j| f|S rA )rû r r rF rF rG r á s z Enum.copyc s | j r | j S t jS d S rA )r3 rg r rD ri rF rG r ä s zEnum.python_type)F)$rW rX rY r_ r ry r` r4 r2 rC r rY rD r8 ri rh rr r\ r r^ rq rr rt rc rv r rz r+ Úpreload_moduler r r r r r rk rF rF ri rG r. ¾ sB J
|
38
|
|
|
|
r. c s` e Zd ZdZeZdZejdddfddddd fd d
|
Z d d Z
|
d d Z dd Z dd Z ZS )Ú
|
PickleTypea© Holds Python objects, which are serialized using pickle.
|
|
PickleType builds upon the Binary type to apply Python's
|
``pickle.dumps()`` to incoming objects, and ``pickle.loads()`` on
|
the way out, allowing any pickleable Python object to be stored as
|
a serialized binary field.
|
|
To allow ORM change events to propagate for elements associated
|
with :class:`.PickleType`, see :ref:`mutable_toplevel`.
|
|
TNr§ r z$Optional[Callable[[Any, Any], bool]]z"Optional[_TypeEngineArgument[Any]])ÚprotocolÚpicklerÚ
|
comparatorÚimplc s2 || _ |p t| _|| _t ¡ |r.t|| _dS )a×
|
Construct a PickleType.
|
|
:param protocol: defaults to ``pickle.HIGHEST_PROTOCOL``.
|
|
:param pickler: defaults to pickle. May be any object with
|
pickle-compatible ``dumps`` and ``loads`` methods.
|
|
:param comparator: a 2-arg callable predicate used
|
to compare values of this type. If left as ``None``,
|
the Python "equals" operator is used to compare values.
|
|
:param impl: A binary-storing :class:`_types.TypeEngine` class or
|
instance to use in place of the default :class:`_types.LargeBinary`.
|
For example the :class: `_mysql.LONGBLOB` class may be more effective
|
when using MySQL.
|
|
.. versionadded:: 1.4.20
|
|
N)r Úpickler r rg ry r! r )rE r r r r ri rF rG ry ü s
|
|
zPickleType.__init__c C s t | jd | jffS rA )r r r rD rF rF rG Ú
|
__reduce__! s zPickleType.__reduce__c sF | j |¡}| jj | j|r4| fdd}n fdd}|S )Nc s | d k r | } | S rA rF r
©ÚdumpsÚfixed_impl_processorr rF rG r + s
|
z*PickleType.bind_processor.<locals>.processc s | d k r | } | S rA rF r
)r r rF rG r 2 s
|
)Ú impl_instancer r r r ©rE r Úimpl_processorr rF r rG r $ s zPickleType.bind_processorc s> | j ||¡}| jj|r.| fdd}n fdd}|S )Nc s | } | d krd S | S rA rF r
©r ÚloadsrF rG r ? s z,PickleType.result_processor.<locals>.processc s | d kr d S | S rA rF r
)r rF rG r G s )r r r r ©rE r r r r rF r rG r 9 s zPickleType.result_processorc C s | j r| ||¡S ||kS d S rA )r ©rE r? ÚyrF rF rG Úcompare_valuesN s zPickleType.compare_values)rW rX rY r_ rú r Úcache_okr ÚHIGHEST_PROTOCOLry r r r r rk rF rF ri rG r ì s û%r c @ s e Zd ZdZdZdZdddddd d
|
d Zd d Ze d¡dd Z
|
e dd Z e dddgZdd Zdd Zdd Zdd ZdS ) ÚBooleanaÇ A bool datatype.
|
|
:class:`.Boolean` typically uses BOOLEAN or SMALLINT on the DDL side,
|
and on the Python side deals in ``True`` or ``False``.
|
|
The :class:`.Boolean` datatype currently has two levels of assertion
|
that the values persisted are simple true/false values. For all
|
backends, only the Python values ``None``, ``True``, ``False``, ``1``
|
or ``0`` are accepted as parameter values. For those backends that
|
don't support a "native boolean" datatype, an option exists to
|
also create a CHECK constraint on the target column
|
|
.. versionchanged:: 1.2 the :class:`.Boolean` datatype now asserts that
|
incoming Python values are already in pure boolean form.
|
|
|
ÚbooleanTFNrÁ ru rý )r6 rü r r c C s* || _ || _|| _|r&| j |j¡| _dS )a Construct a Boolean.
|
|
:param create_constraint: defaults to False. If the boolean
|
is generated as an int/smallint, also create a CHECK constraint
|
on the table that ensures 1 or 0 as a value.
|
|
.. note:: it is strongly recommended that the CHECK constraint
|
have an explicit name in order to support schema-management
|
concerns. This can be established either by setting the
|
:paramref:`.Boolean.name` parameter or by setting up an
|
appropriate naming convention; see
|
:ref:`constraint_naming_conventions` for background.
|
|
.. versionchanged:: 1.4 - this flag now defaults to False, meaning
|
no CHECK constraint is generated for a non-native enumerated
|
type.
|
|
:param name: if a CHECK constraint is generated, specify
|
the name of the constraint.
|
|
N)r6 rü r r r )rE r6 rü r r rF rF rG ry l s
|
zBoolean.__init__c K s$ | |j|¡sdS |jj o"|jjS rw )r& r Úsupports_native_booleanZ#non_native_boolean_check_constraintrx rF rF rG rz s
|
|
þz!Boolean._should_create_constraintr{ c C sn t jj}| jsd S | |¡}|jt|| ddg¡| jd kr@t n| jt
|
| j d|i¡dd}|j |ksjt d S )Nr r r Tr| )r+ r} r~ r6 r r r r rü r r rz r rR r rF rF rG r s
|
þù zBoolean._set_tablec C s t S rA )rÁ rD rF rF rG r © s zBoolean.python_typec C s6 || j kr2t|ts$td|f ntd|f |S )NzNot a boolean value: %rz$Value %r is not None, True, or False)Ú _strict_boolsrQ r§ Ú TypeErrorrG r} rF rF rG Ú_strict_as_bool¯ s
|
|
ÿzBoolean._strict_as_boolc s4 | |d ¡}| d ¡| d ¡ fdd}|S )Nc s | ¡rS S rA )r¡ r
©ÚfalserE ÚtruerF rG r ¾ s z*Boolean.literal_processor.<locals>.process)Zstatement_compilerZ
|
visit_trueZ visit_false)rE r ry r rF r¢ rG r ¹ s
|
|
|
zBoolean.literal_processorc s( | j |jrt nt fdd}|S )Nc s | } | d k r | } | S rA rF r
©Z_coercer¡ rF rG r Í s z'Boolean.bind_processor.<locals>.process)r¡ r rÁ r§ r rF r¥ rG r à s zBoolean.bind_processorc C s |j r
|
d S tjS d S rA )r r, Zint_to_booleanr rF rF rG r Õ s zBoolean.result_processor)FNTN)rW rX rY r_ r ri ry rz r+ r r r` r Ú frozensetr r¡ r r r rF rF rF rG r U s$ û"
|
|
|
|
r c @ s. e Zd Zejdd ZejddddZdS )Ú_AbstractIntervalc C s@ t jttt| jttttit jt| jit jt | jit j
|
t | jiiS rA ) r rc r« rÝ r® rj ré r± r r¬ r¯ rD rF rF rG rH Ý s" ü ÷z)_AbstractInterval._expression_adaptationszType[Interval]r¤ c C s t S rA )r® rD rF rF rG rP î s z _AbstractInterval._type_affinityN)rW rX rY r+ r³ rH Zro_non_memoized_propertyrP rF rF rF rG r§ Ü s
|
r§ c s e Zd ZdZeZej d¡Z dZ
|
d dddd fdd Z G d
|
d d e j e ej e Z e Zed d Zdd Zdd ZdddddZddddddZ ZS ) r® a« A type for ``datetime.timedelta()`` objects.
|
|
The Interval type deals with ``datetime.timedelta`` objects. In
|
PostgreSQL, the native ``INTERVAL`` type is used; for others, the
|
value is stored as a date which is relative to the "epoch"
|
(Jan. 1, 1970).
|
|
Note that the ``Interval`` type does not currently provide date arithmetic
|
operations on platforms which do not support interval types natively. Such
|
operations usually require transformation of both sides of the expression
|
(such as, conversion of both sides into integer epoch values first) which
|
currently is a manual procedure (such as via
|
:attr:`~sqlalchemy.sql.expression.func`).
|
|
r TNrÁ rt )ri Úsecond_precisionÚ day_precisionc s t ¡ || _|| _|| _dS )a; Construct an Interval object.
|
|
:param native: when True, use the actual
|
INTERVAL type provided by the database, if
|
supported (currently PostgreSQL, Oracle).
|
Otherwise, represent the interval data as
|
an epoch value regardless.
|
|
:param second_precision: For native interval types
|
which support a "fractional seconds precision" parameter,
|
i.e. Oracle and PostgreSQL
|
|
:param day_precision: for native interval types which
|
support a "day precision" parameter, i.e. Oracle.
|
|
N)rg ry ri r¨ r© )rE ri r¨ r© ri rF rG ry s
|
zInterval.__init__c @ s e Zd ZdZdS )zInterval.ComparatorrF N)rW rX rY rZ rF rF rF rG r\ $ s r\ c C s t jS rA )rç Ú timedeltarD rF rF rG r , s zInterval.python_typec K s t j| |f|S rA )r§ r ru rF rF rG rv 0 s zInterval.adapt_to_emulatedc C s | j ||¡S rA )r r÷ rø rF rF rG r÷ 3 s z Interval.coerce_compared_valuer: z _BindProcessorType[dt.timedelta])r rN c s^ t rt| jtst| j |¡}| j |rF|ddd fdd }nddd fdd }|S )NúOptional[dt.timedelta]r rX c s | d k r | }nd }|S rA rF ©r~ Zdt_value©Úepochr rF rG r @ s
|
z(Interval.bind_processor.<locals>.processc s | d k r | }nd }|S rA rF r¬ ©r® rF rG r K s
|
)r rQ r rÝ rR r r® r rF r rG r 6 s zInterval.bind_processorr z"_ResultProcessorType[dt.timedelta])r r rN c s` t rt| jtst| j ||¡}| j |rH|ddd fdd }nddd fdd }|S )Nr r« rX c s | }|d krd S | S rA rF r¬ r rF rG r ` s z*Interval.result_processor.<locals>.processc s | d kr d S | S rA rF r
r¯ rF rG r h s )r rQ r rÝ rR r r® r rF r rG r V s zInterval.result_processor)TNN)rW rX rY r_ rÝ r rç rÞ Úutcfromtimestampr® r ry r" r\ r= r§ r^ r` r rv r÷ r r rk rF rF ri rG r® ó s& ü
|
þ
|
r® c @ sô e Zd ZdZd ZdZe d¡Zd"ddddZ G dd d e
|
e Z G d
|
d d e Z G d d d e ZG dd de ZG dd de ZG dd deje eje ZeZedd Zedd Zejdd Zejdd Zdd Z d d Z d d Z d!S )#ÚJSONa Represent a SQL JSON type.
|
|
.. note:: :class:`_types.JSON`
|
is provided as a facade for vendor-specific
|
JSON types. Since it supports JSON SQL operations, it only
|
works on backends that have an actual JSON type, currently:
|
|
* PostgreSQL - see :class:`sqlalchemy.dialects.postgresql.JSON` and
|
:class:`sqlalchemy.dialects.postgresql.JSONB` for backend-specific
|
notes
|
|
* MySQL - see
|
:class:`sqlalchemy.dialects.mysql.JSON` for backend-specific notes
|
|
* SQLite as of version 3.9 - see
|
:class:`sqlalchemy.dialects.sqlite.JSON` for backend-specific notes
|
|
* Microsoft SQL Server 2016 and later - see
|
:class:`sqlalchemy.dialects.mssql.JSON` for backend-specific notes
|
|
:class:`_types.JSON` is part of the Core in support of the growing
|
popularity of native JSON datatypes.
|
|
The :class:`_types.JSON` type stores arbitrary JSON format data, e.g.::
|
|
data_table = Table('data_table', metadata,
|
Column('id', Integer, primary_key=True),
|
Column('data', JSON)
|
)
|
|
with engine.connect() as conn:
|
conn.execute(
|
data_table.insert(),
|
{"data": {"key1": "value1", "key2": "value2"}}
|
)
|
|
**JSON-Specific Expression Operators**
|
|
The :class:`_types.JSON`
|
datatype provides these additional SQL operations:
|
|
* Keyed index operations::
|
|
data_table.c.data['some key']
|
|
* Integer index operations::
|
|
data_table.c.data[3]
|
|
* Path index operations::
|
|
data_table.c.data[('key_1', 'key_2', 5, ..., 'key_n')]
|
|
* Data casters for specific JSON element types, subsequent to an index
|
or path operation being invoked::
|
|
data_table.c.data["some key"].as_integer()
|
|
.. versionadded:: 1.3.11
|
|
Additional operations may be available from the dialect-specific versions
|
of :class:`_types.JSON`, such as
|
:class:`sqlalchemy.dialects.postgresql.JSON` and
|
:class:`sqlalchemy.dialects.postgresql.JSONB` which both offer additional
|
PostgreSQL-specific operations.
|
|
**Casting JSON Elements to Other Types**
|
|
Index operations, i.e. those invoked by calling upon the expression using
|
the Python bracket operator as in ``some_column['some key']``, return an
|
expression object whose type defaults to :class:`_types.JSON` by default,
|
so that
|
further JSON-oriented instructions may be called upon the result type.
|
However, it is likely more common that an index operation is expected
|
to return a specific scalar element, such as a string or integer. In
|
order to provide access to these elements in a backend-agnostic way,
|
a series of data casters are provided:
|
|
* :meth:`.JSON.Comparator.as_string` - return the element as a string
|
|
* :meth:`.JSON.Comparator.as_boolean` - return the element as a boolean
|
|
* :meth:`.JSON.Comparator.as_float` - return the element as a float
|
|
* :meth:`.JSON.Comparator.as_integer` - return the element as an integer
|
|
These data casters are implemented by supporting dialects in order to
|
assure that comparisons to the above types will work as expected, such as::
|
|
# integer comparison
|
data_table.c.data["some_integer_key"].as_integer() == 5
|
|
# boolean comparison
|
data_table.c.data["some_boolean"].as_boolean() == True
|
|
.. versionadded:: 1.3.11 Added type-specific casters for the basic JSON
|
data element types.
|
|
.. note::
|
|
The data caster functions are new in version 1.3.11, and supersede
|
the previous documented approaches of using CAST; for reference,
|
this looked like::
|
|
from sqlalchemy import cast, type_coerce
|
from sqlalchemy import String, JSON
|
cast(
|
data_table.c.data['some_key'], String
|
) == type_coerce(55, JSON)
|
|
The above case now works directly as::
|
|
data_table.c.data['some_key'].as_integer() == 5
|
|
For details on the previous comparison approach within the 1.3.x
|
series, see the documentation for SQLAlchemy 1.2 or the included HTML
|
files in the doc/ directory of the version's distribution.
|
|
**Detecting Changes in JSON columns when using the ORM**
|
|
The :class:`_types.JSON` type, when used with the SQLAlchemy ORM, does not
|
detect in-place mutations to the structure. In order to detect these, the
|
:mod:`sqlalchemy.ext.mutable` extension must be used, most typically
|
using the :class:`.MutableDict` class. This extension will
|
allow "in-place" changes to the datastructure to produce events which
|
will be detected by the unit of work. See the example at :class:`.HSTORE`
|
for a simple example involving a dictionary.
|
|
Alternatively, assigning a JSON structure to an ORM element that
|
replaces the old one will always trigger a change event.
|
|
**Support for JSON null vs. SQL NULL**
|
|
When working with NULL values, the :class:`_types.JSON` type recommends the
|
use of two specific constants in order to differentiate between a column
|
that evaluates to SQL NULL, e.g. no value, vs. the JSON-encoded string of
|
``"null"``. To insert or select against a value that is SQL NULL, use the
|
constant :func:`.null`. This symbol may be passed as a parameter value
|
specifically when using the :class:`_types.JSON` datatype, which contains
|
special logic that interprets this symbol to mean that the column value
|
should be SQL NULL as opposed to JSON ``"null"``::
|
|
from sqlalchemy import null
|
conn.execute(table.insert(), {"json_value": null()})
|
|
To insert or select against a value that is JSON ``"null"``, use the
|
constant :attr:`_types.JSON.NULL`::
|
|
conn.execute(table.insert(), {"json_value": JSON.NULL})
|
|
The :class:`_types.JSON` type supports a flag
|
:paramref:`_types.JSON.none_as_null` which when set to True will result
|
in the Python constant ``None`` evaluating to the value of SQL
|
NULL, and when set to False results in the Python constant
|
``None`` evaluating to the value of JSON ``"null"``. The Python
|
value ``None`` may be used in conjunction with either
|
:attr:`_types.JSON.NULL` and :func:`.null` in order to indicate NULL
|
values, but care must be taken as to the value of the
|
:paramref:`_types.JSON.none_as_null` in these cases.
|
|
**Customizing the JSON Serializer**
|
|
The JSON serializer and deserializer used by :class:`_types.JSON`
|
defaults to
|
Python's ``json.dumps`` and ``json.loads`` functions; in the case of the
|
psycopg2 dialect, psycopg2 may be using its own custom loader function.
|
|
In order to affect the serializer / deserializer, they are currently
|
configurable at the :func:`_sa.create_engine` level via the
|
:paramref:`_sa.create_engine.json_serializer` and
|
:paramref:`_sa.create_engine.json_deserializer` parameters. For example,
|
to turn off ``ensure_ascii``::
|
|
engine = create_engine(
|
"sqlite://",
|
json_serializer=lambda obj: json.dumps(obj, ensure_ascii=False))
|
|
.. versionchanged:: 1.3.7
|
|
SQLite dialect's ``json_serializer`` and ``json_deserializer``
|
parameters renamed from ``_json_serializer`` and
|
``_json_deserializer``.
|
|
.. seealso::
|
|
:class:`sqlalchemy.dialects.postgresql.JSON`
|
|
:class:`sqlalchemy.dialects.postgresql.JSONB`
|
|
:class:`sqlalchemy.dialects.mysql.JSON`
|
|
:class:`sqlalchemy.dialects.sqlite.JSON`
|
|
FZ JSON_NULLrÁ ©Ú none_as_nullc C s
|
|| _ dS )a Construct a :class:`_types.JSON` type.
|
|
:param none_as_null=False: if True, persist the value ``None`` as a
|
SQL NULL value, not the JSON encoding of ``null``. Note that when this
|
flag is False, the :func:`.null` construct can still be used to
|
persist a NULL value, which may be passed directly as a parameter
|
value that is specially interpreted by the :class:`_types.JSON` type
|
as SQL NULL::
|
|
from sqlalchemy import null
|
conn.execute(table.insert(), {"data": null()})
|
|
.. note::
|
|
:paramref:`_types.JSON.none_as_null` does **not** apply to the
|
values passed to :paramref:`_schema.Column.default` and
|
:paramref:`_schema.Column.server_default`; a value of ``None``
|
passed for these parameters means "no default present".
|
|
Additionally, when used in SQL comparison expressions, the
|
Python value ``None`` continues to refer to SQL null, and not
|
JSON NULL. The :paramref:`_types.JSON.none_as_null` flag refers
|
explicitly to the **persistence** of the value within an
|
INSERT or UPDATE statement. The :attr:`_types.JSON.NULL`
|
value should be used for SQL expressions that wish to compare to
|
JSON null.
|
|
.. seealso::
|
|
:attr:`.types.JSON.NULL`
|
|
Nr² )rE r³ rF rF rG ry c s !z JSON.__init__c @ s< e Zd ZdZe Ze Zdd Zdd Z dd Z
|
dd Z d
|
S ) zJSON.JSONElementTypez?Common function for index / path elements in a JSON expression.c C s | j |¡S rA )Ú_stringÚ_cached_bind_processorr rF rF rG Ústring_bind_processor s z*JSON.JSONElementType.string_bind_processorc C s | j |¡S rA )r´ Ú_cached_literal_processorr rF rF rG Ústring_literal_processor s z-JSON.JSONElementType.string_literal_processorc s( | j |¡ | |¡ fdd}|S )Nc s2 rt | tr | } nr.t | tr.| } | S rA ©rQ r§ r r
©Z int_processorZstring_processorrF rG r s
|
|
z4JSON.JSONElementType.bind_processor.<locals>.process)Ú_integerrµ r¶ r rF rº rG r s
|
z#JSON.JSONElementType.bind_processorc s( | j |¡ | |¡ fdd}|S )Nc s2 rt | tr | } nr.t | tr.| } | S rA r¹ r
rº rF rG r £ s
|
|
z7JSON.JSONElementType.literal_processor.<locals>.process)r» r· r¸ r rF rº rG r s
|
z&JSON.JSONElementType.literal_processorN) rW rX rY r_ r¢ r» rr r´ r¶ r¸ r r rF rF rF rG ÚJSONElementType s r¼ c @ s e Zd ZdZdS )zJSON.JSONIndexTypeúPlaceholder for the datatype of a JSON index value.
|
|
This allows execution-time processing of JSON index values
|
for special syntaxes.
|
|
N©rW rX rY r_ rF rF rF rG Ú JSONIndexType¬ s r¿ c @ s e Zd ZdZdS )zJSON.JSONIntIndexTyper½ Nr¾ rF rF rF rG ÚJSONIntIndexType´ s rÀ c @ s e Zd ZdZdS )zJSON.JSONStrIndexTyper½ Nr¾ rF rF rF rG ÚJSONStrIndexType¼ s rÁ c @ s e Zd ZdZdZdS )zJSON.JSONPathTypez£Placeholder type for JSON path operations.
|
|
This allows execution-time processing of a path-based
|
index value into a specific SQL syntax.
|
|
Z json_pathNr rF rF rF rG Ú JSONPathTypeÄ s r c @ sV e Zd ZdZdZdd Zdd Zdd Zd d
|
Zd d Z dddZ
|
dd Z dd Z dS )zJSON.Comparatorz6Define comparison operations for :class:`_types.JSON`.rF c C sx t |ts:t |tjr:tjtj|| jt j
|
t j d}t j
|
}n2tjtj|| jt j t |tr\t jnt jd}t j }||| jfS )N)rf ÚoperatorÚbindparam_type)rQ r Úcollections_abcr
|
r Úexpectr ÚBinaryElementRolerf r Újson_path_getitem_opr± r Újson_getitem_opr§ rÀ rÁ rO )rE rn rà rF rF rG ro Ó s. ÿûÿù z JSON.Comparator._setup_getitemc C s | t d¡S )aD Cast an indexed value as boolean.
|
|
e.g.::
|
|
stmt = select(
|
mytable.c.json_column['some_data'].as_boolean()
|
).where(
|
mytable.c.json_column['some_data'].as_boolean() == True
|
)
|
|
.. versionadded:: 1.3.11
|
|
Ú
|
as_boolean)Ú_binary_w_typer rD rF rF rG rÊ î s zJSON.Comparator.as_booleanc C s | t d¡S )a^ Cast an indexed value as string.
|
|
e.g.::
|
|
stmt = select(
|
mytable.c.json_column['some_data'].as_string()
|
).where(
|
mytable.c.json_column['some_data'].as_string() ==
|
'some string'
|
)
|
|
.. versionadded:: 1.3.11
|
|
Ú as_string)rË r rD rF rF rG rÌ þ s zJSON.Comparator.as_stringc C s | t d¡S )aA Cast an indexed value as integer.
|
|
e.g.::
|
|
stmt = select(
|
mytable.c.json_column['some_data'].as_integer()
|
).where(
|
mytable.c.json_column['some_data'].as_integer() == 5
|
)
|
|
.. versionadded:: 1.3.11
|
|
Ú
|
as_integer)rË r¢ rD rF rF rG rÍ
|
s zJSON.Comparator.as_integerc C s | t d¡S )a? Cast an indexed value as float.
|
|
e.g.::
|
|
stmt = select(
|
mytable.c.json_column['some_data'].as_float()
|
).where(
|
mytable.c.json_column['some_data'].as_float() == 29.75
|
)
|
|
.. versionadded:: 1.3.11
|
|
Úas_float)rË rÌ rD rF rF rG rÎ
|
s zJSON.Comparator.as_floatTc C s | t|||dd¡S )am Cast an indexed value as numeric/decimal.
|
|
e.g.::
|
|
stmt = select(
|
mytable.c.json_column['some_data'].as_numeric(10, 6)
|
).where(
|
mytable.c.
|
json_column['some_data'].as_numeric(10, 6) == 29.75
|
)
|
|
.. versionadded:: 1.4.0b2
|
|
)r¿ Ú
|
as_numeric)rË r¬ )rE r¼ r½ r¿ rF rF rG rÏ /
|
s ÿzJSON.Comparator.as_numericc C s | j S )a Cast an indexed value as JSON.
|
|
e.g.::
|
|
stmt = select(mytable.c.json_column['some_data'].as_json())
|
|
This is typically the default behavior of indexed elements in any
|
case.
|
|
Note that comparison of full JSON structures may not be
|
supported by all backends.
|
|
.. versionadded:: 1.3.11
|
|
)rf rD rF rF rG Úas_jsonB
|
s zJSON.Comparator.as_jsonc C sH t | jtjr"| jjtjtjfkr4t d||f ¡| j
|
¡ }||_ |S )Nz[The JSON cast operator JSON.%s() only works with a JSON index expression e.g. col['q'].%s()) rQ rf r ÚBinaryExpressionrà r rÉ rÈ r) ZInvalidRequestErrorZ_clonerO )rE r+ Ú method_namerf rF rF rG rË T
|
s" ÿþþþÿ
|
z JSON.Comparator._binary_w_typeN)T) rW rX rY r_ rZ ro rÊ rÌ rÍ rÎ rÏ rÐ rË rF rF rF rG r\ Î s
|
r\ c C s t S rA )r rD rF rF rG r f
|
s zJSON.python_typec C s | j S )z)Alias of :attr:`_types.JSON.none_as_null`r² rD rF rF rG Úshould_evaluate_nonej
|
s zJSON.should_evaluate_nonec C s | | _ d S rA r² r} rF rF rG rÓ o
|
s c C s t S rA )rr rD rF rF rG Ú _str_impls
|
s zJSON._str_implc s( r fdd}n fdd}|S )Nc s> | j krd } n t| tjs*| d kr.jr.d S | }|S rA ©ÚNULLrQ r ZNullr³ )r~ Z
|
serialized©Újson_serializerrE Ústring_processrF rG r z
|
s
|
ÿÿz*JSON._make_bind_processor.<locals>.processc s6 | j krd } n t| tjs*| d kr.jr.d S | S rA rÕ r
)rØ rE rF rG r
|
s
|
ÿÿrF )rE rÙ rØ r rF r× rG Ú_make_bind_processorw
|
s
|
zJSON._make_bind_processorc C s$ | j |¡}|jptj}| ||¡S rA )rÔ r Z_json_serializerÚjsonr rÚ )rE r rÙ rØ rF rF rG r
|
s zJSON.bind_processorc s, | j ||¡|jptj fdd}|S )Nc s | d kr d S r| } | S rA rF r
©Zjson_deserializerrÙ rF rG r
|
s
|
z&JSON.result_processor.<locals>.process)rÔ r Z_json_deserializerrÛ r rô rF rÜ rG r
|
s zJSON.result_processorN)F) rW rX rY r_ r Úhashabler+ ÚsymbolrÖ ry r# r r¼ r¿ rÀ rÁ r rm r\ r; rb r^ r` r rÓ Úsetterr³ rÔ rÚ r r rF rF rF rG r± p s2 D
|
,#&
|
|
|
|
|
r± c s¦ e Zd ZdZd ZdZdZG dd deje e
|
e je e
|
ZeZ dddd dd
|
d d Z ed d Zedd Zdd Zd ddZ fddZdd Zdd Z ZS ) r) aè Represent a SQL Array type.
|
|
.. note:: This type serves as the basis for all ARRAY operations.
|
However, currently **only the PostgreSQL backend has support for SQL
|
arrays in SQLAlchemy**. It is recommended to use the PostgreSQL-specific
|
:class:`sqlalchemy.dialects.postgresql.ARRAY` type directly when using
|
ARRAY types with PostgreSQL, as it provides additional operators
|
specific to that backend.
|
|
:class:`_types.ARRAY` is part of the Core in support of various SQL
|
standard functions such as :class:`_functions.array_agg`
|
which explicitly involve
|
arrays; however, with the exception of the PostgreSQL backend and possibly
|
some third-party dialects, no other SQLAlchemy built-in dialect has support
|
for this type.
|
|
An :class:`_types.ARRAY` type is constructed given the "type"
|
of element::
|
|
mytable = Table("mytable", metadata,
|
Column("data", ARRAY(Integer))
|
)
|
|
The above type represents an N-dimensional array,
|
meaning a supporting backend such as PostgreSQL will interpret values
|
with any number of dimensions automatically. To produce an INSERT
|
construct that passes in a 1-dimensional array of integers::
|
|
connection.execute(
|
mytable.insert(),
|
{"data": [1,2,3]}
|
)
|
|
The :class:`_types.ARRAY` type can be constructed given a fixed number
|
of dimensions::
|
|
mytable = Table("mytable", metadata,
|
Column("data", ARRAY(Integer, dimensions=2))
|
)
|
|
Sending a number of dimensions is optional, but recommended if the
|
datatype is to represent arrays of more than one dimension. This number
|
is used:
|
|
* When emitting the type declaration itself to the database, e.g.
|
``INTEGER[][]``
|
|
* When translating Python values to database values, and vice versa, e.g.
|
an ARRAY of :class:`.Unicode` objects uses this number to efficiently
|
access the string values inside of array structures without resorting
|
to per-row type inspection
|
|
* When used with the Python ``getitem`` accessor, the number of dimensions
|
serves to define the kind of type that the ``[]`` operator should
|
return, e.g. for an ARRAY of INTEGER with two dimensions::
|
|
>>> expr = table.c.column[5] # returns ARRAY(Integer, dimensions=1)
|
>>> expr = expr[6] # returns Integer
|
|
For 1-dimensional arrays, an :class:`_types.ARRAY` instance with no
|
dimension parameter will generally assume single-dimensional behaviors.
|
|
SQL expressions of type :class:`_types.ARRAY` have support for "index" and
|
"slice" behavior. The Python ``[]`` operator works normally here, given
|
integer indexes or slices. Arrays default to 1-based indexing.
|
The operator produces binary expression
|
constructs which will produce the appropriate SQL, both for
|
SELECT statements::
|
|
select(mytable.c.data[5], mytable.c.data[2:7])
|
|
as well as UPDATE statements when the :meth:`_expression.Update.values`
|
method
|
is used::
|
|
mytable.update().values({
|
mytable.c.data[5]: 7,
|
mytable.c.data[2:7]: [1, 2, 3]
|
})
|
|
The :class:`_types.ARRAY` type also provides for the operators
|
:meth:`.types.ARRAY.Comparator.any` and
|
:meth:`.types.ARRAY.Comparator.all`. The PostgreSQL-specific version of
|
:class:`_types.ARRAY` also provides additional operators.
|
|
.. container:: topic
|
|
**Detecting Changes in ARRAY columns when using the ORM**
|
|
The :class:`_sqltypes.ARRAY` type, when used with the SQLAlchemy ORM,
|
does not detect in-place mutations to the array. In order to detect
|
these, the :mod:`sqlalchemy.ext.mutable` extension must be used, using
|
the :class:`.MutableList` class::
|
|
from sqlalchemy import ARRAY
|
from sqlalchemy.ext.mutable import MutableList
|
|
class SomeOrmClass(Base):
|
# ...
|
|
data = Column(MutableList.as_mutable(ARRAY(Integer)))
|
|
This extension will allow "in-place" changes such to the array
|
such as ``.append()`` to produce events which will be detected by the
|
unit of work. Note that changes to elements **inside** the array,
|
including subarrays that are mutated in place, are **not** detected.
|
|
Alternatively, assigning a new array value to an ORM element that
|
replaces the old one will always trigger a change event.
|
|
.. seealso::
|
|
:class:`sqlalchemy.dialects.postgresql.ARRAY`
|
|
TFc @ sV e Zd ZU dZdZded< dd Zdd Ze d ¡dd d Z
|
e d ¡dd dZ d
|
S )zARRAY.ComparatorzÆDefine comparison operations for :class:`_types.ARRAY`.
|
|
More operators are available on the dialect-specific form
|
of this type. See :class:`.postgresql.ARRAY.Comparator`.
|
|
rF r) rO c C s² | j }t|trZ|}|jr4t|jd |jd |j}t|j|j|j| jj d}t
|
j ||fS |jrh|d7 }|j d ks||j dkr|j }n d|j d i}|j|jf|}t
|
j ||fS d S )Nr )Ú_nameÚ
|
dimensions)rO rQ ÚsliceÚ zero_indexesÚstartÚstopÚstepr rf Úkeyr Úgetitemrá r* r rj )rE rn Úarr_typeÚ return_typeZslice_Zadapt_kwrF rF rG ro 6 s.
|
ÿ ÿÿz ARRAY.Comparator._setup_getitemc O s t dd S )NzdARRAY.contains() not implemented for the base ARRAY type; please use the dialect-specific ARRAY typerB )rE r] r rF rF rG ÚcontainsQ s ÿzARRAY.Comparator.containszsqlalchemy.sql.elementsNc C sJ t jj}|r|ntj}| j}| tjt j
|
||| j |j d|j | j ¡|¡S )aS Return ``other operator ANY (array)`` clause.
|
|
.. note:: This method is an :class:`_types.ARRAY` - specific
|
construct that is now superseded by the :func:`_sql.any_`
|
function, which features a different calling style. The
|
:func:`_sql.any_` function is also mirrored at the method level
|
via the :meth:`_sql.ColumnOperators.any_` method.
|
|
Usage of array-specific :meth:`_types.ARRAY.Comparator.any`
|
is as follows::
|
|
from sqlalchemy.sql import operators
|
|
conn.execute(
|
select(table.c.data).where(
|
table.c.data.any(7, operator=operators.lt)
|
)
|
)
|
|
:param other: expression to be compared
|
:param operator: an operator object from the
|
:mod:`sqlalchemy.sql.operators`
|
package, defaults to :func:`.operators.eq`.
|
|
.. seealso::
|
|
:func:`_expression.any_`
|
|
:meth:`.types.ARRAY.Comparator.all`
|
|
©Úelementrà rf rÄ )r+ r} Ú sql_elementsr ÚeqrO rÑ r rÆ r rÇ rf r* ÚCollectionAggregateZ _create_any©rE Úotherrà r ré rF rF rG ÚanyW s !û ÷zARRAY.Comparator.anyc C sJ t jj}|r|ntj}| j}| tjt j
|
||| j |j d|j | j ¡|¡S )aS Return ``other operator ALL (array)`` clause.
|
|
.. note:: This method is an :class:`_types.ARRAY` - specific
|
construct that is now superseded by the :func:`_sql.any_`
|
function, which features a different calling style. The
|
:func:`_sql.any_` function is also mirrored at the method level
|
via the :meth:`_sql.ColumnOperators.any_` method.
|
|
Usage of array-specific :meth:`_types.ARRAY.Comparator.all`
|
is as follows::
|
|
from sqlalchemy.sql import operators
|
|
conn.execute(
|
select(table.c.data).where(
|
table.c.data.all(7, operator=operators.lt)
|
)
|
)
|
|
:param other: expression to be compared
|
:param operator: an operator object from the
|
:mod:`sqlalchemy.sql.operators`
|
package, defaults to :func:`.operators.eq`.
|
|
.. seealso::
|
|
:func:`_expression.all_`
|
|
:meth:`.types.ARRAY.Comparator.any`
|
|
rì )r+ r} rî r rï rO rÑ r rÆ r rÇ rf r* rð Z _create_allrñ rF rF rG Úall s !û ÷zARRAY.Comparator.all)N)N) rW rX rY r_ rZ ra ro rë r+ r ró rô rF rF rF rG r\ & s
|
3r\ Nú_TypeEngineArgument[Any]rÁ rt )r* Úas_tuplerá rã c C s> t |trtdt |tr"| }|| _|| _|| _|| _dS )aý Construct an :class:`_types.ARRAY`.
|
|
E.g.::
|
|
Column('myarray', ARRAY(Integer))
|
|
Arguments are:
|
|
:param item_type: The data type of items of this array. Note that
|
dimensionality is irrelevant here, so multi-dimensional arrays like
|
``INTEGER[][]``, are constructed as ``ARRAY(Integer)``, not as
|
``ARRAY(ARRAY(Integer))`` or such.
|
|
:param as_tuple=False: Specify whether return results
|
should be converted to tuples from lists. This parameter is
|
not generally needed as a Python list corresponds well
|
to a SQL array.
|
|
:param dimensions: if non-None, the ARRAY will assume a fixed
|
number of dimensions. This impacts how the array is declared
|
on the database, how it goes about interpreting Python and
|
result values, as well as how expression behavior in conjunction
|
with the "getitem" operator works. See the description at
|
:class:`_types.ARRAY` for additional detail.
|
|
:param zero_indexes=False: when True, index values will be converted
|
between Python zero-based and SQL one-based indexes, e.g.
|
a value of one will be added to all index values before passing
|
to the database.
|
|
zUDo not nest ARRAY types; ARRAY(basetype) handles multi-dimensional arrays of basetypeN)rQ r) rG rO r* rö rá rã )rE r* rö rá rã rF rF rG ry Á s &
|
ÿ
|
zARRAY.__init__c C s | j S rA )rö rD rF rF rG rÝ ó s zARRAY.hashablec C s t S rA )rW rD rF rF rG r ÷ s zARRAY.python_typec C s ||kS rA rF r rF rF rG r û s zARRAY.compare_valuesc K s$ |s t | jtr | jj|f| dS )úSupport SchemaEventTargetN)rQ r* r r )rE r Úouterr rF rF rG r þ s zARRAY._set_parentc s, t j|dd t| jtr(| j |¡ dS )r÷ T)rø N)rg Ú_set_parent_with_dispatchrQ r* r )rE Úparentri rF rG rù s z ARRAY._set_parent_with_dispatchc s: j |¡ |¡ d kr d S dd fdd}|S )Nc S s dd | ¡ dS )Nú[r^ ú])ra r rF rF rG Úto_str s z'ARRAY.literal_processor.<locals>.to_strc s | j¡}|S rA )Ú_apply_item_processorrá )r~ Úinner©Z item_procrE rý rF rG r s ÿz(ARRAY.literal_processor.<locals>.process)r* r r r rF r rG r s ÿzARRAY.literal_processorc sz dkrt |}dks6dkrZ|r6t|d t tfsZrP fdd|D S |S n fdd|D S dS )aA Helper method that can be used by bind_processor(),
|
literal_processor(), etc. to apply an item processor to elements of
|
an array value, taking into account the 'dimensions' for this
|
array type.
|
|
See the Postgresql ARRAY datatype for usage examples.
|
|
.. versionadded:: 2.0
|
|
Nr r c 3 s | ]} |V qd S rA rF r= )ÚitemprocrF rG r@ 8 s z.ARRAY._apply_item_processor.<locals>.<genexpr>c 3 s: | ]2}|d k r. |d k r&d nd ¡nd V qd S )Nr )rþ r= ©Úcollection_callableÚdimr rE rF rG r@ < s þúü)rW rQ Útuple)rE Zarrr r r rF r rG rþ s ÿþùø
|
÷zARRAY._apply_item_processor)FNF)F)rW rX rY r_ r Z _is_arrayrã rm r\ r
|
r rb r^ ry r` rÝ r r r rù r rþ rk rF rF ri rG r) §
|
s. t
|
þ û2
|
|
|
r) c s^ e Zd ZU dZdZded< ddddZd d
|
d d fd d Zd
|
d dddZdd Z Z
|
S )Ú TupleTypez(represent the composite type of a Tuple.TzList[TypeEngine[Any]]Útypesrõ )r c G s t |k| _dd |D | _d S )Nc S s g | ]}t |tr| n|qS rF )rQ rO )r> r* rF rF rG rT R s ÿz&TupleType.__init__.<locals>.<listcomp>)ÚNULLTYPEÚ _fully_typedr )rE r rF rF rG ry P s
|
þzTupleType.__init__zOptional[OperatorType]r r? )rL r~ rN c s: |t jkrt |¡S t fddt| j|D S d S )Nc s g | ]\}}| |¡qS rF )r÷ ©r> r+ ro ©rL rF rG rT _ s ÿz3TupleType.coerce_compared_value.<locals>.<listcomp>)r Z_NO_VALUE_IN_LISTrg r÷ r re r rø ri r rG r÷ W s
|
|
|
þÿz TupleType.coerce_compared_valuerX c C s( | j r
|
| S tdd t| j|D S d S )Nc S s$ g | ] \}}|t kr t|n|qS rF )r Ú_resolve_value_to_typer
|
rF rF rG rT j s ÿz6TupleType._resolve_values_to_types.<locals>.<listcomp>)r r re r r} rF rF rG Ú_resolve_values_to_typese s
|
þÿz"TupleType._resolve_values_to_typesc C s t dd S )NzJThe tuple type does not support being fetched as a column in a result row.rB r rF rF rG r p s ÿzTupleType.result_processor) rW rX rY r_ Z_is_tuple_typera ry r÷ r r rk rF rF ri rG r I s
|
r .c @ s e Zd ZdZd ZdS )ÚREALzlThe SQL REAL type.
|
|
.. seealso::
|
|
:class:`_types.Float` - documentation for the base type.
|
|
Nr rF rF rF rG r w s r c @ s e Zd ZdZd ZdS )ÚFLOATzmThe SQL FLOAT type.
|
|
.. seealso::
|
|
:class:`_types.Float` - documentation for the base type.
|
|
Nr rF rF rF rG r s r c @ s e Zd ZdZd ZdS )ÚDOUBLEzThe SQL DOUBLE type.
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
:class:`_types.Double` - documentation for the base type.
|
|
Nr rF rF rF rG r s
|
r c @ s e Zd ZdZd ZdS )ÚDOUBLE_PRECISIONzThe SQL DOUBLE PRECISION type.
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
:class:`_types.Double` - documentation for the base type.
|
|
Nr rF rF rF rG r s
|
r c @ s e Zd ZdZd ZdS )ÚNUMERICzqThe SQL NUMERIC type.
|
|
.. seealso::
|
|
:class:`_types.Numeric` - documentation for the base type.
|
|
Nr rF rF rF rG r s r c @ s e Zd ZdZd ZdS )ÚDECIMALzqThe SQL DECIMAL type.
|
|
.. seealso::
|
|
:class:`_types.Numeric` - documentation for the base type.
|
|
Nr rF rF rF rG r º s r c @ s e Zd ZdZd ZdS )ÚINTEGERzxThe SQL INT or INTEGER type.
|
|
.. seealso::
|
|
:class:`_types.Integer` - documentation for the base type.
|
|
Nr rF rF rF rG r Ç s r c @ s e Zd ZdZd ZdS )ÚSMALLINTzwThe SQL SMALLINT type.
|
|
.. seealso::
|
|
:class:`_types.SmallInteger` - documentation for the base type.
|
|
Nr rF rF rF rG r × s r c @ s e Zd ZdZd ZdS )ÚBIGINTzsThe SQL BIGINT type.
|
|
.. seealso::
|
|
:class:`_types.BigInteger` - documentation for the base type.
|
|
Nr rF rF rF rG r ä s r c s4 e Zd ZdZd Zd dd fdd Zdd Z ZS )
|
Ú TIMESTAMPa The SQL TIMESTAMP type.
|
|
:class:`_types.TIMESTAMP` datatypes have support for timezone
|
storage on some backends, such as PostgreSQL and Oracle. Use the
|
:paramref:`~types.TIMESTAMP.timezone` argument in order to enable
|
"TIMESTAMP WITH TIMEZONE" for these backends.
|
|
FrÁ rß c s t j|d dS )am Construct a new :class:`_types.TIMESTAMP`.
|
|
:param timezone: boolean. Indicates that the TIMESTAMP type should
|
enable timezone support, if available on the target database.
|
On a per-dialect basis is similar to "TIMESTAMP WITH TIMEZONE".
|
If the target database does not support timezones, this flag is
|
ignored.
|
|
|
rß Nr rá ri rF rG ry þ s zTIMESTAMP.__init__c C s |j S rA )r r rF rF rG r s zTIMESTAMP.get_dbapi_type)F)rW rX rY r_ r ry r rk rF rF ri rG r ñ s r c @ s e Zd ZdZd ZdS )rã zThe SQL DATETIME type.Nr rF rF rF rG rã s rã c @ s e Zd ZdZd ZdS )ÚDATEzThe SQL DATE type.Nr rF rF rF rG r s r c @ s e Zd ZdZd ZdS )ÚTIMEzThe SQL TIME type.Nr rF rF rF rG r s r c @ s e Zd ZdZd ZdS )ÚTEXTzThe SQL TEXT type.Nr rF rF rF rG r $ s r c @ s e Zd ZdZd ZdS )ÚCLOBzCThe CLOB type.
|
|
This type is found in Oracle and Informix.
|
Nr rF rF rF rG r + s r c @ s e Zd ZdZd ZdS )ÚVARCHARzThe SQL VARCHAR type.Nr rF rF rF rG r 5 s r c @ s e Zd ZdZd ZdS )ÚNVARCHARzThe SQL NVARCHAR type.Nr rF rF rF rG r < s r c @ s e Zd ZdZd ZdS )ÚCHARzThe SQL CHAR type.Nr rF rF rF rG r C s r c @ s e Zd ZdZd ZdS )ÚNCHARzThe SQL NCHAR type.Nr rF rF rF rG r J s r c @ s e Zd ZdZd ZdS )ÚBLOBzThe SQL BLOB type.Nr rF rF rF rG r Q s r c @ s e Zd ZdZd ZdS )rù zThe SQL BINARY type.Nr rF rF rF rG rù X s rù c @ s e Zd ZdZd ZdS )Ú VARBINARYzThe SQL VARBINARY type.Nr rF rF rF rG r! _ s r! c @ s e Zd ZdZd ZdS )ÚBOOLEANzThe SQL BOOLEAN type.Nr rF rF rF rG r" f s r" c @ s: e Zd ZdZdZdZdd ZG dd deje ZeZ
|
dS ) rd a An unknown type.
|
|
:class:`.NullType` is used as a default type for those cases where
|
a type cannot be determined, including:
|
|
* During table reflection, when the type of a column is not recognized
|
by the :class:`.Dialect`
|
* When constructing SQL expressions using plain Python objects of
|
unknown types (e.g. ``somecolumn == my_special_object``)
|
* When a new :class:`_schema.Column` is created,
|
and the given type is passed
|
as ``None`` or is not passed at all.
|
|
The :class:`.NullType` can be used within SQL expression invocation
|
without issue, it just has no behavior either at the expression
|
construction level or at the bind-parameter/result processing level.
|
:class:`.NullType` will result in a :exc:`.CompileError` if the compiler
|
is asked to render the type itself, such as if it is used in a
|
:func:`.cast` operation or within a schema creation operation such as that
|
invoked by :meth:`_schema.MetaData.create_all` or the
|
:class:`.CreateTable`
|
construct.
|
|
ÚnullTc C s d S rA rF r rF rF rG r s zNullType.literal_processorc @ s" e Zd ZdZddddddZdS ) zNullType.ComparatorrF r4 rI rJ rK c C s2 t |tjst |¡s"|| jjfS | || ¡S d S rA )rQ rd r\ r Zis_commutativerf rO rV rh rF rF rG rV s ÿþ z%NullType.Comparator._adapt_expressionN)rW rX rY rZ rV rF rF rF rG r\ s r\ N) rW rX rY r_ r Z_isnullr r# r\ r; r^ rF rF rF rG rd m s rd c @ s. e Zd ZdZdZdejfgZddddZdS ) ÚTableValueTypez Refers to a table value type.TÚ _elementsz*Union[str, _ColumnExpressionArgument[Any]]r c G s dd |D | _ d S )Nc S s g | ]}t tj|¡qS rF )r rÆ r ZStrAsPlainColumnRole)r> ro rF rF rG rT « s ÿz+TableValueType.__init__.<locals>.<listcomp>)r% )rE r rF rF rG ry ª s þzTableValueType.__init__N) rW rX rY r_ Z_is_table_valuer& Zdp_clauseelement_listZ_traverse_internalsry rF rF rF rG r$ ¡ s
|
ÿr$ c @ s e Zd ZdZdS )Ú MatchTypea' Refers to the return type of the MATCH operator.
|
|
As the :meth:`.ColumnOperators.match` is probably the most open-ended
|
operator in generic SQLAlchemy Core, we can't assume the return type
|
at SQL evaluation time, as MySQL returns a floating point, not a boolean,
|
and other backends might do something different. So this type
|
acts as a placeholder, currently subclassing :class:`.Boolean`.
|
The type allows dialects to inject result-processing functionality
|
if needed, and on MySQL will return floating-point values.
|
|
Nr¾ rF rF rF rG r& ± s r& Ú _UUID_RETURNc s e Zd ZU dZdZdZded< ed ddd d
|
d d Zed d dd d
|
dd Zd d d ddd Ze dd Z
|
fddZ dd Z dd Z dd Z ZS ) ÚUuidaú Represent a database agnostic UUID datatype.
|
|
For backends that have no "native" UUID datatype, the value will
|
make use of ``CHAR(32)`` and store the UUID as a 32-character alphanumeric
|
hex string.
|
|
For backends which are known to support ``UUID`` directly or a similar
|
uuid-storing datatype such as SQL Server's ``UNIQUEIDENTIFIER``, a
|
"native" mode enabled by default allows these types will be used on those
|
backends.
|
|
In its default mode of use, the :class:`_sqltypes.Uuid` datatype expects
|
**Python uuid objects**, from the Python
|
`uuid <https://docs.python.org/3/library/uuid.html>`_
|
module::
|
|
import uuid
|
|
from sqlalchemy import Uuid
|
from sqlalchemy import Table, Column, MetaData, String
|
|
|
metadata_obj = MetaData()
|
|
t = Table(
|
"t",
|
metadata_obj,
|
Column('uuid_data', Uuid, primary_key=True),
|
Column("other_data", String)
|
)
|
|
with engine.begin() as conn:
|
conn.execute(
|
t.insert(),
|
{"uuid_data": uuid.uuid4(), "other_data", "some data"}
|
)
|
|
To have the :class:`_sqltypes.Uuid` datatype work with string-based
|
Uuids (e.g. 32 character hexadecimal strings), pass the
|
:paramref:`_sqltypes.Uuid.as_uuid` parameter with the value ``False``.
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
:class:`_sqltypes.UUID` - represents exactly the ``UUID`` datatype
|
without any backend-agnostic behaviors.
|
|
ÚuuidNru rx .zUuid[_python_UUID]rº rÁ ©rE Úas_uuidÚ native_uuidc C s d S rA rF r* rF rF rG ry ú s z Uuid.__init__z Uuid[str]rÀ c C s d S rA rF r* rF rF rG ry s T©r+ r, c C s || _ || _dS )a^ Construct a :class:`_sqltypes.Uuid` type.
|
|
:param as_uuid=True: if True, values will be interpreted
|
as Python uuid objects, converting to/from string via the
|
DBAPI.
|
|
.. versionchanged: 2.0 ``as_uuid`` now defaults to ``True``.
|
|
:param native_uuid=True: if True, backends that support either the
|
``UUID`` datatype directly, or a UUID-storing value
|
(such as SQL Server's ``UNIQUEIDENTIFIER`` will be used by those
|
backends. If False, a ``CHAR(32)`` datatype will be used for
|
all backends regardless of native support.
|
|
Nr- r* rF rF rG ry
|
s c C s | j r
|
tS tS rA )r+ Ú _python_UUIDr rD rF rF rG r s zUuid.python_typec s t |tr| S t ||¡S dS rõ rö rø ri rF rG r÷ ! s
|
zUuid.coerce_compared_valuec C s< |j p| j }|r4| jr&dd }|S dd }|S nd S d S )Nc S s | d k r| j } | S rA ©Úhexr
rF rF rG r 1 s z$Uuid.bind_processor.<locals>.processc S s | d k r| dd¡} | S )Nú-Ú ©r r
rF rF rG r 9 s ©Zsupports_native_uuidr, r+ ©rE r Úcharacter_based_uuidr rF rF rG r ) s ÿzUuid.bind_processorc C sN |j p| j }|r4| jr&dd }|S dd }|S n| jsFdd }|S d S d S )Nc S s | d k rt | } | S rA )r. r
rF rF rG r J s z&Uuid.result_processor.<locals>.processc S s | d k rt t| } | S rA )r r. r
rF rF rG r R s c S s | d k rt | } | S rA r r
rF rF rG r \ s r4 )rE r r r6 r rF rF rG r B s ÿzUuid.result_processorc C sB |j p| j }| js"dd }|S |r2dd }|S dd }|S d S )Nc S s( | d k r$d| dd¡ dd¡ d} | S )Nr r1 r2 r r3 r
rF rF rG r l s ÿz'Uuid.literal_processor.<locals>.processc S s | d k rd| j d} | S )Nr r/ r
rF rF rG r w s c S s$ | d k r dt | dd¡ d} | S )Nr r )r r r
rF rF rG r s r4 r5 rF rF rG r e s ÿzUuid.literal_processor)..)..)TT)rW rX rY r_ r rx ra r ry r` r r÷ r r r rk rF rF ri rG r( Â s$
|
2 ý ý
|
#r( c @ sP e Zd ZdZd ZeddddddZeddd dd
|
dZdd d ddZdS )r a Represent the SQL UUID type.
|
|
This is the SQL-native form of the :class:`_types.Uuid` database agnostic
|
datatype, and is backwards compatible with the previous PostgreSQL-only
|
version of ``UUID``.
|
|
The :class:`_sqltypes.UUID` datatype only works on databases that have a
|
SQL datatype named ``UUID``. It will not function for backends which don't
|
have this exact-named type, including SQL Server. For backend-agnostic UUID
|
values with native support, including for SQL Server's ``UNIQUEIDENTIFIER``
|
datatype, use the :class:`_sqltypes.Uuid` datatype.
|
|
.. versionadded:: 2.0
|
|
.. seealso::
|
|
:class:`_sqltypes.Uuid`
|
|
.zUUID[_python_UUID]rº ©rE r+ c C s d S rA rF r7 rF rF rG ry s z UUID.__init__z UUID[str]rÀ c C s d S rA rF r7 rF rF rG ry £ s TrÁ )r+ c C s || _ d| _dS )a Construct a :class:`_sqltypes.UUID` type.
|
|
|
:param as_uuid=True: if True, values will be interpreted
|
as Python uuid objects, converting to/from string via the
|
DBAPI.
|
|
.. versionchanged: 2.0 ``as_uuid`` now defaults to ``True``.
|
|
TNr- r7 rF rF rG ry § s N).).)T)rW rX rY r_ r r ry rF rF rF rG r s r r¹ Ú NUMERICTYPETrß z Dict[Type[Any], TypeEngine[Any]]Ú _type_maprX c C sl t t| d}|dkr"t| dd}|dkr^t | d¡}|d k rZ|jtjkrZt d| f ¡t S |
|
| ¡S d S )NFZ__sa_type_engine__z-Object %r is not legal as a SQL literal value) Ú _type_map_getrO rà r* Úinspectrj Z _registrarsr) r` r r )r~ Z _result_typeZinsprF rF rG r Ú s ÿ
|
ûÿÿr )ªr_ Ú
|
__future__r Úcollections.abcÚabcrÅ rÞ rç rÆ r/ rÛ r Útypingr r r r r r r r
|
r r r r r r) r r. r2 r r r r r Úbaser r r Ú cache_keyr r r r r r r r! r" r# r$ r% Zvisitorsr& r( r) r* r+ Zenginer, r- r. Z util.typingr/ r0 r1 Ú_typingr2 r3 r4 rÿ r5 r6 r7 r8 r9 Zengine.interfacesr: r; r= r> r@ rb rm r rr r r r¡ r§ r¢ r´ rµ rÇ rÈ r¶ r¬ rÌ rÎ rÐ rÝ rè r« rê ré rñ rì rú rû r. r0 r rÁ r rª r§ r® r± r) r r r r r r r r ÚINTr r r rã r r r r r r r r r rù r! r" rd r$ r& r' r( r Z BOOLEANTYPEZ
|
STRINGTYPEZ INTEGERTYPEr8 ra Z MATCHTYPEZ
|
TABLEVALUErå rë rª Z _DATETIMEZ_TIMEr{ r| rO r9 rS r: r Z INDEXABLErF rF rF rG Ú<module> s 'W 62 9a
|
ÿC)%@ h$ 2i } ;
|
|
ÿ % .
|
4 F/
|
|
ò
|
|
