teradataml 20.0.0.8__py3-none-any.whl

teradataml/data/docs/sqle/docs_17_20/Unpack.py

@@ -0,0 +1,214 @@
+def Unpack(data=None, input_column=None,
+           output_columns=None, output_datatypes=None,
+           delimiter=",", column_length=None,
+           regex="(.*)", regex_set=1, exception=False,
+           accumulate=None, **generic_arguments):
+    """
+    DESCRIPTION:
+        The Unpack() function unpacks data from a single packed column into
+        multiple columns. The packed column is composed of multiple virtual columns,
+        which become the output columns. To determine the virtual  columns, the function
+        must have either the delimiter that separates them in the packed column or their
+        lengths.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the teradataml DataFrame containing the input attributes.
+            Types: teradataml DataFrame
+
+        input_column:
+            Required Argument.
+            Specifies the name of the input column that contains the packed data.
+            Types: str
+
+        output_columns:
+            Required Argument.
+            Specifies the names to give to the output columns, in the order in
+            which the corresponding virtual columns appear in "input_column". If you
+            specify fewer output column names than there are in virtual input
+            columns, the function ignores the extra virtual input columns. That
+            is, if the packed data contains x+y virtual columns and the
+            "output_columns" argument specifies x output column names, the function
+            assigns the names to the first x virtual columns and ignores the
+            remaining y virtual columns.
+            Types: str OR list of Strings (str)
+
+        output_datatypes:
+            Required Argument.
+            Specifies the datatypes of the unpacked output columns.Supported
+            output.datatypes are VARCHAR, int, float, TIME, DATE, and
+            TIMESTAMP. If "output_datatypes" specifies only one value and
+            "output_columns" specifies multiple columns, then the specified value
+            applies to every output_column. If "output_datatypes" specifies
+            multiple values, then it must specify a value for each output_column.
+            The nth datatype corresponds to the nth output_column.The function
+            can output only 16 VARCHAR columns.
+            Types: str OR list of Strings (str)
+
+        delimiter:
+            Optional Argument.
+            Specifies the delimiter (a string) that separates the virtual
+            columns in the packed data. If the virtual columns are separated by a
+            delimiter, then specify the delimiter with this argument; otherwise, specify
+            the "column_length" argument. Do not specify both - this argument and
+            the "column_length" argument.
+            Default Value: ","
+            Types: str
+
+        column_length:
+            Optional Argument.
+            Specifies the lengths of the virtual columns; therefore, to use this
+            argument, you must know the length of each virtual column. If
+            "column_length" specifies only one value and "output_columns" specifies
+            multiple columns, then the specified value applies to every
+            output_column. If "column_length" specifies multiple values, then it
+            must specify a value for each output_column. The nth datatype
+            corresponds to the nth output_column. However, the last column_name
+            can be an asterisk (*), which represents a single virtual column that
+            contains the remaining data. For example, if the first three virtual
+            columns have the lengths 2, 1, and 3, and all remaining data belongs
+            to the fourth virtual column, you can specify "column_length" as
+            ("2", "1", "3", *). If you specify this argument, you must omit the
+            delimiter argument.
+            Types: str OR list of Strings (str)
+
+        regex:
+            Optional Argument.
+            Specifies a regular expression that describes a row of packed data,
+            enabling the function to find the data values. A row of packed data
+            contains one data value for each virtual column, but the row might
+            also contain other information (such as the virtual column name). In
+            the "regex", each data value is enclosed in parentheses.
+            For example, suppose that the packed data has two virtual columns,
+            age and sex, and that one row of packed data is: age:34,sex:male The
+            "regex" that describes the row is ".*:(.*)". The ".*:"
+            matches the virtual column names, age and sex, and the "(.*)" matches
+            the values, 34 and male. The default "regex" is "(.*)"
+            which matches the whole string (between delimiters, if any). When
+            applied to the preceding sample row, the default "regex" causes the function
+            to return "age:34" and "sex:male" as data values. To represent multiple data
+            groups in "regex", use multiple pairs of parentheses. By default, the last
+            data group in "regex" represents the data value (other data groups are
+            assumed to be virtual column names or unwanted data). If a different
+            data group represents the data value, specify its group number with
+            the "regex_set" argument.
+            Default Value: "(.*)"
+            Types: str
+
+        regex_set:
+            Optional Argument.
+            Specifies the ordinal number of the data group in "regex" that represents the
+            data value in a virtual column. By default, the last data group in "regex"
+            represents the data value.
+            For example, suppose that "regex" is: "([a-zA-Z]*):(.*)". If
+            group number is "1", then "([a-zA-Z]*)" represents the data value. If
+            group number is "2", then "(.*)" represents the data value.
+            Default Value: 1
+            Types: int
+
+        exception:
+            Optional Argument.
+            Specifies whether the function ignores rows that contain invalid data;
+            By default the function to fails if it encounters a row with invalid data.
+            Default Value: False
+            Types: bool
+
+        accumulate:
+            Optional Argument.
+            Specifies the name(s) of input teradataml DataFrame column(s) to copy to the
+            output. By default, the function copies no input teradataml
+            DataFrame columns to the output.
+            Types: str OR list of Strings (str)
+
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept.
+            Below are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the function in a table or not.
+                    When set to True, results are persisted in a table; otherwise, results
+                    are garbage collected at the end of the session.
+                    Default Value: False
+                    Types: boolean
+
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the function in a volatile table or not.
+                    When set to True, results are stored in a volatile table, otherwise not.
+                    Default Value: False
+                    Types: boolean
+
+            Function allows the user to partition, hash, order or local order the input
+            data. These generic arguments are available for each argument that accepts
+            teradataml DataFrame as input and can be accessed as:
+                * "<input_data_arg_name>_partition_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if the underlying
+                SQLE function supports it, else an exception is raised.
+
+    RETURNS:
+        Instance of Unpack.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as UnpackObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            result
+
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage to execute the function.
+        #     2. One must import the required functions mentioned in
+        #        the example from teradataml.
+        #     3. Function will raise error if not supported on the Vantage
+        #        user is connected to.
+
+        # Load the example data.
+        load_example_data("Unpack",["ville_tempdata","ville_tempdata1"])
+
+        # Create teradataml DataFrame objects.
+        ville_tempdata1 = DataFrame.from_table("ville_tempdata1")
+        ville_tempdata = DataFrame.from_table("ville_tempdata")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Delimiter separates Virtual Columns.
+        #           The input table, ville_tempdata, is a collection of temperature readings
+        #           for two cities, Nashville and Knoxville, in the state of Tennessee.
+        #           In the column of packed data, the delimiter comma (,) separates the virtual
+        #           columns.
+        unpack_out1 = Unpack(data=ville_tempdata,
+                             input_column='packed_temp_data',
+                             output_columns=['city','state','temp_f'],
+                             output_datatypes=['varchar','varchar','real'],
+                             delimiter=',',
+                             regex='(.*)',
+                             regex_set=1,
+                             exception=True)
+
+        # Print the results DataFrame.
+        print(unpack_out1.result)
+
+        # Example 2: No Delimiter separates Virtual Columns.
+        #            The input, ville_tempdata1, contains same data as the previous example,
+        #            except that no delimiter separates the virtual columns in the packed data.
+        #            To enable the function to determine the virtual columns, the function call
+        #            specifies the column lengths.
+        unpack_out2 = Unpack(data=ville_tempdata1,
+                             input_column='packed_temp_data',
+                             output_columns=['city','state','temp_f'],
+                             output_datatypes=['varchar','varchar','real'],
+                             column_length=['9','9','4'],
+                             regex='(.*)',
+                             regex_set=1,
+                             exception=True)
+
+        # Print the results DataFrame.
+        print(unpack_out2.result)
+    """

