
    IZj'                    ~   U d Z ddlmZ ddlmZ ddlZddlmZm	Z	m
Z
mZ g dZi d ej                    d ej                    d	 ej                    d
 ej                    d ej                    d ej                    d ej                    d ej                    d ej                    d ej                    d ej                    d ej                    d ej                    d ej                    d ej                    d ej                    d ej                     ej                     ej                     ej                     ej                     ej                     ej                    dZded<   d*dZed e e!e"e#e$f         Z% G d! d           Z&d+d$Z'd,d&Z(d-d)Z)dS ).a  Type-safe expression builder for filters and projections.

Instead of writing raw SQL strings you can build expressions with Python
operators::

    from lancedb.expr import col, lit

    # filter: age > 18 AND status = 'active'
    filt = (col("age") > lit(18)) & (col("status") == lit("active"))

    # projection: compute a derived column
    proj = {"score": col("raw_score") * lit(1.5)}

    table.search().where(filt).select(proj).to_list()
    )annotations)UnionN)PyExprexpr_colexpr_lit	expr_func)Exprcollitfuncboolbooleanint8int16int32int64uint8uint16uint32uint64float16float32floatfloat64doublestringutf8)strlarge_string
large_utf8date32datedate64dict_STR_TO_PA_TYPEvalue
'ExprLike'return'Expr'c                N    t          | t                    r| S t          |           S )z_Return *value* as an :class:`Expr`, wrapping plain Python values via
    :func:`lit` if needed.)
isinstancer	   r   r&   s    X/Users/jameslopez/projects/MentorCore/.venv/lib/python3.11/site-packages/lancedb/expr.py_coercer.   9   s'     % u::    r	   c                     e Zd ZdZdZd/dZd0dZd0dZd0dZd0dZ	d0dZ
d0dZd1dZd1dZd2dZd0dZd0dZd0dZd0dZd0dZd0dZd0dZd0dZd2dZd2dZd3d Zd4d#Zd0d$Zd0d%Zd0d&Zd0d'Zd0d(Zd0d)Z d1d*Z!d1d+Z"d5d-Z#d5d.Z$dS )6r	   ae  A type-safe expression node.

    Construct instances with :func:`col` and :func:`lit`, then combine them
    using Python operators or the named methods below.

    Examples
    --------
    >>> from lancedb.expr import col, lit
    >>> filt = (col("age") > lit(18)) & (col("name").lower() == lit("alice"))
    >>> proj = {"double": col("x") * lit(2)}
    Ninnerr   r(   Nonec                    || _         d S )N)_inner)selfr1   s     r-   __init__zExpr.__init__V   s    r/   otherExprLiker)   c                t    t          | j                            t          |          j                            S )zEqual to (``col("x") == 1``).)r	   r4   eqr.   r5   r7   s     r-   __eq__zExpr.__eq__[   '    DKNN75>>#899:::r/   c                t    t          | j                            t          |          j                            S )z!Not equal to (``col("x") != 1``).)r	   r4   ner.   r;   s     r-   __ne__zExpr.__ne___   r=   r/   c                t    t          | j                            t          |          j                            S )zLess than (``col("x") < 1``).)r	   r4   ltr.   r;   s     r-   __lt__zExpr.__lt__c   r=   r/   c                t    t          | j                            t          |          j                            S )z*Less than or equal to (``col("x") <= 1``).)r	   r4   lter.   r;   s     r-   __le__zExpr.__le__g   '    DKOOGENN$9::;;;r/   c                t    t          | j                            t          |          j                            S )z Greater than (``col("x") > 1``).)r	   r4   gtr.   r;   s     r-   __gt__zExpr.__gt__k   r=   r/   c                t    t          | j                            t          |          j                            S )z-Greater than or equal to (``col("x") >= 1``).)r	   r4   gter.   r;   s     r-   __ge__zExpr.__ge__o   rG   r/   c                t    t          | j                            t          |          j                            S )z"Logical AND (``expr_a & expr_b``).)r	   r4   and_r.   r;   s     r-   __and__zExpr.__and__u   s)    DK$$WU^^%:;;<<<r/   c                t    t          | j                            t          |          j                            S )z!Logical OR (``expr_a | expr_b``).)r	   r4   or_r.   r;   s     r-   __or__zExpr.__or__y   rG   r/   c                N    t          | j                                                  S )zLogical NOT (``~expr``).)r	   r4   not_r5   s    r-   
