ó º9—^c@sädZddlZddlmZddlmZmZejƒZ de fd„ƒYZ de fd„ƒYZ d e fd „ƒYZ d e fd „ƒYZd e fd„ƒYZde fd„ƒYZe dƒZe dƒZdS(sSQL composition utility module iÿÿÿÿN(t extensions(tPY3t string_typest ComposablecBsMeZdZd„Zd„Zd„Zd„Zd„Zd„Zd„Z RS(s6 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. cCs ||_dS(N(t_wrapped(tselftwrapped((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyt__init__1scCsd|jj|jfS(Ns%s(%r)(t __class__t__name__R(R((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyt__repr__4scCs t‚dS(sj 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(tNotImplementedError(Rtcontext((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyt as_string7s cCsQt|tƒr t|gƒ|St|tƒrIt|gƒt|gƒStSdS(N(t isinstancetComposedRtNotImplemented(Rtother((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyt__add__Ds cCst|g|ƒS(N(R(Rtn((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyt__mul__LscCs(t|ƒt|ƒko'|j|jkS(N(ttypeR(RR((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyt__eq__OscCs|j|ƒ S(N(R(RR((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyt__ne__Rs( R t __module__t__doc__RR R RRRR(((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR#s      RcBsJeZdZd„Zed„ƒZd„Zd„Zd„Zd„Z RS(s 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). cCs`g}x=|D]5}t|tƒs5td|ƒ‚n|j|ƒq Wtt|ƒj|ƒdS(Ns4Composed elements must be Composable, got %r instead(RRt TypeErrortappendtsuperRR(RtseqRti((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyRhs cCs t|jƒS(s+The list of the content of the `!Composed`.(tlistR(R((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyRrscCs=g}x'|jD]}|j|j|ƒƒqWdj|ƒS(Nt(RRR tjoin(RR trvR((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR wscCs t|jƒS(N(titerR(R((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyt__iter__}scCsNt|tƒr#t|j|jƒSt|tƒrFt|j|gƒStSdS(N(RRRRR(RR((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR€s cCsIt|tƒrt|ƒ}nt|tƒs<tdƒ‚n|j|ƒS(s| 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" s3Composed.join() argument must be a string or an SQL(RRtSQLRR!(Rtjoiner((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR!ˆs  ( R RRRtpropertyRR R$RR!(((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyRVs    R%cBsAeZdZd„Zed„ƒZd„Zd„Zd„ZRS(sA 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" cCs8t|tƒstdƒ‚ntt|ƒj|ƒdS(NsSQL values must be strings(RRRRR%R(Rtstring((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyRµscCs|jS(s(The string wrapped by the `!SQL` object.(R(R((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR(ºscCs|jS(N(R(RR ((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR ¿sc Os(g}d}xtj|jƒD]û\}}}}|rFtdƒ‚n|r[tdƒ‚n|rw|jt|ƒƒn|dkr‰qn|jƒrÊ|rªtdƒ‚n|j|t|ƒƒd}q|s |dkrëtdƒ‚n|j||ƒ|d7}q|j||ƒqWt |ƒS(s^ 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 is(no format specification supported by SQLs%no format conversion supported by SQLs6cannot switch from automatic field numbering to manuals6cannot switch from manual field numbering to automaticiN( t _formattertparseRt ValueErrorRR%tNonetisdigittintR( RtargstkwargsR"tautonumtpretnametspectconv((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pytformatÂs2 %       cCsrg}t|ƒ}y|jt|ƒƒWntk r<n,Xx(|D] }|j|ƒ|j|ƒqDWt|ƒS(s 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#Rtnextt StopIterationR(RRR"titR((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR!s    ( R RRRR'R(R R6R!(((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR%Ÿs    @t IdentifiercBsGeZdZd„Zed„ƒZed„ƒZd„Zd„ZRS(s* 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" cGs^|stdƒ‚nx,|D]$}t|tƒstdƒ‚qqWtt|ƒj|ƒdS(NsIdentifier cannot be emptys$SQL identifier parts must be strings(RRRRR:R(Rtstringsts((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyRAs  cCs|jS(s5A tuple with the strings wrapped by the `Identifier`.(R(R((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR;KscCs0t|jƒdkr |jdStdƒ‚dS(s0The string wrapped by the `Identifier`. iis2the Identifier wraps more than one than one stringN(tlenRtAttributeError(R((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR(Ps cCs)d|jjdjtt|jƒƒfS(Ns%s(%s)s, (RR R!tmaptreprR(R((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR Zs cs dj‡fd†|jDƒƒS(Nt.c3s!|]}tj|ˆƒVqdS(N(textt quote_ident(t.0R<(R (s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pys `s(R!R(RR ((R s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR _s( R RRRR'R;R(R R (((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR:"s   tLiteralcBs&eZdZed„ƒZd„ZRS(sˆ 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 ` 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 cCs|jS(s%The object wrapped by the `!Literal`.(R(R((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyRwscCs·t|tjƒr|}n*t|tjƒr9|j}n tdƒ‚tj|jƒ}t|dƒrv|j|ƒn|j ƒ}t r³t|t ƒr³|j tj |jƒ}n|S(Ns(context must be a connection or a cursortprepare(RRBt connectiontcursorRtadaptRthasattrRFt getquotedRtbytestdecodet encodingstencoding(RR tconntaR"((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR |s    (R RRR'RR (((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyREcst PlaceholdercBs;eZdZdd„Zed„ƒZd„Zd„ZRS(sã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) cCsjt|tƒr1d|krPtd|ƒ‚qPn|dk rPtd|ƒ‚ntt|ƒj|ƒdS(Nt)sinvalid name: %rs'expected string or None as name, got %r(RRR+R,RRRRR(RR3((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR«s   cCs|jS(sThe name of the `!Placeholder`.(R(R((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR3µscCs#d|jdk r|jndfS(NsPlaceholder(%r)R (RR,(R((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR ºscCs"|jdk rd|jSdSdS(Ns%%(%s)ss%s(RR,(RR ((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyR ¾s N( R RRR,RR'R3R R (((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyRRs   tNULLtDEFAULT(RR(tpsycopg2RRBtpsycopg2.compatRRt FormatterR)tobjectRRR%R:RERRRTRU(((s./tmp/pip-unpacked-wheel-WyN9Ij/psycopg2/sql.pyts  3IƒA-6