teradataml/data/docs/sqle/docs_17_20/Unpivoting.py

@@ -0,0 +1,216 @@
+def Unpivoting(data = None, id_column = None, target_columns = None,
+                alias_names = None, attribute_column = "AttributeName", value_column = "AttributeValue",
+                accumulate = None, include_nulls = False, input_types = False, output_varchar = False,
+                indexed_attribute = False, include_datatypes = False,
+                **generic_arguments):
+    
+    """
+    DESCRIPTION:
+        Function unpivots the data, that is, changes the data from
+        dense format to sparse format.
+    
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+        
+        id_column:
+            Required Argument.
+            Specifies the name of the column in "data" which contains the input data identifier.
+            Types: str
+        
+        target_columns:
+            Required Argument.
+            Specifies the name(s) of input teradataml DataFrame column(s) which contains the data for  
+            unpivoting.
+            Types: str OR list of Strings (str)
+
+            Optional Argument.
+            Specifies alternate names for the values in the 'attribute_column'.
+            Types: str OR list of strs
+
+        alias_names:
+            Optional Argument.
+            Specifies alternate names for the values in the 'attribute_column'. 
+            column.
+            Types: str OR list of strs
+        
+        attribute_column:
+            Optional Argument.
+            Specifies the name of the column in the output DataFrame, which holds the names of pivoted columns.
+            Default Value: "AttributeName"
+            Types: str
+        
+        value_column:
+            Optional Argument.
+            Specifies the name of the column in the output DataFrame, which holds the values of pivoted columns.
+            Default Value: "AttributeValue"
+            Types: str
+        
+        accumulate:
+            Optional Argument.
+            Specifies the name(s) of input teradataml DataFrame column(s) to copy to the output.
+            By default, the function copies no input teradataml DataFrame columns to the output.
+            Types: str OR list of Strings (str)
+        
+        include_nulls:
+            Optional Argument.
+            Specifies whether or not to include nulls in the transformation.
+            Default Value: False
+            Types: bool
+        
+        input_types:
+            Optional Argument.
+            Specifies whether attribute values should be organized into multiple columns based on data type groups.
+            Note:
+                * 'input_types' argument cannot be used when output_varchar is set to True.
+            Default Value: False
+            Types: bool
+        
+        output_varchar:
+            Optional Argument.
+            Specifies whether to output the 'value_column' in varchar format regardless of its data type.
+            Note:
+                * 'output_varchar' argument cannot be used when input_types is set to True.
+            Default Value: False
+            Types: bool
+        
+        indexed_attribute:
+            Optional Argument.
+            Specifies whether to output the column indexes instead of column names in AttributeName column. 
+            When set to True, outputs the column indexes instead of column names.
+            Default Value: False
+            Types: bool
+        
+        include_datatypes:
+            Optional Argument.
+            Specifies whether to output the original datatype name. When set to True,
+            outputs the original datatype name.
+            Default Value: False
+            Types: bool
+
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept. Below 
+            are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the 
+                    function in a table or not. When set to True, 
+                    results are persisted in a table; otherwise, 
+                    results are garbage collected at the end of the 
+                    session.
+                    Default Value: False
+                    Types: bool
+                
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the 
+                    function in a volatile table or not. When set to 
+                    True, results are stored in a volatile table, 
+                    otherwise not.
+                    Default Value: False
+                    Types: bool
+                    
+            Function allows the user to partition, hash, order or local 
+            order the input data. These generic arguments are available 
+            for each argument that accepts teradataml DataFrame as 
+            input and can be accessed as:    
+                * "<input_data_arg_name>_partition_column" accepts str or 
+                    list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list 
+                    of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list 
+                    of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if 
+                the underlying SQL Engine function supports, else an 
+                exception is raised.        
+    
+    RETURNS:
+        Instance of Unpivoting.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as UnpivotingObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            result
+    
+    
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+    
+    
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage, before importing the 
+        #        function in user space.
+        #     2. User can import the function, if it is available on 
+        #        Vantage user is connected to.
+        #     3. To check the list of analytic functions available on 
+        #        Vantage user connected to, use 
+        #        "display_analytic_functions()".
+        
+        # Load the example data.
+        load_example_data('unpivot', 'unpivot_input')
+        
+        # Create teradataml DataFrame objects.
+        upvt_inp = DataFrame('unpivot_input')
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Import function  Unpivoting.
+        from teradataml import  Unpivoting
+        
+        # Example 1 : Unpivot the data.
+        upvt1 = Unpivoting(data = upvt_inp, 
+                           id_column = 'sn', 
+                           target_columns = 'city',
+                           accumulate = 'week',
+                           include_nulls = True)
+        
+        # Print the result DataFrame.
+        print( upvt1.result)
+
+        # Example 2 : Unpivot the data with alternate names for the values in
+        #             the AttributeName output column.
+        upvt2= Unpivoting(data = upvt_inp, 
+                          id_column = 'sn',
+                          target_columns = 'city',
+                          alias_names = 'city_us', 
+                          attribute_column = "Attribute", 
+                          value_column = "value",
+                          accumulate = 'week', 
+                          include_nulls = True)
+
+        # Print the result DataFrame.
+        print( upvt2.result)
+
+        # Example 3 : Unpivot the data with multiple target columns and output
+        #             data types.
+        upvt3 = Unpivoting(data = upvt_inp, 
+                           id_column = 'sn', 
+                           target_columns = ['city','pressure'],
+                           attribute_column = "Attribute", 
+                           value_column = "value",
+                           accumulate = 'week', 
+                           include_nulls = True,
+                           indexed_attribute = True, 
+                           include_datatypes = True)
+
+        # Print the result DataFrame.
+        print( upvt3.result)
+    
+        # Example 4 : Unpivot the data with multiple target columns and output
+        #             the input types.
+        upvt4 = Unpivoting(data = upvt_inp, 
+                           id_column = 'sn', 
+                           target_columns = ['city','temp'],
+                           accumulate = 'week', 
+                           include_nulls = True, 
+                           input_types = True)
+                        
+        # Print the result DataFrame.
+        print( upvt4.result)
+
+    """

