2iJfdZddlmZddlZddlZddlmZmZddlm Z m Z ddl m Z m Z mZddlmZdd lmZdd lmZdd lmZmZdd lmZdd lmZdd dZGddeZGddeZGddeZGddeZGddeZ GddeZ!edZ"edZ#dd dZ$dd!dZ%y)"z SQL composition utility module ) annotationsN)ABCabstractmethod)Anyoverload)IterableIteratorSequence)Escaping) AdaptContext)PyFormat) LiteralStringTemplate) conn_encoding) Transformerc6t|j|S)a Adapt a Python object to a quoted SQL string. Use this function only if you absolutely want to convert a Python string to an SQL quoted literal to use e.g. to generate batch SQL and you won't have a connection available when you will need to use it. This function is relatively inefficient, because it doesn't cache the adaptation rules. If you pass a `!context` you can adapt the adaptation rules used, otherwise only global rules are used. )Literal as_string)objcontexts J/var/www/html/secretsanta/venv/lib/python3.12/site-packages/psycopg/sql.pyquoters 3< ! !' **c^eZdZdZd dZd dZed ddZd ddZddZ ddZ dd Z dd Z y) ComposableaP Abstract base class for objects that can be used to compose an SQL 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. `!SQL` and `!Composed` objects can be passed directly to `~psycopg.Cursor.execute()`, `~psycopg.Cursor.executemany()`, `~psycopg.Cursor.copy()` in place of the query string. c||_yN_obj)selfrs r__init__zComposable.__init__6s  rcN|jjd|jdS)N()) __class____name__r r!s r__repr__zComposable.__repr__9s$..))*!DII=::rNct)a~ Return the value of the object as bytes. :param context: the context to evaluate the object into. :type context: `connection` or `cursor` The method is automatically invoked by `~psycopg.Cursor.execute()`, `~psycopg.Cursor.executemany()`, `~psycopg.Cursor.copy()` if a `!Composable` is passed instead of the query string. )NotImplementedErrorr!rs ras_byteszComposable.as_bytes<s "!rct|r |jnd}t|j|x}tr|j |St j|j |dS)z Return the value of the object as string. :param context: the context to evaluate the string into. :type context: `connection` or `cursor` Nr)r connection isinstancer-bytesdecodecodecslookup)r!rencbs rrzComposable.as_stringKs_'G..tD DMM'22qU ;88C= ==%,,Q/2 2rct|trt|g|zSt|trt|gt|gzStSr)r0ComposedrNotImplementedr!others r__add__zComposable.__add__ZsG eX &TF#e+ + eZ (TF#hw&77 7! !rc t|g|zSr)r8)r!ns r__mul__zComposable.__mul__bs ##rcdt|t|uxr|j|jk(Sr)typer r:s r__eq__zComposable.__eq__es'DzT%[(DTYY%**-DDrc&|j| Sr)rBr:s r__ne__zComposable.__ne__hs;;u%%%r)rrreturnstrrrAdaptContext | NonerFr1rrIrFrGr;rrFr8)r>intrFr8)r;rrFbool) r' __module__ __qualname____doc__r"r)rr-rr<r?rBrDrrrr's? ; " " 3"$E&rrcReZdZUdZded<d fd Zd d dZd dZd dZddZ xZ S)r8a. A `Composable` object made of a sequence of `!Composable`. The object is usually created using `!Composable` operators and methods (such as the `SQL.format()` method). `!Composed` objects can be passed directly to `~psycopg.Cursor.execute()`, `~psycopg.Cursor.executemany()`, `~psycopg.Cursor.copy()` in place of the query string. It is also possible to create a `!Composed` directly specifying a sequence of objects as arguments: if they are not `!Composable` they will be wrapped in a `Literal`. 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). zlist[Composable]r c|Dcgc]}t|tr|n t|!}}t||ycc}wr)r0rrsuperr")r!seqrr&s rr"zComposed.__init__s;ORSjj1sws|CSS Ts$<cLdjfd|jDS)Nrc3@K|]}|jywrr-).0rrs r z$Composed.as_bytes..sC# W-Cs)joinr r,s `rr-zComposed.as_bytessxxCCCCrc,t|jSr)iterr r(s r__iter__zComposed.__iter__sDIIrct|tr"t|j|jzSt|trt|j|gzStSr)r0r8r rr9r:s rr<zComposed.__add__sJ eX &DII 23 3 eZ (DII/0 0! !rct|tr t|}nt|tstd|d|j |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" z5Composed.join() argument must be strings or SQL, got  instead)r0rGSQL TypeErrorr[r )r!joiners rr[z Composed.joinsT fc "[FFC(z+  {{499%%r)rUz Sequence[Any]rrH)rFzIterator[Composable]rK)rdzSQL | LiteralStringrFr8) r'rNrOrP__annotations__r"r-r^r<r[ __classcell__r&s@rr8r8ls*. D"&rr8ceZdZUdZded<ej Zd fd Zd d dZ d ddZ ddZ e ddZ e dd Z dd Z xZS)rba 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 `!obj` 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. `!SQL` objects can be passed directly to `~psycopg.Cursor.execute()`, `~psycopg.Cursor.executemany()`, `~psycopg.Cursor.copy()` in place of the query string. 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" rr cbt||t|tst d|dy)Nz SQL values must be strings, got ra)rTr"r0rGrc)r!rr&s rr"z SQL.__init__s4 #s#>sgXNO O$rc|jSrrr,s rrz SQL.as_strings yyrcn|r |jnd}t|}|jj|Sr)r/rr encoder!rconnr5s rr-z SQL.as_bytess0%,w!!$D!yy$$rcg}d}|jj|jD]\}}}}|r td|r td|r|j t ||A|j r-|r td|j |t|d}~|s'| td|j |||dz }|j ||t|S)a Merge `Composable` objects into a template. :param args: parameters to replace to numbered (``{0}``, ``{1}``) or auto-numbered (``{}``) placeholders :param 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. If a `!Composable` objects is passed to the template it will be merged according to its `as_string()` method. If any other Python object is passed, it will be wrapped in a `Literal` object and so escaped according to SQL rules. 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 name = {name}") ... .format(tbl=sql.Identifier('people'), name="O'Rourke")) ... .as_string(conn)) SELECT * FROM "people" WHERE name = 'O''Rourke' 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 automaticr ) _formatterparser ValueErrorappendrbisdigitrLr8) r!argskwargsrvautonumprenamespecconvs rformatz SQL.formatsF "&*__%:%:499%E ( !CtT !KLL !HII #c(#|||~$P $s4y/*?$P $w-(1  &,'9 (<|rcyrrQr!rUs rr[zSQL.join$s9>> snip = sql.SQL(', ').join( ... sql.Identifier(n) for n in ['foo', 'bar', 'baz']) >>> print(snip.as_string(conn)) "foo", "bar", "baz" zcan't mix Template and ) r]next StopIterationr8r0rlistrcrAr'rsr extend)r!rUitfirstitemstcsis rr[zSQL.join*s 0#Y HE eX &KE !!X.#&=d1g>N>N=O$PQQ TYY' Q  U# #W A!X&"9$q':J:J9K LMM IIdO IIaL   |' B<  s DDD)rrrrJrH)rurrvrrFr8)rUzIterable[Template]rFr)rU Iterable[Any]rFr8)rUrrFzComposed | Template)r'rNrOrPrestring Formatterrpr"rr-r}rr[rfrgs@rrbrbsZ4 !!!#JP % FP<< 77.rrbcJeZdZUdZded<dfd Zd dZd d dZd dZxZ 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/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" z Sequence[str]r ct|||s td|D]!}t|trtd|dy)NzIdentifier cannot be emptyz*SQL identifier parts must be strings, got ra)rTr"rcr0rG)r!stringssr&s rr"zIdentifier.__init__}sQ !89 9 Aa%@XN rc|jjddjtt|j dS)Nr$, r%)r&r'r[mapreprr r(s rr)zIdentifier.__repr__s5..))*!DIIc$ 6J,K+LANNrcx|r |jndx}rXt|j}t|}|jDcgc]"}|j |j |$}}n6|jDcgc]!}|j|j #}}dj|Scc}wcc}w)N.) r/r pgconnrr escape_identifierrl_escape_identifierr[)r!rrnescr5rescss rr-zIdentifier.as_bytess*1G&&t <4 <4;;'C%CBF))LQC))!((3-8LDLAEKAD++AHHJ7KDKyyMKs 'B29&B7c2d|jddzdzS)zK Approximation of PQescapeIdentifier taking no connection. "s"")replace)r!rs rrzIdentifier._escape_identifiersaiie,,t33r)rrGrErrH)rr1rFr1) r'rNrOrPrer"r)r-rrfrgs@rrr[s%>  O4rrceZdZdZdddZy)ra 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("fo'o") >>> s2 = sql.Literal(42) >>> s3 = sql.Literal(date(2000, 1, 1)) >>> print(sql.SQL(', ').join([s1, s2, s3]).as_string(conn)) 'fo''o', 42, '2000-01-01'::date Ncbtj|}|j|jSr)r from_context as_literalr )r!rtxs rr-zLiteral.as_bytess%  % %g .}}TYY''rrrH)r'rNrOrPr-rQrrrrs ((rrcZeZdZdZdej fdfd ZddZd d dZd d dZ xZ S) Placeholdera A `Composable` representing a placeholder for query parameters. If the name is specified, generate a named placeholder (e.g. ``%(name)s``, ``%(name)b``), otherwise generate a positional placeholder (e.g. ``%s``, ``%b``). The object is useful to generate SQL queries with a variable number of arguments. Examples:: >>> names = ['foo', 'bar', 'baz'] >>> q1 = sql.SQL("INSERT INTO my_table ({}) VALUES ({})").format( ... sql.SQL(', ').join(map(sql.Identifier, names)), ... sql.SQL(', ').join(sql.Placeholder() * len(names))) >>> print(q1.as_string(conn)) INSERT INTO my_table ("foo", "bar", "baz") VALUES (%s, %s, %s) >>> q2 = sql.SQL("INSERT INTO my_table ({}) VALUES ({})").format( ... sql.SQL(', ').join(map(sql.Identifier, names)), ... sql.SQL(', ').join(map(sql.Placeholder, names))) >>> print(q2.as_string(conn)) INSERT INTO my_table ("foo", "bar", "baz") VALUES (%(foo)s, %(bar)s, %(baz)s) c,t||t|tst d|d|vrt d|t |tur t|}t|ts!t dt |j||_ y)Nzexpected string as name, got r%zinvalid name: z!expected PyFormat as format, got ) rTr"r0rGrcrrrArr'_format)r!rzr}r&s rr"zPlaceholder.__init__s $$;D8DE E $;~dX67 7 <3 f%F&(+3DL4I4I3LM "( rcDg}|jr$|jt|j|jtj ur(|jd|jj |jjddj|dS)Nzformat=r$rr%) r rsrrrAUTOrzr&r'r[)r!partss rr)zPlaceholder.__repr__sx 99 LLdii ) <`. If `!context` is specified then it is be used to customize the conversion. for example using the encoding of a connection or the dumpers registered. rr )r)r0rrr _tstringsr)rrrs rrrsQ&#z"}}W}-- C "(g&&s|%%g%66rct|tr|j|St|trddlm}|||St |j|S)aConvert an object to a bytes string according to SQL rules. :param obj: the object to convert :param context: the context in which to convert the object :type context: `~psycopg.abc.AdaptContext` | `!None` See `as_string()` for details. rr rX)r0rr-rrr)rrr-s rr-r-sQ#z"||G|,, C "'W%%s|$$W$55rr)rrrrIrFrG)rrrrIrFr1)&rP __future__rr3rabcrrtypingrrcollections.abcrr r pqr r _enumsr_compatrr _encodingsr _transformerrrrr8rbrrrrrrr-rQrrrs # # 88,%% + B&B&JB&zB&Jg*gT?4?4D(j(4=3*=3B 6{ i.7:6r