
    2iv=                    &   U d Z ddlmZ ddlZddlmZmZmZmZm	Z	 ddl
mZ ddlmZmZmZ ddlmZ dd	lmZmZ dd
lmZmZmZmZ ddlmZ ddlmZ ddlmZ erddlm Z  dZ!dZ" G d de      Z# G d d      Z$ee%e&gdf   Z'de(d<   	 	 	 	 	 	 d#dZ) ee)      Z* G d de$      Z+ee%e&gdf   Z,de(d<   	 	 	 	 	 	 d$dZ- ee-      Z. ej^                  d      Z0	 d%	 	 	 	 	 	 	 d&dZ1ejd                  ejf                  ejh                  d Z5 G d! d"e$      Z6y)'z&
Utility module to manipulate queries
    )annotationsN)TYPE_CHECKINGAny
NamedTuple	TypeAlias	TypeGuard)	lru_cache)CallableMappingSequence   )errors)pqsql)BufferParamsQueryQueryNoTemplate)PyFormat)Template)TemplateProcessor)Transformeri   2   c                  ,    e Zd ZU ded<   ded<   ded<   y)	QueryPartbytesprez	int | stritemr   formatN)__name__
__module____qualname____annotations__     O/var/www/html/secretsanta/venv/lib/python3.12/site-packages/psycopg/_queries.pyr   r      s    	J
Or%   r   c                      e Zd ZdZdj	                         ZddZddZddZe	dd       Z
e		 	 	 	 	 	 	 	 dd       ZddZdd	Zy
)PostgresQueryzO
    Helper to convert a Python query and parameters into Postgres format.
    z^
        query params types formats
        _tx _want_formats _parts _encoding _order
        c                j    || _         d | _        d| _        d | _        d | _        |  d| _        d | _        y )Nr$   r%   )_txparamstypes_want_formatsformatsquery_order)selftransformers     r&   __init__zPostgresQuery.__init__,   s9    6:&(
 5937
(,r%   c                   t        |t              r| j                  ||      S | j                  |      }|ht	        |      t
        k  rt	        |      t        k  rt        }nt        } ||| j                  j                        \  | _        | _        | _        | _        n|| _        dx| _        | _        | j                  |       yz
        Set up the query and parameters to convert.

        The results of this function can be obtained accessing the object
        attributes (`query`, `params`, `types`, `formats`).
        N)
isinstancer   _convert_template_ensure_byteslenMAX_CACHED_STATEMENT_LENGTHMAX_CACHED_STATEMENT_PARAMS	_query2pg_query2pg_nocacher*   encodingr/   r-   r0   _partsdumpr1   r/   varsfs       r&   convertzPostgresQuery.convert;   s     eX&))%66""5) E
99I!<<(%IJtxx((JFTZ+T[$+ DJ/33D		$r%   c                h   || j                  | j                  || j                        }| j                  J | j                  j                  || j                        | _        | j                  j                  xs d| _        | j                  j                  | _        yd| _        d| _        d| _        y)
        Process a new set of variables on the query processed by `convert()`.

        This method updates `params` and `types`.
        Nr$   )	validate_and_reorder_paramsr?   r0   r-   r*   dump_sequencer+   r,   r.   r1   rB   r+   s      r&   r@   zPostgresQuery.dump^   s     55dkk4UF%%111((009K9KLDK-2DJ88++DLDKDJDLr%   c                   t        |       }|t        u s|t        u rd}|S |t        u rd}|S t	        | t
              rt	        | t        t        f      sd}|S t	        | t              rd}|S t        dt        |       j                         )NTFz8query parameters should be a sequence or a mapping, got )typelisttupledictr6   r   r   strr   	TypeErrorr"   )rB   tsequences      r&   is_params_sequencez PostgresQuery.is_params_sequenceo   s     J9U
H  $YH  h'
4%0NH  g&H 	 T
//02 r%   c                J   t         j                        rwt              t        |       dz
  k7  r1t        j                  dt        |       dz
   dt               d      r(t        | d   j                  t              st        d      S r/t        |       dkD  r!t        | d   d   t              st        d      	 |r|D cg c]  }|   	 c}S yc c}w # t        $ r> t        j                  d	d
