9h9SrSSKrSSKJr \R "5r"SS5r"SS\5r"SS \5r "S S \5r "S S \5r "SS\5r \ "S5r \ "S5rg)zSQL composition utility module N) extensionscB\rSrSrSrSrSrSrSrSr Sr S r S r g ) Composable#a 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. cXlgN_wrapped)selfwrappeds >/var/www/html/env/lib/python3.13/site-packages/psycopg2/sql.py__init__Composable.__init__1s cPURRSUR<S3$)N()) __class____name__r r s r __repr__Composable.__repr__4s%..))*!DMM+>rc[e)a2 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. )NotImplementedErrorr contexts r as_stringComposable.as_string7s "!rc[U[5(a[U/5U-$[U[5(a[U/5[U/5-$[$r) isinstanceComposedrNotImplementedr others r __add__Composable.__add__DsM eX & &TF#e+ + eZ ( (TF#hw&77 7! !rc [U/U-5$r)r!)r ns r __mul__Composable.__mul__Ls ##rcn[U5[U5L=(a URUR:H$r)typer r#s r __eq__Composable.__eq__Os'DzT%[(LT]]enn-LLrc.URU5(+$r)r-r#s r __ne__Composable.__ne__Rs;;u%%%rr N) r __module__ __qualname____firstlineno____doc__rrrr%r)r-r0__static_attributes__rr rr#s+  ? ""$M&rrcT^\rSrSrSrU4Sjr\S5rSrSr Sr Sr S r U=r $) r!Va 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). c>/nUH9n[U[5(d[SU<S35eURU5 M; [TU]U5 g)Nz*Composed elements must be Composable, got z instead)r r TypeErrorappendsuperr)r seqr irs r rComposed.__init__hsUAa,,@XNPP NN1   !rc,[UR5$)z+The list of the content of the `!Composed`.)listr rs r r> Composed.seqrsDMM""rc/nURH#nURURU55 M% SRU5$)N)r r<rjoin)r rrvr?s r rComposed.as_stringws8 A IIakk'* +wwr{rc,[UR5$r)iterr rs r __iter__Composed.__iter__}sDMM""rc[U[5(a"[URUR-5$[U[5(a[URU/-5$[$r)r r!r rr"r#s r r%Composed.__add__sP eX & &DMMENN:; ; eZ ( (DMMUG34 4! !rc[U[5(a [U5nO [U[5(d [S5eUR U5$)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)r strSQLr;rF)r joiners r rF Composed.joinsJ fc " "[FFC((EG G{{4  rr7)rr2r3r4r5rpropertyr>rrKr%rFr6 __classcell__rs@r r!r!Vs:""## #"!!rr!cN^\rSrSrSrU4Sjr\S5rSrSr Sr Sr U=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 *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" cd>[U[5(d [S5e[TU]U5 g)NzSQL values must be strings)r rPr;r=r)r stringrs r r SQL.__init__s)&#&&89 9  rcUR$)z(The string wrapped by the `!SQL` object.r rs r rZ SQL.string}}rcUR$rr rs r r SQL.as_strings }}rc/nSn[RUR5HupVpxU(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 `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) _formatterparser ValueErrorr<rQisdigitintr!) r argskwargsrGautonumprenamespecconvs r format SQL.formats@%/%5%5dmm%D !Ct !KLL !HII #c(#|||~~$PRR $s4y/*?$PRR $-(1  &,'5&E8|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" )rJr<next StopIterationr!)r r>rGitr?s r rFSQL.joinsi$ #Y  IId2h  $ ! |   sA A,+A,r7) rr2r3r4r5rrTrZrrorFr6rUrVs@r rQrQs6*! >@rrQcX^\rSrSrSrU4Sjr\S5r\S5rSr Sr Sr 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/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" c>U(d [S5eUH#n[U[5(aM[S5e [TU]U5 g)NzIdentifier cannot be emptyz$SQL identifier parts must be strings)r;r rPr=r)r stringssrs r rIdentifier.__init__AsD89 9Aa%% FGG !rcUR$)z5A tuple with the strings wrapped by the `Identifier`.r rs r ryIdentifier.stringsKr^rch[UR5S:XaURS$[S5e)z0The string wrapped by the `Identifier`. rbrz2the Identifier wraps more than one than one string)lenr AttributeErrorrs r rZIdentifier.stringPs6 t}}  "==# # DF FrcURRSSR[[UR 55S3$)Nrz, r)rrrFmapreprr rs r rIdentifier.__repr__Zs6..))*!DIIc$ 6N,O+PPQRRrcN^SRU4SjUR55$)N.c3R># UHn[R"UT5v M g7fr)ext quote_ident).0rzrs r 'Identifier.as_string..^sK]733]s$')rFr rs `r rIdentifier.as_string]sxxKT]]KKKrr7) rr2r3r4r5rrTryrZrrr6rUrVs@r rwrw"sI<"FFSLLrrwc.\rSrSrSr\S5rSrSrg)LiteraliaaT 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 cUR$)z%The object wrapped by the `!Literal`.r rs r r Literal.wrappedur^rc[U[R5(aUnO7[U[R5(a URnO [ S5e[R "UR 5n[US5(aURU5 UR5n[U[5(a,UR[RUR5nU$)Nz(context must be a connection or a cursorprepare)r r connectioncursorr;adaptr hasattrr getquotedbytesdecode encodingsencoding)r rconnarGs r rLiteral.as_stringzs gs~~ . .D  , ,%%DFG G IIdmm $ 1i IIdO [[] b% 3==78B rr7N) rr2r3r4r5rTr rr6r7rr rras &rrcL^\rSrSrSrSU4Sjjr\S5rSrSr Sr U=r $) PlaceholderiaA `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) c>[U[5(aSU;a[SU<35eOUb[SU<35e[TU]U5 g)Nrzinvalid name: z%expected string or None as name, got )r rPrer;r=r)r rlrs r rPlaceholder.__init__sV dC d{ >$!:;; CD8LM M rcUR$)zThe name of the `!Placeholder`.r rs r rlPlaceholder.namer^rcURcURRS3$URRSUR<S3$)Nz()rr)r rrrs r rPlaceholder.__repr__sG == nn--.b1 1nn--.a /@B Brc>URbSURS3$g)Nz%(z)sz%sr rs r rPlaceholder.as_strings" == $ b) )rr7r) rr2r3r4r5rrTrlrrr6rUrVs@r rrs14C rrNULLDEFAULT)r5rZpsycopg2rr Formatterrcrr!rQrwrrrrr7rr rs4&    0&0&fF!zF!R@*@F<L<L~*j*Z4*4p 6{ i.r