U (¬Þa7:ã@s¤dZddlZddlmZddlmZmZe ¡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 ú{/home/adriano.carvalho/ftp/files/BrinquedotecaVirtual/brinquedotecavirtual/venv/lib/python3.8/site-packages/psycopg2/sql.pyÚ__init__2szComposable.__init__cCsd|jj|jfS)Nz%s(%r))Ú __class__Ú__name__r©r r 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ƒStSdSr)Ú isinstanceÚComposedrÚNotImplemented©r Úotherr r r Ú__add__Es   zComposable.__add__cCst|g|ƒSr)r)r Únr r r Ú__mul__MszComposable.__mul__cCst|ƒt|ƒko|j|jkSr)Útyperrr r r Ú__eq__PszComposable.__eq__cCs | |¡ Sr)rrr r r Ú__ne__SszComposable.__ne__N) rÚ __module__Ú __qualname__Ú__doc__r rrrrrr r 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). csBg}|D]$}t|tƒs"td|ƒ‚| |¡qtt|ƒ |¡dS)Nz4Composed elements must be Composable, got %r instead)rrÚ TypeErrorÚappendÚsuperrr )r Úseqr Úi©rr r r is ÿ zComposed.__init__cCs t|jƒS)z+The list of the content of the `!Composed`.)Úlistrrr r r r'ssz Composed.seqcCs*g}|jD]}| | |¡¡q d |¡S)NÚ)rr%rÚjoin)r rÚrvr(r r r rxs zComposed.as_stringcCs t|jƒSr)Úiterrrr r r Ú__iter__~szComposed.__iter__cCs<t|tƒrt|j|jƒSt|tƒr4t|j|gƒStSdSr)rrrrrrr r r rs   zComposed.__add__cCs0t|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)rrÚSQLr$r,)r Zjoinerr r r r,‰s   ÿz Composed.join) rr!r"r#r Úpropertyr'rr/rr,Ú __classcell__r r r)r rWs  rcsDeZdZdZ‡fdd„Zedd„ƒZdd„Zdd „Zd d „Z ‡Z S) r0aA 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|ƒ |¡dS)NzSQL values must be strings)rrr$r&r0r )r Ústringr)r r r ¶s z SQL.__init__cCs|jS)z(The string wrapped by the `!SQL` object.rrr r r r3»sz SQL.stringcCs|jSrrrr r r rÀsz SQL.as_stringc OsÄg}d}t |j¡D]¦\}}}}|r,tdƒ‚|r8tdƒ‚|rJ| t|ƒ¡|dkrTq| ¡r€|rhtdƒ‚| |t|ƒ¡d}q|s¬|dkr”tdƒ‚| ||¡|d7}q| ||¡qt|ƒ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%r0ÚisdigitÚintr) r ÚargsÚkwargsr-ZautonumÚpreÚnameÚspecÚconvr r r ÚformatÃs6 ÿÿ z SQL.formatcCsZg}t|ƒ}z| t|ƒ¡Wntk r2Yn X|D]}| |¡| |¡q8t|ƒ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) rr!r"r#r r1r3rr@r,r2r r r)r r0 s  @r0csHeZdZdZ‡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ƒ‚|D]}t|tƒstdƒ‚qtt|ƒ |¡dS)NzIdentifier cannot be emptyz$SQL identifier parts must be strings)r$rrr&rDr )r ÚstringsÚsr)r r r Bs   zIdentifier.__init__cCs|jS)z5A tuple with the strings wrapped by the `Identifier`.rrr r r rELszIdentifier.stringscCs$t|jƒdkr|jdStdƒ‚dS)z0The string wrapped by the `Identifier`. r4rz2the Identifier wraps more than one than one stringN)ÚlenrÚAttributeErrorrr r r r3Qs  ÿzIdentifier.stringcCsd|jjd tt|jƒ¡fS)Nz%s(%s)z, )rrr,ÚmapÚreprrrr r r r[sþzIdentifier.__repr__csd ‡fdd„|jDƒ¡S)NÚ.c3s|]}t |ˆ¡VqdSr)ÚextZ quote_ident)Ú.0rF©rr r Ú asz'Identifier.as_string..)r,rrr rNr r`szIdentifier.as_string) rr!r"r#r r1rEr3rrr2r r r)r rD#s   rDc@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`.rrr r r r xszLiteral.wrappedcCszt|tjƒr|}nt|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)rrLÚ connectionÚcursorr$ZadaptrÚhasattrrQZ getquotedrÚbytesÚdecodeÚ encodingsÚencoding)r rÚconnÚar-r r r r}s     zLiteral.as_stringN)rr!r"r#r1r rr r r r rPds rPcs>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|ƒ |¡dS)Nú)zinvalid name: %rz'expected string or None as name, got %r)rrr7r$r&r[r )r r=r)r r r ¬s   zPlaceholder.__init__cCs|jS)zThe name of the `!Placeholder`.rrr r r r=¶szPlaceholder.namecCsd|jdk r|jndfS)NzPlaceholder(%r)r+rrr r r r»sÿzPlaceholder.__repr__cCs|jdk rd|jSdSdS)Nz%%(%s)sz%srrr r r r¿s  zPlaceholder.as_string)N) rr!r"r#r r1r=rrr2r r r)r r[‘s   r[ÚNULLÚDEFAULT)r#r3Zpsycopg2rrLZpsycopg2.compatrrÚ Formatterr5Úobjectrrr0rDrPr[r]r^r r r r Ús 3IA-6