d=dZddlZddlZddlmZddlmZejdZ dZ dZ e d Z d Z d Zd ZGd dZdZdZddZdS)a&Utility functions and classes for supporting query conditions. Classes: `CompileCondition` Container for a compiled condition. Functions: `compile_condition` Compile a condition and extract usable index conditions. `call_on_recarr` Evaluate a function over a structured array. N)get_nested_field)lazyattrz[^a-z]([a-z]+)_([a-z]+)[^a-z]c|jd}t|\}}d|z}|dd|ddDz }||S)zvMake the "no matching opcode" Numexpr `exception` more clear. A new exception of the same kind is returned. rz$unsupported operand types for *%s*: z, c3DK|]}tjj|VdSN)ne necompilertypecode_to_kind).0ts 1lib/python3.11/site-packages/tables/conditions.py z/_unsupported_operation_error..&s=>>./ &q)>>>>>>rN)args_no_matching_opcodesearchgroupsjoin __class__) exceptionmessageoptypes newmessages r_unsupported_operation_errorrsnQG#**733::<>389>>>>>>J   z * **rcBfd}j|_j|_|S)zDecorate `getidxcmp` to check the returned indexable comparison. This does some extra checking that Numexpr would perform later on the comparison if it was compiled within a complete condition. c||}|d_ tjtj|n!#t$r}t |d}~wwxYw|S)Nr)r r typeCompileAstexpressionToASTNotImplementedErrorr)exprnode indexedcolsresultnie getidxcmps rnewfuncz%_check_indexable_cmp..newfunc3s8[11 !9  8 ,,M11(;;====& 8 8 823777 8 s.get_cmpVs[!$EK; K: % %){*B*B} 888} ***o r;/ /trcB|jdko|jdko|jvS)Nr2bool)r5astKindr4)noder#s ris_indexed_booleanz._get_indexable_cmp..is_indexed_boolean_s0 *.LF*.J+- /rTrinvertrFr<N)r4r5childrenr=) r"r# not_indexableturncmpr:r?childcmpopleftrightcmp_s ` r_get_indexable_cmprIBsf'M G ///// (##,d++4HNh$>$>!!$  e $ $ .Ku- - =F " "8T* *4 NE G#KD% 74 & &D  75$ / /D  rcDt|tjjs%t|tjjs||kSt |t |ust|tjjrit|tjjrJ|j|jks:|j|jks*t|jt|jkrdSt|j|jD]\}}t||sdSdS)zReturns whether two ExpressionNodes are equivalent. This is needed because '==' is overridden on ExpressionNode to return a new ExpressionNode. FT) isinstancer expressionsExpressionNodetyper4r=lenrAzip_equiv_expr_node)xyxchildychilds rrQrQs q".7 8 8 q"."?@@ Av q''a Ar~<== !Ar~<== !W   Y!) # # __AJ / /uaj!*55// 55  4rc6gdgf}dddddddd d }d }t||}||||\}}}|d rF|r(|\} } d kr | dvr| dz} n|| f| ff} d}n|d |df|dff} | gS|r|S|jdks |jdvr|S|j\} } t| |\}}}t| |\}}}|j|@|>t ||r.dkr(|dvr|dvr |||f||ff} | gS|dvr|dvr |||f||ff} | gSt | |||}t | |||}fd}||kr0dks||kr$||||||kr ||||||fS||krdkr||||||fS|S)a Here lives the actual implementation of the get_idx_expr() wrapper. 'idxexprs' is a list of expressions in the form ``(var, (ops), (limits))``. 'strexpr' is the indexable expression in string format. These parameters will be received empty (i.e. [], ['']) for the first time and populated during the different recursive calls. Finally, they are returned in the last level to the original wrapper. If 'exprnode' is not indexable, it will return the tuple ([], ['']) so as to signal this. &|~)andornotr-r,r0r/)r0r/r-r,czd}|ddkr)|dz}|d}t||}|ddk)|||fS)NFrr@Tr)rI)idxcmpr"r#r@s r fix_invertz)_get_idx_expr_recurse..fix_invertsWQi8## dNFayH'+>>F Qi8## x''rrr.)TFTFrr)r[r\Nr[)r,r-)r0r/ct|trY||dt|}|dkr dg|dd<dSd|d|dz fzg|dd<dSdS)z$Add a single expression to the list.rre0Nz (%s %s e%d))rKlistappendrO)expridxexprsstrexprlenexprsrop_convs radd_exprz'_get_idx_expr_recurse..add_exprs dD ! ! M OODG $ $ $8}}H1}}"V "WQZhl$KKM  M Mr)rIr5r4rArQ_get_idx_expr_recurse)r"r#rgrhrBnegcmpr`r_r@r6r4rfrFrGlcolvarlopllimrcolvarroprlimlexprrexprrkrrjs @@rrlrls"JMG  F((( + 6 6F)z&(KHHFHf ay   ;#NCUTzze}44 BZ")DFF1Iq |fQi\:Dv 48>#F#F#KD%+D+>>GS$+E;??GS$ B 3 '22!479U{{ ,  3,#6#6c3Z$6D6M ,  3,#6#6c3Z$6D6M "$ Xw G GE !%h H HE M M M M M M  2;;%=2H2H'*** M ! ! HUHg . . .'"" "++'***'"" rc(t||gdgS)aExtract an indexable expression out of `exprnode`. Looks for variable-constant comparisons in the expression node `exprnode` involving variables in `indexedcols`. It returns a tuple of (idxexprs, strexpr) where 'idxexprs' is a list of expressions in the form ``(var, (ops), (limits))`` and 'strexpr' is the indexable expression in string format. Expressions such as ``0 < c1 <= 1`` do not work as expected. Right now only some of the *indexable comparisons* are considered: * ``a <[=] x``, ``a == x`` and ``a >[=] x`` * ``(a <[=] x) & (y <[=] b)`` and ``(a == x) | (b == y)`` * ``~(~c_bool)``, ``~~c_bool`` and ``~(~c_bool) & (c_extra != 2)`` (where ``a``, ``b`` and ``c_bool`` are indexed columns, but ``c_extra`` is not) Particularly, the ``!=`` operator and negations of complex boolean expressions are *not considered* as valid candidates: * ``a != 1`` and ``c_bool != False`` * ``~((a > 0) & (c_bool))`` rW)rl)rfr#s r _get_idx_exprrws: !{B = ==rc:eZdZdZedZdZdZdZdS)CompiledConditionz#Container for a compiled condition.c~|j}g}|D]#}|d}||vr||$t|S)z2The columns participating in the index expression.r)index_expressionsre frozenset)selfrgidxvarsrfidxvars rindex_variablesz!CompiledCondition.index_variables2sU) ' 'D!WFW$$v&&&!!!rc T||_ ||_ ||_ ||_ ||_dSr)function parametersr{string_expressionkwargs)r}funcparamsrgrhrs r__init__zCompiledCondition.__init__>s9 K ;!)K!(8 BBrc6d|jd|jd|jS)Nz idxexprs: z strexpr: z idxvars: )r{rr)r}s r__repr__zCompiledCondition.__repr__Js.)))4+A+A+A'') *rcv|j}g}|D]}|d}g}|D]N}t|tr"||d}|}||O|\}} } ||| t|ft |j|j||jfi|j } | S)zReplace index limit variables with their values in-place. A new compiled condition is returned. Values are taken from the `condvars` mapping and converted to Python scalars. rar) r{rKtupletolistreryrrrr) r}condvarsexprsexprs2rfidxlims limit_valuesidxlimr6ops_newccs rwith_replaced_varsz$CompiledCondition.with_replaced_varsOs& ; ;D1gGL! , ,fe,,-%fQi0F#]]__F##F++++KCa MM3U<%8%89 : : : :! M4?FD4Jk rN) r( __module__ __qualname__r)rrrrrrrryry/sc--  " "X " C C C*** rrycg}|g}|rf|}|jdkr||jn*t |dr||j|ftt|S)z>Return the list of variable names in the Numexpr `expression`.r2rA) popr5rer4hasattrextendrArdset) expressionnamesstackr>s r_get_variable_namesrjs E LE (yy{{ <: % % LL $ $ $ $ T: & & ( LL ' ' ' ( E  rctj|i}|jdkrt d|zt ||}t |trdg}n|\}}|d}t|}fd|D} tj ||}n!#t$r} t| d} ~ wwxYwtj |i\} } d| i} |} t|| ||fi| S)aCompile a condition and extract usable index conditions. Looks for variable-constant comparisons in the `condition` string involving the indexed columns whose variable names appear in `indexedcols`. The part of `condition` having usable indexes is returned as a compiled condition in a `CompiledCondition` container. Expressions such as '0 < c1 <= 1' do not work as expected. The Numexpr types of *all* variables must be given in the `typemap` mapping. The ``function`` of the resulting `CompiledCondition` instance is a Numexpr function object, and the ``parameters`` list indicates the order of its parameters. r<z-condition ``%s`` does not have a boolean typercrc$g|] }||f Srr)r r6typemaps r z%compile_condition..s"999#ws|$999rN ex_uses_vml)r r stringToExpressionr= TypeErrorrwrKrdrNumExprr!r getExprNamesry) conditionrr#rfrgrhvarnames signaturerr%rrrrs ` rcompile_conditionrxsD" = + +Iw C CD |vG#$%% %T;//H(D!!%&%'ajG#4((H9999999I0}$$T955 000*3///0]// 2>>NA{[ )F F T68W G G G GGs B55 C?CCc g}|D]L}|r ||}n|}t|drt||j}||M||i|S)a3Call `func` with `params` over `recarr`. The `param2arg` function, when specified, is used to get an argument given a parameter name; otherwise, the parameter itself is used as an argument. When the argument is a `Column` object, the proper column from `recarr` is used as its value. pathname)rrrre)rrrecarr param2argrrparamargs rcall_on_recarrrs D  )E""CCC 3 # # 9"63<88C C 4   rr)r)renumexprr utilsextensionrutilsrcompilerrr*rIrQrlrwryrrrrrrrs5  ,,,,,,!bj!ABB + + +.>>>B.qqqh>>>@88888888v   2H2H2Hj!!!!!!r