teradataml 20.0.0.8__py3-none-any.whl

teradataml/data/docs/sqle/docs_17_10/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_10/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 table or not.
+                    When set to True, results are persisted in 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 volatile table or not.
+                    When set to True, results are stored in 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 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)
+
+    """

teradataml/data/docs/sqle/docs_17_10/WhichMin.py

@@ -0,0 +1,83 @@
+def WhichMin(data=None, target_column=None, **generic_arguments):
+
+    """
+    DESCRIPTION:
+        WhichMin() function displays all rows that have the minimum 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 minimum 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 table or not.
+                    When set to True, results are persisted in 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 volatile table or not.
+                    When set to True, results are stored in 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 Engine
+                function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of WhichMin.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as WhichMinObj.<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 minimum value in 'age' column.
+        obj = WhichMin(data=titanic_data,
+                       target_column='age')
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+    """

teradataml/data/docs/sqle/docs_17_10/ZTest.py

@@ -0,0 +1,155 @@
+def ZTest(data=None, alpha=0.5, first_sample_column=None, second_sample_column=None,
+          alternate_hypothesis="two-tailed", first_sample_variance=None,
+          second_sample_variance=None, mean_under_h0=None,
+          **generic_arguments):
+    
+    """
+    DESCRIPTION:
+        ZTest() function tests the equality of two means under the assumption that the
+        population variances are known. For large samples, sample variances
+        approximate population variances, so it uses sample variances
+        instead of population variances in the test statistic.
+
+
+    PARAMETERS:
+        data:
+            Required Argument.
+            Specifies the input teradataml DataFrame.
+            Types: teradataml DataFrame
+
+        alpha:
+            Optional Argument.
+            Specifies the value of alpha in hypothesis test function.
+            Default Value: 0.5
+            Types: float
+
+        first_sample_column:
+            Required Argument.
+            Specifies the first sample column in z test.
+            Types: str
+
+        second_sample_column:
+            Optional Argument.
+            Specifies the second sample column in z test.
+            Types: str
+
+        alternate_hypothesis:
+            Optional Argument.
+            Specifies the alternate hypothesis.
+            Permitted Values:
+                * lower-tailed - Alternate hypothesis (H 1): μ < μ0.
+                * upper-tailed - Alternate hypothesis (H 1): μ > μ0.
+                * two-tailed - Rejection region is on two sides of sampling distribution
+                               of test statistic.
+                               Two-tailed test considers both lower and upper tails of
+                               distribution of test statistic.
+                               Alternate hypothesis (H 1): μ ≠ μ0
+            Default Value: "two-tailed"
+            Types: str
+
+        first_sample_variance:
+            Required Argument.
+            Specifies the first sample variance.
+            Types: float
+
+        second_sample_variance:
+            Optional Argument.
+            Specifies the second sample variance.
+            Types: float
+
+        mean_under_h0:
+            Optional Argument.
+            Specifies the mean under the null hypothesis.
+            Types: float
+
+        **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 table or not.
+                    When set to True, results are persisted in 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 volatile table or not.
+                    When set to True, results are stored in 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 Engine
+                function supports, else an exception is raised.
+
+    RETURNS:
+        Instance of ZTest.
+        Output teradataml DataFrames can be accessed using attribute
+        references, such as ZTestObj.<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: Perform ZTest analysis on input data column that
+        #            contains data for the first sample population and
+        #            variance of the first sample population.
+        obj = ZTest(data=titanic_data,
+                    first_sample_column='age',
+                    first_sample_variance=5)
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+        # Example 2: Perform ZTest analysis on input data column that
+        #            contains data for the first and second sample
+        #            population and variance of the first and second sample
+        #            population by specifying data_partition_column as ANY.
+
+        # To partition data using ANY, one must import 'PartitionKind' module first,
+        # then pass PartitionKind.ANY as input to "data_partition_column" argument.
+        from teradataml import PartitionKind
+        obj = ZTest(data=titanic_data,
+                    alpha=0.5,
+                    data_partition_column=PartitionKind.ANY,
+                    data_order_column='pclass',
+                    first_sample_column='age',
+                    second_sample_column='parch',
+                    alternate_hypothesis='two-tailed',
+                    first_sample_variance=5,
+                    second_sample_variance=8,
+                    mean_under_h0=0)
+
+        # Print the result DataFrame.
+        print(obj.result)
+
+    """