teradataml 20.0.0.2__py3-none-any.whl → 20.0.0.3__py3-none-any.whl

teradataml/dataframe/sql.py

@@ -222,6 +222,10 @@ class _MetaExpression(object):
     def __repr__(self):
       return repr(self.__t)
 
+    def _get_table_expr(self):
+        return self.__t
+
+
 class _PandasTableExpression(TableExpression):
 
     def _assign(self, drop_columns, **kw):
@@ -484,6 +488,7 @@ class _SQLTableExpression(_PandasTableExpression):
             columns = []
             for c in kw['column_order']:
                 name = c.strip()
+                # Get case-insensitive column names from Table object.
                 col = table.c.get(name, table.c.get(name.lower(), table.c.get(name.upper())))
 
                 if col is None:
@@ -5473,7 +5478,8 @@ class _SQLColumnExpression(_LogicalColumnExpression,
         self._env_name = kw.get("env_name", None)
         self._delimiter = kw.get("delimiter", None)
         self._quotechar = kw.get("quotechar", None)
-        self.alias_name = self.compile() if self._udf is None else None
+        self._udf_script = kw.get("udf_script", None)
+        self.alias_name = self.compile() if (self._udf or self._udf_script) is None else None
 
     @property
     def expression(self):
@@ -5653,23 +5659,23 @@ class _SQLColumnExpression(_LogicalColumnExpression,
         """
         Calls the compile method of the underlying sqlalchemy.Column
         """
-        if len(kw) == 0:
-            kw = dict({'dialect': td_dialect(),
-                'compile_kwargs':
-                    {
-                        'include_table': False,
-                        'literal_binds': True
-                    }
-                })
-
-        return str(self.expression.compile(*args, **kw))
+        kw_new = dict({'dialect': td_dialect(),
+                       'compile_kwargs':
+                           {
+                                'include_table': False,
+                                'literal_binds': True
+                           }
+                       })
+        if len(kw) != 0:
+            kw_new.update(kw)
+        return str(self.expression.compile(*args, **kw_new))
 
     def compile_label(self, label):
         """
         DESCRIPTION:
             Compiles expression with label, by calling underlying sqlalchemy methods.
 
-        PARAMETES:
+        PARAMETERS:
             label:
                 Required Argument.
                 Specifies the label to be used to alias the compiled expression.
@@ -5699,7 +5705,7 @@ class _SQLColumnExpression(_LogicalColumnExpression,
             with the "value". Use this function either to replace or remove
             NA from Column.
 
-        PARAMETES:
+        PARAMETERS:
             value:
                 Required Argument.
                 Specifies the replacement value for null values in the column.
@@ -6186,12 +6192,19 @@ class _SQLColumnExpression(_LogicalColumnExpression,
                     # If user has not passed any type, then set it to
                     # NullType().
                     type = sqlalc.sql.sqltypes.NullType()
-
+                # Boolean flag to treat function as an instance method.
+                function_has_col_caller = column_function
                 # Generate the function syntax based on whether the
                 # function is column function or not.
                 if column_function:
                     name = quoted_name("{}.{}".format(col_name, func_name),
                                        False)
+                    # Dynamic function gets called on teradataml._SQLColumnExpression type object.
+                    # 'expression' attribute of _SQLColumnExpression object holds
+                    # corresponding SQLAlchemy.Expression type object.
+                    # SQLAlchemy.Expression type object should be available from FunctionElement.
+                    # This 'func_caller' attribute points to that Expression object.
+                    func_caller = self.expression
                 else:
                     name = quoted_name(func_name, False)
 
@@ -10809,4 +10822,160 @@ class _SQLColumnExpression(_LogicalColumnExpression,
             whens = case([((self != 0) & (base != 0) & (base.ln() != 0),
                            (self.ln() / base.ln()).cast(FLOAT))])
 
-        return whens
+        return whens
+
+    def isnan(self):
+        """
+        DESCRIPTION:
+            Function evaluates a variable or expression to determine if the
+            floating-point argument is a NaN (Not-a-Number) value. When a database
+            table contains a NaN value, the data is undefined and unrepresentable
+            in floating-point arithmetic. For example, division by 0, or the square root
+            of a negative number would return a NaN result.
+
+        RETURNS:
+            ColumnExpression.
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("teradataml","titanic")
+
+            # Create a DataFrame on 'titanic' table.
+            >>> titanic = DataFrame.from_table('titanic')
+            >>> df = titanic.select(["passenger", "age", "fare"])
+            >>> print(df)
+                        age      fare
+            passenger
+            326        36.0  135.6333
+            183         9.0   31.3875
+            652        18.0   23.0000
+            40         14.0   11.2417
+            774         NaN    7.2250
+            366        30.0    7.2500
+            509        28.0   22.5250
+            795        25.0    7.8958
+            61         22.0    7.2292
+            469         NaN    7.7250
+            >>>
+
+            # Example 1: Find whether 'fare' column contains NaN values or not.
+            >>> nan_df = df.assign(nanornot = df.fare.isnan())
+            >>> print(nan_df)
+                        age      fare nanornot
+            passenger
+            326        36.0  135.6333        0
+            183         9.0   31.3875        0
+            652        18.0   23.0000        0
+            40         14.0   11.2417        0
+            774         NaN    7.2250        0
+            366        30.0    7.2500        0
+            509        28.0   22.5250        0
+            795        25.0    7.8958        0
+            61         22.0    7.2292        0
+            469         NaN    7.7250        0
+            >>>
+        """
+        return _SQLColumnExpression(literal_column(f"TD_ISNAN({self.compile()})"), type=INTEGER)
+
+    def isinf(self):
+        """
+        DESCRIPTION:
+            Function evaluates a variable or expression to determine if the
+            floating-point argument is an infinite number. This function determines
+            if a database table contains positive or negative infinite values.
+
+        RETURNS:
+            ColumnExpression.
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("teradataml","titanic")
+
+            # Create a DataFrame on 'titanic' table.
+            >>> titanic = DataFrame.from_table('titanic')
+            >>> df = titanic.select(["passenger", "age", "fare"])
+            >>> print(df)
+                        age      fare
+            passenger
+            326        36.0  135.6333
+            183         9.0   31.3875
+            652        18.0   23.0000
+            40         14.0   11.2417
+            774         NaN    7.2250
+            366        30.0    7.2500
+            509        28.0   22.5250
+            795        25.0    7.8958
+            61         22.0    7.2292
+            469         NaN    7.7250
+            >>>
+
+            # Example 1: Find whether 'fare' column contains infinity values or not.
+            >>> inf_df = df.assign(infornot = df.fare.isinf())
+            >>> print(inf_df)
+                        age      fare infornot
+            passenger
+            326        36.0  135.6333        0
+            183         9.0   31.3875        0
+            652        18.0   23.0000        0
+            40         14.0   11.2417        0
+            774         NaN    7.2250        0
+            366        30.0    7.2500        0
+            509        28.0   22.5250        0
+            795        25.0    7.8958        0
+            61         22.0    7.2292        0
+            469         NaN    7.7250        0
+            >>>
+        """
+        return _SQLColumnExpression(literal_column(f"TD_ISINF({self.compile()})"), type=INTEGER)
+
+    def isfinite(self):
+        """
+        DESCRIPTION:
+            Function evaluates a variable or expression to determine if
+            it is a finite floating value. A finite floating value is not
+            a NaN (Not a Number) value and is not an infinity value.
+
+        RETURNS:
+            ColumnExpression.
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("teradataml","titanic")
+
+            # Create a DataFrame on 'titanic' table.
+            >>> titanic = DataFrame.from_table('titanic')
+            >>> df = titanic.select(["passenger", "age", "fare"])
+            >>> print(df)
+                        age      fare
+            passenger
+            326        36.0  135.6333
+            183         9.0   31.3875
+            652        18.0   23.0000
+            40         14.0   11.2417
+            774         NaN    7.2250
+            366        30.0    7.2500
+            509        28.0   22.5250
+            795        25.0    7.8958
+            61         22.0    7.2292
+            469         NaN    7.7250
+            >>>
+
+            # Example 1: Find whether 'fare' column contains finite values or not.
+            >>> finite_df = df.assign(finiteornot = df.fare.isfinite())
+            >>> print(finite_df)
+                        age    fare finiteornot
+            passenger
+            530        23.0  11.500           1
+            591        35.0   7.125           1
+            387         1.0  46.900           1
+            856        18.0   9.350           1
+            244        22.0   7.125           1
+            713        48.0  52.000           1
+            448        34.0  26.550           1
+            122         NaN   8.050           1
+            734        23.0  13.000           1
+            265         NaN   7.750           1
+            >>>
+
+        """
+        return _SQLColumnExpression(literal_column(f"TD_ISFINITE({self.compile()})"), type=INTEGER)