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

teradataml/dataframe/sql.py

@@ -40,7 +40,7 @@ import sqlalchemy as sqlalc
 
 import re
 
-from teradatasqlalchemy.dialect import dialect as td_dialect, compiler as td_compiler
+from teradatasqlalchemy.dialect import dialect as td_dialect, compiler as td_compiler, TeradataTypeCompiler as td_type_compiler
 from teradatasqlalchemy import (INTEGER, SMALLINT, BIGINT, BYTEINT, DECIMAL, FLOAT, NUMBER)
 from teradatasqlalchemy import (DATE, TIME, TIMESTAMP)
 from teradatasqlalchemy import (BYTE, VARBYTE, BLOB)
@@ -52,7 +52,7 @@ from teradatasqlalchemy import (INTERVAL_DAY, INTERVAL_DAY_TO_HOUR, INTERVAL_DAY
                                 INTERVAL_YEAR_TO_MONTH)
 from teradatasqlalchemy import (PERIOD_DATE, PERIOD_TIME, PERIOD_TIMESTAMP)
 from teradatasqlalchemy import XML, GEOMETRY
-from teradatasqlalchemy.telemetry.queryband import collect_queryband
+from teradataml.telemetry_utils.queryband import collect_queryband
 import decimal
 import datetime as dt
 from teradataml.dataframe.window import Window
@@ -612,8 +612,9 @@ class _SQLTableExpression(_PandasTableExpression):
                 expression = display_number(c.expression)
             elif isinstance(c.type, tuple(datetime_period_types)):
                 expression = cast_expr(c.expression, 30)
+            # Change the size as INTERVAL_DAY_TO_SECOND(4, 6) is failing.
             elif isinstance(c.type, tuple(interval_types)):
-                expression = cast_expr(c.expression, 20)
+                expression = cast_expr(c.expression, 25)
             elif isinstance(c.type, GEOMETRY):
                 expression = cast_expr(c.expression, display.geometry_column_length) if \
                     display.geometry_column_length is not None else c.expression.label(c.name)
@@ -1618,6 +1619,8 @@ class _ArithmeticColumnExpression(ColumnExpression):
     def __sub__(self, other):
         """
         Compute the difference between two ColumnExpressions using -
+        Note:
+            * Difference between two timestamp columns return value in seconds.
 
         PARAMETERS:
             other:
@@ -1644,6 +1647,15 @@ class _ArithmeticColumnExpression(ColumnExpression):
             2           67/06/30        07/07/10        421.0   465.0       179.0
             3           67/06/30        07/07/10        434.0   485.0       185.0
             5           67/06/30        07/07/10        459.0   509.0       211.0
+            >>> load_example_data("uaf", "Convolve2RealsLeft")
+            >>> timestamp_df = DataFrame("Convolve2RealsLeft")
+            >>> timestamp_df
+                row_seq                  row_i_time  col_seq               column_i_time    A     B     C     D
+            id
+            1         1  2018-08-08 08:02:00.000000        0  2018-08-08 08:00:00.000000  1.3  10.3  20.3  30.3
+            1         1  2018-08-08 08:02:00.000000        1  2018-08-08 08:02:00.000000  1.4  10.4  20.4  30.4
+            1         0  2018-08-08 08:00:00.000000        1  2018-08-08 08:02:00.000000  1.2  10.2  20.2  30.2
+            1         0  2018-08-08 08:00:00.000000        0  2018-08-08 08:00:00.000000  1.1  10.1  20.1  30.1
 
             # Example 1: Subtract 100 from the income amount and assign the final amount
             #            to new column 'remaining_income'.
@@ -1666,7 +1678,26 @@ class _ArithmeticColumnExpression(ColumnExpression):
             1           67/06/30        07/07/10        415.0   451.0       180.0             271.0
             5           67/06/30        07/07/10        459.0   509.0       211.0             298.0
             4           67/06/30        07/07/10        448.0   493.0       192.0             301.0
+
+            # Example 3: Subtract 2 timestamp columns and assign to new column 'seconds'.
+            >>> timestamp_df.assign(seconds = timestamp_df.row_i_time-timestamp_df.column_i_time)
+                row_seq                  row_i_time  col_seq               column_i_time    A     B     C     D  seconds
+            id
+            1         1  2018-08-08 08:02:00.000000        0  2018-08-08 08:00:00.000000  1.3  10.3  20.3  30.3    120.0
+            1         1  2018-08-08 08:02:00.000000        1  2018-08-08 08:02:00.000000  1.4  10.4  20.4  30.4      0.0
+            1         0  2018-08-08 08:00:00.000000        1  2018-08-08 08:02:00.000000  1.2  10.2  20.2  30.2   -120.0
+            1         0  2018-08-08 08:00:00.000000        0  2018-08-08 08:00:00.000000  1.1  10.1  20.1  30.1      0.0
+
         """
+        if isinstance(self._type, TIMESTAMP) and isinstance(other._type, TIMESTAMP):
+            s = """
+                (CAST((CAST({0} AS DATE)-CAST({1} AS DATE)) AS FLOAT) * 86400) +
+                ((EXTRACT(HOUR FROM {0}) - EXTRACT(HOUR FROM {1})) * 3600) +
+                ((EXTRACT(MINUTE FROM {0}) - EXTRACT(MINUTE FROM {1})) * 60) +
+                ((EXTRACT(SECOND FROM {0}) - EXTRACT(SECOND FROM {1})))
+                """.format(self.compile(), other.compile())
+            return _SQLColumnExpression(literal_column(s, type_ = FLOAT))
+
         expr = other.expression if isinstance(other, _SQLColumnExpression) else other
         res = _SQLColumnExpression(self.expression - expr)
         return res