j                  t        fd|xs dD                           w xY w)zO
        Verify the compatibility between a query and a set of params.
        r   zthe query has z placeholders but z parameters were passedr   z2named placeholders require a mapping of parametersz=positional placeholders (%s) require a sequence of parametersr$   zquery parameter missing: z, c              3  ,   K   | ]  }|vs|  y wNr$   ).0irB   s     r&   	<genexpr>z<PostgresQuery.validate_and_reorder_params.<locals>.<genexpr>   s     (Qq1D=(Qs   	)r(   rS   r9   eProgrammingErrorr6   r   intrP   rO   KeyErrorjoinsorted)partsrB   orderr   s    `  r&   rG   z)PostgresQuery.validate_and_reorder_params   s)    ++D14yCJN*(($SZ!^$4 5D	{"9;  JuQx}}c: TUUK E
Qz%(1+s/KS 
3894DJ99 :  ((		&(QEKR(Q"QRSU s    C CC C AD"c                    t        |t              r%|j                  | j                  j                        S t        |t
        j                        r|j                  | j                        S |S rV   )r6   rO   encoder*   r>   r   
Composableas_bytes)r1   r/   s     r&   r8   zPostgresQuery._ensure_bytes   sK    eS!<< 1 122s~~.>>$((++Lr%   c                   |t        d      t        |d| j                        }|j                          |j                  | _        |j
                  rp| j                  j                  |j
                  |j                        | _        | j                  j                  xs d| _        | j                  j                  | _        y d | _        d| _        d | _        y )NA'execute()' with string template query doesn't support parametersTserver_paramstxr$   )	rP   r   r*   processr/   r+   rH   r.   r,   r1   r/   rB   tps       r&   r7   zPostgresQuery._convert_template   s    S  uDTXXF


XX
99((00BJJGDK-2DJ88++DLDKDJDLr%   N)r2   r   r/   r   rB   Params | NonereturnNonerB   ro   rp   rq   )rB   r   rp   zTypeGuard[Sequence[Any]])r`   list[QueryPart]rB   r   ra   zlist[str] | Nonerp   zSequence[Any])r/   r   rp   r   r/   r   rB   ro   rp   rq   )r    r!   r"   __doc__split	__slots__r3   rD   r@   staticmethodrS   rG   r8   r7   r$   r%   r&   r(   r(   "   s}     EG 
-!F "  $   &, 5E 	   D r%   r(   ?tuple[bytes, list[PyFormat], list[str] | None, list[QueryPart]]r   	_Query2Pgc                X   t        | |      }d}g }g }t        |d   j                  t              r|dd D ]u  }t        |j                  t              sJ |j	                  |j
                         |j	                  d|j                  dz   z         |j	                  |j                         w nJt        |d   j                  t              r,i }g }|dd D ]  }t        |j                  t              sJ |j	                  |j
                         |j                  |vrtdt        |      dz   z  }||j                  f||j                  <   |j	                  |j                         |j	                  |       |j	                  |j                         ||j                     d   |j                  k7  r#t        j                  d|j                   d      |j	                  ||j                     d          " |j	                  |d   j
                         dj                  |      |||fS )	a  
    Convert Python query and params into something Postgres understands.

    - Convert Python placeholders (``%s``, ``%(name)s``) into Postgres
      format (``$1``, ``$2``)
    - placeholders can be %s, %t, or %b (auto, text or binary)
    - return ``query`` (bytes), ``formats`` (list of formats) ``order``
      (sequence of names used in the query, in the position they appear)
      ``parts`` (splits of queries and placeholders).
    Nr   s   $%dr   zplaceholder 'z' cannot have different formatsr%   )_split_queryr6   r   r\   appendr   r   rO   r9   rZ   r[   r^   )	r/   r>   r`   ra   chunksr.   partseenphs	            r&   r=   r=      s    )E"EFG%(--%#2J 	(Ddii---MM$((#MM&DIIM23NN4;;'		( 
E!HMM3	'24#2J 	2Ddii---MM$((#yy$s4y1}-#%t{{"3TYYTYY'b!t{{+		?1%4,,'		{2QR  d499oa01	2" MM%)-- 88FWeU22r%   c                  ,    e Zd ZdZdZddZddZd	dZy)
PostgresClientQueryzI
    PostgresQuery subclass merging query and arguments client-side.
    )templatec                p   t        |t              r| j                  ||      S | j                  |      }|bt	        |      t
        k  rt	        |      t        k  rt        }nt        } ||| j                  j                        \  | _        | _        | _        n|| _        d| _        | j                  |       yr5   )r6   r   r7   r8   r9   r:   r;   _query2pg_client_query2pg_client_nocacher*   r>   r   r0   r?   r/   r@   rA   s       r&   rD   zPostgresClientQuery.convert  s     eX&))%66""5)E
99I!<<%5,89%ARAR8S5T]DKDJDK		$r%   c                     |_ j                   j                  | j                        }t         fd|D               _         j
                   j                  z   _        yd _        y)rF   Nc              3  \   K   | ]#  }|j                   j                  |      nd % y w)Ns   NULL)r*   
as_literal)rW   pr1   s     r&   rY   z+PostgresClientQuery.dump.<locals>.<genexpr>+  s.       IJ!-##A&WD s   ),)rG   r?   r0   rM   r+   r   r/   rI   s   `  r&   r@   zPostgresClientQuery.dump#  s]     55dkk4UF  NT  DK 4DJDKr%   c                    |t        d      t        |d| j                        }|j                          |j                  | _        |j
                  | _        y )Nrg   Frh   )rP   r   r*   rk   r/   r+   rl   s       r&   r7   z%PostgresClientQuery._convert_template2  sK    S  uEdhhG


