ɯei ddlZddlZddlmZmZmZddlZddlmcm cm cm cm Z ddl mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2m3Z3m4Z4m5Z5m6Z6ddl7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@ddlAmBZBmCZCmDZDmEZEmFZFmGZGddlHmIZImJZJmKZKmLZLmMZMmNZNmOZOdd lPmQZQmRZRmSZSmTZTdd lUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]dd l^m_Z_m`Z`ejd krdd lmbZbndd lcmbZbdeeJdfdedddfdZedeMdedddfdZfdeLdedddfdZgdeeLehfdedddfdZiGddZjGddejZkejdZlejdZmejdZnejdZoejdZpeljeWemjeXenjeZeYjeojeZeYjepjeXiZuy)N)AnyOptionalUnion)AddAnd BitwiseAnd BitwiseOr BitwiseXorDivide EqualNullSafeEqualTo GreaterThanGreaterThanOrEqualLessThanLessThanOrEqualMultiply NotEqualToOrPow RemainderSubtract)CaseWhenCollate Expression InExpressionLikeLiteralMultipleExpressionNamedExpressionRegExpScalarSubqueryStar SubfieldIntSubfieldStringUnresolvedAttribute Attribute WithinGroup) Ascending Descending NullsFirst NullsLast SortOrder) AliasCastIsNaN IsNotNullIsNullNot UnaryMinusUnresolvedAlias_InternalAlias)build_expr_from_python_val-build_expr_from_snowpark_column_or_python_val*build_expr_from_snowpark_column_or_sql_strcreate_ast_for_columnsnowpark_expression_to_astwith_src_position)$VALID_PYTHON_TYPES_FOR_LITERAL_VALUEColumnOrLiteralColumnOrLiteralStr ColumnOrNameColumnOrSqlExpr LiteralTypetype_string_to_type_object)parse_positional_args_to_list publicapi quote_name#split_snowflake_identifier_with_dot)DataType IntegerType StringTypeTimestampTimeZone TimestampType ArrayTypeMapType StructType)Window WindowSpec) )Iterablecolsnowflake.snowpark.DataFrame func_namereturnColumnct|ttjjt t tfr|St|trtt|dStd|dt|)NF _emit_ast'z<' expected Column, DataFrame, Iterable or LiteralType, got: ) isinstancerX snowflakesnowpark DataFramelisttuplesetr<r TypeErrortyperTrVs [/var/www/html/glpi_dashboard/venv/lib/python3.12/site-packages/snowflake/snowpark/column.py_to_col_if_litrhpsl# 2 2 < gcle44 {VW[\_W`Va b  ct|tr|St|trtj|St d|dt |)Nr\z1' expected Column or str as SQL expression, got: )r]rXstr_exprrdrerfs rg_to_col_if_sql_exprrm}sM#v C ||C   {KDQTI; W  rict|tr|St|tr t|dStd|j dt |)N _caller_namer\z' expected Column or str, got: )r]rXrkrdupperrerfs rg_to_col_if_strrrsR#v C c-- !""A$s) M  rict|tr|St|tr t|dSt|trtt |dSt d|j dt|)NroFrZr\z$' expected Column, int or str, got: )r]rXrkintrrdrqrerfs rg_to_col_if_str_or_intrusm#v C c-- C gcle44 !""FtCyk R  riceZdZdZe djdddeeefdeedee jd e d eed e d dfd Z de d e fdZdeeefd dfdZdeeefd dfdZdeeefd dfdZdeeefd dfdZdeeefd dfdZdeeefd dfdZdeeefd dfdZdeeefd dfdZdeeefd dfdZdeeefd dfdZdeeefd dfdZdeeefd dfdZdeeefd dfdZdeeefd dfdZdeeefd dfdZdeeefd dfd Z deeefd dfd!Z!deeefd dfd"Z"deeefd dfd#Z#d e fd$Z$dkd%Z%dld&Z&d'Z'edd(d)ee(e)e(de)dd*fd e d dfd+Z*e dmd,eeefd-eeefd e d dfd.Z+e dmdeeefd e d dfd/Z,e dmdeeefd e d dfd0Z-e dmdeeefd e d dfd1Z.dnd2Z/edmddd e d dfd3Z0edmd e d dfd4Z1edmd e d dfd5Z2edmd e d dfd6Z3dede fd dfd7Z4dede fd dfd8Z5dede fd dfd9Z6dede fd dfd:Z7dnd;Z8 dode d?e d e d df d@Z:e dpde d?e d e d df dAZ;e dpde d?e d e d df dBZedmd e d dfdEZ?edmd e d dfdFZ@edmd e d dfdGZAedmd e d dfdHZBedmdIeCd e d dfdJZDe dqdIeCdKeeCd e d dfdLZEedmdeCd e d dfdMZFedmdeCd e d dfdNZGe dmdOedefdPedefd e d dfdQZHedmdRed e d dfdSZIedmdTeJd e d dfdUZKd eefdVZLdWZMdXZNedmdYed e d dfdZZOedmdYed e d dfd[ZPdYed dfd\ZQe drdYed]eRjd^d e d dfd_ZTe dqd`eeUd e d dfdaZVedd(dbeeJe)eJfd e d dfdcZWd eXfddZYeZdeeeefd efdfZ[eZdldgedhee jd dfdiZ\e*Z]e;Z^eEZ_eHZ`e,Zae-Zbe.Zce3Zde2Zee0ZfeLZgeZheZiy)srXa;Represents a column or an expression in a :class:`DataFrame`. To access a Column object that refers a column in a :class:`DataFrame`, you can: - Use the column name. - Use the :func:`functions.col` function. - Use the :func:`DataFrame.col` method. - Use the index operator ``[]`` on a dataframe object with a column name. - Use the dot operator ``.`` on a dataframe object with a column name. >>> from snowflake.snowpark.functions import col >>> df = session.create_dataframe([["John", 1], ["Mike", 11]], schema=["name", "age"]) >>> df.select("name").collect() [Row(NAME='John'), Row(NAME='Mike')] >>> df.select(col("name")).collect() [Row(NAME='John'), Row(NAME='Mike')] >>> df.select(df.col("name")).collect() [Row(NAME='John'), Row(NAME='Mike')] >>> df.select(df["name"]).collect() [Row(NAME='John'), Row(NAME='Mike')] >>> df.select(df.name).collect() [Row(NAME='John'), Row(NAME='Mike')] Snowflake object identifiers, including column names, may or may not be case sensitive depending on a set of rules. Refer to `Snowflake Object Identifier Requirements `_ for details. When you use column names with a DataFrame, you should follow these rules. The returned column names after a DataFrame is evaluated follow the case-sensitivity rules too. The above ``df`` was created with column name "name" while the returned column name after ``collect()`` was called became "NAME". It's because the column is regarded as ignore-case so the Snowflake database returns the upper case. To create a Column object that represents a constant value, use :func:`snowflake.snowpark.functions.lit`: >>> from snowflake.snowpark.functions import lit >>> df.select(col("name"), lit("const value").alias("literal_column")).collect() [Row(NAME='John', LITERAL_COLUMN='const value'), Row(NAME='Mike', LITERAL_COLUMN='const value')] This class also defines utility functions for constructing expressions with Columns. Column objects can be built with the operators, summarized by operator precedence, in the following table: ============================================== ============================================== Operator Description ============================================== ============================================== ``x[index]`` Index operator to get an item out of a Snowflake ARRAY or OBJECT ``**`` Power ``-x``, ``~x`` Unary minus, unary not ``*``, ``/``, ``%`` Multiply, divide, remainder ``+``, ``-`` Plus, minus ``&`` And ``|`` Or ``==``, ``!=``, ``<``, ``<=``, ``>``, ``>=`` Equal to, not equal to, less than, less than or equal to, greater than, greater than or equal to ============================================== ============================================== The following examples demonstrate how to use Column objects in expressions: >>> df = session.create_dataframe([[20, 5], [1, 2]], schema=["a", "b"]) >>> df.filter((col("a") == 20) | (col("b") <= 10)).collect() # use parentheses before and after the | operator. [Row(A=20, B=5), Row(A=1, B=2)] >>> df.filter((df["a"] + df.b) < 10).collect() [Row(A=1, B=2)] >>> df.select((col("b") * 10).alias("c")).collect() [Row(C=50), Row(C=20)] When you use ``|``, ``&``, and ``~`` as logical operators on columns, you must always enclose column expressions with parentheses as illustrated in the above example, because their order precedence is higher than ``==``, ``<``, etc. Do not use ``and``, ``or``, and ``not`` logical operators on column objects, for instance, ``(df.col1 > 1) and (df.col2 > 2)`` is wrong. The reason is Python doesn't have a magic method, or dunder method for them. It will raise an error and tell you to use ``|``, ``&`` or ``~``, for which Python has magic methods. A side effect is ``if column:`` will raise an error because it has a hidden call to ``bool(a_column)``, like using the ``and`` operator. Use ``if a_column is None:`` instead. To access elements of a semi-structured Object and Array, use ``[]`` on a Column object: >>> from snowflake.snowpark.types import StringType, IntegerType >>> df_with_semi_data = session.create_dataframe([[{"k1": "v1", "k2": "v2"}, ["a0", 1, "a2"]]], schema=["object_column", "array_column"]) >>> df_with_semi_data.select(df_with_semi_data["object_column"]["k1"].alias("k1_value"), df_with_semi_data["array_column"][0].alias("a0_value"), df_with_semi_data["array_column"][1].alias("a1_value")).collect() [Row(K1_VALUE='"v1"', A0_VALUE='"a0"', A1_VALUE='1')] >>> # The above two returned string columns have JSON literal values because children of semi-structured data are semi-structured. >>> # The next line converts JSON literal to a string >>> df_with_semi_data.select(df_with_semi_data["object_column"]["k1"].cast(StringType()).alias("k1_value"), df_with_semi_data["array_column"][0].cast(StringType()).alias("a0_value"), df_with_semi_data["array_column"][1].cast(IntegerType()).alias("a1_value")).collect() [Row(K1_VALUE='v1', A0_VALUE='a0', A1_VALUE=1)] This class has methods for the most frequently used column transformations and operators. Module :mod:`snowflake.snowpark.functions` defines many functions to transform columns. NTF_is_qualified_nameexpr1expr2_astr[rprxrWcJ||_||_||_ d dtdttdt fd}|t |trt |ts td|dk(rtg||_ n,|r||||_ nt t|||_ |j|rt||||_nt |tr`|dk(rtg|_ n)|r|||_ nt t||_ |jt|rrt|d||_n_t |trD||_ |j<|r:t|dr|j|_nt||_n td |jJy) Nexprdf_aliasrWc t|}t|dk(rtt|d|Stt|dddj d|ddDd| S) z[Note that this method does not work for full column name like ...column.rr~:.c36K|]}t|dyw)T) keep_caseN)rE).0parts rg zFColumn.__init__..derive_qualified_name_expr..s6n\`z$RV7W7W6nsNT) is_sql_textr~)rFlenr%rEjoin)r}r~partss rgderive_qualified_name_exprz3Column.__init__..derive_qualified_name_expr sv8=E5zQ*:eAh+?(SS+!%(+,Achh6ndijkjldm6n.n-op $%rizAWhen Column constructor gets two arguments, both need to be *rr{z2Column constructor only accepts str or expression.N)r{_expr1_expr2rkrr%r] ValueErrorr" _expressionrEr9rhasattrr:rd)selfryrzr{r[rprxrs rg__init__zColumn.__init__s   26  !)#     uc*z%/E W|#'U#; ##=eU#K #6u%$ yy Y1% M s #|#'8 ##=e#D #6z%7H#I yy Y1%|L z *$D yy Y5&) % DI :5 ADIPQ Q+++riothercdt|ttfr |jy|jduS)zHelper function to determine without a session whether AST should be generated or not based on checking whether self and other have an AST.NF)r]rXrr{)rrs rg__should_emit_ast_for_binaryz#Column.__should_emit_ast_for_binaryKs. efj1 2uzz7Iyy$$rifieldct|jdu}d}t|try|rUtj}t |j }|jj|j||_ tt|j|||St|try|rUtj}t |j}|jj|j||_tt!|j|||St#dt%|)z_Accesses an element of ARRAY column by ordinal position, or an element of OBJECT column by key.Nr{r[zUnexpected item type: )r{r]rkprotoExprr;column_apply__stringrTCopyFromrrXr$rrtcolumn_apply__intidxr#rdre)rrr[r}asts rg __getitem__zColumn.__getitem__RsIIT)  eS !zz|'(A(AB  +! t//7di s #zz|'(>(>?  +D,,e449 4T%[MBC Cricbd}|j|x}rdtj}t|j}|j j |jt|j|tj|}tt|j|||S)z Equal to.Nr)#_Column__should_emit_ast_for_binaryrrr;eqlhsrr{r7rhsrX_to_exprr rrrr}r[rrights rg__eq__z Column.__eq__ls99%@ @9 @::  ric^d}|j|x}rdtj}t|j}|j j |jt|j|tt|jtj|||S)zGreater than or equal to.Nr)rrrr;geqrrr{r7rrXrrrrs rg__ge__z Column.__ge__s99%@ @9 @::  ric^d}|j|x}rdtj}t|j}t |j ||jj|jtttj||j||Sr)rrrr;rr7rrrr{rXrrrrs rg__rsub__zColumn.__rsub__99%@ @9 @::  ric^d}|j|x}rdtj}t|j}|j j |jt|j|tt|jtj|||S)z Multiply.Nr)rrrr;mulrrr{r7rrXrrrrs rg__mul__zColumn.__mul__rric^d}|j|x}rdtj}t|j}t |j ||jj|jtttj||j||Sr)rrrr;rr7rrrr{rXrrrrs rg__rmul__zColumn.__rmul__rric^d}|j|x}rdtj}t|j}|j j |jt|j|tt|jtj|||S)zDivide.Nr)rrrr;divrrr{r7rrXr rrrs rg __truediv__zColumn.__truediv__s99%@ @9 @:: ?  ric^d}|j|x}rdtj}t|j}t |j ||jj|jtttj||j||Sr)rrrr;rr7rrrr{rXrrrrs rg__rmod__zColumn.__rmod__8s99%@ @9 @::.> ?  ric^d}|j|x}rdtj}t|j}|j j |jt|j|tt|jtj|||S)zPower.Nr)rrrr;powrrr{r7rrXrrrrs rg__pow__zColumn.__pow__Erric^d}|j|x}rdtj}t|j}t |j ||jj|jtttj||j||Sr)rrrr;rr7rrrr{rXrrrrs rg__rpow__zColumn.__rpow__Srrictd)NzCannot convert a Column object into bool: please use '&' for 'and', '|' for 'or', '~' for 'not' if you're building DataFrame filter expressions. For example, use df.filter((col1 > 1) & (col2 > 2)) instead of df.filter(col1 > 1 and col2 > 2).rdrs rg__bool__zColumn.__bool__`s n  rictd)NzColumn is not iterable. This error can occur when you use the Python built-ins for sum, min and max. Please make sure you use the corresponding function from snowflake.snowpark.functions.rrs rg__iter__zColumn.__iter__fs J  rictd)NzColumn cannot be rounded. This error can occur when you use the Python built-in round. Please make sure you use the snowflake.snowpark.functions.round function instead.r)rns rg __round__zColumn.__round__ks w  ric,t|jSr)hashrrs rg__hash__zColumn.__hash__psD$$%%rirZvalsrUc t|}|s`d}|rEtj}|j}|jj |j ttd||S|Dcgc]}t|d}}t|jtrt|jjnd fd}|Dcgc] }|| }}t|dk7st|dtsdt f fd |D] }  |  d}|rtj}|j}|jj |j |D]h} |j"j%} t| t&j(j*j,r| j/| ]t1| | jtt3|j|||Scc}wcc}w) aReturns a conditional expression that you can pass to the :meth:`DataFrame.filter` or where :meth:`DataFrame.where` to perform the equivalent of a WHERE ... IN query with a specified list of values. You can also pass this to a :meth:`DataFrame.select` call. The expression evaluates to true if the value in the column is one of the values in a specified sequence. For example, the following code returns a DataFrame that contains the rows where the column "a" contains the value 1, 2, or 3. This is equivalent to ``SELECT * FROM table WHERE a IN (1, 2, 3)``. :meth:`isin` is an alias for :meth:`in_`. Examples:: >>> from snowflake.snowpark.functions import lit >>> df = session.create_dataframe([[1, "x"], [2, "y"] ,[4, "z"]], schema=["a", "b"]) >>> # Basic example >>> df.filter(df["a"].in_(lit(1), lit(2), lit(3))).collect() [Row(A=1, B='x'), Row(A=2, B='y')] >>> # Check in membership for a DataFrame that has a single column >>> df_for_in = session.create_dataframe([[1], [2] ,[3]], schema=["col1"]) >>> df.filter(df["a"].in_(df_for_in)).sort(df["a"].asc()).collect() [Row(A=1, B='x'), Row(A=2, B='y')] >>> # Use in with a select method call >>> df.select(df["a"].in_(lit(1), lit(2), lit(3)).alias("is_in_list")).collect() [Row(IS_IN_LIST=True), Row(IS_IN_LIST=True), Row(IS_IN_LIST=False)] >>> # Use in with column object >>> df2 = session.create_dataframe([[1, 1], [2, 4] ,[3, 0]], schema=["a", "b"]) >>> df2.select(df2["a"].in_(df2["b"]).alias("is_a_in_b")).collect() [Row(IS_A_IN_B=True), Row(IS_A_IN_B=False), Row(IS_A_IN_B=False)] Args: vals: The literal values, the columns in the same DataFrame, or a :class:`DataFrame` instance to use to check for membership against this column. NFrin_rc,t|tttfrUt |k(r,t |Dcgc]}t j|c}Stdt |ddt|tjjrft |jjk(rt|jStdt |jjddt j|Scc}w)NzThe number of values z& does not match the number of columns r)r]rbrcrarrrXrrr^r_r`schemafieldsr!_plan)valuev column_counts rg value_mapperz Column.in_..value_mappers%%d!34u:--5.Qavq/A.QRR$/E |;abnaoopqE9#5#5#?#?@u||**+|;)%++66$/ELL4G4G0H/IIop|o}}~u--/RsDr value_exprct|ttttfryt|t r|j D] }| ytdt|d)Nr\z' is not supported for the values parameter of the function in(). You must either specify a sequence of literals or a DataFrame that represents a subquery.) r]rr&r%r.r expressionsrdre)rr}validate_values rgrz"Column.in_..validate_valuesn)5H$ O ,>? * 6 6-&t,-#D,-.12ri)rCrr column_inrTrr{rXrrhr]rrrrr!rvaluesrr^r_ dataframer` _set_ast_refr6r)rr[rcolsr proto_astrTrvalue_expressionsvevalval_astrrs @@rgrz Column.in_ssj-d3CjjlMM  &&tyy1'%.siH H6:;ssE*;;$**,>?   ,, -   .$;??3\#.?? t9>,=a,@.!Q : "( #r" # **,C I MM " "499 - =#**..0c9#5#5#?#?#I#IJ$$W-.w<  = ))+< =  }<4@s 1G/ G4 lower_bound upper_boundcd}|r|jztj}t|j}|j j |jt|j|t|j|tj||k|tj|kz}||_|S)z$Between lower bound and upper bound.N) r{rrr;column_betweenrTrr7rrrXr)rrrr[r}rrets rgbetweenzColumn.betweens .::.> ?  ricTd}|rp|jdtj}t|j}|j j |jt|j|tttj||j||S)z Bitwise xor.Nr) r{rrr;bit_xorrrr7rrXr rrrs rgbitxorz Column.bitxor0rricd}|jdu}|rNtj}t|j}|j j |jtt|j||S)z Unary minus.Nr) r{rrr;negoperandrrXr3rrr}r[rs rg__neg__zColumn.__neg__CscIIT) ::sp ::`_. Nr) rrr;column_string_likerTrr{r7r[rXrrr)rr[r[r}rs rglikez Column.like^sw ::`_. :meth:`rlike` is an alias of :meth:`regexp`. Nr)rrr; column_regexprTrr{r7r[r_rXr rr)rr[r_r[r}rs rgregexpz Column.regexpus& :: J J  ri start_poslengthcd}|rztj}t|j}|jj |j t|j|t|j|ttjjj|||j||S)aDReturns a substring of this string column. Args: start_pos: The starting position of the substring. Please note that the first character has position 1 instead of 0 in Snowflake database. length: The length of the substring. :meth:`substring` is an alias of :meth:`substr`. Nr)rrr;column_string_substrrTrr{r7posrrXr^r_rf substringr)rrmrnr[r}rs rgsubstrz Column.substrs ::C GG  TYY ' 9#''9 M 9#''6 J    ( ( 2 24F K W W  ricollation_speccd}|rdtj}t|j}|jj |j t|j|tt|j|||S)acReturns a copy of the original :class:`Column` with the specified ``collation_spec`` property, rather than the original collation specification property. For details, see the Snowflake documentation on `collation specifications `_. Nr) rrr;column_string_collaterTrr{r7rtrXrr)rrtr[r}rs rgcollatezColumn.collatess ::$>?C GG  TYY ' 9""N  D$$n 5DI  ristringcRd}|rdtj}t|j}|jj |j t|j|ttjjj||j||S)zReturns true if the column contains `string` for each row. Args: string: the string to search for in this column. Nr)rrr;column_string_containsrTrr{r7r[rXr^r_rfcontainsr)rrxr[r}rs rgr{zColumn.containss ::`_). Examples:: >>> from snowflake.snowpark.functions import array_agg, col >>> from snowflake.snowpark import Window >>> df = session.create_dataframe([(3, "v1"), (1, "v3"), (2, "v2")], schema=["a", "b"]) >>> # create a DataFrame containing the values in "a" sorted by "b" >>> df.select(array_agg("a").within_group(col("b").asc()).alias("new_column")).show() ---------------- |"NEW_COLUMN" | ---------------- |[ | | 3, | | 2, | | 1 | |] | ---------------- >>> # create a DataFrame containing the values in "a" grouped by "b" >>> # and sorted by "a" in descending order. >>> df_array_agg_window = df.select(array_agg("a").within_group(col("a").desc()).over(Window.partitionBy(col("b"))).alias("new_column")) >>> df_array_agg_window.show() ---------------- |"NEW_COLUMN" | ---------------- |[ | | 3 | |] | |[ | | 1 | |] | |[ | | 2 | |] | ---------------- Nrrz,'WITHIN_GROUP' expected Column or str, got: r)rrr;column_within_grouprTrr{rr]rarbrcrvariadicrCrXargsappendrkr string_valrrdrer'r) rr[rr}r order_by_colsrTcol_ast order_by_cols rg within_groupzColumn.within_groupfsnh ::KLl))L    MsF3cxt|jtr |jSt|jSr)r]rrr4rs rg_namedz Column._nameds/ d&& 8## #"4#3#34 4rir}clt||r |jSt|tr|St|S)a; Convert a Column object, or an literal value to an expression. If it's a Column, get its expression. If it's already an expression, return it directly. If it's a literal value (here we treat str as literal value instead of column name), create a Literal expression. )r]rrr)clsr}s rgrzColumn._to_exprs3 dC ## # j )K4= rierc,|t|d|S)NT)rr{)r%)rrrs rgrlz Column._exprs&qd;#FFri)NNTrX)rWNrT)rWrX)FFFT)FFTNT)r}T)j__name__ __module__ __qualname____doc__rDrrkrrrrboolrrrrtrr=rrrrrrrrrrrrrrrrrrrrrrrArSrr rrrrrr"r%r(r,r/r2r4r7rGrArFrHrMrPrSrVrXrZr>r^rbrhrlrsrwr?r{r~rrrrrtypingrr}rPrrrr classmethodrrlisinastyperlikerr bitwiseAnd bitwiseOR bitwiseXOR isNotNullisNull eqNullSafegetNamegetItemgetFieldrirgrXrXs Uz $%)&. J,$)J,S*_%J,}J,uzz" J,  J, sm J,!J, J,J,X%#%$%DsCxDXD4 XE/:"=> X8 X  E/:"=>  8    E/:"=>  8    E/:"=>  8    E/:"=>  8    E/:"=>  8    U?J#>?  H    eOZ$?@  X    U?J#>?  H    eOZ$?@  X    U?J#>?  H    eOZ$?@  X     'B!C      %(C"D      U?J#>?  H    eOZ$?@  X    U?J#>?  H    eOZ$?@  X   $   &B   [ !  X  *  , B B  B B H  ?J67?J67   *KO ?J67 DH   KO ?J67 DH   KO ?J67 DH   $ T    T  X    O4O8OOPPPPSTSXSS  U8S=1  h    eHcM2  x    E(C-0  X    U8S=1  h   M#   #x-           B$   #x-          $$   #x-          $  d  h      $  (              T  X                     . 4 8  ,48 % #% /0%  %  % % N 2 t x  0 0 T X  2   3' hm$      8 c d h  & |    $ (3- --DDDDDF3F4F8FFCCCHC;A    67      BEIVz*V>BV VV&TXU <,)??@U MQU U U n55  !E/:"=> !: ! !GcG 4GGG D F EIJIJI FJGGHric eZdZdZe ddddedeejde de d df fd Z e dd e d e de d dfd Z edd e de d dfdZeZxZS)CaseExpra# Represents a `CASE `_ expression. To construct this object for a CASE expression, call the :func:`functions.when` specifying a condition and the corresponding result for that condition. Then, call :func:`when` and :func:`otherwise` methods to specify additional conditions and results. Examples:: >>> from snowflake.snowpark.functions import when, col, lit >>> df = session.create_dataframe([[None], [1], [2]], schema=["a"]) >>> df.select(when(col("a").is_null(), lit(1)) \ ... .when(col("a") == 1, lit(2)) \ ... .otherwise(lit(3)).alias("case_when_column")).collect() [Row(CASE_WHEN_COLUMN=1), Row(CASE_WHEN_COLUMN=2), Row(CASE_WHEN_COLUMN=3)] NFrwr}r{r[rxrWcNt||||||j|_y)N)rxr{r[)superrbranches _branches)rr}r{r[rx __class__s rgrzCaseExpr.__init__s.  %7di  ri conditionrc ||rct|jjjj }t |j |t|j|ttg|jt|djtj|f|j|S)aC Appends one more WHEN condition to the CASE expression. Args: condition: A :class:`Column` expression or SQL text representing the specified condition. value: A :class:`Column` expression or a literal value, which will be returned if ``condition`` is true. whenr)r;r{column_case_exprcasesrr8rr7rrrrrmrrXr)rrrr[ case_exprs rgrz CaseExpr.when s )$))*D*D*J*J*N*N*PQI 6y7J7JI V 9)//5 Q ^^,Iv>JJ.   ric|rMt|jjjj }t |j |tt|jtj||jS)zsSets the default result for this CASE expression. :meth:`else_` is an alias of :meth:`otherwise`. r) r;r{rrrr7rrrrrXr)rrr[rs rg otherwisezCaseExpr.otherwise+sb )$))*D*D*J*J*N*N*PQI 9)//5 Q T^^V__U%; <499  rirr)rrrrrDrrrrrrr@r=rrelse_ __classcell__)rs@rgrrs(&* ' $) ' 'uzz" ' ' ! '  ' 'TX ( 1@ MQ   >    4  :     ErirzMETADATA$FILE_ROW_NUMBERzMETADATA$FILE_CONTENT_KEYzMETADATA$FILE_LAST_MODIFIEDzMETADATA$START_SCAN_TIMEzMETADATA$FILENAME)vsysrrrrsnowflake.snowparkr^4snowflake.snowpark._internal.proto.generated.ast_pb2r_ _internalr generatedast_pb27snowflake.snowpark._internal.analyzer.binary_expressionrrrr r r r r rrrrrrrrrr0snowflake.snowpark._internal.analyzer.expressionrrrrrrrrr r!r"r#r$r%r&r'5snowflake.snowpark._internal.analyzer.sort_expressionr(r)r*r+r,6snowflake.snowpark._internal.analyzer.unary_expressionr-r.r/r0r1r2r3r4r5&snowflake.snowpark._internal.ast.utilsr6r7r8r9r:r;'snowflake.snowpark._internal.type_utilsr<r=r>r?r@rArB"snowflake.snowpark._internal.utilsrCrDrErFsnowflake.snowpark.typesrGrHrIrJrKrLrMrNsnowflake.snowpark.windowrOrP version_inforScollections.abcrkrhrmrrrtrurXrMETADATA_FILE_ROW_NUMBERMETADATA_FILE_CONTENT_KEYMETADATA_FILE_LAST_MODIFIEDMETADATA_START_SCAN_TIMEMETADATA_FILENAMEr~rNTZLTZMETADATA_COLUMN_TYPESrrirgrs  ''DDD($      9 v(   >> ?  LO      _         u\3%67  C  H  EEP*QvQl""<="#>?$%BC!"<=./%%'%%''')=9J9N9N+O$$& 6G6K6K(L ri