+ i;Rt^RIt^RIHt]P !4t!RR4t!RR]4t!RR]4t !R R ]4t !R R ]4t !R R]4t ] !R4t ] !R4tR#)zSQL composition utility module N) extensionscNa]tRt^#toRtRtRtRtRtRt Rt Rt R t Vt R #) Composablea 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. cWnR#N_wrapped)selfwrappeds&&fC:\Users\petid\OneDrive\Desktop\Maestro\MAESTRO\maestro-backend\venv\Lib\site-packages\psycopg2/sql.py__init__Composable.__init__1s cPVPP RVP: R2#)()) __class____name__rr s&r __repr__Composable.__repr__4s%..))*!DMM+>rc \h)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\V\4'd\V.4V,#\V\4'd\V.4\V.4,#\#r) isinstanceComposedrNotImplementedr others&&r __add__Composable.__add__DsM eX & &TF#e+ + eZ ( (TF#hw&77 7! !rc(\V.V,4#r)r)r ns&&r __mul__Composable.__mul__Ls ##rcp\V4\V4J;'dVPVP8H#r)typerr!s&&r __eq__Composable.__eq__Os*DzT%[(LLT]]enn-LLrc.VPV4'*#r)r+r!s&&r __ne__Composable.__ne__Rs;;u%%%rrN)r __module__ __qualname____firstlineno____doc__r rrr#r'r+r.__static_attributes____classdictcell__ __classdict__s@r rr#s3  ? ""$M&&rrc^aa]tRt^VtoRtV3Rlt]R4tRtRt Rt Rt Rt Vt V;t#) 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). c<.pVF:p\V\4'g\RV: R24hVPV4K< \SV`V4R#)z*Composed elements must be Composable, got z insteadN)rr TypeErrorappendsuperr )r seqr irs&& r r Composed.__init__hsUAa,,@XNPP NN1   !rc ,\VP4#)z+The list of the content of the `!Composed`.)listrrs&r r= Composed.seqrsDMM""rc.pVPF#pVPVPV44K% RPV4#))rr;rjoin)r rrvr>s&& r rComposed.as_stringws8 A IIakk'* +wwr{rc,\VP4#r)iterrrs&r __iter__Composed.__iter__}sDMM""rc\V\4'd'\VPVP,4#\V\4'd\VPV.,4#\#r)rrrrr r!s&&r r#Composed.__add__sP eX & &DMMENN:; ; eZ ( (DMMUG34 4! !rc \V\4'd \V4pM!\V\4'g \R4hVP V4#)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)rstrSQLr:rE)r joiners&&r rE Composed.joinsJ fc " "[FFC((EG G{{4  r)rr0r1r2r3r propertyr=rrJr#rEr4r5 __classcell__rr7s@@r rrVs<""## #"!!rrcXaa]tRt^toRtV3Rlt]R4tRtRt Rt Rt Vt V;t #)rPa 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" ch<\V\4'g \R4h\SV`V4R#)zSQL values must be stringsN)rrOr:r<r )r stringrs&&r r SQL.__init__s)&#&&89 9  rc VP#)z(The string wrapped by the `!SQL` object.rrs&r rY SQL.string}}rcVP#rrrs&&r r SQL.as_strings }}rc J.p^p\PVP4FwrVrxV'd \R4hV'd \R4hV'dVP \ V44VfKTVP 4'd9V'd \R4hVP V\V4,4RpKV'g2Vf \R4hVP W,4V^, pKVP W&,4K \V4#)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 z(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;rPisdigitintr) r argskwargsrFautonumprenamespecconvs &*, r format SQL.formats@%/%5%5dmm%D !Ct !KLL !HII #c(#|||~~$PRR $s4y/*?$PRR $-(1  &,'5&E8|rc .p\V4pVP\V44VF%pVPV4VPV4K' \ V4# \dLi;i)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" )rIr;next StopIterationr)r r=rFitr>s&& r rESQL.joinsi$ #Y  IId2h  $ ! |   sA A-,A-rS)rr0r1r2r3r rTrYrrmrEr4r5rUrVs@@r rPrPs8*! >@rrPcbaa]tRtRtoRtV3Rlt]R4t]R4tRt Rt Rt Vt V;t #) 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<V'g \R4hVF$p\V\4'dK\R4h \SV`V4R#)zIdentifier cannot be emptyz$SQL identifier parts must be stringsN)r:rrOr<r )r stringssrs&* r r Identifier.__init__AsD89 9Aa%% FGG !rc VP#)z5A tuple with the strings wrapped by the `Identifier`.rrs&r rwIdentifier.stringsKr]rc r\VP4^8XdVP^,#\R4h)z0The string wrapped by the `Identifier`. z2the Identifier wraps more than one than one string)lenrAttributeErrorrs&r rYIdentifier.stringPs6 t}}  "==# # DF FrcVPP RRP\\VP 44 R2#)rz, r)rrrEmapreprrrs&r rIdentifier.__repr__Zs6..))*!DIIc$ 6N,O+PPQRRrcNaRPV3RlVP44#).c3R<"TFp\P!VS4xK R#5ir)ext quote_ident).0rxrs& r 'Identifier.as_string..^sK]733]s$')rErrs&fr rIdentifier.as_string]sxxKT]]KKKrrS)rr0r1r2r3r rTrwrYrrr4r5rUrVs@@r ruru"sK<"FFSLLrruc:a]tRtRtoRt]R4tRtRtVt R#)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 c VP#)z%The object wrapped by the `!Literal`.rrs&r r Literal.wrappedur]rc\V\P4'dTpM8\V\P4'dVPpM \ R4h\P !VP 4p\VR4'dVPV4VP4p\V\4'd1VP\PVP,4pV#)z(context must be a connection or a cursorprepare)rr connectioncursorr:adaptrhasattrr getquotedbytesdecode encodingsencoding)r rconnarFs&& r rLiteral.as_stringzs gs~~ . .D  , ,%%DFG G IIdmm $ 1i IIdO [[] b% 3==78B rrSN) rr0r1r2r3rTr rr4r5r6s@r rras(&rrcVaa]tRtRtoRtRV3Rllt]R4tRtRt Rt Vt V;t #) 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<\V\4'dRV9d\RV: 24hMVe\RV: 24h\SV`V4R#)rzinvalid name: Nz%expected string or None as name, got )rrOrcr:r<r )r rjrs&&r r Placeholder.__init__sV dC d{ >$!:;; CD8LM M rc VP#)zThe name of the `!Placeholder`.rrs&r rjPlaceholder.namer]rcVPfVPP R2#VPP RVP: R2#)Nz()rr)rrrrs&r rPlaceholder.__repr__sG == nn--.b1 1nn--.a /@B BrcBVPeRVP R2#R#)Nz%(z)sz%srrs&&r rPlaceholder.as_strings" == $ b) )rrSr) rr0r1r2r3r rTrjrrr4r5rUrVs@@r rrs34C rrNULLDEFAULT)r3rYpsycopg2rr FormatterrarrrPrurrrrrSrr rs4&    0&0&fF!zF!R@*@F<L<L~*j*Z4*4p 6{ i.r