XX
iir%   Nrn   rr   rt   )r    r!   r"   ru   rw   rD   r@   r7   r$   r%   r&   r   r      s     I8	 r%   r   /tuple[bytes, list[str] | None, list[QueryPart]]_Query2PgClientc                V   t        | |d      }d}g }t        |d   j                  t              rS|dd D ]J  }t        |j                  t              sJ |j	                  |j
                         |j	                  d       L nt        |d   j                  t              ri }g }|dd D ]  }t        |j                  t              sJ |j	                  |j
                         |j                  |vrJd}||j                  f||j                  <   |j	                  |j                         |j	                  |       |j	                  ||j                     d          |j	                  |j                          |j	                  |d   j
                         dj                  |      ||fS )zX
    Convert Python query and params into a template to perform client-side binding
    F)collapse_double_percentNr   r|   s   %sr%   )	r}   r6   r   r\   r~   r   rO   r   r^   )r/   r>   r`   ra   r   r   r   r   s           r&   r   r   C  sb    %HE"EF%(--%#2J 	!Ddii---MM$((#MM% 	!
 
E!HMM3	'24#2J 
	(Ddii---MM$((#yy$#%t{{"3TYYTYY'b!d499oa01TYY'
	( MM%)-- 88FUE))r%   s"  (?x)
        %                       # a literal %
        (?:
            (?:
                \( ([^)]+) \)   # or a name in (braces)
                .               # followed by a format
            )
            |
            (?:.)               # or any char, really
        )
        c                   g }d}d }t         j                  |       D ]@  }| ||j                  d      d    }|j                  ||f       |j                  d      d   }B |r|j                  | |d  d f       n|j                  | d f       g }d}d }	|t	        |      k  r||   \  }}|-|j                  t        |dt        j                               	 |S |j                  d      x}
dk(  r#|rd}
||dz      \  }}||
z   |z   |f||dz   <   ||= |
dk(  rNt        j                  d| |j                  d      d   d  j                         d   j                  |       d      |
dk(  rt        j                  d	      |
d
d  dvr7t        j                  d|j                  d      j                  |       d      |j                  d      r |j                  d      j                  |      n|}|	st        |      }	n"|	t        |      urt        j                  d      t        |
d
d     }|j                  t        |||             |dz  }|t	        |      k  r|S )Nr   r   s   %%   %s   %(zincomplete placeholder: ''s   % zfincomplete placeholder: '%'; if you want to use '%' as an operator you can double it up, i.e. use '%%'r|   s   sbtz8only '%s', '%b', '%t' are allowed as placeholders, got 'z1positional and named placeholders cannot be mixed)_re_placeholderfinditerspanr~   r9   r   r   AUTOgrouprZ   r[   rv   decoderK   
_ph_to_fmt)r/   r>   r   r`   curmr   rvrX   phtyper   pre1m1r   r   s                  r&   r}   r}   z  s    9;E
C 	A%%e, C!&&)A,'c1XffQil 	eCDk4()eT]#	B 	
AF
c%j.qQ9IIiQ67V IS ''!*B&&QU|HD""HtOR0E!a%La;$$166!9Q<=)//1!4;;HEFaI  5[$$@  WF"$$WWQZ&&x014  /0ggajqwwqz  *a$ZF4:%$$C  BrsG$
		)Cv./	Q] c%j.` Ir%   )   s   t   bc                  $    e Zd ZddZddZddZy)PostgresRawQueryc                    t        |t              r| j                  ||      S | j                  |      | _        d x| _        | _        | j                  |       y rV   )r6   r   r7   r8   r/   r-   r0   r@   r1   r/   rB   s      r&   rD   zPostgresRawQuery.convert  sK    eX&))%66''.
+//T[		$r%   c                   |t         j                  |      st        d      t        j                  gt        |      z  | _        | j                  j                  || j                        | _	        | j                  j                  xs d| _
        | j                  j                  | _        y d | _	        d| _
        d | _        y )Nz,raw queries require a sequence of parametersr$   )r(   rS   rP   r   r   r9   r-   r*   rH   r+   r,   r.   )r1   rB   s     r&   r@   zPostgresRawQuery.dump  s     33D9 NOO"*--3t9!<D((00t7I7IJDK-2DJ88++DLDKDJDLr%   c                X    t        j                  t        |       j                   d      )Nz! doesn't support template strings)rZ   NotSupportedErrorrK   r    r   s      r&   r7   z"PostgresRawQuery._convert_template  s+    !!Dz""##DE
 	
r%   Nrn   rr   rt   )r    r!   r"   rD   r@   r7   r$   r%   r&   r   r     s     
r%   r   )r/   r   r>   rO   rp   ry   )r/   r   r>   rO   rp   r   )asciiT)r/   r   r>   rO   r   boolrp   rs   )7ru   
__future__r   retypingr   r   r   r   r   	functoolsr	   collections.abcr
   r   r    r   rZ   r   r   abcr   r   r   r   _enumsr   _compatr   	_tstringsr   r   r:   r;   r   r(   r   rO   rz   r#   r=   r<   r   r   r   r   compiler   r}   r   TEXTBINARYr   r   r$   r%   r&   <module>r      sx   # 	 G G  7 7   7 7   ( "   
 [  [ ~  
CLSS	9 
/3/3/3D/3n '(	; - ; | &
CLCC 
"*"*"*4"*J 56  "**
  LPFFFDHFFT --
--
//

} 
r%   