YtjJdZddlmZddlZddlZddlmZmZddlm Z m Z ddl m Z m Z mZddlmZdd lmZdd lmZdd lmZmZdd lmZdd lmZd&d'dZGddeZGddeZGddeZGddeZGddeZ Gdd eZ!ed!Z"ed"Z#d&d'd#Z$d&d(d%Z%dS))z SQL composition utility module ) annotationsN)ABCabstractmethod)Anyoverload)IterableIteratorSequence)Escaping) AdaptContext)PyFormat) LiteralStringTemplate) conn_encoding) TransformerobjrcontextAdaptContext | NonereturnstrcFt||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)rrs I/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/psycopg/sql.pyquoters 3<< ! !' * **cfeZdZdZddZddZeddd Zddd ZddZ ddZ ddZ ddZ dS) 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. rrc||_dSN_obj)selfrs r__init__zComposable.__init__6s  rrrc0|jjd|jdS)N()) __class____name__r#r$s r__repr__zComposable.__repr__9s .)::DI::::rNrrbytesct)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 "!rc t|r|jnd}t||x}tr||St 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 isinstancer1r-decodecodecslookup)r$rencbs rrzComposable.as_stringKsv'CG..tDD DMM'222qU ; ; 388C== =%%,,Q//2 2rotherComposedct|trt|g|zSt|tr!t|gt|gzStSr!)r4r;rNotImplementedr$r:s r__add__zComposable.__add__Zs` eX & & ,TF##e+ + eZ ( ( "TF##hw&7&77 7! !rnintc(t|g|zSr!)r;)r$r@s r__mul__zComposable.__mul__bs ###rboolc^t|t|uo|j|jkSr!)typer#r>s r__eq__zComposable.__eq__es'DzzT%[[(DTY%*-DDrc.|| Sr!)rGr>s r__ne__zComposable.__ne__hs;;u%%%%r)rrrrr!rrrr-rrrrr:rrr;)r@rArr;)r:rrrD) r* __module__ __qualname____doc__r%r,rr1rr?rCrGrIrrrr's  ;;;; " " " "^ " 3 3 3 3 3""""$$$$EEEE&&&&&&rrcReZdZUdZded<dfd Zddd ZddZddZddZ xZ S)r;a. 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#seq Sequence[Any]cbd|D}t|dS)NcZg|](}t|tr|nt|)SrQ)r4rr).0rs r z%Composed.__init__..s1SSSjj11Cssws||SSSr)superr%)r$rSr)s rr%zComposed.__init__s4SSsSSS rNrrrr-cPdfd|jDS)Nrc3BK|]}|VdSr!r1)rWrrs r z$Composed.as_bytes..s/CC# W--CCCCCCr)joinr#r0s `rr1zComposed.as_bytess,xxCCCCCCCCCCrIterator[Composable]c*t|jSr!)iterr#r+s r__iter__zComposed.__iter__sDIrr:rct|trt|j|jzSt|trt|j|gzStSr!)r4r;r#rr=r>s rr?zComposed.__add__sZ eX & & 4DI 233 3 eZ ( ( "DI/00 0! !rjoinerSQL | LiteralStringct|trt|}n(t|tstd|d||jS)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)r4rSQL TypeErrorr^r#)r$rds rr^z Composed.joinst fc " " [[FFFC(( ++++  {{49%%%r)rSrTr!rK)rr_rM)rdrerr;) r*rNrOrP__annotations__r%r1rbr?r^ __classcell__r)s@rr;r;ls.DDDDD""""&&&&&&&&rr;ceZdZUdZded<ejZdfd Zddd Z ddd Z ddZ e d dZ e d!dZ d"dZ xZS)#rha 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#rct|t|tst d|ddS)Nz SQL values must be strings, got rg)rYr%r4rri)r$rr)s rr%z SQL.__init__sT #s## PNsNNNOO O P PrNrrrrc|jSr!r"r0s rrz SQL.as_strings yrr-cj|r|jnd}t|}|j|Sr!)r3rr#encoder$rconnr8s rr1z SQL.as_bytess7%,6w!!$D!!y$$$rargsrkwargsr;cFg}d}|j|jD]\}}}}|rtd|rtd|r"|t ||P|r<|rtd||t|d}|s2|td||||dz }|||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# ValueErrorappendrhisdigitrAr;) r$rtrurvautonumprenamespecconvs rformatz SQL.formatsQF "&*_%:%:49%E%E ( ( !CtT M !KLLL J !HIII $ #c((###|||~~ ($P $s4yy/*** (?$P $w-(((1  &,''''||rrSIterable[Template]rcdSr!rQr$rSs rr^zSQL.join$s9<r Iterable[Any]cdSr!rQrs rr^zSQL.join's47CrComposed | Templatect|} t|}n#t$rtgcYSwxYwt |t rt |}|D]j}t |t s$tdt|j | |j | |kt |S|g}|D]e}t |t r$tdt|j | || |ft|S)a Join a sequence of `Composable`. :param seq: the elements to join. Use the `!SQL` object's string to separate the elements in `!seq`. Elements that are not `Composable` will be considered `Literal`. If the arguments are `Template` instance, return a `Template` joining all the items. Note that arguments must either be all templates or none should be. 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" zcan't mix Template and ) ranext StopIterationr;r4rlistrirFr*rzr#extend)r$rSitfirstitemstcsis rr^zSQL.join*sT0#YY HHEE   B<<     eX & & $KKE  !!X..R#$Pd1gg>N$P$PQQQ TY''' QU# #W  A!X&& N L$q'':J L LMMM IIdOOO IIaLLLL||s !==)rrr!rLrK)rtrrurrr;)rSrrr)rSrrr;)rSrrr)r*rNrOrPrjstring Formatterrwr%rr1rrr^rkrls@rrhrhs4!!##JPPPPPP %%%%% FFFFP<<<X< 777X7........rrhcJeZdZUdZded<dfd ZddZddd ZddZxZ 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#stringsrct||std|D]*}t|tstd|d+dS)NzIdentifier cannot be emptyz*SQL identifier parts must be strings, got rg)rYr%rir4r)r$rsr)s rr%zIdentifier.__init__}s !!! :899 9  Aa%% NNNN   rrc||jjddtt|jdS)Nr', r()r)r*r^mapreprr#r+s rr,zIdentifier.__repr__s6.)NNDIIc$ 6J6J,K,KNNNNrNrrr-c|r|jndx}r8t|jt|fdjD}nfdjD}d|S)Nc`g|]*}|+SrQ)escape_identifierrq)rWrr8escs rrXz'Identifier.as_bytes..s1LLLQC))!((3--88LLLrc^g|])}|*SrQ)_escape_identifierrq)rWrr$s rrXz'Identifier.as_bytes..s/KKKAD++AHHJJ77KKKr.)r3r pgconnrr#r^)r$rrsescsr8rs` @@rr1zIdentifier.as_bytess*1;G&&t <4 L4;''C%%CLLLLL$)LLLDDKKKKKKKDyyrrc:d|ddzdzS)zK Approximation of PQescapeIdentifier taking no connection. "s"")replace)r$rs rrzIdentifier._escape_identifiers"aiie,,,t33r)rrrJr!rK)rr-rr-) r*rNrOrPrjr%r,r1rrkrls@rrr[s>      OOOO44444444rrceZdZdZdd dZdS) 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 Nrrrr-c^tj|}||jSr!)r from_context as_literalr#)r$rtxs rr1zLiteral.as_bytess&  %g . .}}TY'''rr!rK)r*rNrOrPr1rQrrrrs7((((((((rrcPeZdZdZdejfdfd Zdd Zddd ZdddZ 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) rrrstr | PyFormatct|t|tst d|d|vrt d|t |turt|}t|ts$t dt |j||_ dS)Nzexpected string as name, got r(zinvalid name: z!expected PyFormat as format, got ) rYr%r4rriryrFrr*_format)r$rrr)s rr%zPlaceholder.__init__s $$$ FDDDDEE E $;;6d6677 7 <<3  f%%F&(++ MDLL4IMM "( rrcg}|jr'|t|j|jtjur"|d|jj|jjdd |dS)Nzformat=r'rr() r#rzrrrAUTOrr)r*r^)r$partss rr,zPlaceholder.__repr__s 9 * LLdi ) ) ) `. 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)r4rrr _tstringsr)rrrs rrrs}&#z""7}}W}--- C " "7((((((yg&&&s||%%g%666rr-ct|tr||St|trddlm}|||St ||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 r\)r4rr1rrr)rrr1s rr1r1s}#z""6||G|,,, C " "6''''''xW%%%s||$$W$555rr!)rrrrrr)rrrrrr-)&rP __future__rr6rabcrrtypingrrcollections.abcrr r pqr r _enumsr_compatrr _encodingsr _transformerrrrr;rhrrrrrrr1rQrrrs #""""" ######## 8888888888,,,,,,,,%%%%%%%%%%%% + + + + + B&B&B&B&B&B&B&B&JB&B&B&B&B&zB&B&B&Jggggg*gggT?4?4?4?4?4?4?4?4D(((((j(((4=3=3=3=3=3*=3=3=3B s6{{ #i..77777:6666666r