__invert__zExpr.__invert__}   s    DK$$&&'''r/   c                t    t          | j                            t          |          j                            S )zAdd (``col("x") + 1``).)r	   r4   addr.   r;   s     r-   __add__zExpr.__add__   rG   r/   c                t    t          t          |          j                            | j                            S )z"Right-hand add (``1 + col("x")``).)r	   r.   r4   rY   r;   s     r-   __radd__zExpr.__radd__   )    GENN)--dk::;;;r/   c                t    t          | j                            t          |          j                            S )zSubtract (``col("x") - 1``).)r	   r4   subr.   r;   s     r-   __sub__zExpr.__sub__   rG   r/   c                t    t          t          |          j                            | j                            S )z'Right-hand subtract (``1 - col("x")``).)r	   r.   r4   r_   r;   s     r-   __rsub__zExpr.__rsub__   r]   r/   c                t    t          | j                            t          |          j                            S )zMultiply (``col("x") * 2``).)r	   r4   mulr.   r;   s     r-   __mul__zExpr.__mul__   rG   r/   c                t    t          t          |          j                            | j                            S )z'Right-hand multiply (``2 * col("x")``).)r	   r.   r4   rd   r;   s     r-   __rmul__zExpr.__rmul__   r]   r/   c                t    t          | j                            t          |          j                            S )zDivide (``col("x") / 2``).)r	   r4   divr.   r;   s     r-   __truediv__zExpr.__truediv__   rG   r/   c                t    t          t          |          j                            | j                            S )z%Right-hand divide (``1 / col("x")``).)r	   r.   r4   ri   r;   s     r-   __rtruediv__zExpr.__rtruediv__   r]   r/   c                N    t          | j                                                  S )z*Convert string column values to lowercase.)r	   r4   lowerrV   s    r-   rn   z
Expr.lower       DK%%''(((r/   c                N    t          | j                                                  S )z*Convert string column values to uppercase.)r	   r4   upperrV   s    r-   rq   z
Expr.upper   ro   r/   substrr'   c                t    t          | j                            t          |          j                            S )z/Return True where the string contains *substr*.)r	   r4   containsr.   )r5   rr   s     r-   rt   zExpr.contains   s)    DK(()?@@AAAr/   	data_typeUnion[str, 'pa.DataType']c           	        t          |t                    rJ	 t          |         }n;# t          $ r. t	          d| dd                    t                               w xY wt          | j                            |                    S )u  Cast values to *data_type*.

        Parameters
        ----------
        data_type:
            A PyArrow ``DataType`` (e.g. ``pa.int32()``) or one of the type
            name strings: ``"bool"``, ``"int8"``, ``"int16"``, ``"int32"``,
            ``"int64"``, ``"uint8"``–``"uint64"``, ``"float32"``,
            ``"float64"``, ``"string"``, ``"date32"``, ``"date64"``.
        zunsupported data type: 'z'. Supported: z, )	r+   r   r%   KeyError
ValueErrorjoinr	   r4   cast)r5   ru   s     r-   r{   z	Expr.cast   s     i%% 	+I6		    4y 4 4yy114 4  
 DK$$Y//000s	   % 8Ac                ,    |                      |          S )z	Equal to.)r<   r;   s     r-   r:   zExpr.eq       {{5!!!r/   c                ,    |                      |          S )zNot equal to.)r@   r;   s     r-   r?   zExpr.ne   r}   r/   c                ,    |                      |          S )z
Less than.)rC   r;   s     r-   rB   zExpr.lt   r}   r/   c                ,    |                      |          S )zLess than or equal to.)rF   r;   s     r-   rE   zExpr.lte   r}   r/   c                ,    |                      |          S )zGreater than.)rJ   r;   s     r-   rI   zExpr.gt   r}   r/   c                ,    |                      |          S )zGreater than or equal to.)rM   r;   s     r-   rL   zExpr.gte   r}   r/   c                ,    |                      |          S )zLogical AND.)rP   r;   s     r-   rO   z	Expr.and_   s    ||E"""r/   c                ,    |                      |          S )zLogical OR.)rS   r;   s     r-   rR   zExpr.or_   r}   r/   r   c                4    | j                                         S )z=Render the expression as a SQL string (useful for debugging).r4   to_sqlrV   s    r-   r   zExpr.to_sql   s    {!!###r/   c                <    d| j                                          dS )NzExpr()r   rV   s    r-   __repr__zExpr.__repr__   s!    .t{))++....r/   )r1   r   r(   r2   )r7   r8   r(   r)   )r7   r)   r(   r)   )r(   r)   )rr   r'   r(   r)   )ru   rv   r(   r)   )r(   r   )%__name__
__module____qualname____doc____hash__r6   r<   r@   rC   rF   rJ   rM   rP   rS   rW   rZ   r\   r`   rb   re   rg   rj   rl   rn   rq   rt   r{   r:   r?   rB   rE   rI   rL   rO   rR   r   r    r/   r-   r	   r	   E   s       
 
 H   
; ; ; ;; ; ; ;; ; ; ;< < < <; ; ; ;< < < <= = = =< < < <( ( ( (< < < << < < << < < << < < << < < << < < << < < << < < <) ) ) )) ) ) )B B B B1 1 1 1." " " "" " " "" " " "" " " "" " " "" " " "# # # #" " " "$ $ $ $/ / / / / /r/   namer   c                :    t          t          |                     S )zReference a table column by name.

    Parameters
    ----------
    name:
        The column name.

    Examples
    --------
    >>> from lancedb.expr import col, lit
    >>> col("age") > lit(18)
    Expr((age > 18))
    )r	   r   )r   s    r-   r
   r
      s     r/   #Union[bool, int, float, str, bytes]c                :    t          t          |                     S )a  Create a literal (constant) value expression.

    Parameters
    ----------
    value:
        A Python ``bool``, ``int``, ``float``, ``str``, or ``bytes``.

    Examples
    --------
    >>> from lancedb.expr import col, lit
    >>> col("price") * lit(1.1)
    Expr((price * 1.1))
    )r	   r   r,   s    r-   r   r     s        r/   argsr8   c                T    d |D             }t          t          | |                    S )ah  Call an arbitrary SQL function by name.

    Parameters
    ----------
    name:
        The SQL function name (e.g. ``"lower"``, ``"upper"``).
    *args:
        The function arguments as :class:`Expr` or plain Python literals.

    Examples
    --------
    >>> from lancedb.expr import col, func
    >>> func("lower", col("name"))
    Expr(lower(name))
    c                6    g | ]}t          |          j        S r   )r.   r4   ).0as     r-   
<listcomp>zfunc.<locals>.<listcomp>)  s!    222'!**#222r/   )r	   r   )r   r   
inner_argss      r-   r   r     s/      32T222J	$
++,,,r/   )r&   r'   r(   r)   )r   r   r(   r	   )r&   r   r(   r	   )r   r   r   r8   r(   r	   )*r   
__future__r   typingr   pyarrowpalancedb._lancedbr   r   r   r   __all__bool_r   r   r   r   r   r   r   r   r   r   r   r   r    r!   r#   r%   __annotations__r.   r   intr   r   bytesr8   r	   r
   r   r   r   r/   r-   <module>r      s      # " " " " "           B B B B B B B B B B B B
(
(
(
HBHJJxrxzz GBGII XRXZZ	
 XRXZZ XRXZZ XRXZZ ibikk ibikk ibikk zrz|| zrz|| ZRZ\\ zrz|| jbjll  ibikk!" IBIKK#$ 29;;!BMOO"-//bikkBIKKbikk/      6    sE356l/ l/ l/ l/ l/ l/ l/ l/d       "! ! ! !"- - - - - -r/   