관리-도구
편집 파일: base.cpython-38.pyc
U -?�f� � @ s. d Z ddlmZ ddlZddlmZ ddlZddlmZ ddlZddl Z ddl m Z ddl m Z ddl m Z dd l mZ dd l mZ dd l mZ dd l mZ dd l mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl mZ ddl m Z ddl m Z ddl m Z ddl m Z ddl m Z d d l!m"Z" d d l!m#Z# d d l$m%Z% d d l$m&Z& d d!l'm(Z( d d"l#m)Z) d d#l#m*Z* d d$l#m+Z+ d d%l#m,Z, d&d'l!m-Z- d&d(l!m.Z. d&d)l!m/Z/ d&d*l/m0Z0 d&d+l/m1Z1 d&d,l/m Z2 d&d-l3m4Z4 d&d.l3m5Z5 d&d/l3m6Z6 e �r�d d0l!m7Z7 d d1l!m8Z8 d d2l!m9Z9 d d3l:m;Z; d d4l:m<Z< d d5l=m>Z> d d6l8m?Z? d d7l8m@Z@ d d8l8mAZA d d9l8mBZB d d:l8mCZC d d;l8mDZD d d<l8mEZE d d=lFmGZG d d>lFmHZH d d?lImJZJ d d@lImKZK d dAlImLZL d&dBlMmNZN d&dClMmOZO d&dDlPmQZQ d&dElPmRZR d&dFlPmSZS d&dGlPmTZT d&dHlPmUZU d&dIlPmVZV d&dJlPmWZW d&dKlPmXZX d&dLlPmYZY d&dMlPmZZZ d&dNl-m[Z[ e �s�dZ7dZ8dZ9G dOdP� dPe�Z\e\j]Z]G dQdR� dRe�Z^e^j_Z`e dSe dT�Zae dUe dVe f dT�Zbeececf ZdG dWdX� dXe�Zee�fdY�ZgG dZd[� d[e4�ZhG d\d]� d]e4�Zid^d_d`�dadb�Zje dce dT�ZkG ddde� de�ZlG dfdg� dgel�Zmdhdidj�dkdl�Zndmdndj�dodp�Zoe dqdrdT�ZpG dsdr� dre2j4�ZqdUdUdt�dudv�Zrdwd^dxdy�dzd{�Zsd|d}� Ztd~d~dj�dd��Zud~d~dj�d�d��Zvd~d~d�d��d�d��Zwd~d~d�d��d�d��ZxG d�d�� d�eece f �ZyG d�d�� d�eece f �Zze/�{d��d�d�� �Z|G d�d�� d��Z}G d�d�� d��Z~G d�d�� d�e0�ZG d�d�� d�e0�Z�G d�d�� d�e�Z�G d�d�� d�e��Z�G d�d�� d�e�d��Z�G d�d�� d�e�e%�Z�G d�d�� d�e(�Z�G d�d�� d�e"j��Z�G d�d�� d�e-j��Z�G d�d�� d�e)�Z�G d�d�� d�e�Z�G d�d�� d�e�Z�e d�e decf ec�Z�e d�d�d�d��Z�e d�d�dT�Z�G d�d�� d�ee� �Z�G d�d�� d�ee�e�f �Z�e d�d�dT�Z�G d�d�� d�e�ece�f �Z�G d�d�� d�e/j�e�e�e�f �Z�G d�d�� d�e/j�d� �Z�d�d[d��d�dÄZ�e]fd�dwd�d�dƜd�dȄZ�dS )�z4Foundational utilities common to many sql modules. � )� annotationsN)�Enum�� zip_longest)�Any)�Callable)�cast)�Dict)� FrozenSet)�Generic)�Iterable)�Iterator)�List)�Mapping)�MutableMapping)� NamedTuple)�NoReturn)�Optional)�overload)�Sequence)�Set)�Tuple)�Type)� TYPE_CHECKING)�TypeVar)�Union� )�roles)�visitors)� HasCacheKey)�MemoizedHasCacheKey)�HasCopyInternals)� ClauseVisitor)�ExtendedInternalTraversal)�ExternallyTraversible)�InternalTraversal� )�event)�exc)�util)� HasMemoized)� hybridmethod)�typing)�Protocol)�Self)� TypeGuard)� coercions��elements)�type_api)�DMLStrategyArgument)�SynchronizeSessionArgument)�_CLE)� BindParameter)� ClauseList)� ColumnClause)� ColumnElement)� NamedColumn)�SQLCoreOperations)� TextClause)�Column)�DefaultGenerator)�_JoinTargetElement)�_SelectIterable)� FromClause)� Connection)� CursorResult)�_CoreMultiExecuteParams)�_ExecuteOptions)�_ImmutableExecuteOptions)� CacheStats)�Compiled)�CompiledCacheType)�CoreExecuteOptionsParameter)�Dialect)�IsolationLevel)�SchemaTranslateMapType)� dispatcherc @ s e Zd ZdZdd� ZdS )�_NoArgr c C s d| j � �S )Nz_NoArg.)�name��self� rT �C/opt/hc_python/lib64/python3.8/site-packages/sqlalchemy/sql/base.py�__repr__j s z_NoArg.__repr__N)�__name__� __module__� __qualname__�NO_ARGrV rT rT rT rU rP g s rP c @ s e Zd ZdZdS )� _NoneNamer N)rW rX rY � NONE_NAMErT rT rT rU r[ q s r[ �_T)�bound�_Fn.c @ sB e Zd ZU ded< ded< ded< ded< edd d�d d ��Zd S ) �_DefaultDescriptionTupler �argzOptional[bool]� is_scalar� is_callable� is_sentinelzOptional[DefaultGenerator])�default�returnc C s: |r,|j s|js,|jr,t|j|j|j|j�S td d d d �S �N)�has_argZ for_updaterd r` ra rb rc )�clsre rT rT rU �_from_column_default� s �� � �� �z-_DefaultDescriptionTuple._from_column_defaultN)rW rX rY �__annotations__� classmethodrj rT rT rT rU r` s r` Z_omit_from_statementsc @ s e Zd Zddd�dd�ZdS )�_EntityNamespace�str�SQLCoreOperations[Any]��keyrf c C s d S rg rT �rS rq rT rT rU � __getattr__� � z _EntityNamespace.__getattr__N)rW rX rY rs rT rT rT rU rm � s rm c @ s e Zd Zejdd�dd��ZdS )�_HasEntityNamespacerm �rf c C s d S rg rT rR rT rT rU �entity_namespace� s z$_HasEntityNamespace.entity_namespaceN)rW rX rY r) �ro_non_memoized_propertyrw rT rT rT rU ru � s ru r z TypeGuard[_HasEntityNamespace])�elementrf c C s t | d�S )Nrw )�hasattr)ry rT rT rU �_is_has_entity_namespace� s r{ �_Selfc @ sR e Zd ZdZdZdZdd� Zdd� Zdd dd �d d �Zdd �dd dd�dd�Z dS )� Immutablea% mark a ClauseElement as 'immutable' when expressions are cloned. "immutable" objects refers to the "mutability" of an object in the context of SQL DQL and DML generation. Such as, in DQL, one can compose a SELECT or subquery of varied forms, but one cannot modify the structure of a specific table or column within DQL. :class:`.Immutable` is mostly intended to follow this concept, and as such the primary "immutable" objects are :class:`.ColumnClause`, :class:`.Column`, :class:`.TableClause`, :class:`.Table`. rT Tc O s t d��d S �Nz(Immutable objects do not support copying��NotImplementedError�rS Z optionaldict�kwargsrT rT rU � unique_params� s zImmutable.unique_paramsc O s t d��d S r~ r r� rT rT rU �params� s zImmutable.paramsr| r )rS �kwrf c K s | S rg rT �rS r� rT rT rU �_clone� s zImmutable._clone)� omit_attrsz Iterable[str]�None)r� r� rf c K s d S rg rT )rS r� r� rT rT rU �_copy_internals� s zImmutable._copy_internalsN) rW rX rY �__doc__� __slots__� _is_immutabler� r� r� r� rT rT rT rU r} � s �r} c @ sR e Zd ZU dZdZd ed< ddddd�dd�Zejd d �d d ��Z e d d� �Z dS )�SingletonConstantz.Represent SQL constants like NULL, TRUE, FALSET� _singletonr] r )ri ra r� rf c O s t t| j�S rg )r r] r� )ri ra r� rT rT rU �__new__� s zSingletonConstant.__new__z FrozenSet[ColumnElement[Any]]rv c C s t � �d S rg r rR rT rT rU � proxy_set� s zSingletonConstant.proxy_setc C s( t �| �}|�� t|g�|_|| _d S rg )�objectr� �__init__� frozensetr� r� )ri �objrT rT rU �_create_singleton� s z#SingletonConstant._create_singletonN) rW rX rY r� Z_is_singleton_constantrk r� r) Znon_memoized_propertyr� rl r� rT rT rT rU r� � s r� zEUnion[ColumnElement[Any], FromClause, TextClause, _JoinTargetElement]zIterator[FromClause]�r2 rf c G s t j�dd� | D ��S )Nc S s g | ] }|j �qS rT )� _from_objects)�.0ry rT rT rU � <listcomp>� s z!_from_objects.<locals>.<listcomp>�� itertools�chain� from_iterabler1 rT rT rU r� � s �r� z!Iterable[roles.ColumnsClauseRole]rA c C s t j�dd� | D ��S )zXexpand tables into individual columns in the given list of column expressions. c S s g | ] }|j �qS rT )Z_select_iterable�r� �crT rT rU r� � s z%_select_iterables.<locals>.<listcomp>r� r1 rT rT rU �_select_iterables� s �r� �_SelfGenerativeType�_GenerativeTypec @ s e Zd Zdd�dd�ZdS )r� r. rv c C s d S rg rT rR rT rT rU � _generate rt z_GenerativeType._generateN)rW rX rY r� rT rT rT rU r� s )�fnrf c C s. t jdddddd�dd��}|| �}| |_|S )z�non-caching _generative() decorator. This is basically the legacy decorator that copies the object and runs a method on the new copy. r_ r� r )r� rS �argsr� rf c _ s, |� � }| |f|�|�}||ks(td��|S )z Mark a method as generative.z#generative methods must return self)r� �AssertionError)r� rS r� r� �xrT rT rU � _generative s z _generative.<locals>._generative)r) � decoratorZnon_generative)r� r� Z decoratedrT rT rU r� s r� rn �Callable[[_Fn], _Fn])�namesr� rf c sB |� di ��|� di �� � fdd�| D ��tj��fdd��}|S )N�msgs�defaultsc s$ g | ] }|t �|�� �|d �f�qS rg )�operator� attrgetter�get)r� rQ )r� rT rU r� % s �z&_exclusive_against.<locals>.<listcomp>c sb |d }|dd � }� D ]8\}}}||�|k r�� |d| j|jf �}t�|��q| |f|�|�S )Nr r z9Method %s() has already been invoked on this %s construct)r� rW � __class__r( �InvalidRequestError)r� r� r� rS rQ �getterZdefault_�msg)�gettersr� rT rU �check* s �� z!_exclusive_against.<locals>.check)�popr) r� )r� r� r� rT )r� r� r� rU �_exclusive_against s �r� c K s | j f |�S rg )r� )ry r� rT rT rU r� = s r� zIterable[_CLE]c C s t jdd� | D �� S )z\expand the given set of ClauseElements to be the set of all 'cloned' predecessors. c S s g | ] }|j �qS rT )� _cloned_set�r� r� rT rT rU r� I s z"_expand_cloned.<locals>.<listcomp>)r� r� r1 rT rT rU �_expand_clonedA s r� c c s& | D ] }|j d k r|j }q|V qd S rg )Z _is_clone_of)r2 r� rT rT rU � _de_cloneL s r� z Set[_CLE])�a�brf c s( t t| ���t|��� � fdd�| D �S )z�return the intersection of sets a and b, counting any overlap between 'cloned' predecessors. The returned set is in terms of the entities present within 'a'. c s h | ]}� � |j�r|�qS rT �� intersectionr� �r� �elem�Z all_overlaprT rU � <setcomp>] s z'_cloned_intersection.<locals>.<setcomp>��setr� r� �r� r� rT r� rU �_cloned_intersectionU s r� c s( t t| ���t|��� � fdd�| D �S )Nc s h | ]}� � |j�s|�qS rT r� r� r� rT rU r� b s z%_cloned_difference.<locals>.<setcomp>r� r� rT r� rU �_cloned_difference` s �r� c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�_DialectArgViewzaA dictionary view of dialect-level arguments in the form <dialectname>_<argument_name>. c C s || _ d S rg )r� )rS r� rT rT rU r� m s z_DialectArgView.__init__c C sN z|� dd�\}}W n, tk r@ } zt|�|�W 5 d }~X Y n X ||fS d S )N�_r )�split� ValueError�KeyError)rS rq �dialect� value_key�errrT rT rU �_keyp s z_DialectArgView._keyc C sZ | � |�\}}z| jj| }W n. tjk rL } zt|�|�W 5 d }~X Y n X || S d S rg )r� r� �dialect_optionsr( �NoSuchModuleErrorr� )rS rq r� r� �optr� rT rT rU � __getitem__x s z_DialectArgView.__getitem__c C sV z| � |�\}}W n. tk r@ } zt�d�|�W 5 d }~X Y nX || jj| |< d S )Nz0Keys must be of the form <dialectname>_<argname>)r� r� r( � ArgumentErrorr� r� )rS rq �valuer� r� r� rT rT rU � __setitem__� s ��z_DialectArgView.__setitem__c C s | � |�\}}| jj| |= d S rg )r� r� r� )rS rq r� r� rT rT rU � __delitem__� s z_DialectArgView.__delitem__c C s t dd� | jj�� D ��S )Nc s s | ]}t |j�V qd S rg )�len� _non_defaults)r� r� rT rT rU � <genexpr>� s �z*_DialectArgView.__len__.<locals>.<genexpr>)�sumr� r� �valuesrR rT rT rU �__len__� s �z_DialectArgView.__len__c s � fdd�� j jD �S )Nc 3 s. | ]&}� j j| jD ]}d ||f V qqdS )z%s_%sN)r� r� r� )r� � dialect_nameZ value_namerR rT rU r� � s � �z+_DialectArgView.__iter__.<locals>.<genexpr>)r� r� rR rT rR rU �__iter__� s �z_DialectArgView.__iter__N) rW rX rY r� r� r� r� r� r� r� r� rT rT rT rU r� g s r� c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�_DialectArgDictz�A dictionary view of dialect-level arguments for a specific dialect. Maintains a separate collection of user-specified arguments and dialect-specified default arguments. c C s i | _ i | _d S rg �r� � _defaultsrR rT rT rU r� � s z_DialectArgDict.__init__c C s t t| j��| j��S rg )r� r� r� �unionr� rR rT rT rU r� � s z_DialectArgDict.__len__c C s t t| j��| j��S rg )�iterr� r� r� r� rR rT rT rU r� � s z_DialectArgDict.__iter__c C s" || j kr| j | S | j| S d S rg r� rr rT rT rU r� � s z_DialectArgDict.__getitem__c C s || j |< d S rg �r� �rS rq r� rT rT rU r� � s z_DialectArgDict.__setitem__c C s | j |= d S rg r� rr rT rT rU r� � s z_DialectArgDict.__delitem__N) rW rX rY r� r� r� r� r� r� r� rT rT rT rU r� � s r� zsqlalchemy.dialectsc C s( t jjj�| �}|jd kr d S t|j�S rg )r) � preloadedZdialects�registry�loadZconstruct_arguments�dict)r� Z dialect_clsrT rT rU �_kw_reg_for_dialect� s r� c @ sv e Zd ZdZdZdejfgZedd� �Z e j dd� �Z e dd � �Ze �e�Zd d � Ze j d d � �Zddd�dd�ZdS )� DialectKWArgsa9 Establish the ability for a class to have dialect-specific arguments with defaults and constructor validation. The :class:`.DialectKWArgs` interacts with the :attr:`.DefaultDialect.construct_arguments` present on a dialect. .. seealso:: :attr:`.DefaultDialect.construct_arguments` rT r� c C s@ t j| }|dkr t�d| ��| |kr0i || < ||| |< dS )a_ Add a new kind of dialect-specific keyword argument for this class. E.g.:: Index.argument_for("mydialect", "length", None) some_index = Index('a', 'b', mydialect_length=5) The :meth:`.DialectKWArgs.argument_for` method is a per-argument way adding extra arguments to the :attr:`.DefaultDialect.construct_arguments` dictionary. This dictionary provides a list of argument names accepted by various schema-level constructs on behalf of a dialect. New dialects should typically specify this dictionary all at once as a data member of the dialect class. The use case for ad-hoc addition of argument names is typically for end-user code that is also using a custom compilation scheme which consumes the additional arguments. :param dialect_name: name of a dialect. The dialect must be locatable, else a :class:`.NoSuchModuleError` is raised. The dialect must also include an existing :attr:`.DefaultDialect.construct_arguments` collection, indicating that it participates in the keyword-argument validation and default system, else :class:`.ArgumentError` is raised. If the dialect does not include this collection, then any keyword argument can be specified on behalf of this dialect already. All dialects packaged within SQLAlchemy include this collection, however for third party dialects, support may vary. :param argument_name: name of the parameter. :param default: default value of the parameter. NzRDialect '%s' does have keyword-argument validation and defaults enabled configured)r� � _kw_registryr( r� )ri r� � argument_namere �construct_arg_dictionaryrT rT rU � argument_for� s & ��zDialectKWArgs.argument_forc C s t | �S )a� A collection of keyword arguments specified as dialect-specific options to this construct. The arguments are present here in their original ``<dialect>_<kwarg>`` format. Only arguments that were actually passed are included; unlike the :attr:`.DialectKWArgs.dialect_options` collection, which contains all options known by this dialect including defaults. The collection is also writable; keys are accepted of the form ``<dialect>_<kwarg>`` where the value will be assembled into the list of options. .. seealso:: :attr:`.DialectKWArgs.dialect_options` - nested dictionary form )r� rR rT rT rU �dialect_kwargs s z DialectKWArgs.dialect_kwargsc C s | j S )z4A synonym for :attr:`.DialectKWArgs.dialect_kwargs`.)r� rR rT rT rU r� s zDialectKWArgs.kwargsc C sX t j| }t� }|d kr*|j�dd i� n*t| jj�D ] }||kr6|j�|| � q6|S )N�*)r� r� r� r� �update�reversedr� �__mro__)rS r� r� �dri rT rT rU �_kw_reg_for_dialect_cls' s z%DialectKWArgs._kw_reg_for_dialect_clsc C s t �t �| j��S )a� A collection of keyword arguments specified as dialect-specific options to this construct. This is a two-level nested registry, keyed to ``<dialect_name>`` and ``<argument_name>``. For example, the ``postgresql_where`` argument would be locatable as:: arg = my_object.dialect_options['postgresql']['where'] .. versionadded:: 0.9.2 .. seealso:: :attr:`.DialectKWArgs.dialect_kwargs` - flat dictionary form )r) � PopulateDictZportable_instancemethodr� rR rT rT rU r� 3 s �z DialectKWArgs.dialect_options�Dict[str, Any]r� )r� rf c C s� |sd S |D ]�}t �d|�}|s,td| ��|�dd�\}}z| j| }W nV tjk r� t�d||f � t � | j|< }|j � dd i� || |j |< Y q X d|kr�||kr�t� d||| jf ��q || ||< q d S )Nz ^(.+?)_(.+)$zGAdditional arguments should be named <dialectname>_<argument>, got '%s'r r& zHCan't validate argument %r; can't locate any SQLAlchemy dialect named %rr� z9Argument %r is not accepted by dialect %r on behalf of %r)�re�match� TypeError�groupr� r( r� r) �warnr� r� r� r� r� r� )rS r� �k�mr� Zarg_namer� r� rT rT rU �_validate_dialect_kwargsJ s@ ������ ��z&DialectKWArgs._validate_dialect_kwargsN)rW rX rY r� r� r% Zdp_dialect_optionsZ"_dialect_kwargs_traverse_internalsrl r� r) �memoized_propertyr� �propertyr� r� r� r� r� r� r rT rT rT rU r� � s � / r� c @ s~ e Zd ZU dZdZi Zded< ded< edd� �Zd d � Z ed d d �dd��Z ed dd d�dd��Z edddd�dd��Z dS )� CompileStatea Produces additional object state necessary for a statement to be compiled. the :class:`.CompileState` class is at the base of classes that assemble state for a particular statement object that is then used by the compiler. This process is essentially an extension of the process that the SQLCompiler.visit_XYZ() method takes, however there is an emphasis on converting raw user intent into more organized structures rather than producing string output. The top-level :class:`.CompileState` for the statement being executed is also accessible when the execution context works with invoking the statement and collecting results. The production of :class:`.CompileState` is specific to the compiler, such as within the :meth:`.SQLCompiler.visit_insert`, :meth:`.SQLCompiler.visit_select` etc. methods. These methods are also responsible for associating the :class:`.CompileState` with the :class:`.SQLCompiler` itself, if the statement is the "toplevel" statement, i.e. the outermost SQL statement that's actually being executed. There can be other :class:`.CompileState` objects that are not the toplevel, such as when a SELECT subquery or CTE-nested INSERT/UPDATE/DELETE is generated. .. versionadded:: 1.4 )� statement�_ambiguous_table_name_mapz)Dict[Tuple[str, str], Type[CompileState]]�pluginsz Optional[_AmbiguousTableNameMap]r c K s| |j rB|j �dd�}| j�||jfd �}|d krR| jd|jf }n| jd|jf }|| krh| ||f|�S |j||f|�S d S �NZcompile_state_pluginre )�_propagate_attrsr� r �_effective_plugin_target�create_for_statement)ri r �compilerr� � plugin_name�klassrT rT rU r � s& � ���z!CompileState.create_for_statementc K s || _ d S rg )r )rS r r r� rT rT rU r� � s zCompileState.__init__� Executable� Optional[Type[CompileState]])r rf c C s^ |j �dd �}|r0||jf}|| jkr0| j| S z| jd|jf W S tk rX Y d S X d S r )r r� r r r� )ri r r rq rT rT rU �get_plugin_class� s � z CompileState.get_plugin_classrn )r r rf c C s. z| j ||jf W S tk r( Y d S X d S rg )r r r� )ri r r rT rT rU � _get_plugin_class_for_plugin� s �z)CompileState._get_plugin_class_for_pluginr� )r � visit_namerf c s � ��fdd�}|S )Nc s | � j ��f< | S rg )r )Zcls_to_decorate�ri r r rT rU �decorate� s z)CompileState.plugin_for.<locals>.decoraterT )ri r r r rT r rU � plugin_for� s zCompileState.plugin_forN) rW rX rY r� r� r rk rl r r� r r r rT rT rT rU r r s r c @ s e Zd ZdZdd�dd�ZdS )� GenerativezUProvide a method-chaining pattern in conjunction with the @_generative decorator.r. rv c sJ | j � | j}|�|�}� r:� fdd�| j�� �� D �|_n | j�� |_|S )Nc s i | ]\}}|� kr||�qS rT rT )r� r �v��skiprT rU � <dictcomp>� s z(Generative._generate.<locals>.<dictcomp>)�_memoized_keysr� r� �__dict__�copy�items)rS ri �srT r rU r� � s � zGenerative._generateN)rW rX rY r� r� rT rT rT rU r � s r c @ s e Zd ZdZdZdd� ZdS )�InPlaceGenerativezkProvide a method-chaining pattern in conjunction with the @_generative decorator that mutates in place.rT c C s" | j }|D ]}| j�|d � q | S rg )r r! r� )rS r r rT rT rU r� � s zInPlaceGenerative._generateN)rW rX rY r� r� r� rT rT rT rU r% � s r% c @ s2 e Zd ZU dZdZded< ejZded< e j Z dS )�HasCompileStatez=A class that has a :class:`.CompileState` associated with it.Nr �_compile_state_plugin� util.immutabledict[str, Any]� _attributes) rW rX rY r� r' rk r) � EMPTY_DICTr) r r Z_compile_state_factoryrT rT rT rU r& � s r& c @ sX e Zd ZU dZded< dd� ZerTddd�d d �Zddd d �d d�Zdd d�dd�Z dS )� _MetaOptionsz�metaclass for the Options class. This metaclass is actually necessary despite the availability of the ``__init_subclass__()`` hook as this type also provides custom class-level behavior for the ``__add__()`` method. �Tuple[str, ...]� _cache_attrsc C sB | � }t |��| j�r2td| t |��| j�f ��|j�|� |S �NzBdictionary contains attributes not covered by Options class %s: %r)r� � differencer- r r! r� �rS �otherZo1rT rT rU �__add__ s �� z_MetaOptions.__add__rn r rp c C s d S rg rT rr rT rT rU rs rt z_MetaOptions.__getattr__r� �rq r� rf c C s d S rg rT r� rT rT rU � __setattr__" rt z_MetaOptions.__setattr__c C s d S rg rT rr rT rT rU � __delattr__$ rt z_MetaOptions.__delattr__N) rW rX rY r� rk r2 r rs r4 r5 rT rT rT rU r+ s r+ c s� e Zd ZU dZdZded< dd�� fdd� Zd d � Zd d � Zd d� Z dd� Z e ddd�dd��Z e dd� �Ze dd�dd��ZejZded < ejdd�d d ��Ze d d � �Ze d!d"� �Zer�d#d$d%�d&d'�Zd#d$dd(�d)d*�Zd#dd%�d+d,�Z� ZS )-�Optionsz,A cacheable option dictionary with defaults.rT r, r- r� rv c s, | j }ttdd� |D ���| _t� �� d S )Nc s s$ | ] }|� d �s|dkr|V qdS )�__)Z_cache_key_traversalN)� startswith)r� r� rT rT rU r� 1 s �z,Options.__init_subclass__.<locals>.<genexpr>)r! �tuple�sortedr- �super�__init_subclass__)ri Zdict_�r� rT rU r< . s ��zOptions.__init_subclass__c K s | j �|� d S rg )r! r� r� rT rT rU r� : s zOptions.__init__c C sX | j �| j �}|j�| j� t|��| j�rHtd| t|��| j�f ��|j�|� |S r. )r� r� r! r� r� r/ r- r r0 rT rT rU r2 = s �� zOptions.__add__c C s6 t | j|j�D ]"\}}t| |�t||�kr dS qdS �NFT)r r- �getattr)rS r1 r� r� rT rT rU �__eq__K s zOptions.__eq__c s& d� j jd�� fdd�� jD ��f S )N�%s(%s)�, c 3 s* | ]"}|� j krd |� j | f V qdS )z%s=%rN�r! )r� r rR rT rU r� X s �z#Options.__repr__.<locals>.<genexpr>)r� rW �joinr- rR rT rR rU rV S s ��zOptions.__repr__z Type[Any]�bool)r rf c C s t | |�S rg )� issubclass)ri r rT rT rU � isinstance_ s zOptions.isinstancec C s | |t | |�| i S rg )r? )rS rQ r� rT rT rU �add_to_elementc s zOptions.add_to_elementzMapping[str, Any]c C s | j S rg rC rR rT rT rU �_state_dict_instg s zOptions._state_dict_instr( �_state_dict_constc C s | j S rg )rJ )ri rT rT rU � _state_dictm s zOptions._state_dictc C sR |� � }| |jk rJ|jrJt|j��| j�rJtd|| t|j��| j�f ��| | S )Nz]other element %r is not empty, is not of type %s, and contains attributes not covered here %r)rK r� r- r� r/ r )ri r1 r� rT rT rU � safe_mergeq s ������ zOptions.safe_mergec C s� |� t|��|��}|�|| �}|r�i }|D ]6}d| } ||krN|| || < q,||kr,|| || < q,|| } t�� �||| i�}| |fS ||fS dS )a{ process Options argument in terms of execution options. e.g.:: ( load_options, execution_options, ) = QueryContext.default_load_options.from_execution_options( "_sa_orm_load_options", { "populate_existing", "autoflush", "yield_per" }, execution_options, statement._execution_options, ) get back the Options and refresh "_sa_orm_load_options" in the exec options dict w/ the Options as well r� N)r� r� r� r� r) Z immutabledictZ merge_with) ri rq �attrsZ exec_optionsZstatement_exec_optionsZcheck_argnamesZexisting_options�result�argname�local� new_optionsrT rT rU �from_execution_options� s& � �z Options.from_execution_optionsrn r rp c C s d S rg rT rr rT rT rU rs � rt zOptions.__getattr__r3 c C s d S rg rT r� rT rT rU r4 � rt zOptions.__setattr__c C s d S rg rT rr rT rT rU r5 � rt zOptions.__delattr__) rW rX rY r� r� rk r< r� r2 r@ rV rl rG r+ rH rI r) r* rJ � classlevelrK rL rR r rs r4 r5 � __classcell__rT rT r= rU r6 ' s2 5r6 )� metaclassc @ s6 e Zd ZdZedd� �Zejdd� �Zedd� �ZdS ) �CacheableOptionsrT c C s t �| ||�S rg )r �_gen_cache_key)rS �anon_map� bindparamsrT rT rU �_gen_cache_key_inst� s z$CacheableOptions._gen_cache_key_instc C s | dfS )NrT rT )ri rX rY rT rT rU rW � s z CacheableOptions._gen_cache_keyc C s t �| �S rg )r Z _generate_cache_key_for_objectrR rT rT rU �_generate_cache_key� s z$CacheableOptions._generate_cache_keyN) rW rX rY r� r+ rZ rS rW r[ rT rT rT rU rV � s rV c @ s* e Zd ZdZejZdZdZdZ dd� Z dS )�ExecutableOptionrT Zexecutable_optionFTc K s | j �| j �}t| j�|_|S )z/Create a shallow copy of this ExecutableOption.)r� r� r� r! )rS r� r� rT rT rU r� � s zExecutableOption._cloneN) rW rX rY r� r) r* � _annotations�__visit_name__Z_is_has_cache_keyZ_is_corer� rT rT rT rU r\ � s r\ c @ s� e Zd ZU dZdZded< ejZded< dZ dZ d ed < dZ d ed < d ed< d e j fd ejfdejfgZdZdZdZdZdZdZdZer�ded< ddd�dddddddd�dd �Zd d d d d!�d"d#�Zd d d dd!�d$d%�Z ej d&d'� �Z e dd(�d)d*��Z e!d+d,d-�d.d/��Z"e!d0d,d1�d2d3��Z#e!d0d,d-�d4d5��Z$e!d6dd,d7�d8d9��Z%e&d:d:d:ddd:d:d:d:ddd:d:d:d:d:dd;�ddd<ddd=d=d=dddd>d?dddddd,d@�dAdB��Z'e&dd,dC�dDdB��Z'e!dd,dE�dFdB��Z'dGd(�dHdI�Z(dS )Jr z�Mark a :class:`_expression.ClauseElement` as supporting execution. :class:`.Executable` is a superclass for all "statement" types of objects, including :func:`select`, :func:`delete`, :func:`update`, :func:`insert`, :func:`text`. TrE �supports_executionrG �_execution_optionsFrT z Tuple[ExecutableOption, ...]� _with_optionsz6Tuple[Tuple[Callable[[CompileState], None], Any], ...]�_with_context_optionsz9Optional[Union[Type[CacheableOptions], CacheableOptions]]�_compile_optionsr rn r^ N)�for_executemany�schema_translate_maprL zOptional[CompiledCacheType]z List[str]z Optional[SchemaTranslateMapType]r zCTuple[Compiled, Optional[Sequence[BindParameter[Any]]], CacheStats])r� �compiled_cache� column_keysrd re r� rf c K s d S rg rT )rS r� rf rg rd re r� rT rT rU �_compile_w_cache s zExecutable._compile_w_cacherC rE rK zCursorResult[Any])� connection�distilled_params�execution_optionsrf c C s d S rg rT �rS ri rj rk rT rT rU �_execute_on_connection s z!Executable._execute_on_connectionc C s d S rg rT rl rT rT rU �_execute_on_scalar% s z Executable._execute_on_scalarc C s t � �d S rg r rR rT rT rU �_all_selected_columns, s z Executable._all_selected_columnsrv c C s | j S rg )r^ rR rT rT rU r 0 s z#Executable._effective_plugin_targetr\ r. )�optionsrf c G s | j tdd� |D ��7 _ | S )aJ Apply options to this statement. In the general sense, options are any kind of Python object that can be interpreted by the SQL compiler for the statement. These options can be consumed by specific dialects or specific kinds of compilers. The most commonly known kind of option are the ORM level options that apply "eager load" and other loading behaviors to an ORM query. However, options can theoretically be used for many other purposes. For background on specific kinds of options for specific kinds of statements, refer to the documentation for those option objects. .. versionchanged:: 1.4 - added :meth:`.Executable.options` to Core statement objects towards the goal of allowing unified Core / ORM querying capabilities. .. seealso:: :ref:`loading_columns` - refers to options specific to the usage of ORM queries :ref:`relationship_loader_options` - refers to options specific to the usage of ORM queries c s s | ]}t �tj|�V qd S rg )r0 �expectr ZExecutableOptionRole)r� r� rT rT rU r� R s �z%Executable.options.<locals>.<genexpr>)ra r9 �rS rp rT rT rU rp 4 s � zExecutable.optionsrV )�compile_optionsrf c C s || _ | S )z|Assign the compile options to a new value. :param compile_options: appropriate CacheableOptions structure )rc )rS rs rT rT rU �_set_compile_optionsX s z Executable._set_compile_optionsc C s | j dk st�| j |7 _ | S )z*update the _compile_options with new keys.N)rc r� rr rT rT rU �_update_compile_optionsc s z"Executable._update_compile_optionsz Callable[[CompileState], None])� callable_� cache_argsrf c C s | j ||ff7 _ | S )aM Add a context option to this statement. These are callable functions that will be given the CompileState object upon compilation. A second argument cache_args is required, which will be combined with the ``__code__`` identity of the function itself in order to produce a cache key. )rb )rS rv rw rT rT rU �_add_context_optionk s z Executable._add_context_option.)rf � logging_token�isolation_level� no_parameters�stream_results�max_row_buffer� yield_per�insertmanyvalues_page_sizere �populate_existing� autoflush�synchronize_session� dml_strategy� render_nulls�is_delete_using�is_update_from�preserve_rowcountrM �intr5 r4 )rf ry rz r{ r| r} r~ r re r� r� r� r� r� r� r� r� r� rf c K s d S rg rT )rS rf ry rz r{ r| r} r~ r re r� r� r� r� r� r� r� r� r� rT rT rU rk ~ s z Executable.execution_options)r� rf c K s d S rg rT )rS r� rT rT rU rk � s )r� rf c K s6 d|krt �d��d|kr$t �d��| j�|�| _| S )a� Set non-SQL options for the statement which take effect during execution. Execution options can be set at many scopes, including per-statement, per-connection, or per execution, using methods such as :meth:`_engine.Connection.execution_options` and parameters which accept a dictionary of options such as :paramref:`_engine.Connection.execute.execution_options` and :paramref:`_orm.Session.execute.execution_options`. The primary characteristic of an execution option, as opposed to other kinds of options such as ORM loader options, is that **execution options never affect the compiled SQL of a query, only things that affect how the SQL statement itself is invoked or how results are fetched**. That is, execution options are not part of what's accommodated by SQL compilation nor are they considered part of the cached state of a statement. The :meth:`_sql.Executable.execution_options` method is :term:`generative`, as is the case for the method as applied to the :class:`_engine.Engine` and :class:`_orm.Query` objects, which means when the method is called, a copy of the object is returned, which applies the given parameters to that new copy, but leaves the original unchanged:: statement = select(table.c.x, table.c.y) new_statement = statement.execution_options(my_option=True) An exception to this behavior is the :class:`_engine.Connection` object, where the :meth:`_engine.Connection.execution_options` method is explicitly **not** generative. The kinds of options that may be passed to :meth:`_sql.Executable.execution_options` and other related methods and parameter dictionaries include parameters that are explicitly consumed by SQLAlchemy Core or ORM, as well as arbitrary keyword arguments not defined by SQLAlchemy, which means the methods and/or parameter dictionaries may be used for user-defined parameters that interact with custom code, which may access the parameters using methods such as :meth:`_sql.Executable.get_execution_options` and :meth:`_engine.Connection.get_execution_options`, or within selected event hooks using a dedicated ``execution_options`` event parameter such as :paramref:`_events.ConnectionEvents.before_execute.execution_options` or :attr:`_orm.ORMExecuteState.execution_options`, e.g.:: from sqlalchemy import event @event.listens_for(some_engine, "before_execute") def _process_opt(conn, statement, multiparams, params, execution_options): "run a SQL function before invoking a statement" if execution_options.get("do_special_thing", False): conn.exec_driver_sql("run_special_function()") Within the scope of options that are explicitly recognized by SQLAlchemy, most apply to specific classes of objects and not others. The most common execution options include: * :paramref:`_engine.Connection.execution_options.isolation_level` - sets the isolation level for a connection or a class of connections via an :class:`_engine.Engine`. This option is accepted only by :class:`_engine.Connection` or :class:`_engine.Engine`. * :paramref:`_engine.Connection.execution_options.stream_results` - indicates results should be fetched using a server side cursor; this option is accepted by :class:`_engine.Connection`, by the :paramref:`_engine.Connection.execute.execution_options` parameter on :meth:`_engine.Connection.execute`, and additionally by :meth:`_sql.Executable.execution_options` on a SQL statement object, as well as by ORM constructs like :meth:`_orm.Session.execute`. * :paramref:`_engine.Connection.execution_options.compiled_cache` - indicates a dictionary that will serve as the :ref:`SQL compilation cache <sql_caching>` for a :class:`_engine.Connection` or :class:`_engine.Engine`, as well as for ORM methods like :meth:`_orm.Session.execute`. Can be passed as ``None`` to disable caching for statements. This option is not accepted by :meth:`_sql.Executable.execution_options` as it is inadvisable to carry along a compilation cache within a statement object. * :paramref:`_engine.Connection.execution_options.schema_translate_map` - a mapping of schema names used by the :ref:`Schema Translate Map <schema_translating>` feature, accepted by :class:`_engine.Connection`, :class:`_engine.Engine`, :class:`_sql.Executable`, as well as by ORM constructs like :meth:`_orm.Session.execute`. .. seealso:: :meth:`_engine.Connection.execution_options` :paramref:`_engine.Connection.execute.execution_options` :paramref:`_orm.Session.execute.execution_options` :ref:`orm_queryguide_execution_options` - documentation on all ORM-specific execution options rz z�'isolation_level' execution option may only be specified on Connection.execution_options(), or per-engine using the isolation_level argument to create_engine().rf zm'compiled_cache' execution option may only be specified on Connection.execution_options(), not per statement.)r( r� r` r� r� rT rT rU rk � s g��rF c C s | j S )z�Get the non-SQL options which will take effect during execution. .. versionadded:: 1.3 .. seealso:: :meth:`.Executable.execution_options` )r` rR rT rT rU �get_execution_options s z Executable.get_execution_options))rW rX rY r� r_ rk r) r* r` Z_is_default_generatorra rb r% Zdp_executable_optionsr# Zdp_with_context_optionsZdp_propagate_attrsZ _executable_traverse_internalsZ is_selectZis_from_statementZ is_updateZ is_insertZis_textZ is_deleteZis_dmlr rh rm rn rx ro r r r� rp rt ru rx r rk r� rT rT rT rU r � s� � �� � # �8ur c @ s> e Zd ZU dZded< d ddd�dd�Zd ddd�d d �Zd S ) �SchemaEventTargetz�Base class for elements that are the targets of :class:`.DDLEvents` events. This includes :class:`.SchemaItem` as well as :class:`.SchemaType`. z dispatcher[SchemaEventTarget]�dispatchr r� )�parentr� rf c K s dS )z0Associate with this SchemaEvent's parent object.NrT �rS r� r� rT rT rU � _set_parent% s z SchemaEventTarget._set_parentc K s. | j �| |� | j|f|� | j �| |� d S rg )r� Zbefore_parent_attachr� Zafter_parent_attachr� rT rT rU �_set_parent_with_dispatch( s z+SchemaEventTarget._set_parent_with_dispatchN)rW rX rY r� rk r� r� rT rT rT rU r� s r� c @ s e Zd ZdZddiZdS )� SchemaVisitorz/Define the visiting for ``SchemaItem`` objects.Zschema_visitorTN)rW rX rY r� Z__traverse_options__rT rT rT rU r� 0 s r� c @ s( e Zd ZdZdZdZdZdZdZdZ dS ) � _SentinelDefaultCharacterization�none�unknownZ clientsideZsentinel_defaultZ serverside�identity�sequenceN) rW rX rY �NONE�UNKNOWNZ CLIENTSIDEZSENTINEL_DEFAULTZ SERVERSIDEZIDENTITYZSEQUENCErT rT rT rU r� 6 s r� c @ s@ e Zd ZU dZded< dZded< dZded< ejZ ded < dS ) � _SentinelColumnCharacterizationNz Optional[Sequence[Column[Any]]]�columnsFrE � is_explicit� is_autoincr� �default_characterization) rW rX rY r� rk r� r� r� r� r� rT rT rT rU r� @ s �r� �_COLKEY�_COL_co�ColumnElement[Any]T)r^ � covariant�_COLc @ sJ e Zd ZU dZded< ddd�dd�Zdd � Zd d � Zd d d�dd�ZdS )�_ColumnMetrics��columnr� r� z ColumnCollection[Any, _COL_co])� collection�colc C s. || _ |j}|r*|jD ]}|| �| � qd S rg )r� � _proxy_index�_expanded_proxy_set�add)rS r� r� �pi�eps_colrT rT rU r� T s z_ColumnMetrics.__init__c C s | j jS rg )r� r� rR rT rT rU �get_expanded_proxy_set` s z%_ColumnMetrics.get_expanded_proxy_setc C sL |j }|sd S | jjD ]0}|�|d �}|r4|�| � |d k r|s||= qd S rg )r� r� r� r� �discard)rS r� r� r� ZcolsetrT rT rU �disposec s z_ColumnMetrics.disposez=Union[Set[ColumnElement[Any]], FrozenSet[ColumnElement[Any]]]rE )� target_setrf c C s2 | j j}|�|�D ]}|�t|g��s dS qdS r> )r� r� r/ r� r� )rS r� Zexpanded_proxy_set�trT rT rU �embeddedn s z_ColumnMetrics.embeddedN) rW rX rY r� rk r� r� r� r� rT rT rT rU r� O s r� c @ s� e Zd ZU dZdZded< ded< ded< d ed < d|d d �dd�Ze�d�dd�dd��Z ddd�dd�Z e dd�dd ��Z d d�d d �Z dd�d d!�Zd"d�d#d$�Zd%d�d&d'�Zd(d�d)d*�Zd+d�d,d-�Zed.d/d0�d1d2��Zed3d4d0�d5d2��Zed6d4d0�d7d2��Zd8d9d0�d:d2�Zd;d/d0�d<d=�Zd;d%d0�d>d?�Zd@d%dA�dBdC�ZdDd%dA�dEdF�Zed}d;ddGdH�dIdJ��Zed;dKdLdH�dMdJ��Zd~d;dNdOdH�dPdJ�Zd;d�dQdR�Zd;dDdSdT�dUdV�Zd;dSd0�dWdX�Z d;dDdSdY�dZd[�Z dSd�d\d]�Z dDdd^�d_d`�Z dDdSd�dadb�Z d Z!ddd�dcdd�Z"ddedfddg�dhdi�Z#djd�dkdl�Z$djddm�dndo�Z%ded%dp�dqdr�Z&d4d�dsdt�Z'dudv� Z(d�dKd%dxdy�dzd{�Z)d S )��ColumnCollectiona� Collection of :class:`_expression.ColumnElement` instances, typically for :class:`_sql.FromClause` objects. The :class:`_sql.ColumnCollection` object is most commonly available as the :attr:`_schema.Table.c` or :attr:`_schema.Table.columns` collection on the :class:`_schema.Table` object, introduced at :ref:`metadata_tables_and_columns`. The :class:`_expression.ColumnCollection` has both mapping- and sequence- like behaviors. A :class:`_expression.ColumnCollection` usually stores :class:`_schema.Column` objects, which are then accessible both via mapping style access as well as attribute access style. To access :class:`_schema.Column` objects using ordinary attribute-style access, specify the name like any other object attribute, such as below a column named ``employee_name`` is accessed:: >>> employee_table.c.employee_name To access columns that have names with special characters or spaces, index-style access is used, such as below which illustrates a column named ``employee ' payment`` is accessed:: >>> employee_table.c["employee ' payment"] As the :class:`_sql.ColumnCollection` object provides a Python dictionary interface, common dictionary method names like :meth:`_sql.ColumnCollection.keys`, :meth:`_sql.ColumnCollection.values`, and :meth:`_sql.ColumnCollection.items` are available, which means that database columns that are keyed under these names also need to use indexed access:: >>> employee_table.c["values"] The name for which a :class:`_schema.Column` would be present is normally that of the :paramref:`_schema.Column.key` parameter. In some contexts, such as a :class:`_sql.Select` object that uses a label style set using the :meth:`_sql.Select.set_label_style` method, a column of a certain key may instead be represented under a particular label name such as ``tablename_columnname``:: >>> from sqlalchemy import select, column, table >>> from sqlalchemy import LABEL_STYLE_TABLENAME_PLUS_COL >>> t = table("t", column("c")) >>> stmt = select(t).set_label_style(LABEL_STYLE_TABLENAME_PLUS_COL) >>> subq = stmt.subquery() >>> subq.c.t_c <sqlalchemy.sql.elements.ColumnClause at 0x7f59dcf04fa0; t_c> :class:`.ColumnCollection` also indexes the columns in order and allows them to be accessible by their integer position:: >>> cc[0] Column('x', Integer(), table=None) >>> cc[1] Column('y', Integer(), table=None) .. versionadded:: 1.4 :class:`_expression.ColumnCollection` allows integer-based index access to the collection. Iterating the collection yields the column expressions in order:: >>> list(cc) [Column('x', Integer(), table=None), Column('y', Integer(), table=None)] The base :class:`_expression.ColumnCollection` object can store duplicates, which can mean either two columns with the same key, in which case the column returned by key access is **arbitrary**:: >>> x1, x2 = Column('x', Integer), Column('x', Integer) >>> cc = ColumnCollection(columns=[(x1.name, x1), (x2.name, x2)]) >>> list(cc) [Column('x', Integer(), table=None), Column('x', Integer(), table=None)] >>> cc['x'] is x1 False >>> cc['x'] is x2 True Or it can also mean the same column multiple times. These cases are supported as :class:`_expression.ColumnCollection` is used to represent the columns in a SELECT statement which may include duplicates. A special subclass :class:`.DedupeColumnCollection` exists which instead maintains SQLAlchemy's older behavior of not allowing duplicates; this collection is used for schema level objects like :class:`_schema.Table` and :class:`.PrimaryKeyConstraint` where this deduping is helpful. The :class:`.DedupeColumnCollection` class also has additional mutation methods as the schema constructs have more use cases that require removal and replacement of columns. .. versionchanged:: 1.4 :class:`_expression.ColumnCollection` now stores duplicate column keys as well as the same column in multiple positions. The :class:`.DedupeColumnCollection` class is added to maintain the former behavior in those cases where deduplication as well as additional replace/remove operations are needed. )� _collection�_index�_colsetr� z6List[Tuple[_COLKEY, _COL_co, _ColumnMetrics[_COL_co]]]r� z4Dict[Union[None, str, int], Tuple[_COLKEY, _COL_co]]r� z6Dict[ColumnElement[Any], Set[_ColumnMetrics[_COL_co]]]r� z Set[_COL_co]r� Nz+Optional[Iterable[Tuple[_COLKEY, _COL_co]]])r� c C sT t �| dt� � t �| di � t �| dt�tj�� t �| dg � |rP| �|� d S )Nr� r� r� r� )r� r4 r� � collections� defaultdictr) � OrderedSet�_initial_populate)rS r� rT rT rU r� � s �zColumnCollection.__init__zsqlalchemy.sql.elementsr8 rv c C s t jj}|j| jtjdd��S )NF)Z_literal_as_text_roler )r) r� Z sql_elementsr8 � _all_columnsr ZColumnsClauseRole�rS r2 rT rT rU �__clause_element__� s ��z#ColumnCollection.__clause_element__z!Iterable[Tuple[_COLKEY, _COL_co]]r� ��iter_rf c C s | � |� d S rg ��_populate_separate_keys�rS r� rT rT rU r� s z"ColumnCollection._initial_populatez List[_COL_co]c C s dd� | j D �S )Nc S s g | ]\}}}|�qS rT rT �r� r� r� rT rT rU r� s z1ColumnCollection._all_columns.<locals>.<listcomp>�r� rR rT rT rU r� s z ColumnCollection._all_columnsz List[_COLKEY]c C s dd� | j D �S )zQReturn a sequence of string key names for all columns in this collection.c S s g | ]\}}}|�qS rT rT )r� r r� rT rT rU r� s z)ColumnCollection.keys.<locals>.<listcomp>r� rR rT rT rU �keys s zColumnCollection.keysc C s dd� | j D �S )z�Return a sequence of :class:`_sql.ColumnClause` or :class:`_schema.Column` objects for all columns in this collection.c S s g | ]\}}}|�qS rT rT r� rT rT rU r� s z+ColumnCollection.values.<locals>.<listcomp>r� rR rT rT rU r� s zColumnCollection.valuesz List[Tuple[_COLKEY, _COL_co]]c C s dd� | j D �S )z�Return a sequence of (key, column) tuples for all columns in this collection each consisting of a string key name and a :class:`_sql.ColumnClause` or :class:`_schema.Column` object. c S s g | ]\}}}||f�qS rT rT �r� r r� r� rT rT rU r� s z*ColumnCollection.items.<locals>.<listcomp>r� rR rT rT rU r# s zColumnCollection.itemsrE c C s t | j�S rg )rE r� rR rT rT rU �__bool__" s zColumnCollection.__bool__r� c C s t | j�S rg )r� r� rR rT rT rU r� % s zColumnCollection.__len__zIterator[_COL_co]c C s t dd� | jD ��S )Nc S s g | ]\}}}|�qS rT rT r� rT rT rU r� * s z-ColumnCollection.__iter__.<locals>.<listcomp>)r� r� rR rT rT rU r� ( s zColumnCollection.__iter__zUnion[str, int]r� rp c C s d S rg rT rr rT rT rU r� , s z ColumnCollection.__getitem__zTuple[Union[str, int], ...]z*ReadOnlyColumnCollection[_COLKEY, _COL_co]c C s d S rg rT rr rT rT rU r� / s �slicec C s d S rg rT rr rT rT rU r� 4 s z3Union[str, int, slice, Tuple[Union[str, int], ...]]z:Union[ReadOnlyColumnCollection[_COLKEY, _COL_co], _COL_co]c s� zbt |ttf�rPt |t�r0dd� � j| D �}n� fdd�|D �}t|��� W S � j| d W S W nF tk r� } z(t |jd t �r�t |jd �|�n� W 5 d }~X Y nX d S )Nc s s | ]\}}}||fV qd S rg rT )r� �sub_keyr� r� rT rT rU r� ? s �z/ColumnCollection.__getitem__.<locals>.<genexpr>c 3 s | ]}� j | V qd S rg �r� )r� r� rR rT rU r� D s r r ) rG r9 r� r� r� � as_readonlyr� r� r� r� � IndexError)rS rq �colsr� rT rR rU r� 9 s �rn c C sB z| j | d W S tk r< } zt|�|�W 5 d }~X Y nX d S )Nr )r� r� �AttributeError)rS rq r� rT rT rU rs O s z ColumnCollection.__getattr__c C s* || j kr"t|t�s t�d��dS dS d S )Nz'__contains__ requires a string argumentFT)r� rG rn r( r� rr rT rT rU � __contains__U s �z ColumnCollection.__contains__zColumnCollection[Any, Any])r1 rf c C s& t | |�D ]\}}||k r dS q dS )zdCompare this :class:`_expression.ColumnCollection` to another based on the names of the keysFTNr )rS r1 �l�rrT rT rU �compare_ s zColumnCollection.comparer c C s | � |�S rg )r� )rS r1 rT rT rU r@ i s zColumnCollection.__eq__zOptional[_COL_co])rq re rf c C s d S rg rT �rS rq re rT rT rU r� l s zColumnCollection.getr� zUnion[_COL_co, _COL]c C s d S rg rT r� rT rT rU r� o s zOptional[_COL]z Optional[Union[_COL_co, _COL]]c C s || j kr| j | d S |S dS )z�Get a :class:`_sql.ColumnClause` or :class:`_schema.Column` object based on a string key name from this :class:`_expression.ColumnCollection`.r Nr� r� rT rT rU r� r s c C s d| j jd�dd� | D ��f S )NrA rB c s s | ]}t |�V qd S rg )rn r� rT rT rU r� � s z+ColumnCollection.__str__.<locals>.<genexpr>)r� rW rD rR rT rT rU �__str__~ s �zColumnCollection.__str__r r3 c C s t � �d S rg r r� rT rT rU r� � s z ColumnCollection.__setitem__c C s t � �d S rg r rr rT rT rU r� � s z ColumnCollection.__delitem__)rq r� rf c C s t � �d S rg r )rS rq r� rT rT rU r4 � s z ColumnCollection.__setattr__c C s t � �dS )zQDictionary clear() is not implemented for :class:`_sql.ColumnCollection`.Nr rR rT rT rU �clear� s zColumnCollection.clear�r� rf c C s t � �d S rg r )rS r� rT rT rU �remove� s zColumnCollection.removec C s t � �dS )zRDictionary update() is not implemented for :class:`_sql.ColumnCollection`.Nr r� rT rT rU r� � s zColumnCollection.updatec sn � fdd�|D � � j dd�< }� j�dd� |D �� � j�dd� t|�D �� � j�dd� t|�D �� dS ) �*populate from an iterator of (key, column)c s g | ]\}}||t � |�f�qS rT �r� �r� r r� rR rT rU r� � s z<ColumnCollection._populate_separate_keys.<locals>.<listcomp>Nc s s | ]\}}}|� � V qd S rg �� _deannotate)r� r� r� rT rT rU r� � s z;ColumnCollection._populate_separate_keys.<locals>.<genexpr>c S s i | ]\}\}}}|||f�qS rT rT �r� �idxr r� r� rT rT rU r � s z<ColumnCollection._populate_separate_keys.<locals>.<dictcomp>c S s i | ]\}}}|||f�qS rT rT r� rT rT rU r � s )r� r� r� r� � enumerater� )rS r� r� rT rR rU r� � s ��z(ColumnCollection._populate_separate_keysr� zOptional[_COLKEY]�r� rq rf c C sz |dkr|j }n|}t| j�}tt|�}| j�||t| |�f� | j�|� � � ||f| j |< || j krv||f| j |< dS )a� Add a column to this :class:`_sql.ColumnCollection`. .. note:: This method is **not normally used by user-facing code**, as the :class:`_sql.ColumnCollection` is usually part of an existing object such as a :class:`_schema.Table`. To add a :class:`_schema.Column` to an existing :class:`_schema.Table` object, use the :meth:`_schema.Table.append_column` method. N) rq r� r� r r� �appendr� r� r� r� r� )rS r� rq Zcolkeyr� �_columnrT rT rU r� � s � zColumnCollection.addr� c C s dd� | j D �| jd�S )Nc S s g | ]\}}}||f�qS rT rT �r� r r� r� rT rT rU r� � s z1ColumnCollection.__getstate__.<locals>.<listcomp>�r� r� r� rR rT rT rU � __getstate__� s �z ColumnCollection.__getstate__)�staterf c sf t �� d|d � t �� dt�tj�� t �� d� fdd�|d D �� t �� ddd� � jD �� d S ) Nr� r� r� c s g | ]\}}||t � |�f�qS rT r� r� rR rT rU r� � s �z1ColumnCollection.__setstate__.<locals>.<listcomp>r� c S s h | ]\}}}|�qS rT rT r� rT rT rU r� � s z0ColumnCollection.__setstate__.<locals>.<setcomp>)r� r4 r� r� r) r� r� )rS r� rT rR rU � __setstate__� s$ � �� �z ColumnCollection.__setstate__)r� rf c C s* || j kr"t|t�r t�d��dS dS dS )z3Checks if a column object exists in this collectionzZcontains_column cannot be used with string arguments. Use ``col_name in table.c`` instead.FTN)r� rG rn r( r� �rS r� rT rT rU �contains_column� s �z ColumnCollection.contains_columnc C s t | �S )zIReturn a "read only" form of this :class:`_sql.ColumnCollection`.)�ReadOnlyColumnCollectionrR rT rT rU r� � s z ColumnCollection.as_readonlyc C sD | j }|rdS | jD ]*\}}}|jj}|D ]}|| �|� q*qdS )a� populate the "proxy index", if empty. proxy index is added in 2.0 to provide more efficient operation for the corresponding_column() method. For reasons of both time to construct new .c collections as well as memory conservation for large numbers of large .c collections, the proxy_index is only filled if corresponding_column() is called. once filled it stays that way, and new _ColumnMetrics objects created after that point will populate it with new data. Note this case would be unusual, if not nonexistent, as it means a .c collection is being mutated after corresponding_column() were used, however it is tested in test/base/test_utils.py. N)r� r� r� r� r� )rS r� r� �metrics�epsr� rT rT rU �_init_proxy_index� s z"ColumnCollection._init_proxy_indexFz Optional[Union[_COL, _COL_co]])r� �require_embeddedrf c s� � | j kr� S d\}}� j}| j��s.| �� �fdd�|D �D ]�}|rR|�|�r@|dkr`|}q@|�|jj�}|dkr�|�|jj�}t|�t|�kr�|}|}q@||kr@t � fdd�|j� � D ��}t � fdd�|j� � D ��} | |k r@|}|}q@|r�|jS dS )a� Given a :class:`_expression.ColumnElement`, return the exported :class:`_expression.ColumnElement` object from this :class:`_expression.ColumnCollection` which corresponds to that original :class:`_expression.ColumnElement` via a common ancestor column. :param column: the target :class:`_expression.ColumnElement` to be matched. :param require_embedded: only return corresponding columns for the given :class:`_expression.ColumnElement`, if the given :class:`_expression.ColumnElement` is actually present within a sub-element of this :class:`_expression.Selectable`. Normally the column will match if it merely shares a common ancestor with one of the exported columns of this :class:`_expression.Selectable`. .. seealso:: :meth:`_expression.Selectable.corresponding_column` - invokes this method against the collection returned by :attr:`_expression.Selectable.exported_columns`. .. versionchanged:: 1.4 the implementation for ``corresponding_column`` was moved onto the :class:`_expression.ColumnCollection` itself. )NNc 3 s( | ] }|� kr� | D ] }|V qqd S rg rT )r� �ts�mm)r� rT rU r� @ s z8ColumnCollection.corresponding_column.<locals>.<genexpr>Nc s$ g | ] }|� � �r|j�d d��qS ��weightr ��shares_lineager] r� �r� �scr� rT rU r� e s �z9ColumnCollection.corresponding_column.<locals>.<listcomp>c s$ g | ] }|� � �r|j�d d��qS r� r� r� r� rT rU r� n s �) r� r� r� r� r� r� r� r� r� r� Z_uncached_proxy_list) rS r� r� Zselected_intersectionZselected_metricsr� Zcurrent_metricsZcurrent_intersectionZselected_col_distanceZcurrent_col_distancerT )r� r� rU �corresponding_column sN $ � �� �� �� z%ColumnCollection.corresponding_column)N)N)N)N)F)*rW rX rY r� r� rk r� r) �preload_moduler� r� r r� r� r� r# r� r� r� r r� rs r� r� r@ r� r� r� r� r4 r� r� r� �__hash__r� r� r� r� r� r� r� r� rT rT rT rU r� { sl l � � �$ �r� � _NAMEDCOLzNamedColumn[Any]c @ sz e Zd ZdZddddd�dd�Zd ddd �d d �Zd dd�dd�Zddd�dd�Zddd�dd�Zd dddd�dd�Z dS ) �DedupeColumnCollectionau A :class:`_expression.ColumnCollection` that maintains deduplicating behavior. This is useful by schema level objects such as :class:`_schema.Table` and :class:`.PrimaryKeyConstraint`. The collection includes more sophisticated mutator methods as well to suit schema objects which require mutable column collections. .. versionadded:: 1.4 Nr� z Optional[str]r� r� c C s� |d k r |j |kr t�d��|j }|d kr4t�d��|| jkrr| j| d }||krXd S | �|� tj�|d� n | �||� d S )N�KDedupeColumnCollection requires columns be under the same key as their .keyz-Can't add unnamed column to column collectionr r� ) rq r( r� r� �replacer) r �reset�_append_new_column)rS r� rq �existingrT rT rU r� � s �� zDedupeColumnCollection.addrn )rq � named_columnrf c C sR t | j�}| j�||t| |�f� | j�|�� � ||f| j|< ||f| j|< d S rg )r� r� r� r� r� r� r� r� )rS rq r r� rT rT rU r� � s �z)DedupeColumnCollection._append_new_columnz Iterable[Tuple[str, _NAMEDCOL]]r� c C s� t |�}g }|D ]~\}}|j|kr,t�d��|j| jkrP|j|jkrP|�|� q|j| jkrh|�|� q||f| j|< | j�||t| |�f� q| j � dd� | jD �� | j� dd� t | j�D �� |D ]}| � |� q�dS )r� r� c s s | ]\}}}|� � V qd S rg r� r� rT rT rU r� � s zADedupeColumnCollection._populate_separate_keys.<locals>.<genexpr>c s s$ | ] \}\}}}|||ffV qd S rg rT r� rT rT rU r� � s N) �listrq r( r� rQ r� r� r� r� r� r� r� r� )rS r� r� Z replace_colr r� rT rT rU r� � s& � �z.DedupeColumnCollection._populate_separate_keyszIterable[_NAMEDCOL]c C s | � dd� |D �� d S )Nc s s | ]}|j |fV qd S rg )rq )r� r� rT rT rU r� � s z0DedupeColumnCollection.extend.<locals>.<genexpr>r� r� rT rT rU �extend� s z DedupeColumnCollection.extendr� c s� � | j krtd� ��| j� j= | j �� � � fdd�| jD �| jd d �< | j�� d�D ]}|�| � qX| j� dd� t | j�D �� | jt | j�= d S )Nz8Can't remove column %r; column is not in this collectionc s$ g | ] \}}}|� k r|||f�qS rT rT )r� r r� r� r� rT rU r� � s �z1DedupeColumnCollection.remove.<locals>.<listcomp>rT c S s i | ]\}\}}}|||f�qS rT rT �r� r� r r� r� rT rT rU r � s z1DedupeColumnCollection.remove.<locals>.<dictcomp>) r� r� r� rq r� r� r� r� r� r� r� r� )rS r� r� rT r� rU r� � s" �� � �z DedupeColumnCollection.removez Optional[Iterable[_NAMEDCOL]])r� � extra_removerf c C s� |rt |�}nt � }|j| jkrR|j|jkrR| j|j d }|j|jkrR|�|� |j| jkrt|�| j|j d � |s�| �|j|� dS g }d}| jD ]D\}}} ||kr�|s�d}|�|j|t| |�f� q�|�||| f� q�|�r| j � |� |D ]$} | j � | d�D ]} | � | � �qq�|�s8|�|j|t| |�f� | j �|�� � || jdd�< | j�� | j�dd� t| j�D �� | j�dd� | jD �� dS ) a add the given column to this collection, removing unaliased versions of this column as well as existing columns with the same key. e.g.:: t = Table('sometable', metadata, Column('col1', Integer)) t.columns.replace(Column('col1', Integer, key='columnone')) will remove the original 'col1' from the collection, and add the new column under the name 'columnname'. Used by schema.Column to override columns during table reflection. r NFTrT c S s i | ]\}\}}}|||f�qS rT rT r rT rT rU r * s z2DedupeColumnCollection.replace.<locals>.<dictcomp>c S s i | ]\}}}|||f�qS rT rT r� rT rT rU r , s )r� rQ r� rq r� r� r� r� r� r� �difference_updater� r� r� r� r� r� r� ) rS r� r Z remove_colr1 Znew_colsZreplacedr r� r� �rcrT rT rU r� � sH � �z DedupeColumnCollection.replace)N)N) rW rX rY r� r� r� r� r r� r� rT rT rT rU r� � s � �r� c @ s\ e Zd ZdZdd� Zdd� Zdd� Zdd d d d �d d �Zd d d�dd�Zd d d�dd�Z dS )r� ��_parentc C sR t �| d|� t �| d|j� t �| d|j� t �| d|j� t �| d|j� d S )Nr r� r� r� r� )r� r4 r� r� r� r� )rS r� rT rT rU r� 4 s z!ReadOnlyColumnCollection.__init__c C s d| j iS �Nr r rR rT rT rU r� ; s z%ReadOnlyColumnCollection.__getstate__c C s |d }| � |� d S r )r� )rS r� r� rT rT rU r� > s z%ReadOnlyColumnCollection.__setstate__.r r� c C s | � � d S rg �Z _readonly)rS r� rq rT rT rU r� B s z ReadOnlyColumnCollection.addr r� c C s | � � d S rg r r� rT rT rU r E s z ReadOnlyColumnCollection.extend)�itemrf c C s | � � d S rg r )rS r rT rT rU r� H s z ReadOnlyColumnCollection.removeN).) rW rX rY r� r� r� r� r� r r� rT rT rT rU r� / s r� c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) � ColumnSetc C s || kS rg rT r� rT rT rU r� M s zColumnSet.contains_columnc C s |D ]}| � |� qd S rg )r� )rS r� r� rT rT rU r P s zColumnSet.extendc C s: g }|D ]&}| D ] }|� |�r|�||k� qqtj|� S rg )r� r� r2 �and_)rS r1 r� r� rP rT rT rU r@ T s zColumnSet.__eq__c C s t tdd� | D ���S )Nc s s | ] }|V qd S rg rT r� rT rT rU r� ] s z%ColumnSet.__hash__.<locals>.<genexpr>)�hashr9 rR rT rT rU r� \ s zColumnSet.__hash__N)rW rX rY r� r r@ r� rT rT rT rU r L s r zColumnClause[Any]z1Union[_HasEntityNamespace, ExternallyTraversible])�entityrf c C sV zt t| �jW S tk rP t�t t| ��D ]}t|�r.|j Y S q.� Y nX dS )z�Return the nearest .entity_namespace for the given entity. If not immediately available, does an iterate to find a sub-element that has one, if any. N)r ru rw r� r Ziterater$ r{ )r r� rT rT rU �_entity_namespace` s r z%Union[SQLCoreOperations[Any], _NoArg]ro )r rq re rf c C sj z.t | �}|tk r t|||�W S t||�W S W n6 tk rd } zt�d| |f �|�W 5 d}~X Y nX dS )z�Return an entry from an entity_namespace. Raises :class:`_exc.InvalidRequestError` rather than attribute error on not found. z.Entity namespace for "%s" has no property "%s"N)r rZ r? r� r( r� )r rq re �nsr� rT rT rU �_entity_namespace_keys s ��r )�r� � __future__r r� �enumr r� r r� r� r, r r r r r r r r r r r r r r r r r r r r r r � r r � cache_keyr r Z traversalsr! r" r# r$ r% r' r( r) r* r+ Z compat_typingZ util.typingr- r. r/ r0 r2 r3 Z _orm_typesr4 r5 Z_typingr6 r7 r8 r9 r: r; r< r= Zschemar> r? Z selectabler@ rA rB ZenginerC rD Zengine.interfacesrE rF rG rH rI rJ rK rL rM rN rO rP rZ r[ r\ Z _NONE_NAMEr] r_ rn Z_AmbiguousTableNameMapr` r� Z_never_select_columnrm ru r{ r| r} r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r% r& �typer+ r6 rV r\ Z StatementRoler Z EventTargetr� r� r� r� r� r� r� r� r� r� r� ZReadOnlyContainerr� r� r r r rT rT rT rU �<module> s. 9 +j ! # 2 , 0 � �