3  (ƒh7:ã@s¤dZddlZddlmZddlmZmZejƒZ Gdd„de ƒZ Gdd„de ƒZ Gd d „d e ƒZ Gd d „d e ƒZGd d„de ƒZGdd„de ƒZe dƒZe dƒZdS)zSQL composition utility module éN)Ú extensions)ÚPY3Ú string_typesc@sHeZdZdZdd„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. cCs ||_dS)N)Ú_wrapped)ÚselfÚwrapped©r ú9/tmp/pip-install-q3hcpn_q/psycopg2-binary/psycopg2/sql.pyÚ__init__2szComposable.__init__cCsd|jj|jfS)Nz%s(%r))Ú __class__Ú__name__r)rr r r Ú__repr__5szComposable.__repr__cCst‚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_string8s zComposable.as_stringcCs>t|tƒrt|gƒ|St|tƒr6t|gƒt|gƒStSdS)N)Ú isinstanceÚComposedrÚNotImplemented)rÚotherr r r Ú__add__Es   zComposable.__add__cCst|g|ƒS)N)r)rÚnr r r Ú__mul__MszComposable.__mul__cCst|ƒt|ƒko|j|jkS)N)Útyper)rrr r r Ú__eq__PszComposable.__eq__cCs |j|ƒ S)N)r)rrr r r Ú__ne__SszComposable.__ne__N) r Ú __module__Ú __qualname__Ú__doc__r rrrrrrr r r r r$s  rcsLeZdZdZ‡fdd„Zedd„ƒZdd„Zdd „Zd d „Z d d „Z ‡Z S)ra 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). csFg}x,|D]$}t|tƒs$td|ƒ‚|j|ƒq Wtt|ƒj|ƒdS)Nz4Composed elements must be Composable, got %r instead)rrÚ TypeErrorÚappendÚsuperrr )rÚseqrÚi)r r r r is   zComposed.__init__cCs t|jƒS)z+The list of the content of the `!Composed`.)Úlistr)rr r r r"ssz Composed.seqcCs.g}x|jD]}|j|j|ƒƒq Wdj|ƒS)NÚ)rr rÚjoin)rrÚrvr#r r r rxs zComposed.as_stringcCs t|jƒS)N)Úiterr)rr r r Ú__iter__~szComposed.__iter__cCs<t|tƒrt|j|jƒSt|tƒr4t|j|gƒStSdS)N)rrrrr)rrr r r rs   zComposed.__add__cCs0t|tƒrt|ƒ}nt|tƒs&tdƒ‚|j|ƒ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)rrÚSQLrr&)rZjoinerr r r r&‰s    z Composed.join) r rrrr Úpropertyr"rr)rr&Ú __classcell__r r )r r rWs rcsDeZdZdZ‡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" cs&t|tƒstdƒ‚tt|ƒj|ƒdS)NzSQL values must be strings)rrrr!r*r )rÚstring)r r r r ¶s z SQL.__init__cCs|jS)z(The string wrapped by the `!SQL` object.)r)rr r r r-»sz SQL.stringcCs|jS)N)r)rrr r r rÀsz SQL.as_stringc OsÈg}d}x¶tj|jƒD]¦\}}}}|r.tdƒ‚|r:tdƒ‚|rL|jt|ƒƒ|dkrVq|jƒr‚|rjtdƒ‚|j|t|ƒƒd}q|s®|dkr–tdƒ‚|j||ƒ|d7}q|j||ƒqWt|ƒ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 rz(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'ZautonumÚpreÚnameÚspecÚconvr r r ÚformatÃs2  z SQL.formatc Cs^g}t|ƒ}y|jt|ƒƒWntk r2Yn$Xx |D]}|j|ƒ|j|ƒq:Wt|ƒ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)rr"r'Úitr#r r r r&s  zSQL.join) r rrrr r+r-rr:r&r,r r )r r r* s   @r*csHeZdZdZ‡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" cs@|s tdƒ‚x|D]}t|tƒstdƒ‚qWtt|ƒj|ƒdS)NzIdentifier cannot be emptyz$SQL identifier parts must be strings)rrrr!r>r )rÚstringsÚs)r r r r Bs    zIdentifier.__init__cCs|jS)z5A tuple with the strings wrapped by the `Identifier`.)r)rr r r r?LszIdentifier.stringscCs$t|jƒdkr|jdStdƒ‚dS)z0The string wrapped by the `Identifier`. r.rz2the Identifier wraps more than one than one stringN)ÚlenrÚAttributeError)rr r r r-Qs zIdentifier.stringcCsd|jjdjtt|jƒƒfS)Nz%s(%s)z, )r r r&ÚmapÚreprr)rr r r r[szIdentifier.__repr__csdj‡fdd„|jDƒƒS)NÚ.c3s|]}tj|ˆƒVqdS)N)ÚextZ quote_ident)Ú.0r@)rr r ú asz'Identifier.as_string..)r&r)rrr )rr r`szIdentifier.as_string) r rrrr r+r?r-rrr,r r )r r r>#s   r>c@s$eZdZdZedd„ƒ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 ` 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)z%The object wrapped by the `!Literal`.)r)rr r r rxszLiteral.wrappedcCszt|tjƒr|}nt|tjƒr&|j}ntdƒ‚tj|jƒ}t|dƒrN|j|ƒ|j ƒ}t rvt|t ƒrv|j tj |jƒ}|S)Nz(context must be a connection or a cursorÚprepare)rrFÚ connectionÚcursorrZadaptrÚhasattrrJZ getquotedrÚbytesÚdecodeÚ encodingsÚencoding)rrÚconnÚar'r r r r}s     zLiteral.as_stringN)r rrrr+rrr r r r rIds rIcs>eZdZdZd ‡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) NcsHt|tƒr d|kr4td|ƒ‚n|dk r4td|ƒ‚tt|ƒj|ƒdS)Nú)zinvalid name: %rz'expected string or None as name, got %r)rrr1rr!rTr )rr7)r r r r ¬s   zPlaceholder.__init__cCs|jS)zThe name of the `!Placeholder`.)r)rr r r r7¶szPlaceholder.namecCsd|jdk r|jndfS)NzPlaceholder(%r)r%)r)rr r r r»szPlaceholder.__repr__cCs|jdk rd|jSdSdS)Nz%%(%s)sz%s)r)rrr r r r¿s  zPlaceholder.as_string)N) r rrrr r+r7rrr,r r )r r rT‘s  rTÚNULLÚDEFAULT)rr-Zpsycopg2rrFZpsycopg2.compatrrÚ Formatterr/Úobjectrrr*r>rIrTrVrWr r r r Ús 3IA-6