(ph:?FSrSSKJr SSKrSSKrSSKJrJr SSKJ r J r J r J r SSK Jr SSKJr SS KJr SS KJr SS KJr SS KJr SSS jjr"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r"SS\5r\"S5r\"S5r g)z SQL composition utility module ) annotationsN)ABCabstractmethod)AnyIteratorIterableSequence)Escaping) AdaptContext)PyFormat) LiteralString) conn_encoding) Transformerc6[U5RU5$)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 >/var/www/html/venv/lib/python3.13/site-packages/psycopg/sql.pyquoters 3< ! !' **cz\rSrSrSrS SjrSSjr\SSSjj5rSSSjjr SSjr SS jr SS jr SS jr S rg) Composable&a Abstract base class for objects that can be used to compose an SQL string. `!Composable` objects can be passed directly to `~psycopg.Cursor.execute()`, `~psycopg.Cursor.executemany()`, `~psycopg.Cursor.copy()` 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. cXlgN_obj)selfrs r__init__Composable.__init__5s rcPURRSUR<S3$)N()) __class____name__rr s r__repr__Composable.__repr__8s$..))*!DII=::rNc[e)aF 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_bytesComposable.as_bytes;s "!rcU(a UROSn[U5nURU5n[U[5(aUR U5$[ R"U5R U5S$)z Return the value of the object as string. :param context: the context to evaluate the string into. :type context: `connection` or `cursor` Nr) connectionrr. isinstancebytesdecodecodecslookup)r rconnencbs rrComposable.as_stringJsg&-w!!$D! MM' " a  88C= ==%,,Q/2 2rc[U[5(a[U/5U-$[U[5(a[U/5[U/5-$[$r)r2ComposedrNotImplementedr others r__add__Composable.__add__[sM eX & &TF#e+ + eZ ( (TF#hw&77 7! !rc [U/U-5$r)r<)r ns r__mul__Composable.__mul__cs ##rcn[U5[U5L=(a URUR:H$r)typerr>s r__eq__Composable.__eq__fs'DzT%[(DTYY%**-DDrc.URU5(+$r)rHr>s r__ne__Composable.__ne__is;;u%%%rr)rrreturnstrrrAdaptContext | NonerNr3rrQrNrOr?rrNr<)rCintrNr<)r?rrNbool)r' __module__ __qualname____firstlineno____doc__r!r)rr.rr@rDrHrK__static_attributes__rrrr&s? ; " "3""$E&rrch^\rSrSr%SrS\S'S U4SjjrS S SjjrSSjrSSjr SS jr S r U=r $)r<ma) 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 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]rc>UVs/sH%n[U[5(aUO [U5PM' nn[TU]U5 gs snfr)r2rrsuperr!)r seqrr&s rr!Composed.__init__s?ORSsjj11sws|CsS Ts,AcN^SRU4SjUR55$)Nrc3D># UHoRT5v M g7fr)r.).0rrs r $Composed.as_bytes..sC# W--s )joinrr-s `rr.Composed.as_bytessxxCCCCrc,[UR5$r)iterrr(s r__iter__Composed.__iter__sDIIrc[U[5(a"[URUR-5$[U[5(a[URU/-5$[$r)r2r<rrr=r>s rr@Composed.__add__sP eX & &DII 23 3 eZ ( (DII/0 0! !rc[U[5(a [U5nO%[U[5(d[SU<S35eUR UR 5$)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)r2rOSQL TypeErrorrgr)r joiners rrg Composed.joinsZ fc " "[FFC((z+  {{499%%rr[)r`z Sequence[Any]rrP)rNzIterator[Composable]rS)rszSQL | LiteralStringrNr<) r'rVrWrXrY__annotations__r!r.rkr@rgrZ __classcell__r&s@rr<r<ms/& D"&&rr<c^\rSrSr%SrS\S'\R"5rS U4Sjjr S S Sjjr S SSjjr SSjr SS jr S rU=r$)rqa 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. 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" rrcn>[TU]U5 [U[5(d[ SU<S35eg)Nz SQL values must be strings, got rp)r_r!r2rOrr)r rr&s rr! SQL.__init__s7 #s##>sgXNO O$rcUR$rrr-s rr SQL.as_strings yyrcxU(a UROSn[U5nURRU5$r)r1rrencoder rr7r8s rr. SQL.as_bytess0%,w!!$D!yy$$rc&/nSnURRUR5HupVpxU(a [S5eU(a [S5eU(aUR [ U55 UcMPUR 5(a3U(a [S5eUR U[U55 SnMU(d(Uc [S5eUR X5 US- nMUR X&5 M [U5$)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 ValueErrorappendrqisdigitrTr<) r argskwargsrvautonumprenamespecconvs rformat SQL.formatsF "&*__%:%:499%E !Ct !KLL !HII #c(#|||~~$P $s4y/*?$P $-(1  &,'9&F<|rc/n[U5nUR[U55 UH%nURU5 URU5 M' [ U5$![a Nf=f)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" )rjrnext StopIterationr<)r r`ritis rrgSQL.joinsi$ #Y  IId2h  $ ! |   sA A,+A,r[)rrrrRrP)rrrrrNr<)r`zIterable[Composable]rNr<)r'rVrWrXrYrustring Formatterrr!rr.rrgrZrvrws@rrqrqs?, !!#JP % FPrrqc^^\rSrSr%SrS\S'S U4SjjrS SjrS S SjjrSSjr S r U=r $) Identifieri=a 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]rc>[TU]U5 U(d [S5eUH(n[U[5(aM[SU<S35e g)NzIdentifier cannot be emptyz*SQL identifier parts must be strings, got rp)r_r!rrr2rO)r stringssr&s rr!Identifier.__init___sO !89 9Aa%%@XNrcURRSSR[[UR 55S3$)Nr$, r%)r&r'rgmapreprrr(s rr)Identifier.__repr__ls5..))*!DIIc$ 6J,K+LANNrcU(a UROSnU(aZ[UR5n[U5nURVs/sH"oSR UR U55PM$ nnO8URVs/sH!oPRUR 55PM# nnSRU5$s snfs snf)N.) r1r pgconnrrescape_identifierr_escape_identifierrg)r rr7escr8rescss rr.Identifier.as_bytesos%,w!!$ 4;;'C%CBF))L)Q))!((3-8)DLDAEKA++AHHJ7DKyyMKs )C(Cc2SURSS5-S-$)z; Approximation of PQescapeIdentifier taking no connection. "s"")replace)r rs rrIdentifier._escape_identifierysaiie,,t33rr[)rrOrMrrP)rr3rNr3) r'rVrWrXrYrur!r)r.rrZrvrws@rrr=s*>  O44rrc&\rSrSrSrSSSjjrSrg)riae 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 Ncd[R"U5nURUR5$r)r from_context as_literalr)r rtxs rr.Literal.as_bytess%  % %g .}}TYY''rr[rrP)r'rVrWrXrYr.rZr[rrrrs(((rrcr^\rSrSrSrS\R 4S U4SjjjrS SjrS S Sjjr S S Sjjr Sr U=r $) PlaceholderiaA `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) cJ>[TU]U5 [U[5(d[ SU<35eSU;a[ SU<35e[ U5[La [U5n[U[5(d"[ S[ U5R<35eX l g)Nzexpected string as name, got r%zinvalid name: z!expected PyFormat as format, got ) r_r!r2rOrrrrGr r'_format)r rrr&s rr!Placeholder.__init__s $$$;D8DE E $;~dX67 7 <3 f%F&(++3DL4I4I3LM "( rcP/nUR(a$UR[UR55 UR[R La(URSURR 35 URRSSRU5S3$)Nzformat=r$rr%) rrrrr AUTOrr&r'rg)r partss rr)Placeholder.__repr__sx 99 LLdii ) <rs # #44"%% + D&D&N>&z>&BL*L^@4@4F(j(4=3*=3B 6{ i.r