@@ -5431,12 +5462,18 @@ class _SQLColumnExpression(_LogicalColumnExpression,
             expression = literal_column(expression)
         self.kw = kw
         self.expression = expression
-        self.type = kw.get("type", expression.type)
+        self.type = kw.get("type", expression.type if expression is not None else kw.get("udf_type"))
         # Initial ColumnExpression has only one dataframe and hence
         # __has_multiple_dataframes = False.
         # eg: df1.col1, df2.col2
         self.__has_multiple_dataframes = False
         self.__names = []
+        self._udf = kw.get("udf", None)
+        self._udf_args = kw.get("udf_args", None)
+        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
 
     @property
     def expression(self):
@@ -5801,7 +5838,7 @@ class _SQLColumnExpression(_LogicalColumnExpression,
         return _SQLColumnExpression(func.concat(*columns_))
 
     @collect_queryband(queryband="DFC_cast")
-    def cast(self, type_ = None):
+    def cast(self, type_ = None, format = None, timezone = None):
         """
         DESCRIPTION:
             Apply the CAST SQL function to the column with the type specified.
@@ -5817,6 +5854,32 @@ class _SQLColumnExpression(_LogicalColumnExpression,
                 Default value: None
                 Types: teradatasqlalchemy type or object of teradatasqlalchemy type
 
+            format:
+                Optional Argument.
+                Specifies a variable length string containing formatting characters
+                that define the display format for the data type.
+                Formats can be specified for columns that have character, numeric, byte,
+                DateTime, Period or UDT data types.
+                Note:
+                    * Teradata supports different formats. Look at 'Formats' section in
+                      "SQL-Data-Types-and-Literals" in Vantage documentation for additional
+                      details.
+                Default value: None
+                Types: str
+
+            timezone:
+                Optional Argument.
+                Specifies the timezone string.
+                Check "SQL-Date-and-Time-Functions-and-Expressions" in
+                Vantage documentation for supported timezones.
+                Type: ColumnExpression or str.
+
+        RETURNS:
+            ColumnExpression
+
+        RAISES:
+            TeradataMlException
+
         EXAMPLES:
             >>> load_example_data("dataframe","admissions_train")
             >>> df = DataFrame('admissions_train')
@@ -5841,8 +5904,24 @@ class _SQLColumnExpression(_LogicalColumnExpression,
             programming      str
             admitted         int
 
-            >>> # Let's try creating a new DataFrame casting 'id' column (of type INTEGER) to VARCHAR(5),
-            >>> # an object of a teradatasqlalchemy type.
+            >>> dataframe_dict = {"id": [100, 200,300],
+            >>> "timestamp_col": ['1000-01-10 23:00:12-02:00', '2015-01-08 13:00:00+12:00', '2014-12-10 10:00:35-08:00'],
+            >>> "timezone_col": ["GMT", "America Pacific", "GMT+10"]}
+            >>> pandas_df = pd.DataFrame(dataframe_dict)
+            >>> copy_to_sql(pandas_df, table_name = 'new_table', if_exists = 'replace')
+            >>> df1 = DataFrame("new_table")
+            >>> df1
+            id              timestamp_col     timezone_col
+            300  2014-12-10 10:00:35-08:00           GMT+10
+            200  2015-01-08 13:00:00+12:00  America Pacific
+            100  1000-01-10 23:00:12-02:00              GMT
+            >>> df1.dtypes
+            id               int
+            timestamp_col    str
+            timezone_col     str
+
+            # Example 1: Let's try creating a new DataFrame casting 'id' column (of type INTEGER) to VARCHAR(5),
+            #            an object of a teradatasqlalchemy type.
             >>> from teradatasqlalchemy import VARCHAR
             >>> new_df = df.assign(char_id = df.id.cast(type_=VARCHAR(5)))
             >>> new_df
@@ -5867,8 +5946,8 @@ class _SQLColumnExpression(_LogicalColumnExpression,
             admitted         int
             char_id          str
 
-            >>> # Now let's try creating a new DataFrame casting 'id' column (of type INTEGER) to VARCHAR,
-            >>> # a teradatasqlalchemy type.
+            # Example 2:  Now let's try creating a new DataFrame casting 'id' column (of type INTEGER) to VARCHAR,
+            #             a teradatasqlalchemy type.
             >>> new_df_2 = df.assign(char_id = df.id.cast(type_=VARCHAR))
             >>> new_df_2
                masters   gpa     stats programming  admitted char_id
@@ -5892,25 +5971,65 @@ class _SQLColumnExpression(_LogicalColumnExpression,
             admitted         int
             char_id          str
 
-            >>> # Let's try filtering some data with a match on a column cast to another type,
-            >>> # an object of a teradatasqlalchemy type.
+            # Example 3: Let's try filtering some data with a match on a column cast to another type,
+            #            an object of a teradatasqlalchemy type.
             >>> df[df.id.cast(VARCHAR(5)) == '1']
                masters   gpa     stats programming  admitted
             id
             1      yes  3.95  Beginner    Beginner         0
 
-            >>> # Now let's try the same, this time using a teradatasqlalchemy type.
+            # Example 4: Now let's try the same, this time using a teradatasqlalchemy type.
             >>> df[df.id.cast(VARCHAR) == '1']
                masters   gpa     stats programming  admitted
             id
             1      yes  3.95  Beginner    Beginner         0
 
-        RETURNS:
-            ColumnExpression
+            # Example 5: Let's try creating a new DataFrame casting 'timestamp_col' column (of type VARCHAR) to TIMESTAMP,
+            #            using format.
+            >>> new_df1 = df1.assign(new_col = df1.timestamp_col.cast(TIMESTAMP, format='Y4-MM-DDBHH:MI:SSBZ'))
+            id              timestamp_col     timezone_col              new_col
+            300  2014-12-10 10:00:35-08:00           GMT+10  2014-12-10 18:00:35
+            200  2015-01-08 13:00:00+12:00  America Pacific  2015-01-08 01:00:00
+            100  1000-01-10 23:00:12-02:00              GMT  1000-01-11 01:00:12
+            >>> new_df1.tdtypes
+            id                             int
+            timestamp_col                  str
+            timezone_col                   str
+            new_col          datetime.datetime
+
+            # Example 6: Let's try creating a new DataFrame casting 'id' column (of type INTEGER) to VARCHAR,
+            #            using format.
+            >>> new_df2 = df1.assign(new_col = df1.id.cast(VARCHAR, format='zzz.zz'))
+            id              timestamp_col     timezone_col new_col
+            300  2014-12-10 10:00:35-08:00           GMT+10  300.00
+            200  2015-01-08 13:00:00+12:00  America Pacific  200.00
+            100  1000-01-10 23:00:12-02:00              GMT  100.00
+            >>> new_df2.dtypes
+            id               int
+            timestamp_col    str
+            timezone_col     str
+            new_col          str
+
+            # Example 7: Let's try creating a new DataFrame casting 'timestamp_with_timezone' column (of type TIMESTAMP) to
+            #            TIMESTAMP WITH TIMEZONE, with offset 'GMT+10'.
+            >>> new_df3 = new_df1.assign(timestamp_with_timezone = new_df1.new_col.cast(TIMESTAMP(timezone=True), timezone='GMT+10'))
+            id              timestamp_col     timezone_col              new_col         timestamp_with_timezone
+            300  2014-12-10 10:00:35-08:00           GMT+10  2014-12-10 18:00:35  2014-12-11 04:00:35.000000+10:00
+            200  2015-01-08 13:00:00+12:00  America Pacific  2015-01-08 01:00:00  2015-01-08 11:00:00.000000+10:00
+            100  1000-01-10 23:00:12-02:00              GMT  1000-01-11 01:00:12  1000-01-11 11:00:12.000000+10:00
+            >>> new_df3.dtypes
+            id                                       int
+            timestamp_col                            str
+            timezone_col                             str
+            new_col                    datetime.datetime
+            timestamp_with_timezone    datetime.datetime
+        """
+        # Validating Arguments
+        arg_type_matrix = []
+        arg_type_matrix.append(["format", format , True, (str), True])
+        arg_type_matrix.append(["timezone", timezone, True, (str, ColumnExpression, int, float), True])
+        _Validators._validate_function_arguments(arg_type_matrix)
 
-        RAISES:
-            TeradataMlException
-        """
         # If type_ is None or not specified, raise an Exception
         if type_ is None:
             raise TeradataMlException(Messages.get_message(MessageCodes.MISSING_ARGS, 'type_'),
@@ -5921,8 +6040,26 @@ class _SQLColumnExpression(_LogicalColumnExpression,
             raise TeradataMlException(Messages.get_message(MessageCodes.UNSUPPORTED_DATATYPE, 'type_',
                                                            'a valid teradatasqlalchemy type'),
                                       MessageCodes.UNSUPPORTED_DATATYPE)
-
         expression = func.cast(self.expression, type_=type_).label(self.name)
+        if format or timezone:
+            # Casting to VARCHAR or CHAR with format require this type of query
+            # CAST((CAST (F1 AS FORMAT 'format_str')) AS [CHAR|VARCHAR])
+            if isinstance(type_, (VARCHAR, CHAR)) or (isinstance(type_, type) and issubclass(type_, (VARCHAR, CHAR))):
+                expression = func.cast(literal_column("""CAST({} AS FORMAT '{}')""".format(self.compile(), format)), type_=type_)
+            else:
+                # Compile _TDType to string
+                type_compiler = td_type_compiler(td_dialect)
+                type_expression = type_compiler.process(type_) if not isinstance(type_, type) else type_compiler.process(type_())
+                # Create a query with format and timezone string
+                # CAST(TIMESTAMP "column_name" AS "_TDType" FORMAT "format" AT TIMEZONE "timezone_str")
+                format =  " FORMAT '{}'".format(format) if format else ""
+                if timezone and isinstance(timezone, _SQLColumnExpression):
+                    timezone = _SQLColumnExpression(literal_column(f' AT TIME ZONE {timezone.compile()}')).compile()
+                elif timezone:
+                    timezone = _SQLColumnExpression(literal_column(_SQLColumnExpression._timezone_string(timezone))).compile()
+                else:
+                    timezone = ""
+                expression = literal_column("""CAST({} AS {}{}{})""".format(self.compile(), type_expression, timezone, format), type_=type_)
         return _SQLColumnExpression(expression)
 
     def __hash__(self):
@@ -10088,3 +10225,588 @@ class _SQLColumnExpression(_LogicalColumnExpression,
             return list(set(result))
 
         return []
+    
+    def alias(self, name):
+        """
+        DESCRIPTION:
+            Function to returns this column with aliased name.
+
+        PARAMETERS:
+            name:
+                Required Argument.
+                Specifies the column name.
+                Type: str 
+
+        RAISES:
+            TypeError, ValueError
+
+        RETURNS:
+            ColumnExpression
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("dataframe", "admissions_train")
+
+            # Create a DataFrame on 'admissions_train' table.
+            >>> df = DataFrame("admissions_train")
+            >>> df
+                masters   gpa     stats programming  admitted
+            id
+            38     yes  2.65  Advanced    Beginner         1
+            7      yes  2.33    Novice      Novice         1
+            26     yes  3.57  Advanced    Advanced         1
+            5       no  3.44    Novice      Novice         0
+            3       no  3.70    Novice    Beginner         1
+            22     yes  3.46    Novice    Beginner         0
+            24      no  1.87  Advanced      Novice         1
+            36      no  3.00  Advanced      Novice         0
+            19     yes  1.98  Advanced    Advanced         0
+            40     yes  3.95    Novice    Beginner         0
+
+            # Example 1: Alias the resultant column after aggregation with "count_program".
+            >>> res = df.agg(df.programming.count().alias("count_program"))
+            >>> res
+               count_program
+            0             40
+
+        """
+        
+        # Validate argument types
+        arg_type_matrix = [["name", name , True, (str), True]]
+        _Validators._validate_function_arguments(arg_type_matrix)
+
+        self.alias_name = name
+        return self
+    
+    @staticmethod
+    def _timezone_string(value):
+        """
+        DESCRIPTION:
+            Function to return timezone string in correct format.
+
+        PARAMETERS:
+            value:
+                Required Argument.
+                Specifies timezone string.
+                Types: str, int , float
+
+        RETURNS:
+            bool
+        """
+        if isinstance(value, (float, int)):
+            return " AT TIME ZONE {}".format(value)
+        if value.upper() not in ['LOCAL']:
+            return " AT TIME ZONE '{}'".format(value)
+        return " AT {}".format(value)
+
+    def to_timestamp(self, format=None, type_=TIMESTAMP, timezone=None):
+        """
+        DESCRIPTION:
+            Converts string or integer to a TIMESTAMP data type or TIMESTAMP WITH
+            TIME ZONE data type.
+            Note:
+                * POSIX epoch conversion is implicit in the "to_timestamp" when column
+                  is integer type. POSIX epoch is the number of seconds that have elapsed
+                  since midnight Coordinated Universal Time (UTC) of January 1, 1970.
+
+        PARAMETERS:
+            format:
+                Specifies the format of string column.
+                Argument is not required when column is integer type, Otherwise Required.
+                For valid 'format' values, see documentation on
+                "to_date" or "help(df.col_name.to_date)".
+                Type: ColumnExpression or str
+
+            type_:
+                Optional Argument.
+                Specifies a TIMESTAMP type or an object of a
+                TIMESTAMP type that the column needs to be cast to.
+                Default value: TIMESTAMP
+                Permitted Values: TIMESTAMP data type
+                Types: teradatasqlalchemy type or object of teradatasqlalchemy type
+
+            timezone:
+                Optional Argument.
+                Specifies the timezone string.
+                For valid timezone strings, user should check Vantage documentation.
+                Type: ColumnExpression or str.
+
+        RETURNS:
+            ColumnExpression
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("teradataml", "timestamp_data")
+
+            # Create a DataFrame on 'timestamp_data' table.
+            >>> df = DataFrame("timestamp_data")
+            >>> df
+            id                timestamp_col  timestamp_col1                         format_col     timezone_col
+            2  2015-01-08 00:00:12.2+10:00     45678910234  YYYY-MM-DD HH24:MI:SS.FF6 TZH:TZM           GMT+10
+            1             2015-01-08 13:00          878986                 YYYY-MM-DD HH24:MI  America Pacific
+            0        2015-01-08 00:00:12.2          123456          YYYY-MM-DD HH24:MI:SS.FF6              GMT
+
+            >>> df.tdtypes
+            id                                          INTEGER()
+            timestamp_col     VARCHAR(length=30, charset='LATIN')
+            timestamp_col1                               BIGINT()
+            format_col        VARCHAR(length=30, charset='LATIN')
+            timezone_col      VARCHAR(length=30, charset='LATIN')
+
+            # Example 1: Convert Epoch seconds to timestamp.
+            >>> df.select(['id','timestamp_col1']).assign(col = df.timestamp_col1.to_timestamp())
+            id  timestamp_col1                         col
+            2     45678910234  3417-07-05 02:10:34.000000
+            1          878986  1970-01-11 04:09:46.000000
+            0          123456  1970-01-02 10:17:36.000000
+
+            # Example 2: Convert timestamp string to timestamp with timezone in
+            #            format mentioned in column "format_col".
+            >>> df.select(['id', 'timestamp_col', 'format_col']).assign(col = df.timestamp_col.to_timestamp(df.format_col, TIMESTAMP(timezone=True)))
+            id                timestamp_col                         format_col                             col
+            2  2015-01-08 00:00:12.2+10:00  YYYY-MM-DD HH24:MI:SS.FF6 TZH:TZM  2015-01-08 00:00:12.200000+10:00
+            1             2015-01-08 13:00                 YYYY-MM-DD HH24:MI  2015-01-08 13:00:00.000000+00:00
+            0        2015-01-08 00:00:12.2          YYYY-MM-DD HH24:MI:SS.FF6  2015-01-08 00:00:12.200000+00:00
+
+            # Example 3: Convert Epoch seconds to timestamp with timezone in 'GMT+2' location.
+            >>> df.select(['id', 'timestamp_col1', 'format_col']).assign(col = df.timestamp_col1.to_timestamp(df.format_col, TIMESTAMP(timezone=True), 'GMT+2'))
+            id  timestamp_col1                         format_col                             col
+            2     45678910234  YYYY-MM-DD HH24:MI:SS.FF6 TZH:TZM  3417-07-05 04:10:34.000000+02:00
+            1          878986                 YYYY-MM-DD HH24:MI  1970-01-11 06:09:46.000000+02:00
+            0          123456          YYYY-MM-DD HH24:MI:SS.FF6  1970-01-02 12:17:36.000000+02:00
+
+        """
+        # Validating Arguments
+        arg_type_matrix = []
+        arg_type_matrix.append(["format", format , True, (str, ColumnExpression), True])
+        arg_type_matrix.append(["timezone", timezone, True, (str, ColumnExpression, int, float), True])
+        _Validators._validate_function_arguments(arg_type_matrix)
+
+        if not UtilFuncs._is_valid_td_type(type_):
+            raise TeradataMlException(Messages.get_message(MessageCodes.UNSUPPORTED_DATATYPE, 'type_',
+                                                           'a valid teradatasqlalchemy type'),
+                                      MessageCodes.UNSUPPORTED_DATATYPE)
+
+        _format = format.expression if isinstance(format, _SQLColumnExpression) else format
+        _params = [self.expression, _format]
+        # format is not required when column is of below types.
+        if isinstance(self._type, (BYTEINT, SMALLINT, INTEGER, BIGINT)):
+            _params.pop()
+        # Use to_timestamp_tz when below 3 conditions are true.
+        # Resultant query will be Example:
+        # TO_TIMESTAMP('2015-10-08 00:00:12.2') or TO_TIMESTAMP_TZ('2015-10-08 00:00:12.2+03:00') based on type_
+        _fun = getattr(func, "to_timestamp_tz") if isinstance(type_, TIMESTAMP) and type_.timezone and len(_params) == 2 \
+            else getattr(func, "to_timestamp")
+        if not timezone:
+            return _SQLColumnExpression(_fun(*_params), type=type_)
+
+        # If user uses timezone generate query with time zone.
+        # Resultant query will be Example:
+        # TO_TIMESTAMP('2015-10-08 00:00:12.2') at time zone 'America Alaska',
+        # TO_TIMESTAMP_TZ('2015-10-08 00:00:12.2+03:00') at time zone 'America Alaska'.
+        if isinstance(timezone, _SQLColumnExpression):
+            _timezone_expr = _SQLColumnExpression(literal_column(f' AT TIME ZONE {timezone.compile()}')).compile()
+        else:
+            _timezone_expr = _SQLColumnExpression(literal_column(_SQLColumnExpression._timezone_string(timezone))).compile()
+        return _SQLColumnExpression(_SQLColumnExpression(_fun(*_params)).compile() + _timezone_expr, type=type_)
+
+    def extract(self, value, timezone=None):
+        """
+        DESCRIPTION:
+            Extracts a single specified field from any DateTime, Interval or timestamp value,
+            converting it to an exact numeric value.
+
+        PARAMETERS:
+            value:
+                Required Argument.
+                Specifies the field which needs to be extracted.
+                Permitted Values: YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, TIMEZONE_HOUR, TIMEZONE_MINUTE
+                Note:
+                    * Permitted Values are case insensitive.
+                Type: str
+
+            timezone:
+                Optional Argument.
+                Specifies the timezone string.
+                For valid timezone strings, user should check Vantage documentation.
+                Type: ColumnExpression or str.
+
+        RETURNS:
+            ColumnExpression
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("uaf", "Traindata")
+
+            # Create a DataFrame on 'Traindata' table.
+
+            >>> temp_df = DataFrame("Traindata")
+            >>> df = temp_df.select(["seq_no", "schedule_date", "arrivalTime"])
+            >>> df
+                    schedule_date          arrivalTime
+            seq_no
+            26          16/03/26  2016-03-26 12:33:05
+            24          16/03/26  2016-03-26 12:25:06
+            3           16/03/26  2016-03-26 10:52:05
+            22          16/03/26  2016-03-26 12:18:01
+            20          16/03/26  2016-03-26 12:10:06
+            18          16/03/26  2016-03-26 12:04:01
+            8           16/03/26  2016-03-26 11:15:06
+            17          16/03/26  2016-03-26 11:56:06
+            15          16/03/26  2016-03-26 11:45:00
+            13          16/03/26  2016-03-26 11:33:00
+            11          16/03/26  2016-03-26 11:26:00
+
+            # Example 1: Extract year from column 'schedule_date'.
+            >>> df.assign(col = df.schedule_date.extract('YEAR'))
+                    schedule_date          arrivalTime   col
+            seq_no
+            26          16/03/26  2016-03-26 12:33:05  2016
+            24          16/03/26  2016-03-26 12:25:06  2016
+            3           16/03/26  2016-03-26 10:52:05  2016
+            22          16/03/26  2016-03-26 12:18:01  2016
+            20          16/03/26  2016-03-26 12:10:06  2016
+            18          16/03/26  2016-03-26 12:04:01  2016
+            8           16/03/26  2016-03-26 11:15:06  2016
+            17          16/03/26  2016-03-26 11:56:06  2016
+            15          16/03/26  2016-03-26 11:45:00  2016
+            13          16/03/26  2016-03-26 11:33:00  2016
+            11          16/03/26  2016-03-26 11:26:00  2016
+
+            # Example 2: Extract hour from column 'arrivalTime'.
+            >>> df.assign(col = df.arrivalTime.extract('HOUR'))
+                    schedule_date          arrivalTime col
+            seq_no
+            26          16/03/26  2016-03-26 12:33:05  12
+            24          16/03/26  2016-03-26 12:25:06  12
+            3           16/03/26  2016-03-26 10:52:05  10
+            22          16/03/26  2016-03-26 12:18:01  12
+            20          16/03/26  2016-03-26 12:10:06  12
+            18          16/03/26  2016-03-26 12:04:01  12
+            8           16/03/26  2016-03-26 11:15:06  11
+            17          16/03/26  2016-03-26 11:56:06  11
+            15          16/03/26  2016-03-26 11:45:00  11
+
+            # Example 3: Extract hour from column 'arrivalTime' with offset '-11:00'.
+            >>> df.assign(col = df.arrivalTime.extract('HOUR', '-11:00'))
+                    schedule_date          arrivalTime col
+            seq_no
+            26          16/03/26  2016-03-26 12:33:05   1
+            24          16/03/26  2016-03-26 12:25:06   1
+            3           16/03/26  2016-03-26 10:52:05  23
+            22          16/03/26  2016-03-26 12:18:01   1
+            20          16/03/26  2016-03-26 12:10:06   1
+            18          16/03/26  2016-03-26 12:04:01   1
+            8           16/03/26  2016-03-26 11:15:06   0
+            17          16/03/26  2016-03-26 11:56:06   0
+            15          16/03/26  2016-03-26 11:45:00   0
+
+            # Example 4: Extract hour from column 'arrivalTime' with offset 10.
+            >>> df.assign(col = df.arrivalTime.extract('HOUR', 10))
+                    schedule_date          arrivalTime col
+            seq_no
+            26          16/03/26  2016-03-26 12:33:05  22
+            24          16/03/26  2016-03-26 12:25:06  22
+            3           16/03/26  2016-03-26 10:52:05  20
+            22          16/03/26  2016-03-26 12:18:01  22
+            20          16/03/26  2016-03-26 12:10:06  22
+            18          16/03/26  2016-03-26 12:04:01  22
+            8           16/03/26  2016-03-26 11:15:06  21
+            17          16/03/26  2016-03-26 11:56:06  21
+            15          16/03/26  2016-03-26 11:45:00  21
+            13          16/03/26  2016-03-26 11:33:00  21
+            11          16/03/26  2016-03-26 11:26:00  21
+        """
+        # Validating Arguments
+        arg_type_matrix = []
+        arg_type_matrix.append(["value", value , True, (str), True])
+        arg_type_matrix.append(["timezone", timezone, True, (str, ColumnExpression, int, float), True])
+        _Validators._validate_function_arguments(arg_type_matrix)
+
+        # If user doesn't provide timezone simply use extract functionality.
+        if not timezone:
+            return _SQLColumnExpression(func.extract(value, self.expression))
+
+        # If user uses timezone generate query with time zone.
+        if isinstance(timezone, _SQLColumnExpression):
+            _timezone_expr = _SQLColumnExpression(literal_column(f' AT TIME ZONE {timezone.compile()}')).compile()
+        else:
+            _timezone_expr = _SQLColumnExpression(literal_column(_SQLColumnExpression._timezone_string(timezone))).compile()
+        return _SQLColumnExpression(func.extract(value, literal_column('({}{})'.format(self.compile(), _timezone_expr))))
+
+    def to_interval(self, value=None, type_=INTERVAL_DAY_TO_SECOND):
+        """
+        DESCRIPTION:
+            Converts a numeric value or string value into an INTERVAL_DAY_TO_SECOND or INTERVAL_YEAR_TO_MONTH value.
+
+        PARAMETERS:
+            value:
+                Optional, when column type is VARCHAR or CHAR, otherwise required.
+                Specifies the unit of value for numeric value.
+                when type_ is INTERVAL_DAY_TO_SECOND permitted values:
+                    * DAY, HOUR, MINUTE, SECOND
+                when type_ is INTERVAL_YEAR_TO_MONTH permitted values:
+                    * YEAR, MONTH
+                Note:
+                    * Permitted Values are case insensitive.
+                Type: str or ColumnExpression
+
+            type_:
+                Optional Argument.
+                Specifies a teradatasqlalchemy type or an object of a teradatasqlalchemy type
+                that the column needs to be cast to.
+                Default value: TIMESTAMP
+                Permitted Values: INTERVAL_DAY_TO_SECOND or INTERVAL_YEAR_TO_MONTH type.
+                Types: teradatasqlalchemy type or object of teradatasqlalchemy type
+
+        Returns:
+            ColumnExpression
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("teradataml", "interval_data")
+
+            # Create a DataFrame on 'interval_data' table.
+            >>> df = DataFrame("interval_data")
+            >>> df
+            id  int_col value_col value_col1        str_col1 str_col2
+            2      657    MINUTE      MONTH           PT73H    -P14M
+            3     1234    SECOND      MONTH    100 04:23:59    06-10
+            1      240      HOUR       YEAR  P100DT4H23M59S  P100Y4M
+            0       20       DAY       YEAR    100 04:23:59    04-10
+
+            >>> df.tdtypes
+            id                                      INTEGER()
+            int_col                                  BIGINT()
+            value_col     VARCHAR(length=30, charset='LATIN')
+            value_col1    VARCHAR(length=30, charset='LATIN')
+            str_col1      VARCHAR(length=30, charset='LATIN')
+            str_col2      VARCHAR(length=30, charset='LATIN')
+
+
+            # Example 1: Convert "int_col" column to INTERVAL_DAY_TO_SECOND with value
+            #            provided in "value_col".
+            >>> df.assign(col = df.int_col.to_interval(df.value_col))
+            id  int_col value_col value_col1        str_col1 str_col2                    col
+            2      657    MINUTE      MONTH           PT73H    -P14M      0 10:57:00.000000
+            3     1234    SECOND      MONTH    100 04:23:59    06-10      0 00:20:34.000000
+            1      240      HOUR       YEAR  P100DT4H23M59S  P100Y4M     10 00:00:00.000000
+            0       20       DAY       YEAR    100 04:23:59    04-10     20 00:00:00.000000
+
+            # Example 2: Convert int_col to INTERVAL_YEAR_TO_MONTH when value = 'MONTH'.
+            >>> df.assign(col = df.int_col.to_interval('MONTH', INTERVAL_YEAR_TO_MONTH))
+            id  int_col value_col value_col1        str_col1 str_col2       col
+            2      657    MINUTE      MONTH           PT73H    -P14M     54-09
+            3     1234    SECOND      MONTH    100 04:23:59    06-10    102-10
+            1      240      HOUR       YEAR  P100DT4H23M59S  P100Y4M     20-00
+            0       20       DAY       YEAR    100 04:23:59    04-10      1-08
+
+            # Example 3: Convert string column "str_col1" to INTERVAL_DAY_TO_SECOND.
+            >>> df.assign(col = df.str_col1.to_interval())
+            id  int_col value_col value_col1        str_col1 str_col2                    col
+            2      657    MINUTE      MONTH           PT73H    -P14M      3 01:00:00.000000
+            3     1234    SECOND      MONTH    100 04:23:59    06-10    100 04:23:59.000000
+            1      240      HOUR       YEAR  P100DT4H23M59S  P100Y4M    100 04:23:59.000000
+            0       20       DAY       YEAR    100 04:23:59    04-10    100 04:23:59.000000
+
+            # Example 4: Convert string column "str_col2" to INTERVAL_DAY_TO_MONTH.
+            >>> df.assign(col = df.str_col2.to_interval(type_=INTERVAL_YEAR_TO_MONTH))
+            id  int_col value_col value_col1        str_col1 str_col2       col
+            2      657    MINUTE      MONTH           PT73H    -P14M     -1-02
+            3     1234    SECOND      MONTH    100 04:23:59    06-10      6-10
+            1      240      HOUR       YEAR  P100DT4H23M59S  P100Y4M    100-04
+            0       20       DAY       YEAR    100 04:23:59    04-10      4-10
+
+        """
+        # Validating Arguments
+        arg_type_matrix = []
+        arg_type_matrix.append(["value", value , True, (str, ColumnExpression), True])
+        _Validators._validate_function_arguments(arg_type_matrix)
+
+        if not UtilFuncs._is_valid_td_type(type_):
+            raise TeradataMlException(Messages.get_message(MessageCodes.UNSUPPORTED_DATATYPE, 'type_',
+                                                           'a valid teradatasqlalchemy type'),
+                                      MessageCodes.UNSUPPORTED_DATATYPE)
+
+        # When column type is string, use either to_dsinterval or to_yminterval function based on "type_".
+        if isinstance(self._type, (VARCHAR, CHAR)):
+            _fun = (getattr(func, "to_dsinterval")) if isinstance(type_, INTERVAL_DAY_TO_SECOND)\
+                or (isinstance(type_, type) and issubclass(type_, INTERVAL_DAY_TO_SECOND)) \
+                else (getattr(func, "to_yminterval"))
+            return _SQLColumnExpression(_fun(self.expression), type=type_)
+
+        # When column type is integer or float type, use either numtodsinterval or numtoyminterval
+        # function based on "type_".
+        _fun = (getattr(func, "numtodsinterval")) if isinstance(type_, INTERVAL_DAY_TO_SECOND) \
+            or (isinstance(type_, type) and issubclass(type_, INTERVAL_DAY_TO_SECOND))\
+            else (getattr(func, "numtoyminterval"))
+        value = value.expression if isinstance(value, _SQLColumnExpression) else value
+        return _SQLColumnExpression(_fun(self.expression, value), type=type_)
+
+    def parse_url(self, url_part):
+        """
+        DESCRIPTION:
+            Extracts a specific part from the URL.
+
+        PARAMETERS:
+            url_part:
+                Required Argument.
+                Specifies which part to be extracted.
+                Permitted Values: HOST, PATH, QUERY, REF, PROTOCOL, FILE, AUTHORITY, USERINFO
+                Type: str or ColumnExpression
+
+        Returns:
+            ColumnExpression
+
+        EXAMPLES:
+            # Load the data to run the example.
+            >>> load_example_data("teradataml", "url_data")
+
+            # Create a DataFrame on 'url_data' table.
+            >>> df = DataFrame("url_data")
+            >>> df
+                                                                        urls       part
+            id
+            3                                       https://www.facebook.com       HOST
+            6              smtp://user:password@smtp.example.com:21/file.txt   USERINFO
+            4   https://teracloud-pod-services-pod-account-service.dummyvalu      QUERY
+            2   https://example.net/path4/path5/path6?query4=value4#fragment        REF
+            0                                   http://example.com:8080/path       FILE
+            1                                      ftp://example.net:21/path       PATH
+            5                        http://pg.example.ml/path150#fragment90  AUTHORITY
+            7                                         https://www.google.com   PROTOCOL
+
+            # Example 1: Extract components from column 'urls' using column 'part'
+            >>> df.assign(col = df.urls.parse_url(df.part))
+                                                                        urls       part               col
+            id
+            3                                       https://www.facebook.com       HOST  www.facebook.com
+            6              smtp://user:password@smtp.example.com:21/file.txt   USERINFO     user:password
+            4   https://teracloud-pod-services-pod-account-service.dummyvalu      QUERY              None
+            2   https://example.net/path4/path5/path6?query4=value4#fragment        REF          fragment
+            0                                   http://example.com:8080/path       FILE             /path
+            1                                      ftp://example.net:21/path       PATH             /path
+            5                        http://pg.example.ml/path150#fragment90  AUTHORITY     pg.example.ml
+            7                                         https://www.google.com   PROTOCOL             https
+            >>>
+        """
+
+        # Validating Arguments
+        arg_type_matrix = []
+        arg_type_matrix.append(["url_part", url_part, False, (str, ColumnExpression), True])
+        _Validators._validate_function_arguments(arg_type_matrix)
+
+        # Regex pattern used to extract 'url_part' is '^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?'.
+        # teradataml does not support regex grouping hence in some cases first used 'regex_replace' and
+        # then 'regex_substr' or vice-versa.
+        _part_to_extract_dict = {'HOST': _SQLColumnExpression(
+            func.regexp_replace(func.regexp_substr(self.expression, '//([^/?#]*)'), '(//[^/?#]+@)|(//)|(:\d+)', ''),
+            type=VARCHAR()),
+                                 'PATH': _SQLColumnExpression(func.regexp_substr(
+                                     func.regexp_replace(self.expression, '^(([^:/?#]+):)?(//([^/?#]*))?', ''),
+                                     '([^?#]*)'), type=VARCHAR()),
+                                 'QUERY': _SQLColumnExpression(func.ltrim(func.regexp_substr(
+                                     func.regexp_replace(self.expression, '^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)', ''),
+                                     '\?([^#]*)'), '?'), type=VARCHAR()),
+                                 'REF': _SQLColumnExpression(func.ltrim(func.regexp_substr(
+                                     func.regexp_replace(self.expression,
+                                                         '^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?', ''),
+                                     '(#(.*))'), '#'), type=VARCHAR()),
+                                 'PROTOCOL': _SQLColumnExpression(
+                                     func.rtrim(func.regexp_substr(self.expression, '^(([^:/?#]+):)'), ':'),
+                                     type=VARCHAR()),
+                                 'FILE': _SQLColumnExpression(func.regexp_substr(
+                                     func.regexp_replace(self.expression, '^(([^:/?#]+):)?(//([^/?#]*))?', ''),
+                                     '([^?#]*)(\?([^#]*))?'), type=VARCHAR()),
+                                 'AUTHORITY': _SQLColumnExpression(
+                                     func.ltrim(func.regexp_substr(self.expression, '//([^/?#]*)'), '//'),
+                                     type=VARCHAR()),
+                                 'USERINFO': _SQLColumnExpression(func.rtrim(func.ltrim(
+                                     func.regexp_substr(func.regexp_substr(self.expression, '//([^/?#]*)'),
+                                                        '//[^/?#]+@'), '/'), '@'), type=VARCHAR())
+                                 }
+
+        if isinstance(url_part, str):
+            return _part_to_extract_dict[url_part]
+
+        whens = [(url_part == 'HOST', _part_to_extract_dict['HOST']),
+                 (url_part == 'PATH', _part_to_extract_dict['PATH'] ),
+                 (url_part == 'QUERY', _part_to_extract_dict['QUERY']),
+                 (url_part == 'REF', _part_to_extract_dict['REF']),
+                 (url_part == 'PROTOCOL', _part_to_extract_dict['PROTOCOL']),
+                 (url_part == 'FILE', _part_to_extract_dict['FILE']),
+                 (url_part == 'AUTHORITY', _part_to_extract_dict['AUTHORITY']),
+                 (url_part == 'USERINFO', _part_to_extract_dict['USERINFO'])]
+
+        from teradataml.dataframe.sql_functions import case
+        return case(whens)
+
+    def log(self, base):
+        """
+        DESCRIPTION:
+            Returns the logarithm value of the column with respect to 'base'.
+
+        PARAMETERS:
+            base:
+                Required Argument.
+                Specifies base of logarithm.
+                Type: int or float or ColumnExpression
+
+        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
+            265         NaN    7.7500
+            530        23.0   11.5000
+            122         NaN    8.0500
+            591        35.0    7.1250
+            387         1.0   46.9000
+            734        23.0   13.0000
+            795        25.0    7.8958
+            >>>
+
+            # Example 1: Compute log values for column 'fare' using base as column 'age'.
+            >>> log_df = df.assign(fare_log=df.fare.log(df.age))
+            >>> print(log_df)
+                        age      fare  fare_log
+            passenger
+            326        36.0  135.6333  1.370149
+            183         9.0   31.3875  1.568529
+            652        18.0   23.0000  1.084807
+            40         14.0   11.2417  0.916854
+            774         NaN    7.2250       NaN
+            366        30.0    7.2500  0.582442
+            509        28.0   22.5250  0.934704
+            795        25.0    7.8958  0.641942
+            61         22.0    7.2292  0.639955
+            469         NaN    7.7250       NaN
+            >>>
+        """
+        # Validating Arguments
+        arg_type_matrix = []
+        arg_type_matrix.append(["base", base, False, (int, float, ColumnExpression), True])
+        _Validators._validate_function_arguments(arg_type_matrix)
+
+        # Handling cases when 'base' or 'self' column values are zero or when denominator is zero
+        from teradataml.dataframe.sql_functions import case
+
+        if not isinstance(base, _SQLColumnExpression):
+            whens = case([((self != 0) & (_SQLColumnExpression(literal(base)).ln() != 0),
+                           (self.ln() / _SQLColumnExpression(literal(base)).ln()).cast(FLOAT))])
+        else:
+            whens = case([((self != 0) & (base != 0) & (base.ln() != 0),
+                           (self.ln() / base.ln()).cast(FLOAT))])
+
+        return whens