File: //usr/lib/python3/dist-packages/__pycache__/pg.cpython-310.pyc
o
���^<� � @ sX d Z ddlmZmZ zddlT W nT eyd ddlZddlZejdkraej dkraej
d � ej �D ],Z
ej
�ej
�e
d��r^e�ej
�e
��� ddlT W d � n1 sWw Y nq2� n� Y nw eZg d �ZddlZddlZddlZdd
lmZmZmZmZm Z dd l m Z dd l m Z m!Z! dd
l"m#Z# ddl$m%Z% ddl&m'Z' ddl(m)Z) ddl*m+Z, ddl-m.Z/m0Z1 ddl2m3Z3 ze4 W n e5y� e6Z4Y nw ze7 W n
e5y� e8e9fZ7Y nw zddl(m:Z: W n/ e�y ddl(m;Z; zddl<m=Z= W n e�y G dd� d�Z=Y nw d�dd�Z:Y nw zdd l"m>Z> W n e�y5 e?Z>G d d � d e?�Z@Y n w G d d � d e>�Z@zdd lAmBZB W n e�yZ dd!lAmCZC d"d#� ZDY nw d$d#� ZDzdd%lmEZE W n e�y� G d&d'� d'e �ZEeEed�d(�eE_Fd)ZGY nw d*ZGe?d+d,d-d.d/d+d0d.d.d.d1�
ZHd2d3� ZId4d5� ZJd6d7� ZKG d8d9� d9e?�ZLeL� ZMd:d;� ZNG d<d=� d=eO�ZPG d>d?� d?e9�ZQG d@dA� dAe?�ZRG dBdC� dC�ZSG dDdE� dEe8�ZTG dFdG� dG�ZUdHdI� ZVdJdK� ZWdLdM� ZXdNdO� ZYdPdQ� ZZdRdS� Z[dTdU� Z\e,dV�Z]dWdX� Z^dYdZ� Z_d[d\� Z`e,d]�Zae,d^�Zbe,d_�Zce,d`�Zddadb� ZeG dcdd� dde?�Zfdedf� Zgdgdh� ZhG didj� dje8�ZiG dkdl� dle?�Zje,dm�Zke:dndo�dpdq� �aldrds� Zmdtdu� Zndvdw� Zodxdy� Zpdzd{� ZqG d|d}� d}�Zresfd~d�Ztd�d�� Zud�d�� Zvewe � exe/� eyeneoepeq� G d�d�� d�ez�Z{d�d�� Z|G d�d�� d��Z}e~d�k�r�ed�e � ed�� ee � dS dS )�aZ PyGreSQL classic interface.
This pg module implements some basic database management stuff.
It includes the _pg module and builds on it, providing the higher
level wrapper class named DB with additional functionality.
This is known as the "classic" ("old style") PyGreSQL interface.
For a DB-API 2 compliant interface use the newer pgdb module.
� )�print_function�division)�*N�nt)� � �PATHz libpq.dll)B�DB�Adapter�NotificationHandler� Typecasts�Bytea�Hstore�Json�Literal�Error�Warning� DataError�
DatabaseError�IntegrityError�InterfaceError�
InternalError�InvalidResultError�MultipleResultsError�
NoResultError�NotSupportedError�OperationalError�ProgrammingError�INV_READ� INV_WRITE�SEEK_CUR�SEEK_END�SEEK_SET� TRANS_ACTIVE�
TRANS_IDLE�
TRANS_INERROR�
TRANS_INTRANS�
TRANS_UNKNOWN�
cast_array� cast_hstore� cast_record�connect� escape_bytea�
escape_string�unescape_bytea� get_array�get_bool�get_bytea_escaped�
get_datestyle� get_decimal�get_decimal_point� get_defbase� get_defhost�
get_defopt� get_defport� get_defuser�get_jsondecode� set_array�set_bool�set_bytea_escaped�
set_datestyle� set_decimal�set_decimal_point� set_defbase� set_defhost�
set_defopt�
set_defpasswd� set_defport� set_defuser�set_jsondecode�set_query_helpers�version� __version__)�date�time�datetime� timedelta�tzinfo)�Decimal)�isnan�isinf��
namedtuple)� iskeyword)�
itemgetter)�partial)�compile)�loads�dumps)�UUID)� lru_cache)�update_wrapper)�RLockc @ s e Zd Zdd� Zdd� ZdS )r^ c C � d S �N� ��selfra ra �$/usr/lib/python3/dist-packages/pg.py� __enter__h � zRLock.__enter__c C r_ r` ra )rc �exctype�excinst�exctbra ra rd �__exit__j rf zRLock.__exit__N)�__name__�
__module__� __qualname__re rj ra ra ra rd r^ g s r^ � c s � fdd�}|S )z:Simplified functools.lru_cache decorator for one argument.c s� t � �i � � j�t� �g }|dg�||d d g|d d �< �dkr&�fdd�}n�d u r4� ���fdd�}n � �����fdd�}�|_t|��S )NFr c s � | �}|S r` ra ��arg�res)�functionra rd �wrapperz s z-lru_cache.<locals>.decorator.<locals>.wrapperc s* �| ��}|�ur |S �| �}|� | < |S r` ra ro )�cacherr �get�sentinelra rd rs � s
c s� ��? �| �}|d ur:�d }|\}}}}||d< ||d< |d }| |d< |d< ||d< ||d< |W d � S W d � n1 sDw Y �| �}��v �\}}| � v rYnT|r�|} | | d< || d< | d }�d< |d }
|d } d |d< |d< � |
= | � | < n8|d }||| |g}| |d< |d< � | < t � ��kr�d�d< W d � |S W d � |S W d � |S W d � |S 1 s�w Y |S )Nr � � r T)�len) rp �link�root�prev�next�_argrq �last�full�oldroot�oldarg�oldres)rt rr ru �lock�maxsize� root_fullra rd rs � s` � �
��
��
��
��)�objectru r^ � __wrapped__r] )rr r{ rs �r� )rt rr ru r� r� rv rd � decoratoro s
$
z lru_cache.<locals>.decoratorra )r� r� ra r� rd r\ l s Br\ )� OrderedDictc @ sl e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
edd� �ZdS )�AttrDict�@Simple read-only ordered dictionary for storing attribute names.c O s� t |�dks|r
t�|r|d ng }t|t�rt�t|�}dd� |D �| _t�| |� d| _| j}| | _ | _
| | _ | _ | _
d S )Nrw r c S � g | ]}|d �qS �r ra )�.0�itemra ra rd �
<listcomp>� � z%AttrDict.__init__.<locals>.<listcomp>T)ry � TypeError�
isinstance�dict�list�_keys�__init__�
_read_only�_read_only_error�clear�update�pop�
setdefault�popitem)rc �args�kw�items�errorra ra rd r� � s
�AttrDict.__init__c C � | j r| �� t�| ||� d S r` )r� r� r� � __setitem__�rc �key�valuera ra rd r� � � �AttrDict.__setitem__c C � | j r| �� t�| |� d S r` )r� r� r� � __delitem__�rc r� ra ra rd r� � � �AttrDict.__delitem__c C �
t | j�S r` )�iterr� rb ra ra rd �__iter__� �
zAttrDict.__iter__c C r� r` )r� r� rb ra ra rd �keys� r� z
AttrDict.keysc � � fdd�� D �S )Nc s g | ]}� | �qS ra ra �r� r� rb ra rd r� � r� z#AttrDict.values.<locals>.<listcomp>ra rb ra rb rd �values� � zAttrDict.valuesc r� )Nc s g | ]}|� | f�qS ra ra r� rb ra rd r� � � z"AttrDict.items.<locals>.<listcomp>ra rb ra rb rd r� � r� zAttrDict.itemsc C s | � � S r` )r� rb ra ra rd �iterkeys� s zAttrDict.iterkeysc C � t | �� �S r` )r� r� rb ra ra rd �
itervalues� � zAttrDict.itervaluesc C r� r` )r� r� rb ra ra rd � iteritems� r� zAttrDict.iteritemsc O � t d���NzThis object is read-only�r� �r� r� ra ra rd r� � � �AttrDict._read_only_errorN)rk rl rm �__doc__r� r� r� r� r� r� r� r� r� r� � staticmethodr� ra ra ra rd r� � s r� c @ s4 e Zd ZdZdd� Zdd� Zdd� Zedd � �Zd
S ) r� r� c O sL d| _ tj| g|�R i |�� d| _ | j}| | _| _| | _ | _| _d S )NFT) r� r� r� r� r� r� r� r� r� )rc r� r� r� ra ra rd r� � s r� c C r� r` )r� r� r� r� r� ra ra rd r� � r� r� c C r� r` )r� r� r� r� r� ra ra rd r� r� r� c O r� r� r� r� ra ra rd r� r� r� N) rk rl rm r� r� r� r� r� r� ra ra ra rd r� � s )� signature)�
getargspecc C s
t | �jS r` )r� r� ��funcra ra rd �get_args r� r� c C s t t| �j�S r` )r� r� �
parametersr� ra ra rd r� � )�timezonec @ s2 e Zd ZdZd dd�Zdd� Zdd� Zd d
� ZdS ) r� z Simple timezone implementation.Nc C sf || _ |s.| j jd | j jd }|dk r!t| d�\}}| }nt|d�\}}d||f }|| _d S )Ni� �< r z
UTC%+03d:%02d)�offset�days�seconds�divmod�name)rc r� r� �minutes�hoursra ra rd r� s
ztimezone.__init__c C � | j S r` )r� �rc �dtra ra rd � utcoffset* � ztimezone.utcoffsetc C r� r` )r� r� ra ra rd �tzname- r� ztimezone.tznamec C r_ r` ra r� ra ra rd �dst0 � z timezone.dstr` )rk rl rm r� r� r� r� r� ra ra ra rd r� s
r� �UTCFTz+0100z+0200z-0500�+0000z-1000z-0700)
�CET�EET�EST�GMT�HST�MET�MST�UCTr� �WETc C s6 | � d�rt| �dk r| d S | �dd�S t�| d�S )N)�+�-� �00�:� r� )�
startswithry �replace�
_timezonesru )�tzra ra rd �_timezone_as_offset? s
r� c C sN t | �} dt| dd� � t| dd� � }| d dkr | }tt|d�| �S )Nr� rw r r� r r� )r� )r� �intr� rN )r� r� ra ra rd �
_get_timezoneG s
$ r� c C s d| S )z Build oid key from a table name.zoid(%s)ra )�tablera ra rd �_oid_keyO r� r� c @ s< e Zd ZdZdddddddd d
d d d
� Zdd� Zdd� ZdS )� _SimpleTypesz6Dictionary mapping pg_type names to simple type names.�bool�byteaz?date interval time timetz timestamp timestamptz abstime reltimez
float4 float8zcid int2 int4 int8 oid xid�hstorez
json jsonb�uuid�numeric�moneyz bpchar char name text varchar) r� r� rK �floatr� r� �jsonr� �numr �textc C s> | j �� D ]\}}|�� D ]}|| |< d| | d| < q
qd S )N�%s[]�_%s)�_typesr� �split)rc �typr� r� ra ra rd r� a s ��z_SimpleTypes.__init__c C � dS )Nr ra r� ra ra rd � __missing__h r� z_SimpleTypes.__missing__N)rk rl rm r� r r� r ra ra ra rd r� T s �
r� c C s t |t�rd|vrd| f S | S )a# Quote parameter representing a qualified name.
Puts a quote_ident() call around the give parameter unless
the name contains a dot, in which case the name is ambiguous
(could be a qualified name or just a name with a dot in it)
and must be quoted manually by the caller.
�.zquote_ident(%s))r� �
basestring)�paramr� ra ra rd �_quote_if_unqualifiedn s
r c @ s e Zd ZdZddd�ZdS )�_ParameterListz0Helper class for building typed parameter lists.Nc C s0 | � ||�}t|t�r
|S | �|� dt| � S )z�Typecast value with known database type and build parameter list.
If this is a literal value, it will be returned as is. Otherwise, a
placeholder will be returned and the parameter list will be augmented.
z$%d)�adaptr� r �appendry )rc r� r
ra ra rd �add~ s
z_ParameterList.addr` )rk rl rm r� r ra ra ra rd r { s r c @ � e Zd ZdZdS )r
z'Wrapper class for marking Bytea values.N�rk rl rm r� ra ra ra rd r
� � r
c @ s, e Zd ZdZed�Zedd� �Zdd� ZdS )r z(Wrapper class for marking hstore values.z^[Nn][Uu][Ll][Ll]$|[ ,=>]c C s8 |d u rdS |s
dS |� dd�}| j�|�rd| }|S )N�NULL�""�"z\"�"%s")r� � _re_quote�search)�cls�sra ra rd �_quote� s z
Hstore._quotec s" | j � d�� fdd�| �� D ��S )N�,c 3 s( � | ]\}}d � |�� |�f V qdS )z%s=>%sNra )r� �k�v��qra rd � <genexpr>� s �& z!Hstore.__str__.<locals>.<genexpr>)r �joinr� rb ra r$ rd �__str__� s zHstore.__str__N) rk rl rm r� �regexr � classmethodr r( ra ra ra rd r � s
r c @ s e Zd ZdZdd� ZdS )r z&Wrapper class for marking Json values.c C s
|| _ d S r` )�obj)rc r+ ra ra rd r� � r� z
Json.__init__N)rk rl rm r� r� ra ra ra rd r � s r c @ r )r z-Wrapper class for marking literal SQL values.Nr ra ra ra rd r � r r c @ sn e Zd ZdZed�� �Zed�� �Zed�Z ed�Z
ed� Z Z dd� Z
ed d
� �Zed d � �Zed
d� �Ze Z ZZdd� Zdd� Zedd� �ZeZedd� �Zedd� �Ze Z Z Z dd� Z dd � Z d d � Z!d:d d!�Z"ed"d#� �Z#ed$d%� �Z$ed&d'� �Z%e&d(e'd)e(d)e)d*e*d+e+d+e,d,e-d-e.d.e/d.e0d.e1d.i Z2ed/d0� �Z3ed1d2� �Z4d;d4d5�Z5d6d7� Z6d<d8d9�Z7d S )=r
z@Class providing methods for adapting parameters to the database.zt true 1 y yes onzDcurrent_date current_time current_timestamp localtime localtimestampz [{},"\\\s]|^[Nn][Uu][Ll][Ll]$z[(,"\\]z(["\\])c C s t �|�| _d S r` )�weakref�proxy�db�rc r. ra ra rd r� � s zAdapter.__init__c C s, t |t�r|s dS |�� | jv }|rdS dS )zAdapt a boolean parameter.N�t�f)r� r �lower�_bool_true_values�r r# ra ra rd � _adapt_bool� s
zAdapter._adapt_boolc C s, |sdS t |t�r|�� | jv rt|�S |S )zAdapt a date parameter.N)r� r r2 �_date_literalsr r4 ra ra rd � _adapt_date� s
zAdapter._adapt_datec C s | s| dkrdS | S )zAdapt a numeric parameter.r Nra �r# ra ra rd �
_adapt_num� s zAdapter._adapt_numc C � | j �|�S )zAdapt a bytea parameter.)r. r, �rc r# ra ra rd � _adapt_bytea� � zAdapter._adapt_byteac C s" |sdS t |t�r |S | j�|�S )zAdapt a json parameter.N)r� r r. � encode_jsonr; ra ra rd � _adapt_json� s
zAdapter._adapt_jsonc sj t |t�r| j� dd�� fdd�|D �� S |du r dS |s dS t|�}| j�|�r3d| j�d |� }|S )
z"Adapt a text type array parameter.�{%s}r! c 3 � � | ]}� |�V qd S r` ra �r� r# �r ra rd r& � � � z,Adapter._adapt_text_array.<locals>.<genexpr>N�nullr r �\\\1) r� r� �_adapt_text_arrayr' �str�_re_array_quoter �_re_array_escape�subr4 ra rC rd rG � s
zAdapter._adapt_text_arrayc sd t |t�r| j� dd�� fdd�|D �� S |du r dS t |t�r,|s%dS |�� | jv }|r0dS dS ) z Adapt a boolean array parameter.r@ r! c 3 rA r` ra rB rC ra rd r& � rD z,Adapter._adapt_bool_array.<locals>.<genexpr>NrE r0 r1 )r� r� �_adapt_bool_arrayr' r r2 r3 r4 ra rC rd rL � s
zAdapter._adapt_bool_arrayc sD t |t�r| j� dd�� fdd�|D �� S |s |dkr dS t|�S )z Adapt a numeric array parameter.r@ r! c 3 rA r` ra rB rC ra rd r& rD z+Adapter._adapt_num_array.<locals>.<genexpr>r rE )r� r� �_adapt_num_arrayr' rH r4 ra rC rd rM s
zAdapter._adapt_num_arrayc sJ t |t�rdd�� fdd�|D �� d S |du rdS � j�|��dd �S )
z Adapt a bytea array parameter.� {� ,c 3 s � | ]}� � |�V qd S r` )�_adapt_bytea_arrayrB rb ra rd r& s �
�z-Adapter._adapt_bytea_array.<locals>.<genexpr>� }Ns null� \s \\)r� r� r' r. r, r� r; ra rb rd rP s
��zAdapter._adapt_bytea_arrayc sl t |t�r| j� dd�� fdd�|D �� S |sdS t |t�s%| j�|�}| j�|�r4d| j �
d|� }|S )z Adapt a json array parameter.r@ r! c 3 rA r` ra rB rC ra rd r& rD z,Adapter._adapt_json_array.<locals>.<genexpr>rE r rF ) r� r� �_adapt_json_arrayr' r r. r> rI r rJ rK r; ra rC rd rS s
zAdapter._adapt_json_arrayc C s� | � |��� }t|�t|�krtd| ��| j}g }t||�D ]<\}}|||�}|du r/d}n'|s4d}n"t|t�rCtturB|� d�}nt|�}| j
� |�rVd| j �
d|� }|�|� q dd �|� S )
z)Adapt a record parameter with given type.z"Record parameter %s has wrong sizeNr� r �asciir rF �(%s)r! )� get_attnamesr� ry r� r �zipr� �bytesrH �decode�_re_record_quoter �_re_record_escaperK r r' )rc r# r
r r� r0 ra ra rd �
_adapt_record' s(
� zAdapter._adapt_recordNc C s� |durdt |t�sd|r| �|�}n | �|�pd }}t|dd�}|r&||�}|dkr- |S |dkr>t |t�r<| �||�}|S |�d�rYt |t�rWt| d|dd� �}||�}|S t| d| �}||�}|S ) z'Adapt a value with known database type.Nr �
__pg_str__�recordz[]z_adapt_%s_array���z _adapt_%s) r� r �get_simple_name�guess_simple_type�getattr�tupler\ �endswithr� )rc r� r
�simple�pg_strr ra ra rd r ? s, �
�
�z
Adapter.adaptc C s t | �}| |_|S )z9Create a simple database type with given attribute names.)�DbTypere )r� r
ra ra rd � simple_typeW s zAdapter.simple_typec C s t | t�r| jS t| S )z'Get the simple name of a database type.)r� rg re � _simpletypes�r
ra ra rd r` ^ s
zAdapter.get_simple_namec C s t | t�r| jS i S )z5Get the attribute names of a composite database type.)r� rg �attnamesrj ra ra rd rV e s
zAdapter.get_attnamesr� r r� r� r r rK c s� z| j t�� W S ty Y nw t�t�rdS t�t�r dS t�t�r'dS t�ttf�r0dS t�t �r7dS t�t
�r>dS t�t t t
tf�rIdS t�t�rXd| ���pUdf S t�t�rt| j�| j� � ��fd d
�}�d �}||_|S d S )
z5Try to guess which database type the given value has.r� r r� r� r r rK r c s t � �fdd�t��D ��S )Nc 3 s, � | ]\}}t |d ��� |��fV qdS )rw N�rH �r� �nr# )�guessrh ra rd r& � s � �zBAdapter.guess_simple_type.<locals>.get_attnames.<locals>.<genexpr>)r� � enumeraterb �ro rh r� ra rd rV � s �z/Adapter.guess_simple_type.<locals>.get_attnamesr^ N)�_frequent_simple_types�type�KeyErrorr� r
r r� r� �longr rP rK rL rM rN r� �guess_simple_base_typerc rh ra �
_get_attnames)r r� rV r
ra rq rd ra { s: �
�zAdapter.guess_simple_typec C s: |D ]}t |t�r| �|�}n| �|�}|r| S qdS )z,Try to guess the base type of a given array.N)r� r� rv ra )r r� r# r
ra ra rd rv � s
��z Adapter.guess_simple_base_typeFc s� |du rdS t |t�r
|S t |t�r"| j�|�}ttur!|�d�}n t |t�r5|j r.|� � S | j�
|�}n
t |t t t
tf�rBt|�}t |t�rQ| j�|�}d| S t |t�r\|rZdS dS t |t�rut|�rm|dk rkdS d S t|�rsd
S |S t |tttf�r|S t |t�r�| j� |r�d nd }|d
�� fdd�|D �� S t |t�r�| j� dd
�� fdd�|D �� S t |dd�}|s�t dt |� ��|� }t |ttf�r�| �|�}|S )z>Adapt a value that is put into the SQL and needs to be quoted.Nr rT �'%s'�true�falser z '-Infinity'z
'Infinity'z'NaN'z[%s]z ARRAY[%s]r! c 3 s � | ] }t � |d d��V qdS )T)�nestedNrl rB r$ ra rd r& � � � z'Adapter.adapt_inline.<locals>.<genexpr>rU c 3 s � | ] }t � |��V qd S r` rl rB r$ ra rd r& � � � � __pg_repr__z Do not know how to adapt type %s) r� r r
r. r, rX rH rY r �encoder> rM rK rL rN r r- r� r rR rQ r� ru rP r� � adapt_inliner' rc rb r rs )rc r� r{ r �pg_reprra r$ rd r� � sX
�
�
zAdapter.adapt_inlinec C s t � }| j|_|S )z�Return a parameter list for parameters with known database types.
The list has an add(value, typ) method that will build up the
list and return either the literal value or a placeholder.
)r r �rc �paramsra ra rd �parameter_list� s zAdapter.parameter_listc s� �s|g fS |r�rt d��| �� }t�ttf�r`|r(| j� � fdd��D �}n.|j��rMt�ttf�r<t��t��kr@td���fdd�t ���D �}n �fdd��D �}|t|�; }||fS t�t
�r�i }t
� �d�}�D ] }||= z|| W n t y� �| ||< Y nw d||< qo|�|r�| j� t
� fdd ���
� D ��}n,|j��r�t�t
�s�td��t
���fd
d �t��D ��}nt
��fd d �t��D ��}||; }||fS td ��)
z9Format a database query using the given values and types.z(Typed parameters must be sent separatelyc � g | ]}� |��qS ra ra �r� r� rC ra rd r� � r� z(Adapter.format_query.<locals>.<listcomp>z!The values and types do not matchc s g | ] \}}� ||��qS ra ra )r� r� r
�r ra rd r� � s �c r� ra ra r� r� ra rd r� � r� r� c 3 s � | ] \}}|� |�fV qd S r` ra )r� r� r� rC ra rd r& s � �z'Adapter.format_query.<locals>.<genexpr>c 3 s( � | ]}|� �| �� |��fV qd S r` )ru r� )r �typesr� ra rd r&
s � �c 3 s � | ] }|� �| �fV qd S r` ra r� )r r� ra rd r& s � �z0The values must be passed as tuple, list or dict)�
ValueErrorr� r� r� rc r� r ry r� rW r� �fromkeysrt r� �sorted) rc �commandr� r� �inliner� �literals� used_valuesr� ra )r r r� r� rd � format_query� sd
�
� �
�
���zAdapter.format_queryr` �F�NNF)8rk rl rm r� � frozensetr r3 r6 r) rI rZ rJ r[ r� r* r5 r7 r� r9 �
_adapt_int� _adapt_float� _adapt_moneyr< r? rG �_adapt_date_arrayrL rM �_adapt_int_array�_adapt_float_array�_adapt_money_arrayrP rS r\ r rh r` rV r
rH rX r� r� ru r rP rK rL rM rN rr ra rv r� r� r� ra ra ra rd r
� st �
�
�
#
-
r
c C s t � s| S | d dkS )zCast a boolean value.r r0 )r0 �r� ra ra rd � cast_bool s r� c C s t � }|s| S || �S )zCast a JSON value.)r: )r� �castra ra rd � cast_json s r� c C s t � pt| �S )zCast a numeric value.)r3 r r� ra ra rd �cast_num' � r� c C sP t � }|s| S |dkr| �|d�} | �dd�} d�dd� | D ��} t� p%t| �S )zCast a money value.r
�(r� r� c s s$ � | ]
}|� � s |d v r|V qdS )z.-N)�isdigit)r� �cra ra rd r& 4 s �" z cast_money.<locals>.<genexpr>)r4 r� r' r3 r )r� �pointra ra rd �
cast_money, s r� c C s dd� | � � D �S )zCast an int2vector value.c S � g | ]}t |��qS ra �r� rB ra ra rd r� : r� z#cast_int2vector.<locals>.<listcomp>)r r� ra ra rd �cast_int2vector8 � r� c C sh | dkrt jS | dkrt jS | �� } | d dkrt jS | d } t| �dkr(t jS |�� }t�| |�� � S )zCast a date value.� -infinity�infinity����BCr �
)rK �min�maxr ry � date_formatrM �strptime�r� �
connection�fmtra ra rd � cast_date= s r� c C s$ t | �dkrdnd}t�| |��� S )zCast a time value.r � %H:%M:%S.%f�%H:%M:%S)ry rM r� rL )r� r� ra ra rd � cast_timeQ s r� z (.*)([+-].*)c C sx t �| �}|r|�� \} }nd}t| �dkrdnd}tr.| t|�7 } |d7 }t�| |��� S t�| |��� j t
|�d�S )zCast a timetz value.r� r r� r� �%z�rO ) � _re_timezone�match�groupsry �
_has_timezoner� rM r� �timetzr� r� )r� r� r� ra ra rd � cast_timetzZ s
�r� c C s� | dkrt jS | dkrt jS | �� } | d dkrt jS |�� }|�d�rRt| �dkrR| dd� } t| d �d
kr;t jS |�d �rBd nd
t| d �dkrMdnddg}nt| d �dkr]t jS |t| d �dkrhdndg}t �d� | �d� |��S )zCast a timestamp value.r� r� r� r� �-%Yrx rw r� r � �%d�%d %b�%b %dr r� r� �%Yr r� � )
rM r� r� r r� rd ry r� r� r' r� ra ra rd �cast_timestampj s& � r� c C s� | dkrt jS | dkrt jS | �� } | d dkrt jS |�� }|�d�r]t| �dkr]| dd� } t| d �d
kr;t jS |�d �rBd nd
t| d �dkrMdnddg}| dd� | d } }n>|�d�rwt� | d �}|rt|�
� \| d< }nd}n | dd� | d } }t| d �dkr�t jS |t| d �dkr�dndg}t r�| � t
|�� |� d� t �d�| �d�|��S t �d�| �d�|��jt|�d�S )zCast a timestamptz value.r� r� r� r� r� rx rw Nr r� r� r� r� r r� r� r� z%Y-r� r r� r� r� r� )rM r� r� r r� rd ry r� r� r� r� r� r r� r� r' r� r� )r� r� r� r� ra ra rd �cast_timestamptz� s@ �
�r� zm(?:([+-])?([0-9]+)-([0-9]+) ?)?(?:([+-]?[0-9]+)(?!:) ?)?(?:([+-])?([0-9]+):([0-9]+):([0-9]+)(?:\.([0-9]+))?)?z�(?:([+-]?[0-9]+) ?years? ?)?(?:([+-]?[0-9]+) ?mons? ?)?(?:([+-]?[0-9]+) ?days? ?)?(?:([+-])?([0-9]+):([0-9]+):([0-9]+)(?:\.([0-9]+))?)?z�@ ?(?:([+-]?[0-9]+) ?years? ?)?(?:([+-]?[0-9]+) ?mons? ?)?(?:([+-]?[0-9]+) ?days? ?)?(?:([+-]?[0-9]+) ?hours? ?)?(?:([+-]?[0-9]+) ?mins? ?)?(?:([+-])?([0-9]+)(?:\.([0-9]+))? ?secs?)? ?(ago)?z�P(?:([+-]?[0-9]+)Y)?(?:([+-]?[0-9]+)M)?(?:([+-]?[0-9]+)D)?(?:T(?:([+-]?[0-9]+)H)?(?:([+-]?[0-9]+)M)?(?:([+-])?([0-9]+)(?:\.([0-9]+))?S)?)?c
C s& t �| �}|r0dd� |�� D �}|�d�dk}dd� |D �}|\}}}}}}} |r/| }| } n�t�| �}|rsdd� |�� dd� D �|�d �}}
|�d�dk}|
rZd
d� |D �nd d� |D �}|\}}}}}}} |rr| }| } n�t�| �}|r�t|�� �r�d d� |�� D �}|�d
�dk} dd� |D �}|\}}}}}}} | r�| }| }| }| } nQt�| �}|r�t|�� �r�dd� |�� D �}|�d�dk} |�d
�dk} dd� |D �}|\}}}}}}} | r�| }| }| r�| }| }| }| } nt d| ��|d| d| 7 }t
||||| d�S )zCast an interval value.c S � g | ]}|pd �qS ��0ra �r� �dra ra rd r� � r� z!cast_interval.<locals>.<listcomp>r� r� c S r� ra r� r� ra ra rd r� � r� c S r� r� ra r� ra ra rd r� � r� Nr � c S s g | ]}t |� �qS ra r� r� ra ra rd r� � � c S r� ra r� r� ra ra rd r� � r� c S r� r� ra r� ra ra rd r� � r� r c S r� ra r� r� ra ra rd r� � r� c S r� r� ra r� ra ra rd r� � r� r c S r� ra r� r� ra ra rd r� � r� zCannot parse interval: %sim � )r� r� r� r� � microseconds) �_re_interval_iso_8601r� r� r� � _re_interval_postgres_verbose�group�_re_interval_postgres�any�_re_interval_sql_standardr� rN )
r� �m�secs_ago�years�monsr� r� �mins�secs�usecs�ago� hours_ago� years_agora ra rd �
cast_interval� sj
�
& �
�
� �r� c @ s e Zd ZdZi de�de�de�de�de�de�de�d e�d
e�d e�d e�d
e�de �de
�de
�de �de �e e
eeeeeeeeeed� �ZdZdd� Zedd� �Z dd� Z d-dd �Z d d � Z d-d d �Z e!d!d"� �Z"e!d#d$� �Z#d%d&� Z$d'd(� Z%d)d*� Z&d+d,� Z'dS ).r a� Dictionary mapping database types to typecast functions.
The cast functions get passed the string representation of a value in
the database which they need to convert to a Python object. The
passed string will never be None since NULL values are already
handled before the cast function is called.
Note that the basic types are already handled by the C extension.
They only need to be handled here as record or array components.
�char�bpcharr� r �varcharr� r� �int2�int4�serial�int8�oidr� r �jsonb�float4�float8) r r rK �intervalrL r� � timestamp� timestamptz�
int2vectorr� �anyarrayr^ Nc s� t |t�s td| ��� j�|�}|r � �|�}|� |< |S |�d�r8� |dd� }� �|�}|r6|� |< |S � �|�}|rU� fdd�|� � D �}� �
|||�}|� |< |S )z�Create a cast function if it is not cached.
Note that this class never raises a KeyError,
but returns None when no special cast function exists.
zInvalid type: %s�_rw Nc s g | ]}� |j �qS ra )�pgtyperB rb ra rd r� / r� z)Typecasts.__missing__.<locals>.<listcomp>) r� rH r� �defaultsru �_add_connectionr� �create_array_castrV r� �create_record_cast)rc r
r� � base_castrk �castsra rb rd r s&
�
�zTypecasts.__missing__c C s6 zt | �}W n ttfy Y dS w d|dd� v S )z9Check if a typecast function needs a connection argument.Fr� rw N)r� r� r� )r� r� ra ra rd �_needs_connection4 s �zTypecasts._needs_connectionc C s" | j r| �|�s
|S t|| j d�S )z@Add a connection argument to the typecast function if necessary.)r� )r� r� rW )rc r� ra ra rd r� > s zTypecasts._add_connectionc C s | | p|S �z6Get the typecast function for the given database type.ra )rc r
�defaultra ra rd ru D r= z
Typecasts.getc C s~ t |t�r|g}|du r!|D ]}| �|d� | �d| d� qdS t|�s)td��|D ]}| �|�| |< | �d| d� q+dS )�;Set a typecast function for the specified database type(s).Nr � Cast parameter must be callable)r� r r� �callabler� r� )rc r
r� r0 ra ra rd �setH s
��z
Typecasts.setc C s> |du r
| � � dS t|t�r|g}|D ]}| �|d� qdS )z�Reset the typecasts for the specified type(s) to their defaults.
When no type is specified, all typecasts will be reset.
N)r� r� r r� )rc r
r0 ra ra rd �resetW s
�zTypecasts.resetc C r: )z>Get the default typecast function for the given database type.)r� ru )r r
ra ra rd � get_defaultd s zTypecasts.get_defaultc C s~ t |t�r|g}| j}|du r$|D ]}|�|d� |�d| d� qdS t|�s,td��|D ]}|||< |�d| d� q.dS )z?Set a default typecast function for the given database type(s).Nr r )r� r r� r� r r� )r r
r� r� r0 ra ra rd � set_defaulti s
��zTypecasts.set_defaultc C s i S )z�Return the fields for the given record type.
This method will be replaced with the get_attnames() method of DbTypes.
ra �rc r
ra ra rd rV z � zTypecasts.get_attnamesc C r )zwReturn the current date format.
This method will be replaced with the dateformat() method of DbTypes.
z%Y-%m-%dra rb ra ra rd �
dateformat� r zTypecasts.dateformatc s | d �� �fdd�}|S )z1Create an array typecast for the given base cast.r� c s
�| � �S r` ra r8 ��basecastr( ra rd r� � r� z)Typecasts.create_array_cast.<locals>.castra )rc r r� ra r
rd r� � s zTypecasts.create_array_castc s& | d � t ||��� ��fdd�}|S )z>Create a named record typecast for the given fields and casts.r^ c s �� | ��� S r` ra r8 �r* r� r^ ra rd r� � r� z*Typecasts.create_record_cast.<locals>.castrS )rc r� �fieldsr� r� ra r rd r� � s
z Typecasts.create_record_castr` )(rk rl rm r� rH r� r. r� ru r) r� r r� r� r� r� r� r� r� r� r� r[ r( r* r� r� r r� r� r� ru r r r* r r rV r r� r� ra ra ra rd r � sl
���������������
r c C s
t �| �S )z@Get the global typecast function for the given database type(s).)r r rj ra ra rd � get_typecast� �
r c C s t �| |� dS )z�Set a global typecast function for the given database type(s).
Note that connections cache cast functions. To be sure a global change
is picked up by a running connection, call db.db_types.reset_typecast().
N)r r )r
r� ra ra rd � set_typecast� s r c @ s e Zd ZdZedd� �ZdS )rg aO Class augmenting the simple type name with additional info.
The following additional information is provided:
oid: the PostgreSQL type OID
pgtype: the internal PostgreSQL data type name
regtype: the registered PostgreSQL data type name
simple: the more coarse-grained PyGreSQL type name
typtype: b = base type, c = composite type etc.
category: A = Array, b = Boolean, C = Composite etc.
delim: delimiter for array types
relid: corresponding table for composite types
attnames: attributes for composite types
c C s
| � | �S )�6Get names and types of the fields of a composite type.)rw rb ra ra rd rk � s
zDbType.attnamesN)rk rl rm r� �propertyrk ra ra ra rd rg � s rg c sp e Zd ZdZed�� �Z� fdd�Zdd� Zdd� Z dd
d �Z
d d
� Z dd� Z dd� Z
ddd�Zdd� Z� ZS )�DbTypesz�Cache for PostgreSQL data types.
This cache maps type OIDs and names to DbType objects containing
information on the associated database type.
z>int float num money int2 int4 int8 float4 float8 numeric moneyc sZ t t| ��� t�|�| _d| _t� | _| j | j_ | j| j_
|j dk r(d| _ dS d| _ dS )z%Initialize type cache for connection.F�: z�SELECT oid, typname, typname::text::regtype, typtype, null as typcategory, typdelim, typrelid FROM pg_catalog.pg_type WHERE oid OPERATOR(pg_catalog.=) %s::regtypez�SELECT oid, typname, typname::regtype, typtype, typcategory, typdelim, typrelid FROM pg_catalog.pg_type WHERE oid OPERATOR(pg_catalog.=) %s::regtypeN)
�superr r� r, r- �_db� _regtypesr �
_typecastsrV r� �server_version�_query_pg_typer/ �� __class__ra rd r� � s
��zDbTypes.__init__c
C sn || v r| | S |r dnt | }t| jr|n|�} || _|| _|| _|| _|| _|| _|| _ || _
| j | _ | S )z3Create a PostgreSQL type name with additional info.r^ )
ri rg r r� re r� �regtype�typtype�category�delim�relidrV rw )
rc r� r� r r r r r! re r
ra ra rd r � s z DbTypes.addc C s| z| j td|�f }| j�||f��� }W n ty d}Y nw |s)td| ��|d }| j|� }| | |j< | |j < |S )z8Get the type info from the database if it is not cached.�$1NzType %s could not be foundr )
r r r �query� getresultr rt r r� r� )rc r� r% rq r
ra ra rd r � s �
zDbTypes.__missing__Nc C s" z| | W S t y | Y S w )z&Get the type even if it is not cached.)rt )rc r� r� ra ra rd ru � s
�z DbTypes.getc C s8 t |t�s| �|�}|sdS |jsdS | jj|jdd�S )r NF)�with_oid)r� rg ru r! r rV r ra ra rd rV s
zDbTypes.get_attnamesc C r: r� )r ru r ra ra rd r
r= zDbTypes.get_typecastc C s | j �||� dS )r N)r r )rc r
r� ra ra rd r r� zDbTypes.set_typecastc C s | j �|� dS )z?Reset the typecast function for the specified database type(s).N)r r r ra ra rd �reset_typecast s zDbTypes.reset_typecastc C sT |du rdS t |t�s| �|�}|r|j}|r | �|�nd}|r$|tu r&|S ||�S )z:Cast the given value according to the given database type.N)r� rg ru r� r rH )rc r� r
r� ra ra rd �typecast s
zDbTypes.typecastr` )rk rl rm r� r� r �
_num_typesr� r r ru rV r r r& r' �
__classcell__ra ra r rd r � s �
r z^[A-Za-z][_a-zA-Z0-9]*$i r� c C s~ z$z
t d| dd�jW W S ty$ dd� t| �D �} t d| �j Y W S w ty> dd� tt| ��D �} t d| �j Y S w )z>Get a namedtuple factory for row results with the given names.�RowT)�renamec S s0 g | ]\}}t �|�rt|�s|nd |f �qS �z column_%d)�
_re_fieldnamer� rU rm ra ra rd r� 6 s
��z _row_factory.<locals>.<listcomp>c S s g | ]}d |f �qS r, ra )r� rn ra ra rd r� ; r� )rT �_maker� rp r� �rangery )�namesra ra rd � _row_factory/ s �� �r1 c C s t | �tj�adS )zwChange the size of the namedtuple factory cache.
If maxsize is set to None, the cache can grow without bound.
N)r\ r1 r� r� ra ra rd �set_row_factory_size? s r2 c c s( � | � � }| D ]
}tt||��V qdS )z0Get query result as an iterator of dictionaries.N)�
listfieldsr� rW )r% r
�rra ra rd � _dictiterJ s
��r5 c c s& � t | �� �}| D ]}||�V q dS )z0Get query result as an iterator of named tuples.N)r1 r3 )r% �rowr4 ra ra rd �
_namediterQ s
� �r7 c C s t | �� �t| ��S )z0Get next row from query result as a named tuple.)r1 r3 r} r$ ra ra rd �
_namednextX s r8 c c s � | D ]}|d V qdS )z1Get query result as an iterator of scalar values.r Nra )r% r4 ra ra rd � _scalariter] s � �r9 c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) � _MemoryQueryz)Class that embodies a given query result.c C s || _ t|�| _dS )z4Create query from given result rows and field names.N)�resultrc r
)rc r; r
ra ra rd r� f s z_MemoryQuery.__init__c C r� )z,Return the stored field names of this query.)r
rb ra ra rd r3 k � z_MemoryQuery.listfieldsc C r� )z'Return the stored result of this query.)r; rb ra ra rd r$ o r< z_MemoryQuery.getresultc C r� r` )r� r; rb ra ra rd r� s r� z_MemoryQuery.__iter__N)rk rl rm r� r� r3 r$ r� ra ra ra rd r: c s r: c C s || �}d|_ |S )z3Return DatabaseError with empty sqlstate attribute.N)�sqlstate)�msgr r� ra ra rd � _db_errorw s r? c C �
t | t�S )zReturn InternalError.)r? r �r> ra ra rd �
_int_error~ r rB c C r@ )zReturn ProgrammingError.)r? r rA ra ra rd �
_prg_error� r rC c @ sP e Zd ZdZ ddd�Zdd� Zdd� Zd d
� Zd d � Zddd�Z dd� Z
dS )r z;A PostgreSQL client-side asynchronous notification handler.Nc C sB || _ || _|p d| | _d| _|| _|du ri }|| _|| _dS )a� Initialize the notification handler.
You must pass a PyGreSQL database connection, the name of an
event (notification channel) to listen for and a callback function.
You can also specify a dictionary arg_dict that will be passed as
the single argument to the callback function, and a timeout value
in seconds (a floating point number denotes fractions of seconds).
If it is absent or None, the callers will never time out. If the
timeout is reached, the callback function will be called with a
single argument that is None. If you set the timeout to zero,
the handler will poll notifications synchronously and return.
You can specify the name of the event that will be used to signal
the handler to stop listening as stop_event. By default, it will
be the event name prefixed with 'stop_'.
zstop_%sFN)r. �event�
stop_event� listening�callback�arg_dict�timeout)rc r. rD rG rH rI rE ra ra rd r� � s
z NotificationHandler.__init__c C s | � � d S r` )�unlistenrb ra ra rd �__del__� r� zNotificationHandler.__del__c C s& | j r| �� | j �� d| _ dS dS )z(Stop listening and close the connection.N)r. rJ �closerb ra ra rd rL � s
�zNotificationHandler.closec C s8 | j s| j�d| j � | j�d| j � d| _ dS dS )z1Start listening for the event and the stop event.z listen "%s"TN�rF r. r# rD rE rb ra ra rd �listen� �
�zNotificationHandler.listenc C s8 | j r| j�d| j � | j�d| j � d| _ dS dS )z0Stop listening for the event and the stop event.z
unlisten "%s"FNrM rb ra ra rd rJ � rO z NotificationHandler.unlistenFc C sB | j r |s| j}d|r| jn| j }|r|d| 7 }|�|�S dS )a� Generate a notification.
Optionally, you can pass a payload with the notification.
If you set the stop flag, a stop notification will be sent that
will cause the handler to stop listening.
Note: If the notification handler is running in another thread, you
must pass a different database connection since PyGreSQL database
connections are not thread-safe.
z notify "%s"z, '%s'N)rF r. rE rD r# )rc r. �stop�payloadr% ra ra rd �notify� s
�zNotificationHandler.notifyc C s� | � � | jdk}|s| j�� g}| jrv|s!t�|g g | j�d rh| jrc| j�� }|s,n7|\}}}|| j| jfvrH| � � t
d| j| j|f ��|| jkrQ| � � | j j |||d� | �
| j � | js$|rgdS n | � � | �
d� | jsdS dS )as Invoke the notification handler.
The handler is a loop that listens for notifications on the event
and stop event channels. When either of these notifications are
received, its associated 'pid', 'event' and 'extra' (the payload
passed with the notification) are inserted into its arg_dict
dictionary and the callback is invoked with this dictionary as
a single argument. When the handler receives a stop event, it
stops listening to both events and return.
In the special case that the timeout of the handler has been set
to zero, the handler will poll all events synchronously and return.
If will keep listening until it receives a stop event.
Note: If you run this loop in another thread, don't use the same
database connection for database operations in the main thread.
r z1Listening for "%s" and "%s", but notified of "%s")�pidrD �extraN)rN rI r. �filenorF �select� getnotifyrD rE rJ r? rH r� rG )rc �poll�rlist�noticerD rS rT ra ra rd �__call__� s:
��
��
�z NotificationHandler.__call__)NNNN)NFN) rk rl rm r� r� rK rL rN rJ rR r[ ra ra ra rd r � s
�
r c O s t jdtdd� t| i |��S )z8Same as NotificationHandler, under the traditional name.z7pgnotify is deprecated, use NotificationHandler insteadrx )�
stacklevel)�warnings�warn�DeprecationWarningr r� ra ra rd �pgnotify
s �r` c @ s� e Zd ZdZdZdd� Zdd� Zdd� Zd d
� Zd d � Z d
d� Z
dd� Z dd� Z e
dd� �Zdd� Ze
e�Zdd� Zdd� Zdd � Zd d � Zd d � Zd`d!d"�ZeZd#d$� ZeZd`d%d&�ZeZd'd(� Z d)d*� Z d+d,� Z dad.d/�Z d0d1� Z -dbd2d3�Z!d4d5� Z"d6d7� Z#d`d8d9�Z$d`d:d;�Z%dcd<d=�Z&d>d?� Z'dad@dA�Z(dddBdC�Z)dedEdF�Z*d`dGdH�Z+dfdJdK�Z,d`dLdM�Z-d`dNdO�Z.d`dPdQ�Z/d`dRdS�Z0d`dTdU�Z1d`dVdW�Z2dgdXdY�Z3 -dhdZd[�Z4 -did\d]�Z5 djd^d_�Z6dS )kr z*Wrapper class for the _pg connection type.Nc O s |st |�dkr|�d�}n|st |�dkr|d }nd}|r7t|t�r(|j}nz|j}W n ty6 Y nw |rCt|d�rCt|d�sSt|i |��}||f| _ d| _
n|| _ d| _
|| _|j| _ d| _ i | _
i | _i | _t| �| _t| �| _|jdk rd | _nd
| _|�| jj� d| _dS ) z�Create a new connection
You can pass either the connection parameters or an existing
_pg or pgdb connection. This allows you to use the methods
of the classic pg interface with a DB-API 2 pgdb connection.
rw r. r Nr# TFr a= SELECT a.attname, t.oid, t.typname, t.typname::text::regtype, t.typtype, null as typcategory, t.typdelim, t.typrelid FROM pg_catalog.pg_attribute a JOIN pg_catalog.pg_type t ON t.oid OPERATOR(pg_catalog.=) a.atttypid WHERE a.attrelid OPERATOR(pg_catalog.=) %s::regclass AND %s AND NOT a.attisdropped ORDER BY a.attnuma1 SELECT a.attname, t.oid, t.typname, t.typname::regtype, t.typtype, t.typcategory, t.typdelim, t.typrelid FROM pg_catalog.pg_attribute a JOIN pg_catalog.pg_type t ON t.oid OPERATOR(pg_catalog.=) a.atttypid WHERE a.attrelid OPERATOR(pg_catalog.=) %s::regclass AND %s AND NOT a.attisdropped ORDER BY a.attnum)ry ru r� r r. �_cnx�AttributeError�hasattrr+ �_db_args�
_closeable�dbnamer � _attnames�_pkeys� _privilegesr
�adapterr �dbtypesr �_query_attnames�
set_cast_hookr' �debug)rc r� r� r. ra ra rd r� sD
�
�
�
z DB.__init__c C s | j r t| j |�S td��)N�Connection is not valid)r. rb rB �rc r� ra ra rd � __getattr__V s zDB.__getattr__c C s0 t | jj�}|�| j� |�t| j�� t|�S r` )r r �__dict__r� �dirr. r� )rc �attrsra ra rd �__dir__] s z
DB.__dir__c C s | � � | S )z9Enter the runtime context. This will start a transaction.)�beginrb ra ra rd re f s z DB.__enter__c C s0 |du r|du r|du r| � � dS | �� dS )z8Exit the runtime context. This will end the transaction.N)�commit�rollback)rc �et�ev�tbra ra rd rj k s z DB.__exit__c C sz z| j }W n ty d }Y nw |r9z|�d � W n ty# Y nw | jr;z|�� W d S ty8 Y d S w d S d S r` )r. rb rm r� re rL r r/ ra ra rd rK r s&
� � ��z
DB.__del__c G s� | j r>d�dd� |D ��}t| j t�r t| j | � dS t| j d�r,| j �|d � dS t| j �r8| � |� dS t|� dS dS )zPrint a debug message�
c s s � | ]}t |�V qd S r` rl )r� rp ra ra rd r& � rD z DB._do_debug.<locals>.<genexpr>�writeN)rn r' r� r �printrc r} r )rc r� r ra ra rd � _do_debug� s
�z DB._do_debugc C s d|vr | � |�}|S )a Escape a qualified name.
Escapes the name for use as an SQL identifier, unless the
name contains a dot, in which case the name is ambiguous
(could be a qualified name or just a name with a dot in it)
and must be quoted manually by the caller.
r
)�escape_identifier�rc r ra ra rd �_escape_qualified_name� s
zDB._escape_qualified_namec C s t � rt| �S | r dS dS )z%Get boolean value corresponding to d.r0 r1 )r0 r� )r� ra ra rd �
_make_bool� s z
DB._make_boolc C s d� dd� t|d�D ��S )z'Create a human readable parameter list.�, c s s � | ] \}}d ||f V qdS )z$%d=%rNra rm ra ra rd r& � r| z"DB._list_params.<locals>.<genexpr>rw )r' rp r� ra ra rd � _list_params� s zDB._list_paramsc C s t � pt|�S )z.Decode a JSON string coming from the database.)r: �
jsondecoder� ra ra rd � decode_json� r� zDB.decode_jsonc C s t |�S )z(Encode a JSON string for use within SQL.)�
jsonencode)rc r� ra ra rd r> � r� zDB.encode_jsonc C sL | j }|r"z|�d� W n ty Y nw | jr |�� d| _ dS td��)z Close the database connection.N�Connection already closed)r. rm r� re rL rB r/ ra ra rd rL � s �
zDB.closec C s | j r
| j �� dS td��)z�Reset connection with current parameters.
All derived queries and large objects derived from this connection
will not be usable after this call.
r� N)r. r rB rb ra ra rd r � s zDB.resetc C s` | j r*t| jd i | jd ��}| jr | j�d� | j�� |�| jj� || _dS | j| _dS )z�Reopen connection to the database.
Used in case we need another connection to the same database.
Note that we can still reopen a database that we have closed.
r rw N)re r+ rd r. rm rL rk r' r/ ra ra rd �reopen� s
z DB.reopenc C � d}|r
|d| 7 }| � |�S )zBegin a transaction.�BEGINr� �r# )rc �mode�qstrra ra rd rv � �
zDB.beginc C s
| � d�S )z Commit the current transaction.�COMMITr� rb ra ra rd rw � r z DB.commitc C r� )z"Roll back the current transaction.�ROLLBACKz TO r� )rc r� r� ra ra rd rx � r� z DB.rollbackc C � | � d| �S )z6Define a new savepoint within the current transaction.z
SAVEPOINT r� rp ra ra rd � savepoint� r� z DB.savepointc C r� )z'Destroy a previously defined savepoint.zRELEASE r� rp ra ra rd �release� r� z
DB.releasec C sV t |t�r |g}d}n t |ttf�rg }nt |ttf�r i }n t |t�r'|}ntd��|s1td��t |t�r8i ng }|D ]>}t |t�rI|�� � � nd}|sQtd��|dkrkd}| j
� |�� � }tdd� |D ��} |S t |t�ru|||< q<|�
|� q<|D ]+}d |f }| j
� |�� � d
d
}|du r�|}q}t |t�r�|�
|� q}|||| < q}|S ) a/ Get the value of a run-time parameter.
If the parameter is a string, the return value will also be a string
that is the current setting of the run-time parameter with that name.
You can get several parameters at once by passing a list, set or dict.
When passing a list of parameter names, the return value will be a
corresponding list of parameter settings. When passing a set of
parameter names, a new dict will be returned, mapping these parameter
names to their settings. Finally, if you pass a dict as parameter,
its values will be set to the current parameter settings corresponding
to its keys.
By passing the special name 'all' as the parameter, you can get a dict
of all existing configuration parameters.
N�1The parameter must be a string, list, set or dict� No parameter has been specified�Invalid parameter�allzSHOW ALLc s s � | ] }|d d� V qd S )Nrx ra r� ra ra rd r& ) r} z#DB.get_parameter.<locals>.<genexpr>zSHOW %sr )r� r r� rc r r� r� r� �stripr2 r. r# r$ r )rc � parameterr� r� r� r r% r� ra ra rd �
get_parameter sR
���
�
zDB.get_parameterFc C s� t |t�r
||i}nat |ttf�r't |ttf�r tt||��}nKt�||�}nDt |ttf�rYt |ttttf�rEt|�}t |�dkrE|�
� }|du sRt |t�sRt d��t�||�}nt |t�rg|durft d��nt d��|sqt d��i }|�
� D ]-\}}t |t�r�|�� �� nd}|s�t d��|dkr�|dur�t d ��ddi} n|||< qw|r�d
nd }|�
� D ]!\}}|du r�d ||f }nd
|||f }| �|� | j�|� q�dS )a� Set the value of a run-time parameter.
If the parameter and the value are strings, the run-time parameter
will be set to that value. If no value or None is passed as a value,
then the run-time parameter will be restored to its default value.
You can set several parameters at once by passing a list of parameter
names, together with a single value that all parameters should be
set to or with a corresponding list of values. You can also pass
the parameters as a set if you only provide a single value.
Finally, you can pass a dict with parameter names as keys. In this
case, you should not pass a value, since the values for the parameters
will be taken from the dict.
By passing the special name 'all' as the parameter, you can reset
all existing settable run-time parameters to their default values.
If you set local to True, then the command takes effect for only the
current transaction. After commit() or rollback(), the session-level
setting takes effect again. Setting local to True will appear to
have no effect if it is executed outside a transaction, since the
transaction will end immediately.
rw Nz8A single value must be specified when parameter is a setz<A value must not be specified when parameter is a dictionaryr� r� r� r� z4A value must ot be specified when parameter is 'all'z LOCALr� z
RESET%s %szSET%s %s TO %s)r� r r� rc r� rW r� r r� ry r� r� r� r� r� r2 r r. r# )rc r� r� �localr� r� r r% ra ra rd �
set_parameter; s\
����
�zDB.set_parameterc G sB | j std��|r| �||� | j �||�S | �|� | j �|�S )a; Execute a SQL command string.
This method simply sends a SQL query to the database. If the query is
an insert statement that inserted exactly one row into a table that
has OIDs, the return value is the OID of the newly inserted row.
If the query is an update or delete statement, or an insert statement
that did not insert exactly one row in a table with OIDs, then the
number of rows affected is returned as a string. If it is a statement
that returns rows as a result (usually a select statement, but maybe
also an "insert/update ... returning" statement), this method returns
a Query object that can be accessed via getresult() or dictresult()
or simply printed. Otherwise, it returns `None`.
The query can contain numbered parameters of the form $1 in place
of any data constant. Arguments given after the query string will
be substituted for the corresponding numbered parameter. Parameter
values can also be given as a single list or tuple argument.
ro )r. rB r r# )rc r� r� ra ra rd r# � s
zDB.queryc C s | j | j�||||�� S )aD Execute a formatted SQL command string.
Similar to query, but using Python format placeholders of the form
%s or %(names)s instead of PostgreSQL placeholders of the form $1.
The parameters must be passed as a tuple, list or dict. You can
also pass a corresponding tuple, list or dict of database types in
order to format the parameters properly in case there is ambiguity.
If you set inline to True, the parameters will be sent to the database
embedded in the SQL command, otherwise they will be sent separately.
)r# rj r� )rc r� r� r� r� ra ra rd �query_formatted� s
�zDB.query_formattedc G sR | j std��|du r
d}|r | �d||� | j �||�S | �d|� | j �|�S )a Execute a prepared SQL statement.
This works like the query() method, except that instead of passing
the SQL command, you pass the name of a prepared statement. If you
pass an empty name, the unnamed statement will be executed.
ro Nr� �EXECUTE)r. rB r �query_prepared)rc r� r� ra ra rd r� � s zDB.query_preparedc C s6 | j std��|du r
d}| �d||� | j �||�S )ao Create a prepared SQL statement.
This creates a prepared statement for the given command with the
given name for later execution with the query_prepared() method.
The name can be empty to create an unnamed statement, in which case
any pre-existing unnamed statement is automatically replaced;
otherwise it is an error if the statement name is already
defined in the current database session. We recommend always using
named queries, since unnamed queries have a limited lifetime and
can be automatically replaced or destroyed by various operations.
ro Nr� �prepare)r. rB r r� )rc r� r� ra ra rd r� � s
z
DB.preparec C s |du rd}| j �|�S )a
Describe a prepared SQL statement.
This method returns a Query object describing the result columns of
the prepared statement with the given name. If you omit the name,
the unnamed statement will be described if you created one before.
Nr� )r. �describe_preparedrp ra ra rd r� � s zDB.describe_preparedc C s$ d|pdf }| � |� | j�|�S )a8 Delete a prepared SQL statement
This deallocates a previously prepared SQL statement with the given
name, or deallocates all prepared statements if you do not specify a
name. Note that prepared statements are also deallocated automatically
when the current session ends.
z
DEALLOCATE %s�ALL)r r. r# )rc r� r% ra ra rd �delete_prepared� s
zDB.delete_preparedc s� | j }|r|�� | �d� z|| }W nM tya dtd|�f }| j�||f��� }|s5td| ��t|�dkrU|d d � t |� fdd �d
�}t
d d � |D ��}n|d d }|||< Y nw |rlt |t
�sl|f}|S )
a� Get or set the primary key of a table.
Single primary keys are returned as strings unless you
set the composite flag. Composite primary keys are always
represented as tuples. Note that this raises a KeyError
if the table does not have a primary key.
If flush is set then the internal cache for primary keys will
be flushed. This may be necessary after the database schema or
the search path has been changed.
z The pkey cache has been flusheda1 SELECT a.attname, a.attnum, i.indkey FROM pg_catalog.pg_index i JOIN pg_catalog.pg_attribute a ON a.attrelid OPERATOR(pg_catalog.=) i.indrelid AND a.attnum OPERATOR(pg_catalog.=) ANY(i.indkey) AND NOT a.attisdropped WHERE i.indrelid OPERATOR(pg_catalog.=) %s::regclass AND i.indisprimary ORDER BY a.attnumr" �Table %s has no primary keyrw r rx c s � � | d �S )Nrw )�index�r6 ��indkeyra rd �<lambda>
s zDB.pkey.<locals>.<lambda>)r� c s s � | ]}|d V qdS )r Nra �r� r6 ra ra rd r& rD zDB.pkey.<locals>.<genexpr>) rh r� r rt r r. r# r$ ry r� rc r� )rc r� � composite�flush�pkeys�pkeyr% ra r� rd r� � s0
�� �zDB.pkeyc C s dd� | j �d��� D �S )z$Get list of databases in the system.c S r� r� ra )r� r ra ra rd r� r� z$DB.get_databases.<locals>.<listcomp>z*SELECT datname FROM pg_catalog.pg_database)r. r# r$ rb ra ra rd �
get_databases s ��zDB.get_databasesc C sl g }|r|� dd�dd� |D �� � |s|� d� |r#dd�|� nd}d | }d
d � | j�|��� D �S ) a` Get list of relations in connected database of specified kinds.
If kinds is None or empty, all kinds of relations are returned.
Otherwise kinds can be a string or sequence of type letters
specifying which kind of relations you want to list.
Set the system flag if you want to get the system relations as well.
zr.relkind IN (%s)r! c s s � | ]}d | V qdS )rx Nra �r� r" ra ra rd r& ( rD z#DB.get_relations.<locals>.<genexpr>z?s.nspname NOT SIMILAR TO 'pg/_%|information/_schema' ESCAPE '/'z WHERE %s� AND r� a SELECT pg_catalog.quote_ident(s.nspname) OPERATOR(pg_catalog.||) '.' OPERATOR(pg_catalog.||) pg_catalog.quote_ident(r.relname) FROM pg_catalog.pg_class r JOIN pg_catalog.pg_namespace s ON s.oid OPERATOR(pg_catalog.=) r.relnamespace%s ORDER BY s.nspname, r.relnamec S r� r� ra )r� r4 ra ra rd r� 3 r� z$DB.get_relations.<locals>.<listcomp>)r r' r. r# r$ )rc �kinds�system�wherer% ra ra rd �
get_relations s �
�zDB.get_relationsc C s | � d|�S )z�Return list of tables in connected database.
Set the system flag if you want to get the system tables as well.
r4 )r� )rc r� ra ra rd �
get_tables5 s z
DB.get_tablesTc s� | j }|r|�� | �d� z|| }W |S tyO d}|r$d| }| jtd|�|f }| j�||f��� }| j � � fdd�|D �}t
|�}|||< Y |S w )at Given the name of a table, dig out the set of attribute names.
Returns a read-only dictionary of attribute names (the names are
the keys, the values are the names of the attributes' types)
with the column names in the proper order if you iterate over it.
If flush is set, then the internal cache for attribute names will
be flushed. This may be necessary after the database schema or
the search path has been changed.
By default, only a limited number of simple types will be returned.
You can get the registered types after calling use_regtypes(True).
z#The attnames cache has been flushedz!a.attnum OPERATOR(pg_catalog.>) 0z.(%s OR a.attname OPERATOR(pg_catalog.=) 'oid')r" c 3 s* � | ]}|d � j |dd� � fV qdS )r rw Nr� )r� r� �r� ra rd r& W s �( z"DB.get_attnames.<locals>.<genexpr>) rg r� r rt rl r r. r# r$ rk r� )rc r� r% r� rk r0 r% ra r� rd rV < s&
�
�zDB.get_attnamesc C sD |du r| j jS t|�}|| j jkr || j _| j�� | j �� |S )z;Use registered type names instead of simplified type names.N)rk r r� rg r� )rc �regtypesra ra rd � use_regtypes\ s
zDB.use_regtypesrV c C s� | j }|r|�� | �d� |�� }z |||f }W |S tyI dtd|�f }| j�|||f�}|�� d d | � d�k}||||f< Y |S w )z�Check whether current user has specified table privilege.
If flush is set, then the internal cache for table privileges will
be flushed. This may be necessary after privileges have been changed.
z%The privileges cache has been flushedz-SELECT pg_catalog.has_table_privilege(%s, $2)r" r T)
ri r� r r2 rt r r. r# r$ r� )rc r� � privileger� �
privileges�retr% ra ra rd �has_table_privilegeh s"
���zDB.has_table_privilegec s0 |� d�r
|dd� �� }| �|��d�v rt|�nd}|r&t|t�r&|f}|r;t�t�r;|�v r;d�vr;�| �d< |s|z| �|d�}W n tyb |rZt�t�rZd�v rZd}nt d| ��Y nw t�t�r|t
|�� ��s||rxd�v rxd}ntd��t�t�s�t�t t
f�s��g�t|�t��kr�td ��tt|����| j�� }|j� | j�|r�d
nd}d �� ���fd d
�|D ��}d�v r�|rʈd �|< �d= d|| �|�|f }| �||� | j�||�}|�� } | s�|�dd�}td||| � |�f ��| d � � D ]\}
} |�r|
dk�r|}
| �|
< �q�S )a� Get a row from a database table or view.
This method is the basic mechanism to get a single row. It assumes
that the keyname specifies a unique row. It must be the name of a
single column or a tuple of column names. If the keyname is not
specified, then the primary key for the table is used.
If row is a dictionary, then the value for the key is taken from it.
Otherwise, the row must be a single value or a tuple of values
corresponding to the passed keyname or primary key. The fetched row
from the table will be returned as a new dictionary or used to replace
the existing values when row was passed as a dictionary.
The OID is also put into the dictionary if the table has one, but
in order to allow the caller to work with multiple tables, it is
munged as "oid(table)" using the actual name of the table.
r Nr� r� T�r� r� z*Missing value in row for specified keynamez,Differing number of items in keyname and row�oid, *r� c 3 �. � | ]}d �|�� �| �| �f V qdS �z %s OPERATOR(pg_catalog.=) %sNra r� �r rk �colr6 ra rd r& � � � ��zDB.get.<locals>.<genexpr>z"SELECT %s FROM %s WHERE %s LIMIT 1zOPERATOR(pg_catalog.=)�=z%No such record in %s
where %s
with %sr ) rd �rstriprV r� r� r r� r� rt rC r �issubsetrc r� ry rW rj r� r r� r' r� r r. r# �
dictresultr� r? r� r� ) rc r� r6 �keyname�qoidr� �whatr� r% rq rn r� ra r� rd ru } st
�� �
�
� � � zDB.getc K sP |� d�r
|dd� �� }|du ri }|�|� d|v r |d= | �|�}d|v r,t|�nd}| j�� }|j}| j}g g } }
|D ]} | |v rY| � || �� |
� ||| || �� q@| s`t
d��d� | �d� |
�} }
|rodnd} d| � |�| |
| f }
| �
|
|� | j�|
|�}
|
�� }|r�|d �� D ]\} }|r�| dkr�|} ||| < q�|S )
ad Insert a row into a database table.
This method inserts a row into a table. The name of the table must
be passed as the first parameter. The other parameters are used for
providing the data of the row that shall be inserted into the table.
If a dictionary is supplied as the second parameter, it starts with
that. Otherwise it uses a blank dictionary. Either way the dictionary
is updated from the keywords.
The dictionary is then reloaded with the values actually inserted in
order to pick up values modified by rules, triggers, etc.
r Nr� r� z$No column found that can be insertedr� r� z,INSERT INTO %s (%s) VALUES (%s) RETURNING %sr )rd r� r� rV r� rj r� r r� r rC r' r� r r. r# r� r� )rc r� r6 r� rk r� r� r r� r0 r� rn r� r% rq r� ra ra rd �insert� sD
� �
z DB.insertc s� |� d�r
|dd� �� }| �|��d�v rt|�nd}�du r#i �nd�v r*�d= ��|� |r?|�v r?d�vr?�| �d< |rHd�v rHd}n!z| �|d�}W n
ty] td| ��w t|�� ��sitd��| j
� � }|j � | j
�d �� ���fd
d �|D ��}d�v r�|r��d �|< �d= g }t|�}�D ] } | �v r�| |vr�|�d �| �� �| �| �f � q�|s��S d
�|�}|r�dnd}
d| �|�|||
f } | �| |� | j�| |�} | �� } | r�| d �� D ]\} }
|r�| dkr�|} |
�| < q�S )a� Update an existing row in a database table.
Similar to insert, but updates an existing row. The update is based
on the primary key of the table or the OID value as munged by get()
or passed as keyword. The OID will take precedence if provided, so
that it is possible to update the primary key itself.
The dictionary is then modified to reflect any changes caused by the
update due to triggers, rules, default values, etc.
r Nr� r� r� Tr� �$Missing value for primary key in rowr� c 3 r� r� ra r� r� ra rd r& r� z DB.update.<locals>.<genexpr>�%s = %sr� r� z&UPDATE %s SET %s WHERE %s RETURNING %sr )rd r� rV r� r� r� rt rC r r� rj r� r r� r' r r� r r. r# r� r� )rc r� r6 r� r� r� r� r� r� rn r� r% rq r� ra r� rd r� � sh
�
� $�
�
z DB.updatec s\ |� d�r
|dd� �� }|du ri }d|v r|d= d|v r!|d= | �|�}d|v r.t|�nd}| j�� }|j}| j� g g g }} }
|D ]} | |v r^|�� | �� | �||| || �� qEd� |�d� | �}} z| �
|d�} W n
t y t d| ��w d� � fdd �| D ��}
g }t
| �} | �d� |D ]$} | | vr�|�| d�}|r�t|t�s�d
� | � }|�d � | �|f � q�| s�|S |r�d d� |� nd
}|r�dnd}d| �|�|| |
||f }| �||� z | j�||�}W n t�y | jdk �rt d��� w |�� }|�r&|d �� D ]\} }|�r | dk�r |} ||| < �q|S | �||� |S )a� Insert a row into a database table with conflict resolution
This method inserts a row into a table, but instead of raising a
ProgrammingError exception in case a row with the same primary key
already exists, an update will be executed instead. This will be
performed as a single atomic operation on the database, so race
conditions can be avoided.
Like the insert method, the first parameter is the name of the
table and the second parameter can be used to pass the values to
be inserted as a dictionary.
Unlike the insert und update statement, keyword parameters are not
used to modify the dictionary, but to specify which columns shall
be updated in case of a conflict, and in which way:
A value of False or None means the column shall not be updated,
a value of True means the column shall be updated with the value
that has been proposed for insertion, i.e. has been passed as value
in the dictionary. Columns that are not specified by keywords but
appear as keys in the dictionary are also updated like in the case
keywords had been passed with the value True.
So if in the case of a conflict you want to update every column that
has been passed in the dictionary row, you would call upsert(table, row).
If you don't want to do anything in case of a conflict, i.e. leave
the existing row as it is, call upsert(table, row, **dict.fromkeys(row)).
If you need more fine-grained control of what gets updated, you can
also pass strings in the keyword parameters. These strings will
be used as SQL expressions for the update columns. In these
expressions you can refer to the value that already exists in
the table by prefixing the column name with "included.", and to
the value that has been proposed for insertion by prefixing the
column name with the "excluded."
The dictionary is modified in any case to reflect the values in
the database after the operation has completed.
Note: The method uses the PostgreSQL "upsert" feature which is
only available since PostgreSQL 9.5.
r Nr� r� r� Tr� c 3 rA r` ra r� �r� ra rd r& x rD z DB.upsert.<locals>.<genexpr>z excluded.%sr� z
update set %s�nothingr� zOINSERT INTO %s AS included (%s) VALUES (%s) ON CONFLICT (%s) DO %s RETURNING %si�a z7Upsert operation is not supported by PostgreSQL versionr )rd r� rV r� rj r� r r� r r' r� rt rC r ru r� r r� r r. r# r r r� r� )rc r� r6 r� rk r� r� r r0 r� �updatesrn r� �targetr� r� �dor� r% rq ra r� rd �upsert6 s�
+
� �
� �� �� �z DB.upsertc C sp |du ri }| � |�}|�� D ]&\}}|dkrq|j}|tjv r%d||< q|dkr1| �d�||< qd||< q|S )ah Clear all the attributes to values determined by the types.
Numeric types are set to 0, Booleans are set to false, and everything
else is set to the empty string. If the row argument is present,
it is used as the row dictionary and any entries matching attribute
names are cleared with everything else left unchanged.
Nr� r r� Fr� )rV r� re r r( r� )rc r� r6 rk rn r0 ra ra rd r� � s
zDB.clearc
sX |� d�r
|dd� �� }| �|��d�v rt|�nd}�du r#i �nd�v r*�d= ��|� |r?|�v r?d�vr?�| �d< |rHd�v rHd}n!z| �|d�}W n
ty] td| ��w t|�� ��sitd��| j
� � }|j � | j
�d �� ���fd
d �|D ��}d�v r�|r��d �|< �d= d | �|�|f }| �||� | j�||�} t| �S )
a# Delete an existing row in a database table.
This method deletes the row from a table. It deletes based on the
primary key of the table or the OID value as munged by get() or
passed as keyword. The OID will take precedence if provided.
The return value is the number of deleted rows (i.e. 0 if the row
did not exist and 1 if the row was deleted).
Note that if the row cannot be deleted because e.g. it is still
referenced by another table, this method raises a ProgrammingError.
r Nr� r� r� Tr� r� r� c 3 r� r� ra r� r� ra rd r& � r� z DB.delete.<locals>.<genexpr>zDELETE FROM %s WHERE %s)rd r� rV r� r� r� rt rC r r� rj r� r r� r' r� r r. r# r� )
rc r� r6 r� r� r� r� r� r% rq ra r� rd �delete� sH
�
�
� z DB.deletec C sz t |t�r
||i}|g}n/t |ttf�r*t |ttf�r#tt||��}nt�||�}nt |ttf�r8t�||�}nt d��|du sKt |t
t f�sKt d��|du sZt |t
t f�sZt d��g }|D ]9}|� |�}|du stt |t
t f�stt d��|�
d�r�|rtd��|dd� �� }| �|�}|r�d | }|�|� q^d
d �|�g}|r�|�d � |r�|�d
� d�|�}| �|� | j�|�S )a� Empty a table or set of tables.
This method quickly removes all rows from the given table or set
of tables. It has the same effect as an unqualified DELETE on each
table, but since it does not actually scan the tables it is faster.
Furthermore, it reclaims disk space immediately, rather than requiring
a subsequent VACUUM operation. This is most useful on large tables.
If restart is set to True, sequences owned by columns of the truncated
table(s) are automatically restarted. If cascade is set to True, it
also truncates all tables that have foreign-key references to any of
the named tables. If the parameter only is not set to True, all the
descendant tables (if any) will also be truncated. Optionally, a '*'
can be specified after the table name to explicitly indicate that
descendant tables are included.
z'The table must be a string, list or setNz#Invalid type for the restart optionz#Invalid type for the cascade optionz Invalid type for the only optionr z)Contradictory table name and only optionsr� zONLY %s�TRUNCATEr� zRESTART IDENTITY�CASCADEr� )r� r r� rc r� rW r� r r� r� r� r� ru rd r� r� r� r r' r r. r# ) rc r� �restart�cascade�only�tablesr0 �ur% ra ra rd �truncate� sJ
�
z DB.truncatec
C sl |st d��|r t|ttf�rd�tt|��}|du r |}nd}d|d|g}|r>t|ttf�r7d�tt|��}|�d|g� |du rkz| �|d �}W n t t
fyj z t| � |��}W n t t
fyg Y nw Y nw |r�t|ttf�r|d�tt|��}|�d
|g� |r�|� d | � |r�|� d | � d
�|�}| �
|� | j�|�}|�� } | r�|r�dd� | D �} | S )a� Get a table as a list.
This gets a convenient representation of the table as a list
of named tuples in Python. You only need to pass the name of
the table (or any other SQL expression returning rows). Note that
by default this will return the full content of the table which
can be huge and overflow your memory. However, you can control
the amount of data returned using the other optional parameters.
The parameter 'what' can restrict the query to only return a
subset of the table columns. It can be a string, list or a tuple.
The parameter 'where' can restrict the query to only return a
subset of the table rows. It can be a string, list or a tuple
of SQL expressions that all need to be fulfilled. The parameter
'order' specifies the ordering of the rows. It can also be a
other string, list or a tuple. If no ordering is specified,
the result will be ordered by the primary key(s) or all columns
if no primary key exists. You can set 'order' to False if you
don't care about the ordering. The parameters 'limit' and 'offset'
can be integers specifying the maximum number of rows returned
and a number of rows skipped over.
If you set the 'scalar' option to True, then instead of the
named tuples you will get the first items of these tuples.
This is useful if the result has only one column anyway.
�The table name is missingr� Nr �SELECT�FROMr� �WHERET�ORDER BY�LIMIT %d� OFFSET %dr� c S r� r� ra r� ra ra rd r� ]
r� z"DB.get_as_list.<locals>.<listcomp>)r� r� r� rc r' �maprH �extendr� rt r rV r r r. r# � namedresult)
rc r� r� r� �order�limitr� �scalarr% rq ra ra rd � get_as_list
sP � ���
zDB.get_as_listc s� |st d��|s z| �|d�}W n ttfy td| ��w t|t�r)|g}n t|ttf�s4td��|rLt|ttf�rEd� t
t |��}|du rK|}nd}d|d |g} |rlt|ttf�red
� t
t |��}| � d |g� |du rr|}|r�t|ttf�r�d� t
t |��}| � d |g� |r�| �
d
| � |r�| �
d| � d� | �} | �| � | j�| �} | �� }
|r�tnt} |
s�| � S t|�� | �� } � �| �s�td��g g }
�t| �D ]\}}|� v r�|
n��
|� q�t|
�dk}t|
� }t
||
�}|r��dd� �d}nt��dk}|�s |�rt�� }n �d ��fdd�}d}t
||
�}|�s'|�rD|�r1tt||��}|�rD� fdd�| D �} tt|| ��}| t ||��S )a- Get a table as a dictionary.
This method is similar to get_as_list(), but returns the table
as a Python dict instead of a Python list, which can be even
more convenient. The primary key column(s) of the table will
be used as the keys of the dictionary, while the other column(s)
will be the corresponding values. The keys will be named tuples
if the table has a composite primary key. The rows will be also
named tuples unless the 'scalar' option has been set to True.
With the optional parameter 'keyname' you can specify an alternative
set of columns to be used as the keys of the dictionary. It must
be set as a string, list or a tuple.
If the Python version supports it, the dictionary will be an
OrderedDict using the order specified with the 'order' parameter
or the key column(s) if not specified. You can set 'order' to False
if you don't care about the ordering. In this case the returned
dictionary will be an ordinary one.
r� Tr� z+The keyname must be a string, list or tupler� Nr r� r� r� r� r� r� r� r� zMissing keyname in rowrw Fr c s
| � fS r` ra r� )�rowindra rd r� �
s
z DB.get_as_dict.<locals>.<lambda>c s g | ]}|� vr|�qS ra ra )r� r1 )�keysetra rd r� �
r� z"DB.get_as_dict.<locals>.<listcomp>) r� r� rt r rC r� r r� rc r' r� rH r� r r r. r# r$ r� r� r r3 r� rp ry rV r7 r: rW )rc r� r� r� r� r� r� r� r� r% rq r r
�keyind�ir1 �keytuple�getkeyr� �rowtuple�getrow�rowsra )r� r� rd � get_as_dict`
s� �
�
zDB.get_as_dictc C s t | |||||�S )z:Get notification handler that will run the given callback.)r )rc rD rG rH rI rE ra ra rd �notification_handler�
s
�zDB.notification_handlerr` )NFr� )FFr� )TF)rV F)FFF)NNNNNF)NNNNNNF)NNN)7rk rl rm r� r. r� rq ru re rj rK r r� r� r� r� r. r� r> rL r r� rv �startrw �endrx �abortr� r� r� r� r# r� r� r� r� r� r� r� r� r� rV r� r� ru r� r� r� r� r� r� r� r� r� ra ra ra rd r sv >
:G
�
,
M
.
>
g
18
�B
�\�r �__main__zPyGreSQL versionr� )rn )�r� �
__future__r r �_pg� ImportError�os�sysr� � version_info�environr �pathsep�path�existsr' �add_dll_directory�abspathrI rJ �__all__rV r] r, rM rK rL rN rO �decimalrP �mathrQ rR � collectionsrT �keywordrU �operatorrV � functoolsrW �rerX r) r rY r� rZ r� r� r[ ru � NameErrorr� r rH rX r\ r] �_threadr^ r� r� r� �inspectr� r� r� r� �utcr� r� r� r� r� r� ri 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 rg r r- r1 r2 r5 r7 r8 r9 r: r r? rB rC r? rG rH r� r r` r rk r~ ra ra ra rd �<module> s<
����� � � ��T�: �� �
k %���� ; m
y
: �