
    i4                       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	m
Z
mZ ddlmZ ddl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 ddlmZ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      Z/	 d#	 	 	 	 	 	 	 d$dZ0ejb                  ejd                  ejf                  d Z4y)%z&
Utility module to manipulate queries
    )annotationsN)TYPE_CHECKINGAnyCallableMappingMatch
NamedTupleSequence)	lru_cache   )errors)pq)BufferParamsQuery)
Composable)PyFormat)	TypeAlias	TypeGuard)conn_encoding)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__     p/var/www/html/hwPaymentPortal-be-dev/hw-payment-portal-api/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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                    || _         d | _        d| _        d | _        d | _        t        |j                        | _        |  d| _        d | _	        y )Nr#   r$   )
_txparamstypes_want_formatsformatsr   
connection	_encodingquery_order)selftransformers     r%   __init__zPostgresQuery.__init__,   sK    6:&(
 5937&{'='=>
(,r$   c                   t        |t              r|j                  | j                        }n.t        |t              r|j                  | j                        }n|}|^t        |      t        k  rt        |      t        k  rt        }nt        } ||| 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)
isinstancestrencoder/   r   as_bytesr)   lenMAX_CACHED_STATEMENT_LENGTHMAX_CACHED_STATEMENT_PARAMS	_query2pg_query2pg_nocacher0   r,   r1   _partsdumpr2   r0   varsbqueryfs        r%   convertzPostgresQuery.convert<   s     eS!\\$..1Fz*^^DHH-FF F::I!<<(%IJ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@   r1   r,   r)   dump_sequencer*   r+   r-   r2   rC   r*   s      r%   rA   zPostgresQuery.dumpa   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dictr7   r
   r   r8   r   	TypeErrorr   )rC   tsequences      r%   is_params_sequencez PostgresQuery.is_params_sequencer   s     J9U
H  $YH  h'
4%0NH  g&H 	 T
++,. 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irC   s     r%   	<genexpr>z<PostgresQuery.validate_and_reorder_params.<locals>.<genexpr>   s     (Qq1D=(Qs   	)r'   rT   r;   eProgrammingErrorr7   r   intrQ   r8   KeyErrorjoinsorted)partsrC   orderr   s    `  r%   rI   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"N)r3   r   r0   r   rC   Params | NonereturnNonerC   rc   rd   re   )rC   r   rd   zTypeGuard[Sequence[Any]])r`   list[QueryPart]rC   r   ra   zlist[str] | Nonerd   zSequence[Any])r   r    r!   __doc__split	__slots__r4   rF   rA   staticmethodrT   rI   r#   r$   r%   r'   r'   "   sr     EG 
- #J "  $   &, 5E 	   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_queryr7   r   r\   appendr   r   r8   r;   rZ   r[   r^   )	r0   encodingr`   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y)PostgresClientQueryzI
    PostgresQuery subclass merging query and arguments client-side.
    )templatec                   t        |t              r|j                  | j                        }n.t        |t              r|j                  | j                        }n|}|Xt        |      t        k  rt        |      t        k  rt        }nt        } ||| j                        \  | _        | _        | _        n|| _        d| _        | j!                  |       yr6   )r7   r8   r9   r/   r   r:   r)   r;   r<   r=   _query2pg_client_query2pg_client_nocachery   r1   r@   r0   rA   rB   s        r%   rF   zPostgresClientQuery.convert   s     eS!\\$..1Fz*^^DHH-FFF::I!<<%5,89&$..8Q5T]DKDJDK		$r$   c                     |_ j                   j                  | j                        }t         fd|D               _         j
                   j                  z   _        yd _        y)rH   Nc              3  \   K   | ]#  }|j                   j                  |      nd % y w)Ns   NULL)r)   
as_literal)rW   pr2   s     r%   rY   z+PostgresClientQuery.dump.<locals>.<genexpr>  s.       IJ!-##A&WD s   ),)rI   r@   r1   rO   r*   ry   r0   rK   s   `  r%   rA   zPostgresClientQuery.dump  s]     55dkk4UF  NT  DK 4DJDKr$   Nrb   rf   )r   r    r!   rh   rj   rF   rA   r#   r$   r%   rx   rx      s     I<r$   rx   /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   ro   s   %sr$   )	rp   r7   r   r\   rq   r   r8   r   r^   )r0   rr   r`   ra   rs   rt   ru   rv   s           r%   r|   r|   #  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 '%%'ro   s   sbtz8only '%s', '%b', '%t' are allowed as placeholders, got 'z1positional and named placeholders cannot be mixed)_re_placeholderfinditerspanrq   r;   r   r   AUTOgrouprZ   r[   ri   decoderM   
_ph_to_fmt)r0   rr   r   r`   curmr   rvrX   phtyperv   pre1m1r   r   s                  r%   rp   rp   Z  s    68E
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   b)r0   r   rr   r8   rd   rl   )r0   r   rr   r8   rd   r   )asciiT)r0   r   rr   r8   r   boolrd   rg   )5rh   
__future__r   retypingr   r   r   r   r   r	   r
   	functoolsr    r   rZ   r   abcr   r   r   sqlr   _enumsr   _compatr   r   
_encodingsr   r   r<   r=   r   r'   r   r8   rm   r"   r?   r>   rx   r   r|   r{   compiler   rp   r   TEXTBINARYr   r#   r$   r%   <module>r      sl   # 	 U U U    & &   ) % "   
 D DP  
CLSS	9 
/3/3/3D/3n '(	2- 2j &
CLCC 
"*"*"*4"*J 56  "**
  LPFFFDHFFT --
--
//
r$   