U
|
¸ý°d8D ã @ sº d dl mZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ ddlm Z dd lm
|
Z
|
dd
|
l m Z dd l m Z dd l mZ dd l mZ ddl mZ ddlmZ ddlmZ ddlmZ erÐddlmZ G dd dejZG dd deZG dd deZG dd deZ G dd d eZ G d d d eej ej Z G d d d eZ!G d!d" d"eZ"G d#d$ d$eej#Z$G d%d& d&e j%Z&G d'd( d(e j%Z'G d)d* d*e j%Z(G d+d, d,e j%Z)d-S ).é )Ú annotations)ÚAny)ÚOptional)ÚType)Ú TYPE_CHECKING)ÚUnioné ©Úschema)Úutil)Ú coercions)Úelements)Úroles)Úsqltypes)Útype_api)Ú_NoArg)ÚInvokeCreateDDLBase)ÚInvokeDropDDLBase)Ú_TypeEngineArgumentc @ sr e Zd ZU dZdZded< ded< ded< dd d
|
Zdd d Zd d ZdddZ d ddZ
|
d ddZ d ddZ dS ) Ú NamedTypezBase for named types.TzType[NamedTypeGenerator]Ú DDLGeneratorzType[NamedTypeDropper]Ú
|
DDLDropperÚboolÚ create_typec K s |j | j| |d dS )al Emit ``CREATE`` DDL for this type.
|
|
:param bind: a connectable :class:`_engine.Engine`,
|
:class:`_engine.Connection`, or similar object to emit
|
SQL.
|
:param checkfirst: if ``True``, a query against
|
the PG catalog will be first performed to see
|
if the type does not exist already before
|
creating.
|
|
©Ú
|
checkfirstN)Ú_run_ddl_visitorr ©ÚselfÚbindr Úkw© r! úad:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\sqlalchemy/dialects/postgresql/named_types.pyÚcreate' s zNamedType.createc K s |j | j| |d dS )aZ Emit ``DROP`` DDL for this type.
|
|
:param bind: a connectable :class:`_engine.Engine`,
|
:class:`_engine.Connection`, or similar object to emit
|
SQL.
|
:param checkfirst: if ``True``, a query against
|
the PG catalog will be first performed to see
|
if the type actually exists before dropping.
|
|
r N)r r r r! r! r" Údrop5 s zNamedType.dropc C sz | j s
|
dS d|krr|d }d| j }||jkr<|j| }nt }|j|< | j| jf|k}| | j| jf¡ |S dS dS )a Look in the 'ddl runner' for 'memos', then
|
note our name in that collection.
|
|
This to ensure a particular named type is operated
|
upon only once within any kind of create/drop
|
sequence without relying upon "checkfirst".
|
|
TZ _ddl_runnerZpg_FN)r Ú__visit_name__ÚmemoÚsetr
|
ÚnameÚadd)r r r Z
|
ddl_runnerZ type_nameÚexistingZpresentr! r! r" Ú_check_for_name_in_memosB s
|
z"NamedType._check_for_name_in_memosFc K s4 |s| j s0| dd¡s0| ||¡s0| j||d d S ©NZ_is_metadata_operationF©r r )ÚmetadataÚgetr+ r# ©r Útargetr r r r! r! r" Ú_on_table_createZ s ÿý
|
ü
|
úzNamedType._on_table_createc K s0 | j s,| dd¡s,| ||¡s,| j||d d S r, )r. r/ r+ r$ r0 r! r! r" Ú_on_table_dropd s ÿ
|
þ
|
ýzNamedType._on_table_dropc K s | ||¡s| j||d d S ©Nr- )r+ r# r0 r! r! r" Ú_on_metadata_createl s z NamedType._on_metadata_createc K s | ||¡s| j||d d S r4 )r+ r$ r0 r! r! r" Ú_on_metadata_dropp s zNamedType._on_metadata_dropN)T)T)F)F)F)F) Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__Z __abstract__Ú__annotations__r# r$ r+ r2 r3 r5 r6 r! r! r! r" r s
|
|
|
|
|
|
|
r c s& e Zd Zd fdd Zdd Z ZS )ÚNamedTypeGeneratorFc s t j|f| || _d S ©N©ÚsuperÚ__init__r ©r ÚdialectÚ
|
connectionr Úkwargs©Ú __class__r! r" r@ v s zNamedTypeGenerator.__init__c C s0 | j s
|
dS | j |¡}| jjj| j|j|d S ©NTr ©r rC Zschema_for_objectrB Zhas_typer( ©r Útype_Zeffective_schemar! r! r" Ú_can_create_typez s ÿz#NamedTypeGenerator._can_create_type)F)r7 r8 r9 r@ rK Ú __classcell__r! r! rE r" r< u s r< c s& e Zd Zd fdd Zdd Z ZS )ÚNamedTypeDropperFc s t j|f| || _d S r= r> rA rE r! r" r@
s zNamedTypeDropper.__init__c C s. | j s
|
dS | j |¡}| jjj| j|j|dS rG rH rI r! r! r" Ú_can_drop_type s ÿz NamedTypeDropper._can_drop_type)F)r7 r8 r9 r@ rN rL r! r! rE r" rM s rM c @ s e Zd Zdd ZdS )Ú EnumGeneratorc C s8 | |¡sd S | |¡ | j t|¡ W 5 Q R X d S r= )rK Úwith_ddl_eventsrC ÚexecuteÚCreateEnumType©r Úenumr! r! r" Ú
|
visit_enum s
|
zEnumGenerator.visit_enumN©r7 r8 r9 rU r! r! r! r" rO s rO c @ s e Zd Zdd ZdS )Ú EnumDropperc C s8 | |¡sd S | |¡ | j t|¡ W 5 Q R X d S r= )rN rP rC rQ Ú DropEnumTyperS r! r! r" rU s
|
zEnumDropper.visit_enumNrV r! r! r! r" rW s rW c s e Zd ZdZdZeZeZe j
|
ddddd fddZ fdd Z e d
|
d Ze d d Zd fdd Zd fdd Zdd Z ZS )ÚENUMa-
|
PostgreSQL ENUM type.
|
|
This is a subclass of :class:`_types.Enum` which includes
|
support for PG's ``CREATE TYPE`` and ``DROP TYPE``.
|
|
When the builtin type :class:`_types.Enum` is used and the
|
:paramref:`.Enum.native_enum` flag is left at its default of
|
True, the PostgreSQL backend will use a :class:`_postgresql.ENUM`
|
type as the implementation, so the special create/drop rules
|
will be used.
|
|
The create/drop behavior of ENUM is necessarily intricate, due to the
|
awkward relationship the ENUM type has in relationship to the
|
parent table, in that it may be "owned" by just a single table, or
|
may be shared among many tables.
|
|
When using :class:`_types.Enum` or :class:`_postgresql.ENUM`
|
in an "inline" fashion, the ``CREATE TYPE`` and ``DROP TYPE`` is emitted
|
corresponding to when the :meth:`_schema.Table.create` and
|
:meth:`_schema.Table.drop`
|
methods are called::
|
|
table = Table('sometable', metadata,
|
Column('some_enum', ENUM('a', 'b', 'c', name='myenum'))
|
)
|
|
table.create(engine) # will emit CREATE ENUM and CREATE TABLE
|
table.drop(engine) # will emit DROP TABLE and DROP ENUM
|
|
To use a common enumerated type between multiple tables, the best
|
practice is to declare the :class:`_types.Enum` or
|
:class:`_postgresql.ENUM` independently, and associate it with the
|
:class:`_schema.MetaData` object itself::
|
|
my_enum = ENUM('a', 'b', 'c', name='myenum', metadata=metadata)
|
|
t1 = Table('sometable_one', metadata,
|
Column('some_enum', myenum)
|
)
|
|
t2 = Table('sometable_two', metadata,
|
Column('some_enum', myenum)
|
)
|
|
When this pattern is used, care must still be taken at the level
|
of individual table creates. Emitting CREATE TABLE without also
|
specifying ``checkfirst=True`` will still cause issues::
|
|
t1.create(engine) # will fail: no such type 'myenum'
|
|
If we specify ``checkfirst=True``, the individual table-level create
|
operation will check for the ``ENUM`` and create if not exists::
|
|
# will check if enum exists, and emit CREATE TYPE if not
|
t1.create(engine, checkfirst=True)
|
|
When using a metadata-level ENUM type, the type will always be created
|
and dropped if either the metadata-wide create/drop is called::
|
|
metadata.create_all(engine) # will emit CREATE TYPE
|
metadata.drop_all(engine) # will emit DROP TYPE
|
|
The type can also be created and dropped directly::
|
|
my_enum.create(engine)
|
my_enum.drop(engine)
|
|
T)r( r zUnion[str, _NoArg, None]r c sH | dd¡}|dkr t d¡ || _|tjk r6||d< t j|| dS )a Construct an :class:`_postgresql.ENUM`.
|
|
Arguments are the same as that of
|
:class:`_types.Enum`, but also including
|
the following parameters.
|
|
:param create_type: Defaults to True.
|
Indicates that ``CREATE TYPE`` should be
|
emitted, after optionally checking for the
|
presence of the type, when the parent
|
table is being created; and additionally
|
that ``DROP TYPE`` is called when the table
|
is dropped. When ``False``, no check
|
will be performed and no ``CREATE TYPE``
|
or ``DROP TYPE`` is emitted, unless
|
:meth:`~.postgresql.ENUM.create`
|
or :meth:`~.postgresql.ENUM.drop`
|
are called directly.
|
Setting to ``False`` is helpful
|
when invoking a creation scheme to a SQL file
|
without access to the actual database -
|
the :meth:`~.postgresql.ENUM.create` and
|
:meth:`~.postgresql.ENUM.drop` methods can
|
be used to emit SQL to a target bind.
|
|
Ú native_enumNFzªthe native_enum flag does not apply to the sqlalchemy.dialects.postgresql.ENUM datatype; this type always refers to ENUM. Use sqlalchemy.types.Enum for non-native enum.r( )Úpopr Úwarnr r ÚNO_ARGr? r@ )r r( r Úenumsr rZ rE r! r" r@ ð s ! ÿ
|
z ENUM.__init__c s( t ||¡}|jtjjkr | S |S d S r= )r? Úcoerce_compared_valueZ_type_affinityr Z
|
STRINGTYPE)r ÚopÚvalueZsuper_coerced_typerE r! r" r_ s ÿÿzENUM.coerce_compared_valuec C s
|
| ddS )Nr( )r( r! ©Úclsr! r! r" Ú __test_init__( s zENUM.__test_init__c K s | d|j¡ | d|j¡ | d|j¡ | d|j¡ | d|j¡ | dd¡ | d|j¡ | d |j¡ | d
|
|¡ | f |S ) zbProduce a PostgreSQL native :class:`_postgresql.ENUM` from plain
|
:class:`.Enum`.
|
|
Úvalidate_stringsr( r
|
Úinherit_schemar. Z_create_eventsFÚvalues_callableZ omit_aliasesZ _adapted_from)Ú
|
setdefaultre r( r
|
rf r. rg Z _omit_aliases)rc Úimplr r! r! r" Úadapt_emulated_to_native, s z ENUM.adapt_emulated_to_nativeNc s |j js dS t j||d dS )aò Emit ``CREATE TYPE`` for this
|
:class:`_postgresql.ENUM`.
|
|
If the underlying dialect does not support
|
PostgreSQL CREATE TYPE, no action is taken.
|
|
:param bind: a connectable :class:`_engine.Engine`,
|
:class:`_engine.Connection`, or similar object to emit
|
SQL.
|
:param checkfirst: if ``True``, a query against
|
the PG catalog will be first performed to see
|
if the type does not exist already before
|
creating.
|
|
Nr )rB Úsupports_native_enumr? r# ©r r r rE r! r" r# = s z ENUM.createc s |j js dS t j||d dS )aÞ Emit ``DROP TYPE`` for this
|
:class:`_postgresql.ENUM`.
|
|
If the underlying dialect does not support
|
PostgreSQL DROP TYPE, no action is taken.
|
|
:param bind: a connectable :class:`_engine.Engine`,
|
:class:`_engine.Connection`, or similar object to emit
|
SQL.
|
:param checkfirst: if ``True``, a query against
|
the PG catalog will be first performed to see
|
if the type actually exists before dropping.
|
|
Nr )rB rk r? r$ rl rE r! r" r$ R s z ENUM.dropc C s dS )zVdont return dbapi.STRING for ENUM in PostgreSQL, since that's
|
a different typeNr! )r Zdbapir! r! r" Úget_dbapi_typef s zENUM.get_dbapi_type)NT)NT)r7 r8 r9 r: rZ rO r rW r r r] r@ r_ Ú classmethodrd rj r# r$ rm rL r! r! rE r" rY ¥ s Eü.
|
|
|
rY c @ s e Zd Zdd ZdS )ÚDomainGeneratorc C s8 | |¡sd S | |¡ | j t|¡ W 5 Q R X d S r= )rK rP rC rQ ÚCreateDomainType©r Údomainr! r! r" Ú visit_DOMAINn s
|
z DomainGenerator.visit_DOMAINN©r7 r8 r9 rs r! r! r! r" ro m s ro c @ s e Zd Zdd ZdS )Ú DomainDropperc C s8 | |¡sd S | |¡ | j t|¡ W 5 Q R X d S r= )rN rP rC rQ ÚDropDomainTyperq r! r! r" rs v s
|
zDomainDropper.visit_DOMAINNrt r! r! r! r" ru u s ru c s^ e Zd ZdZeZeZd Zddddddddddddd dd
|
d d fd dZ e
|
dd Z Z S )ÚDOMAINaI Represent the DOMAIN PostgreSQL type.
|
|
A domain is essentially a data type with optional constraints
|
that restrict the allowed set of values. E.g.::
|
|
PositiveInt = DOMAIN(
|
"pos_int", Integer, check="VALUE > 0", not_null=True
|
)
|
|
UsPostalCode = DOMAIN(
|
"us_postal_code",
|
Text,
|
check="VALUE ~ '^\d{5}$' OR VALUE ~ '^\d{5}-\d{4}$'"
|
)
|
|
See the `PostgreSQL documentation`__ for additional details
|
|
__ https://www.postgresql.org/docs/current/sql-createdomain.html
|
|
.. versionadded:: 2.0
|
|
NT)Ú collationÚdefaultÚconstraint_nameÚnot_nullÚcheckr Ústrz_TypeEngineArgument[Any]z Optional[str]z)Optional[Union[str, elements.TextClause]]zOptional[bool]r r ) r( Ú data_typerx ry rz r{ r| r r c
|
s` t |¡| _|| _|| _|| _|| _|dk r:t t j
|
|¡}|| _ || _ t jf d|i| dS )a
|
Construct a DOMAIN.
|
|
:param name: the name of the domain
|
:param data_type: The underlying data type of the domain.
|
This can include array specifiers.
|
:param collation: An optional collation for the domain.
|
If no collation is specified, the underlying data type's default
|
collation is used. The underlying type must be collatable if
|
``collation`` is specified.
|
:param default: The DEFAULT clause specifies a default value for
|
columns of the domain data type. The default should be a string
|
or a :func:`_expression.text` value.
|
If no default value is specified, then the default value is
|
the null value.
|
:param constraint_name: An optional name for a constraint.
|
If not specified, the backend generates a name.
|
:param not_null: Values of this domain are prevented from being null.
|
By default domain are allowed to be null. If not specified
|
no nullability clause will be emitted.
|
:param check: CHECK clause specify integrity constraint or test
|
which values of the domain must satisfy. A constraint must be
|
an expression producing a Boolean result that can use the key
|
word VALUE to refer to the value being tested.
|
Differently from PostgreSQL, only a single check clause is
|
currently allowed in SQLAlchemy.
|
:param schema: optional schema name
|
:param metadata: optional :class:`_schema.MetaData` object which
|
this :class:`_postgresql.DOMAIN` will be directly associated
|
:param create_type: Defaults to True.
|
Indicates that ``CREATE TYPE`` should be emitted, after optionally
|
checking for the presence of the type, when the parent table is
|
being created; and additionally that ``DROP TYPE`` is called
|
when the table is dropped.
|
|
Nr( )r Z to_instancer~ ry rx rz r{ r Úexpectr ZDDLExpressionRoler| r r? r@ )
|
r r( r~ rx ry rz r{ r| r r rE r! r" r@ s 1 zDOMAIN.__init__c C s | dt jS )Nr( )r ZIntegerrb r! r! r" rd × s zDOMAIN.__test_init__) r7 r8 r9 r: ro r ru r r% r@ rn rd rL r! r! rE r" rw ~ s ö&<rw c @ s e Zd ZdZdS )rR Zcreate_enum_typeN©r7 r8 r9 r% r! r! r! r" rR Ü s rR c @ s e Zd ZdZdS )rX Zdrop_enum_typeNr r! r! r! r" rX à s rX c @ s e Zd ZdZdZdS )rp z$Represent a CREATE DOMAIN statement.Zcreate_domain_typeN©r7 r8 r9 r: r% r! r! r! r" rp ä s rp c @ s e Zd ZdZdZdS )rv z"Represent a DROP DOMAIN statement.Zdrop_domain_typeNr r! r! r! r" rv ê s rv N)*Ú
|
__future__r Útypingr r r r r Ú r
|
r Zsqlr r r r r Zsql.baser Zsql.ddlr r Z sql._typingr Z
|
TypeEnginer r< rM rO rW ZNativeForEmulatedÚEnumrY ro ru Z
|
SchemaTyperw Z_CreateDropBaserR rX rp rv r! r! r! r" Ú<module> s> V I ^
|