teradataml/data/docs/sqle/docs_17_20/VectorDistance.py

@@ -0,0 +1,169 @@
+def VectorDistance(target_data = None, reference_data = None, target_id_column = None, target_feature_columns = None,
+                   ref_id_column = None, ref_feature_columns = None, distance_measure = "COSINE", topk = 10,
+                   **generic_arguments):
+    """
+    DESCRIPTION:
+        The VectorDistance() function accepts a dataframe of target vectors and a dataframe of reference vectors and
+        returns output containing the distance between target-reference pairs.
+
+        The function computes the distance between the target pair and the reference pair from the same input
+        if you provide only one input.
+
+        You must have the same column order in the "target_feature_columns" argument and the "ref_feature_columns"
+        argument. The function ignores the feature values during distance computation if the value is either
+        None, NAN, or INF.
+
+        The function returns N*N output if you use the "topk" value as -1 because the function includes
+        all reference vectors in the output.
+
+        Notes:
+            * The algorithm used in this function is of the order of N*N (where N is the number of rows).
+                Hence, expect the function to run significantly longer as the number of rows increases in either
+                the "target_data" or the "reference_data".
+            * Because the reference data is copied to the spool for each AMP before running the query, the user
+                spool limits the size and scalability of the input.
+            * This function requires the UTF8 client character set for UNICODE data.
+            * This function does not support Pass Through Characters (PTCs).
+                For information about PTCs, see Teradata Vantage™ - Analytics Database International Character Set
+                Support.
+            * This function does not support KanjiSJIS or Graphic data types.
+    
+    
+    PARAMETERS:
+        target_data:
+            Required Argument.
+            Specifies the teradataml DataFrame containing target data vectors.
+            Types: teradataml DataFrame
+        
+        reference_data:
+            Optional Argument.
+            Specifies the teradataml DataFrame containing reference data vectors.
+            Types: teradataml DataFrame
+        
+        target_id_column:
+            Required Argument.
+            Specifies the name of the "target_data" column that contains
+            identifiers of the target data vectors.
+            Types: str
+        
+        target_feature_columns:
+            Required Argument.
+            Specifies the names of the "target_data" columns that contain features
+            of the target data vectors.
+            Note:
+                You can specify up to 2018 feature columns.
+            Types: str OR list of Strings (str)
+        
+        ref_id_column:
+            Optional Argument.
+            Specifies the name of the "reference_data" column that contains
+            identifiers of the reference data vectors.
+            Types: str
+        
+        ref_feature_columns:
+            Optional Argument.
+            Specifies the names of the "reference_data" columns that contain
+            features of the reference data vectors.
+            Note:
+                You can specify up to 2018 feature columns.
+            Types: str OR list of Strings (str)
+        
+        distance_measure:
+            Optional Argument.
+            Specifies the distance type to compute between the target and the reference vector.
+            Default Value: "COSINE"
+            Permitted Values:
+                * Cosine: Cosine distance between the target vector and the reference vector.
+                * Euclidean: Euclidean distance between the target vector and the reference vector.
+                * Manhattan: Manhattan distance between the target vector and the reference vector.
+            Types: str OR list of strs
+        
+        topk:
+            Optional Argument.
+            Specifies the maximum number of closest reference vectors to include in the output table
+            for each target vector. The value k is an integer between 1 and 100.
+            Default Value: 10
+            Types: int
+        
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept. Below 
+            are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the 
+                    function in a table or not. When set to True,
+                    results are persisted in a table; otherwise,
+                    results are garbage collected at the end of the 
+                    session.
+                    Default Value: False
+                    Types: bool
+                
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the 
+                    function in a volatile table or not. When set to
+                    True, results are stored in a volatile table,
+                    otherwise not.
+                    Default Value: False
+                    Types: bool
+                    
+            Function allows the user to partition, hash, order or local 
+            order the input data. These generic arguments are available 
+            for each argument that accepts teradataml DataFrame as 
+            input and can be accessed as:    
+                * "<input_data_arg_name>_partition_column" accepts str or 
+                    list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list 
+                    of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list 
+                    of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if 
+                the underlying SQLE Engine function supports, else an 
+                exception is raised.
+    
+    RETURNS:
+        Instance of VectorDistance.
+        Output teradataml DataFrames can be accessed using attribute 
+        references, such as VectorDistanceObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            result
+    
+    
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+    
+    
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage to execute the function.
+        #     2. One must import the required functions mentioned in
+        #        the example from teradataml.
+        #     3. Function will raise error if not supported on the Vantage
+        #        user is connected to.
+        
+        # Load the example data.
+        load_example_data("vectordistance", ["target_mobile_data_dense", "ref_mobile_data_dense"])
+        
+        # Create teradataml DataFrame objects.
+        target_mobile_data_dense=DataFrame("target_mobile_data_dense")
+        ref_mobile_data_dense=DataFrame("ref_mobile_data_dense")
+        
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+        
+        # Example 1 : Compute the cosine, euclidean, manhattan distance between the target and reference vectors.
+        VectorDistance_out = VectorDistance(target_id_column="userid",
+                                            target_feature_columns=['CallDuration', 'DataCounter', 'SMS'],
+                                            ref_id_column="userid",
+                                            ref_feature_columns=['CallDuration', 'DataCounter', 'SMS'],
+                                            distance_measure=['Cosine', 'Euclidean', 'Manhattan'],
+                                            topk=2,
+                                            target_data=target_mobile_data_dense,
+                                            reference_data=ref_mobile_data_dense)
+        
+        # Print the result DataFrame.
+        print(VectorDistance_out.result)
+    
+    """

