o DDiJ@s8dZddlmZddlZddlZddlmZmZddlm Z m Z ddl m Z m Z mZddlmZdd lmZdd lmZdd lmZmZdd lmZdd lmZd)d*ddZGdddeZGdddeZGdddeZGdddeZGdddeZ Gd d!d!eZ!ed"Z"ed#Z#d)d*d$d%Z$d)d+d'd(Z%dS),z SQL composition utility module ) annotationsN)ABCabstractmethod)Anyoverload)IterableIteratorSequence)Escaping) AdaptContext)PyFormat) LiteralStringTemplate) conn_encoding) TransformerobjrcontextAdaptContext | NonereturnstrcCst||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)rrrD/var/www/Datamplify/venv/lib/python3.10/site-packages/psycopg/sql.pyquotes rc@sheZdZdZdddZd dd Zed!d"ddZd!d#ddZd$ddZ d%ddZ d&ddZ d&ddZ d S)' 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. rrcCs ||_dSN_objselfrrrr__init__6 zComposable.__init__rrcCs|jjd|jdS)N()) __class____name__rr!rrr__repr__9szComposable.__repr__NrrbytescCst)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!rrrras_bytes<s zComposable.as_bytescCsDt|r|jnd}t||}tr||St||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-r*decodecodecslookup)r!rencbrrrrKs zComposable.as_stringotherComposedcCs:t|tr t|g|St|trt|gt|gStSr)r/r6rNotImplementedr!r5rrr__add__Zs  zComposable.__add__nintcCst|g|Sr)r6)r!r:rrr__mul__bszComposable.__mul__boolcCst|t|uo |j|jkSr)typerr8rrr__eq__eszComposable.__eq__cCs || Sr)r?r8rrr__ne__hs zComposable.__ne__)rrrrrrrrr*rrrrr5rrr6)r:r;rr6)r5rrr=) r' __module__ __qualname____doc__r"r)rr-rr9r<r?r@rrrrr's      rcsVeZdZUdZded<dfdd Zddd dZdddZdddZdddZ Z S) r6a. 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]rseq Sequence[Any]csdd|D}t|dS)NcSs"g|] }t|tr |nt|qSr)r/rr.0rrrr s"z%Composed.__init__..)superr"r!rHr&rrr"szComposed.__init__Nrrrr*csdfdd|jDS)Nc3s|]}|VqdSrr-rJrrr sz$Composed.as_bytes..)joinrr,rrRrr-szComposed.as_bytesIterator[Composable]cCs t|jSr)iterrr(rrr__iter__r#zComposed.__iter__r5rcCs8t|tr t|j|jSt|trt|j|gStSr)r/r6rrr7r8rrrr9s  zComposed.__add__joinerSQL | LiteralStringcCs:t|tr t|}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)r/rSQL TypeErrorrTr)r!rXrrrrTs    z Composed.join)rHrIrrB)rrUrD)rXrYrr6) r'rErFrG__annotations__r"r-rWr9rT __classcell__rrrOrr6ls    r6cs|eZdZUdZded<eZd fdd Zd!d"d d Z d!d#ddZ d$ddZ e d%ddZ e d&ddZ d'ddZ ZS)(r[a 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" rrrcs*t|t|tstd|ddS)Nz SQL values must be strings, got rZ)rMr"r/rr\r rOrrr"s  z SQL.__init__NrrrrcCs|jSrrr,rrrrsz SQL.as_stringr*cCs"|r|jnd}t|}|j|Sr)r.rrencoder!rconnr3rrrr-s z SQL.as_bytesargsrkwargsr6c Osg}d}|j|jD]S\}}}}|rtd|rtd|r&|t||dur+q |rA|r5td||t|d}q |sW|durKtd||||d7}q |||q 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 ValueErrorappendr[isdigitr;r6) r!rbrcrvautonumprenamespecconvrrrformats6# z SQL.formatrHIterable[Template]rcCdSrrrNrrrrT$zSQL.join Iterable[Any]cCrqrrrNrrrrT'rrComposed | TemplatecCst|}zt|}Wn tytgYSwt|trDt|}|D]}t|ts4tdt|j | |j | |q#t|S|g}|D]}t|trZtdt|j | || |qIt|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 ) rVnext StopIterationr6r/rlistr\r>r'rgrextend)r!rHitfirstitemstcsirrrrT*s*          )rrrrCrB)rbrrcrrr6)rHrprr)rHrsrr6)rHrsrrt)r'rErFrGr]string Formatterrdr"rr-rorrTr^rrrOrr[s    H  r[csLeZdZUdZded<dfdd Zdd d ZddddZdddZZ 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]rstringsrcs@t||s td|D]}t|tstd|dqdS)NzIdentifier cannot be emptyz*SQL identifier parts must be strings, got rZ)rMr"r\r/r)r!rsrOrrr"}s   zIdentifier.__init__rcCs"|jjddtt|jdS)Nr$, r%)r&r'rTmapreprrr(rrrr)s"zIdentifier.__repr__Nrrr*csZ|r|jnd}rt|jt|fddjD}n fddjD}d|S)Ncsg|] }|qSr)escape_identifierr_rKr)r3escrrrLsz'Identifier.as_bytes..csg|] }|qSr)_escape_identifierr_rr(rrrLs.)r.r pgconnrrrT)r!rraescsr)r3rr!rr-s   zIdentifier.as_bytesrcCsd|dddS)zK Approximation of PQescapeIdentifier taking no connection. "s"")replace)r!rrrrrszIdentifier._escape_identifier)rrrArrB)rr*rr*) r'rErFrGr]r"r)r-rr^rrrOrr[s   rc@seZdZdZd d ddZdS) 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*cCst|}||jSr)r from_context as_literalr)r!rtxrrrr-s  zLiteral.as_bytesrrB)r'rErFrGr-rrrrrsrcsLeZdZdZdejfdfdd Zdd d ZddddZddddZ Z 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) rlrrostr | PyFormatcsvt|t|tstd|d|vrtd|t|tur't|}t|ts6tdt|j||_ dS)Nzexpected string as name, got r%zinvalid name: z!expected PyFormat as format, got ) rMr"r/rr\rfr>r r'_format)r!rlrorOrrr"s     zPlaceholder.__init__rcCsTg}|jr |t|j|jtjur|d|jj|jjdd |dS)Nzformat=r$rr%) rrgrrr AUTOrlr&r'rT)r!partsrrrr)s  zPlaceholder.__repr__NrrcCs*|jj}|jrd|jd|Sd|S)Nz%(r%%)rvaluer)r!rcoderrrrs"zPlaceholder.as_stringr*cCs&|r|jnd}t|}|||Sr)r.rrr_r`rrrr-szPlaceholder.as_bytes)rlrrorrArrCrB) r'rErFrGr rr"r)rr-r^rrrOrrs   rNULLDEFAULTcCFt|tr |j|dSt|trddlm}|||St|j|dS)aConvert an object to a 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` Adaptation happens according to the type of `!obj`: - `Composable` objects are converted according to their `~Composable.as_string()` method; - `~string.templatelib.Template` strings are converted according to the rules documented in :ref:`template-strings`; - every other object is converted as it was :ref:`a parameter passed to a query `. 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. rRr )r)r/rrr _tstringsr)rrrrrrrs     rr*cCr)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. rRr rQ)r/rr-rrr)rrr-rrrr-s    r-r)rrrrrr)rrrrrr*)&rG __future__rr1rabcrrtypingrrcollections.abcrrr pqr r _enumsr _compatrr _encodingsr _transformerrrrr6r[rrrrrrr-rrrrs2       EE+BA