Edit File: sql.cpython-37.opt-1.pyc
B *��]: � @ s� d Z ddlZddlmZ ddlmZmZ e�� Z G dd� de �Z G dd� de �Z G d d � d e �Z G d d � d e �ZG d d� de �ZG dd� de �Ze d�Ze d�ZdS )z SQL composition utility module � N)� extensions)�PY3� string_typesc @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )� Composablea6 Abstract base class for objects that can be used to compose an SQL string. `!Composable` objects can be passed directly to `~cursor.execute()`, `~cursor.executemany()`, `~cursor.copy_expert()` in place of the query string. `!Composable` objects can be joined using the ``+`` operator: the result will be a `Composed` instance containing the objects joined. The operator ``*`` is also supported with an integer argument: the result is a `!Composed` instance containing the left argument repeated as many times as requested. c C s || _ d S )N)�_wrapped)�self�wrapped� r �?/opt/alt/python37/lib64/python3.7/site-packages/psycopg2/sql.py�__init__1 s zComposable.__init__c C s d| j j| jf S )Nz%s(%r))� __class__�__name__r )r r r r �__repr__4 s zComposable.__repr__c C s t �dS )aj Return the string value of the object. :param context: the context to evaluate the string into. :type context: `connection` or `cursor` The method is automatically invoked by `~cursor.execute()`, `~cursor.executemany()`, `~cursor.copy_expert()` if a `!Composable` is passed instead of the query string. N)�NotImplementedError)r �contextr r r � as_string7 s zComposable.as_stringc C s> t |t�rt| g�| S t |t�r6t| g�t|g� S tS d S )N)� isinstance�Composedr �NotImplemented)r �otherr r r �__add__D s zComposable.__add__c C s t | g| �S )N)r )r �nr r r �__mul__L s zComposable.__mul__c C s t | �t |�ko| j|jkS )N)�typer )r r r r r �__eq__O s zComposable.__eq__c C s | � |� S )N)r )r r r r r �__ne__R s zComposable.__ne__N) r � __module__� __qualname__�__doc__r r r r r r r r r r r r # s r c sL e Zd ZdZ� fdd�Zedd� �Zdd� Zdd � Zd d � Z d d � Z � Z S )r a A `Composable` object made of a sequence of `!Composable`. The object is usually created using `!Composable` operators and methods. However it is possible to create a `!Composed` directly specifying a sequence of `!Composable` as arguments. Example:: >>> comp = sql.Composed( ... [sql.SQL("insert into "), sql.Identifier("table")]) >>> print(comp.as_string(conn)) insert into "table" `!Composed` objects are iterable (so they can be used in `SQL.join` for instance). c sF g }x,|D ]$}t |t�s$td| ��|�|� q W tt| ��|� d S )Nz4Composed elements must be Composable, got %r instead)r r � TypeError�append�superr r )r �seqr �i)r r r r h s zComposed.__init__c C s t | j�S )z+The list of the content of the `!Composed`.)�listr )r r r r r" r s z Composed.seqc C s. g }x | j D ]}|�|�|�� q W d�|�S )N� )r r r �join)r r �rvr# r r r r w s zComposed.as_stringc C s t | j�S )N)�iterr )r r r r �__iter__} s zComposed.__iter__c C s< t |t�rt| j|j �S t |t�r4t| j|g �S tS d S )N)r r r r r )r r r r r r � s zComposed.__add__c C s0 t |t�rt|�}nt |t�s&td��|�| �S )a| Return a new `!Composed` interposing the *joiner* with the `!Composed` items. The *joiner* must be a `SQL` or a string which will be interpreted as an `SQL`. Example:: >>> fields = sql.Identifier('foo') + sql.Identifier('bar') # a Composed >>> print(fields.join(', ').as_string(conn)) "foo", "bar" z3Composed.join() argument must be a string or an SQL)r r �SQLr r& )r Zjoinerr r r r& � s z Composed.join) r r r r r �propertyr" r r) r r& � __classcell__r r )r r r V s r c sD e Zd ZdZ� fdd�Zedd� �Zdd� Zdd � Zd d � Z � Z S ) r* aA A `Composable` representing a snippet of SQL statement. `!SQL` exposes `join()` and `format()` methods useful to create a template where to merge variable parts of a query (for instance field or table names). The *string* doesn't undergo any form of escaping, so it is not suitable to represent variable identifiers or values: you should only use it to pass constant strings representing templates or snippets of SQL statements; use other objects such as `Identifier` or `Literal` to represent variable parts. Example:: >>> query = sql.SQL("select {0} from {1}").format( ... sql.SQL(', ').join([sql.Identifier('foo'), sql.Identifier('bar')]), ... sql.Identifier('table')) >>> print(query.as_string(conn)) select "foo", "bar" from "table" c s& t |t�std��tt| ��|� d S )NzSQL values must be strings)r r r r! r* r )r �string)r r r r � s z SQL.__init__c C s | j S )z(The string wrapped by the `!SQL` object.)r )r r r r r- � s z SQL.stringc C s | j S )N)r )r r r r r r � s z SQL.as_stringc O s� g }d}x�t �| j�D ]�\}}}}|r.td��|r:td��|rL|�t|�� |dkrVq|�� r�|rjtd��|�|t|� � d}q|s�|dkr�td��|�|| � |d7 }q|�|| � qW t|�S )a^ Merge `Composable` objects into a template. :param `Composable` args: parameters to replace to numbered (``{0}``, ``{1}``) or auto-numbered (``{}``) placeholders :param `Composable` kwargs: parameters to replace to named (``{name}``) placeholders :return: the union of the `!SQL` string with placeholders replaced :rtype: `Composed` The method is similar to the Python `str.format()` method: the string template supports auto-numbered (``{}``), numbered (``{0}``, ``{1}``...), and named placeholders (``{name}``), with positional arguments replacing the numbered placeholders and keywords replacing the named ones. However placeholder modifiers (``{0!r}``, ``{0:<10}``) are not supported. Only `!Composable` objects can be passed to the template. Example:: >>> print(sql.SQL("select * from {} where {} = %s") ... .format(sql.Identifier('people'), sql.Identifier('id')) ... .as_string(conn)) select * from "people" where "id" = %s >>> print(sql.SQL("select * from {tbl} where {pkey} = %s") ... .format(tbl=sql.Identifier('people'), pkey=sql.Identifier('id')) ... .as_string(conn)) select * from "people" where "id" = %s r z(no format specification supported by SQLz%no format conversion supported by SQLNz6cannot switch from automatic field numbering to manualz6cannot switch from manual field numbering to automatic� ) � _formatter�parser � ValueErrorr r* �isdigit�intr ) r �args�kwargsr' ZautonumZpre�name�specZconvr r r �format� s2 z SQL.formatc C s^ g }t |�}y|�t|�� W n tk r2 Y n$X x |D ]}|�| � |�|� q:W t|�S )a Join a sequence of `Composable`. :param seq: the elements to join. :type seq: iterable of `!Composable` Use the `!SQL` object's *string* to separate the elements in *seq*. Note that `Composed` objects are iterable too, so they can be used as argument for this method. Example:: >>> snip = sql.SQL(', ').join( ... sql.Identifier(n) for n in ['foo', 'bar', 'baz']) >>> print(snip.as_string(conn)) "foo", "bar", "baz" )r( r �next� StopIterationr )r r" r' �itr# r r r r& s zSQL.join) r r r r r r+ r- r r8 r& r, r r )r r r* � s @r* c sH e Zd ZdZ� fdd�Zedd� �Zedd� �Zdd � Zd d � Z � Z S ) � Identifiera* A `Composable` representing an SQL identifier or a dot-separated sequence. Identifiers usually represent names of database objects, such as tables or fields. PostgreSQL identifiers follow `different rules`__ than SQL string literals for escaping (e.g. they use double quotes instead of single). .. __: https://www.postgresql.org/docs/current/static/sql-syntax-lexical.html# SQL-SYNTAX-IDENTIFIERS Example:: >>> t1 = sql.Identifier("foo") >>> t2 = sql.Identifier("ba'r") >>> t3 = sql.Identifier('ba"z') >>> print(sql.SQL(', ').join([t1, t2, t3]).as_string(conn)) "foo", "ba'r", "ba""z" Multiple strings can be passed to the object to represent a qualified name, i.e. a dot-separated sequence of identifiers. Example:: >>> query = sql.SQL("select {} from {}").format( ... sql.Identifier("table", "field"), ... sql.Identifier("schema", "table")) >>> print(query.as_string(conn)) select "table"."field" from "schema"."table" c s@ |s t d��x |D ]}t|t�st d��qW tt| ��|� d S )NzIdentifier cannot be emptyz$SQL identifier parts must be strings)r r r r! r< r )r �strings�s)r r r r A s zIdentifier.__init__c C s | j S )z5A tuple with the strings wrapped by the `Identifier`.)r )r r r r r= K s zIdentifier.stringsc C s$ t | j�dkr| jd S td��dS )z0The string wrapped by the `Identifier`. r. r z2the Identifier wraps more than one than one stringN)�lenr �AttributeError)r r r r r- P s zIdentifier.stringc C s d| j jd�tt| j��f S )Nz%s(%s)z, )r r r& �map�reprr )r r r r r Z s zIdentifier.__repr__c s d� � fdd�| jD ��S )N�.c 3 s | ]}t �|� �V qd S )N)�extZ quote_ident)�.0r> )r r r � <genexpr>` s z'Identifier.as_string.<locals>.<genexpr>)r& r )r r r )r r r _ s zIdentifier.as_string) r r r r r r+ r= r- r r r, r r )r r r< " s r< c @ s$ e Zd ZdZedd� �Zdd� ZdS )�Literala� A `Composable` representing an SQL value to include in a query. Usually you will want to include placeholders in the query and pass values as `~cursor.execute()` arguments. If however you really really need to include a literal value in the query you can use this object. The string returned by `!as_string()` follows the normal :ref:`adaptation rules <python-types-adaptation>` for Python objects. Example:: >>> s1 = sql.Literal("foo") >>> s2 = sql.Literal("ba'r") >>> s3 = sql.Literal(42) >>> print(sql.SQL(', ').join([s1, s2, s3]).as_string(conn)) 'foo', 'ba''r', 42 c C s | j S )z%The object wrapped by the `!Literal`.)r )r r r r r w s zLiteral.wrappedc C sz t |tj�r|}n t |tj�r&|j}ntd��t�| j�}t|d�rN|�|� |� � }t rvt |t �rv|� tj |j �}|S )Nz(context must be a connection or a cursor�prepare)r rD Z connectionZcursorr Zadaptr �hasattrrH Z getquotedr �bytes�decodeZ encodings�encoding)r r Zconn�ar' r r r r | s zLiteral.as_stringN)r r r r r+ r r r r r r rG c s rG c s> e Zd ZdZd � fdd� Zedd� �Zdd� Zd d � Z� Z S ) � Placeholdera� A `Composable` representing a placeholder for query parameters. If the name is specified, generate a named placeholder (e.g. ``%(name)s``), otherwise generate a positional placeholder (e.g. ``%s``). The object is useful to generate SQL queries with a variable number of arguments. Examples:: >>> names = ['foo', 'bar', 'baz'] >>> q1 = sql.SQL("insert into table ({}) values ({})").format( ... sql.SQL(', ').join(map(sql.Identifier, names)), ... sql.SQL(', ').join(sql.Placeholder() * len(names))) >>> print(q1.as_string(conn)) insert into table ("foo", "bar", "baz") values (%s, %s, %s) >>> q2 = sql.SQL("insert into table ({}) values ({})").format( ... sql.SQL(', ').join(map(sql.Identifier, names)), ... sql.SQL(', ').join(map(sql.Placeholder, names))) >>> print(q2.as_string(conn)) insert into table ("foo", "bar", "baz") values (%(foo)s, %(bar)s, %(baz)s) Nc sH t |t�r d|kr4td| ��n|d k r4td| ��tt| ��|� d S )N�)zinvalid name: %rz'expected string or None as name, got %r)r r r1 r r! rN r )r r6 )r r r r � s zPlaceholder.__init__c C s | j S )z The name of the `!Placeholder`.)r )r r r r r6 � s zPlaceholder.namec C s d| j d k r| j ndf S )NzPlaceholder(%r)r% )r )r r r r r � s zPlaceholder.__repr__c C s | j d k rd| j S dS d S )Nz%%(%s)sz%s)r )r r r r r r � s zPlaceholder.as_string)N) r r r r r r+ r6 r r r, r r )r r rN � s rN �NULL�DEFAULT)r r- Zpsycopg2r rD Zpsycopg2.compatr r � Formatterr/ �objectr r r* r< rG rN rP rQ r r r r �<module> s 3I A-6