teradataml/data/docs/sqle/docs_17_20/WhichMax.py

@@ -0,0 +1,83 @@
+def WhichMax(data=None, target_column=None, **generic_arguments):
+
+    """
+    DESCRIPTION:
+        WhichMax() function displays all rows that have the maximum value in specified input DataFrame column.
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        target_column:
+            Required Argument.
+            Specifies the name of the column in "data" to check the maximum value.
+            Types: str
+
+        **generic_arguments:
+            Specifies the generic keyword arguments SQLE functions accept.
+            Below are the generic keyword arguments:
+                persist:
+                    Optional Argument.
+                    Specifies whether to persist the results of the function in a table or not.
+                    When set to True, results are persisted in a table; otherwise, results
+                    are garbage collected at the end of the session.
+                    Default Value: False
+                    Types: boolean
+
+                volatile:
+                    Optional Argument.
+                    Specifies whether to put the results of the function in a volatile table or not.
+                    When set to True, results are stored in a volatile table, otherwise not.
+                    Default Value: False
+                    Types: boolean
+
+            Function allows the user to partition, hash, order or local order the input
+            data. These generic arguments are available for each argument that accepts
+            teradataml DataFrame as input and can be accessed as:
+                * "<input_data_arg_name>_partition_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_hash_column" accepts str or list of str (Strings)
+                * "<input_data_arg_name>_order_column" accepts str or list of str (Strings)
+                * "local_order_<input_data_arg_name>" accepts boolean
+            Note:
+                These generic arguments are supported by teradataml if the underlying SQL Engine
+                function supports, else an exception is raised.
+                    
+    RETURNS:
+        Instance of WhichMax.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as WhichMaxObj.<attribute_name>.
+        Output teradataml DataFrame attribute name is:
+            result
+
+
+    RAISES:
+        TeradataMlException, TypeError, ValueError
+
+
+    EXAMPLES:
+        # Notes:
+        #     1. Get the connection to Vantage to execute the function.
+        #     2. One must import the required functions mentioned in
+        #        the example from teradataml.
+        #     3. Function will raise error if not supported on the Vantage
+        #        user is connected to.
+
+        # Load the example data.
+        load_example_data("teradataml", ["titanic"])
+
+        # Create teradataml DataFrame object.
+        titanic_data = DataFrame.from_table("titanic")
+
+        # Check the list of available analytic functions.
+        display_analytic_functions()
+
+        # Example 1: Display all rows that have the maximum value in 'age' column.
+        obj = WhichMax(data=titanic_data,
+                      target_column='age')
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+    """