@clickzetta/cz-cli-darwin-arm64 0.3.94 → 0.3.96

package/bin/skills/lakehouse-doc-en/references/sql_functions/aggregate_functions/max.md

@@ -0,0 +1,70 @@
+### MAX 
+```
+max([distinct] expr)
+```
+####  Description
+
+The MAX function is used to find the maximum value from a set of data. This function is applicable to various data types, including numeric, temporal, and string types.
+
+#### Parameter Description
+
+* `expr`: Comparable data types, supported types include:
+  * Numeric types: tinyint, smallint, int, bigint, float, double, and decimal;
+  * Temporal types: date and timestamp;
+  * String types: char, varchar, string, and binary.
+* `distinct`: Optional parameter, used to specify whether to remove duplicate values. If distinct is set, the maximum value from the deduplicated set is returned. Note that for numeric data, distinct does not affect the result.
+
+#### Return Value
+
+* The return type is the same as the input parameter `expr`.
+* If the input parameter contains null values, these values will not be included in the calculation.
+* Setting the distinct parameter does not affect the result for numeric data.
+
+#### Usage Example
+
+1. Find the maximum value of numeric data:
+```sql
+SELECT max(col) FROM VALUES (10), (50), (20), (null) AS tab(col);
++------------+
+| `max`(col) |
++------------+
+| 50         |
++------------+
+```
+
+1. Find the maximum value of time-based data:
+```sql
+SELECT max(col) FROM VALUES ('2023-01-01'), ('2022-12-31'), ('2023-02-01') AS tab(col);
++------------+
+| `max`(col) |
++------------+
+| 2023-02-01 |
++------------+
+```
+2. Find the maximum value of string type data:
+```sql
+SELECT max(col) FROM VALUES ('apple'), ('banana'), ('cherry') AS tab(col);
++------------+
+| `max`(col) |
++------------+
+| cherry     |
++------------+
+```
+3. Use the distinct parameter to find the maximum value of numeric data (no effect on the result):
+```sql
+SELECT max(distinct col) FROM VALUES (10), (50), (20), (null), (10) AS tab(col);
++---------------------+
+| `max`(DISTINCT col) |
++---------------------+
+| 50                  |
++---------------------+
+```
+4. Use the distinct parameter to find the maximum value of string data:
+```sql
+SELECT max(distinct col) FROM VALUES ('apple'), ('banana'), ('cherry'), ('apple') AS tab(col);
++---------------------+
+| `max`(DISTINCT col) |
++---------------------+
+| cherry              |
++---------------------+
+```

package/bin/skills/lakehouse-doc-en/references/sql_functions/aggregate_functions/max_by.md

@@ -0,0 +1,46 @@
+### MAX\_BY 
+```sql
+max_by(expr1, expr2)
+```
+#### Description
+
+The MAX\_BY function is used to return the value of the expr1 expression associated with the maximum value of the expr2 expression from a set of data. This function is particularly useful when dealing with paired data, helping you quickly find the data item corresponding to the maximum value.
+
+#### Parameter Description
+
+* expr1: An expression of any data type.
+* expr2: A comparable data type expression, including numeric types (such as tinyint, smallint, int, bigint, float, double, decimal), time types (such as date, timestamp), and string types (such as char, varchar, string, binary).
+
+#### Return Result
+
+Returns the value of the expr1 expression associated with the maximum value of the expr2 expression. The result type matches the type of expr1. If all values in expr2 are null, null is returned.
+
+#### Usage Example
+
+1. Find the string associated with the maximum integer value from a set of string and integer data:
+   ```sql
+   SELECT max_by(str, num) FROM VALUES ('apple', 1), ('banana', 3), ('cherry', 2) AS tab(str, num);
+   +------------------+
+   | max_by(str, num) |
+   +------------------+
+   | banana           |
+   +------------------+
+   ```
+2. Find the string associated with the latest date from a set of dates and string data:
+   ```sql
+   SELECT max_by(str, date) FROM VALUES ('event1', '2022-01-01'), ('event2', '2022-02-01'), ('event3', '2022-01-15') AS tab(str, date);
+   +---------------------+
+   | max_by(str, `date`) |
+   +---------------------+
+   | event2              |
+   +---------------------+
+   ```
+3. Find the employee name associated with the highest salary from a set of employee names and salary data:
+   ```sql
+   SELECT max_by(name, salary) FROM VALUES ('Alice', 5000), ('Bob', 6000), ('Charlie', 4500) AS tab(name, salary);
+   +----------------------+
+   | max_by(name, salary) |
+   +----------------------+
+   | Bob                  |
+   +----------------------+
+   ```

package/bin/skills/lakehouse-doc-en/references/sql_functions/aggregate_functions/median.md

@@ -0,0 +1,75 @@
+### MEDIAN Function
+
+```
+median(expr)
+```
+
+#### Description
+
+The `MEDIAN` function computes the median of a numeric column. The median is the middle value when the data is sorted in order. This function is equivalent to `percentile(expr, 0.5)`, i.e., computing the 50th percentile.
+
+#### Parameters
+
+* `expr`: A numeric expression, which can be of integer, floating-point, or `DECIMAL` type.
+
+#### Return Type
+
+* Returns a `DOUBLE` value.
+* Returns the median of the dataset.
+
+#### Notes
+
+* If the input is an empty set, returns `NULL`.
+* For an even number of values, returns the average of the two middle values.
+* For an odd number of values, returns the exact middle value.
+* `NULL` values are automatically ignored and excluded from computation.
+* `MEDIAN` does not support the `FILTER` clause. For conditional filtering, use a `WHERE` clause at the outer level or switch to `percentile(expr, 0.5) FILTER (...)`.
+
+#### Examples
+
+1. Basic usage: compute the median
+
+```sql
+SELECT median(col) FROM VALUES (0), (10) AS tab(col);
++--------------+
+| median(col)  |
++--------------+
+| 5.0          |
++--------------+
+```
+
+2. Median of an even number of values (average of the two middle values)
+
+```sql
+SELECT median(value) FROM VALUES (1), (2), (3), (4) AS t(value);
++----------------+
+| median(value)  |
++----------------+
+| 2.5            |
++----------------+
+```
+
+3. Median of an odd number of values
+
+```sql
+SELECT median(value) FROM VALUES (1), (2), (3), (4), (5) AS t(value);
++----------------+
+| median(value)  |
++----------------+
+| 3.0            |
++----------------+
+```
+
+4. Compute the median by group
+
+```sql
+SELECT c, median(col)
+FROM VALUES ('a', 1), ('a', 2), ('a', 3), ('b', 10), ('b', 20), ('b', 30) AS tab(c, col)
+GROUP BY c;
++---+-------------+
+| c | median(col) |
++---+-------------+
+| a | 2.0         |
+| b | 20.0        |
++---+-------------+
+```

package/bin/skills/lakehouse-doc-en/references/sql_functions/aggregate_functions/min.md

@@ -0,0 +1,58 @@
+### MIN 
+```
+min([distinct] expr)
+```
+####  Description
+
+The MIN function is used to find the minimum value from a set of data. This function supports various data types, including numeric types (such as tinyint, smallint, int, bigint, float, double, and decimal), time types (such as date and timestamp), string types (such as char, varchar, and string), and binary types.
+
+#### Parameter Description
+
+* `expr`: Comparable data types, including numeric types, time types, and string types.
+
+#### Return Results
+
+* The return value type is the same as the input parameter type.
+* If the `distinct` keyword is set, the minimum value in the deduplicated set is calculated, but it has no effect on the result.
+* `null` values are not included in the calculation.
+
+#### Usage Example
+
+1. Find the minimum value from a set of numbers:
+
+```sql
+SELECT min(col) FROM VALUES (10), (50), (20), (null) AS tab(col);
++------------+
+| `min`(col) |
++------------+
+| 10         |
++------------+
+```
+2. Find the minimum value from a set of time-type data:
+```sql
+SELECT min(col) FROM VALUES ('2023-01-01'), ('2022-12-31'), ('2023-02-01') AS tab(col);
++------------+
+| `min`(col) |
++------------+
+| 2022-12-31 |
++------------+
+```
+3. Find the minimum value from a set of string type data:
+```sql
+SELECT min(col) FROM VALUES ('apple'), ('banana'), ('cherry') AS tab(col);
++------------+
+| `min`(col) |
++------------+
+| apple      |
++------------+
+```
+4. Use the `distinct` keyword to find the minimum value from a set of numbers (no effect on the result):
+```sql
+SELECT min(distinct col) FROM VALUES (10), (50), (20), (null), (10), (20) AS tab(col);
++---------------------+
+| `min`(DISTINCT col) |
++---------------------+
+| 10                  |
++---------------------+
+```
+Through the above example, you can see the application of the MIN function in different data types. Please note that `null` values do not affect the calculation of the minimum value.

package/bin/skills/lakehouse-doc-en/references/sql_functions/aggregate_functions/min_by.md

@@ -0,0 +1,68 @@
+### MIN_BY 
+```sql
+min_by(expr1, expr2)
+```
+####  Description
+
+The MIN\_BY function is used to find the value of expr1 associated with the minimum value in expr2 from a set of data. This function is very useful when dealing with paired data and can help you quickly find the best match for specific conditions.
+
+#### Parameter Description
+
+* expr1: Any data type. This is the value you want to return based on the minimum value of expr2.
+* expr2: Comparable data types, including numeric types (such as tinyint, smallint, int, bigint, float, double, decimal), time types (such as date, timestamp), string types (such as char, varchar, string), and binary types (such as binary).
+
+#### Return Result
+
+* The type of the return result matches the type of expr1.
+* If all values in expr2 are null, the return result is also null.
+
+#### Usage Example
+
+1. Example of numeric types:
+```sql
+SELECT min_by(num1, num2) FROM VALUES
+  ((1, 10)),
+  ((2, 20)),
+  ((3, 5)),
+  ((4, 30)) AS tab(num1, num2);
++--------------------+
+| min_by(num1, num2) |
++--------------------+
+| 3                  |
++--------------------+
+```
+In this example, we can see that the minimum value of num2 is 5, and the value of num1 associated with it is 3.
+
+2. Example of time type:
+```sql
+SELECT min_by(date1, date2) FROM VALUES
+  (('2022-01-01', '2023-01-01')),
+  (('2022-02-01', '2022-12-31')),
+  (('2022-03-01', '2022-01-01')) AS tab(date1, date2);
++----------------------+
+| min_by(date1, date2) |
++----------------------+
+| 2022-03-01           |
++----------------------+
+```
+In this example, we can see that the minimum value of date2 is '2022-01-01', and the value of the associated date1 is also '2022-01-01'.
+
+3. Example of string type:
+```sql
+SELECT min_by(str1, str2) FROM VALUES
+  (('apple', 'A')),
+  (('banana', 'B')),
+  (('cherry', 'C')) AS tab(str1, str2);
++--------------------+
+| min_by(str1, str2) |
++--------------------+
+| apple              |
++--------------------+
+```
+In this example, we can see that the minimum value of str2 is 'A', and the value of str1 associated with it is 'apple'.
+
+#### Notes
+
+* Please ensure that the data types of expr1 and expr2 are compatible, otherwise the function may fail to execute.
+* If all values in expr2 are null, the function will return null.
+* The MIN_BY function is suitable for comparing and filtering paired data, but not for individual data items.

package/bin/skills/lakehouse-doc-en/references/sql_functions/aggregate_functions/percentile.md

@@ -0,0 +1,51 @@
+### PERCENTILE
+```sql
+percentile([distinct] col, percentage[, frequency])
+```
+####  Description
+
+The percentile function `PERCENTILE` is used to calculate the percentile of numerical data in a specified column. When the data is sorted in ascending order, this function returns the value at the specified percentage position.
+
+#### Parameter Description
+
+* `col`: The column for which the percentile is to be calculated. The data type should be numerical, including tinyint, smallint, int, bigint, float, double, and decimal.
+* `percentage`: The percentile to be calculated, with a data type of double constant. The value range should be between 0.0 and 1.0.
+* `frequency` (optional): Indicates the number of times each data row is counted in the calculation. The data type should be a positive integer.
+
+#### Return Result
+
+This function returns a double type value representing the calculated percentile.
+
+If the `distinct` keyword is used in the function, it indicates the calculation of the percentile for the deduplicated set. Note that `null` values are not included in the calculation.
+
+#### Usage Example
+
+The following is an example of using the `PERCENTILE` function:
+
+1. Calculate the 30th percentile of a non-deduplicated dataset:
+```sql
+SELECT percentile(col, 0.3) FROM VALUES (0), (10), (10), (null) AS tab(col);
++------------------------+
+| percentile(col, 0.3BD) |
++------------------------+
+| 6.0                    |
++------------------------+
+```
+2. Calculate the 30th percentile of the deduplicated dataset:
+```sql
+SELECT percentile(DISTINCT col, 0.3) FROM VALUES (0), (10), (10), (null) AS tab(col);
++---------------------------------+
+| percentile(DISTINCT col, 0.3BD) |
++---------------------------------+
+| 3.0                             |
++---------------------------------+
+```
+3. Calculate the 30th percentile of each data row being counted twice in the dataset:
+```sql
+SELECT percentile(col, 0.3, freq) FROM VALUES (0, 1), (10, 2) AS tab(col, freq);
++------------------------------+
+| percentile(col, 0.3BD, freq) |
++------------------------------+
+| 6.0                          |
++------------------------------+
+```

package/bin/skills/lakehouse-doc-en/references/sql_functions/aggregate_functions/percentile_approx.md

@@ -0,0 +1,71 @@
+## Description
+
+The `PERCENTILE_APPROX` function calculates the approximate percentile of a numeric column. Compared to the exact `PERCENTILE` function, `PERCENTILE_APPROX` offers better performance on large datasets and is suitable for scenarios where high precision is not required.
+
+## Syntax
+
+```SQL
+PERCENTILE_APPROX(value_expr, percentile)
+```
+
+## Parameters
+
+* **value_expr**: The numeric column or expression for which to calculate the percentile. Supports numeric types.
+* **percentile**: The desired percentile, either a `DOUBLE` constant in the range 0 to 1, or an array of percentiles (`ARRAY<DOUBLE>`). When an array is passed, the function returns multiple percentile results at once.
+
+## Return Results
+
+* When a single percentile is passed, returns a `DOUBLE` approximation.
+* When an array is passed, returns an `ARRAY<DOUBLE>`, where each element corresponds to the percentile at the same position in the input array.
+* `NULL` values are excluded from the calculation.
+
+## Examples
+
+1. Calculate a single percentile (50th percentile, i.e., median):
+
+```SQL
+SELECT percentile_approx(col, 0.5) FROM VALUES (0), (1), (2), (10) AS tab(col);
++-----------------------------+
+| percentile_approx(col, 0.5) |
++-----------------------------+
+| 1                         |
++-----------------------------+
+```
+
+2. Calculate multiple percentiles at once:
+
+```SQL
+SELECT percentile_approx(col, array(0.5, 0.4, 0.1)) AS res
+FROM VALUES (0), (1), (2), (10) AS tab(col);
++---------------+
+|      res      |
++---------------+
+| [1,1.1,0] |
++---------------+
+```
+
+3. Calculate the median by group:
+
+```SQL
+SELECT c, percentile_approx(col, 0.5)
+FROM VALUES ('a', 1), ('a', 2), ('a', 3), ('b', 10), ('b', 20), ('b', 30) AS tab(c, col)
+GROUP BY c;
++---+-----------------------------+
+| c | percentile_approx(col, 0.5) |
++---+-----------------------------+
+| a | 2                         |
+| b | 20                        |
++---+-----------------------------+
+```
+
+4. Calculate the 25th and 75th percentiles (quartiles):
+
+```SQL
+SELECT percentile_approx(col, array(0.25, 0.75))
+FROM VALUES (1), (2), (3), (4), (5), (6), (7), (8), (9), (10) AS tab(col);
++------------------------------------------+
+| percentile_approx(col, array(0.25, 0.75)) |
++------------------------------------------+
+| [3, 8]                                   |
++------------------------------------------+
+```

package/bin/skills/lakehouse-doc-en/references/sql_functions/aggregate_functions/percentile_rank.md

@@ -0,0 +1,33 @@
+##  Description
+
+The `PERCENT_RANK` function is used to calculate the percentile rank. It returns the relative position of a value within a set of values.
+
+## Syntax
+```SQL
+PERCENT_RANK()
+```
+## Parameter Description
+
+* **column**: The column used to calculate the percentile rank.
+
+## Return Result
+
+Returns a value between 0 and 1, indicating the relative position of the data point within the dataset.
+
+## Example
+```SQL
+SELECT a, b, percent_rank(b) OVER (PARTITION BY a ORDER BY b)
+    FROM VALUES ('A1', 2), ('A1', 1), ('A1', 3), ('A1', 6), ('A1', 7), ('A1', 7), ('A2', 3), ('A1', 1) tab(a, b);
++----+---+-------------------------------------------------------+
+| a  | b | `percent_rank`() OVER (PARTITION BY a ORDER BY b ASC) |
++----+---+-------------------------------------------------------+
+| A1 | 1 | 0.0                                                   |
+| A1 | 1 | 0.0                                                   |
+| A1 | 2 | 0.3333333333333333                                    |
+| A1 | 3 | 0.5                                                   |
+| A1 | 6 | 0.6666666666666666                                    |
+| A1 | 7 | 0.8333333333333334                                    |
+| A1 | 7 | 0.8333333333333334                                    |
+| A2 | 3 | 0.0                                                   |
++----+---+-------------------------------------------------------+
+```

package/bin/skills/lakehouse-doc-en/references/sql_functions/aggregate_functions/std.md

@@ -0,0 +1,72 @@
+### STD Function
+
+```
+std([DISTINCT] expr)
+```
+
+#### Description
+
+The `STD` function is an alias of `STDDEV_SAMP` and computes the sample standard deviation of a set of numeric data. Standard deviation is a statistical measure of dispersion, used to indicate how spread out the values in a dataset are.
+
+#### Parameters
+
+* `expr`: A numeric column or expression, which can be of type `TINYINT`, `SMALLINT`, `INT`, `BIGINT`, `FLOAT`, `DOUBLE`, or `DECIMAL`.
+* `DISTINCT`: An optional parameter. When `DISTINCT` is specified, the function computes the standard deviation of the deduplicated set. If `DISTINCT` is not set, the standard deviation is computed on the set including duplicates.
+
+#### Return Type
+
+* Returns a `DOUBLE` value representing the sample standard deviation of the dataset.
+
+#### Notes
+
+* If the input dataset contains `NULL` values, they are excluded from computation.
+* The `STD` function is fully identical to `STDDEV_SAMP` and the two can be used interchangeably.
+
+#### Examples
+
+1. Basic usage
+
+```sql
+SELECT std(col) FROM VALUES (1), (2), (3), (3), (NULL) AS tab(col);
++--------------------+
+| `std`(col)         |
++--------------------+
+| 0.9574271077563381 |
++--------------------+
+```
+
+2. Using the DISTINCT keyword
+
+```sql
+SELECT std(DISTINCT col) FROM VALUES (1), (2), (3), (3), (NULL) AS tab(col);
++----------------------+
+| `std`(DISTINCT col)  |
++----------------------+
+| 1.0                  |
++----------------------+
+```
+
+3. Using the FILTER clause to conditionally compute standard deviation
+
+```sql
+SELECT std(col) FILTER (WHERE col > 1) FROM VALUES (1), (2), (3), (4) AS tab(col);
++----------------------------------+
+| std(col) FILTER (WHERE col > 1)  |
++----------------------------------+
+| 1.0                              |
++----------------------------------+
+```
+
+4. Compute standard deviation by group
+
+```sql
+SELECT c, std(col)
+FROM VALUES ('a', 1), ('a', 2), ('a', 3), ('b', 10), ('b', 20) AS tab(c, col)
+GROUP BY c;
++---+--------------------+
+| c | std(col)           |
++---+--------------------+
+| a | 1.0                |
+| b | 7.0710678118654755 |
++---+--------------------+
+```

package/bin/skills/lakehouse-doc-en/references/sql_functions/aggregate_functions/stddev.md

@@ -0,0 +1,67 @@
+# STDDEV
+
+## Description
+
+The `STDDEV` function computes the sample standard deviation of a set of numeric values. It is a commonly used aggregate function in statistics for measuring data dispersion. This function is a synonym of the `STD` aggregate function, and returns a `DOUBLE` value.
+
+## Syntax
+
+```sql
+STDDEV(expr) [FILTER (WHERE condition)]
+```
+
+## Parameters
+
+* `expr`: An expression that evaluates to a numeric value. The expression can be a column name, a calculation formula, or any other expression that returns a numeric value.
+
+## Return Value
+
+* Returns a `DOUBLE` value representing the sample standard deviation.
+* If `DISTINCT` is specified, the function computes the standard deviation on unique values of `expr` only.
+* If the aggregation group contains only one row, the function returns `NULL`.
+
+## Examples
+
+Example 1: Compute the standard deviation of all values
+
+```sql
+SELECT STDDEV(col) FROM VALUES (1), (2), (3), (3) AS tab(col);
++--------------------+
+|    STDDEV(col)     |
++--------------------+
+| 0.9574271077563381 |
++--------------------+
+```
+
+Example 2: Compute the standard deviation of unique values
+
+```sql
+SELECT STDDEV(DISTINCT col) FROM VALUES (1), (2), (3), (3) AS tab(col);
++----------------------+
+| STDDEV(DISTINCT col) |
++----------------------+
+| 1.0                  |
++----------------------+
+```
+
+Example 3: Use FILTER clause to conditionally compute standard deviation
+
+```sql
+SELECT STDDEV(col) FILTER (WHERE col > 1) FROM VALUES (1), (2), (3), (4) AS tab(col);
++----------------------------------------+
+| STDDEV(col) FILTER (WHERE (col > 1))   |
++----------------------------------------+
+| 1.0                                    |
++----------------------------------------+
+```
+
+Example 4: Combine FILTER clause and DISTINCT to compute conditional standard deviation
+
+```sql
+SELECT STDDEV(DISTINCT col) FILTER (WHERE col <= 3) FROM VALUES (1), (2), (3), (3), (4) AS tab(col);
++-------------------------------------------------------+
+| STDDEV(DISTINCT col) FILTER (WHERE (col <= 3))        |
++-------------------------------------------------------+
+| 1.0                                                   |
++-------------------------------------------------------+
+```

package/bin/skills/lakehouse-doc-en/references/sql_functions/aggregate_functions/stddev_pop.md

@@ -0,0 +1,67 @@
+### Population Standard Deviation (STDDEV_POP)
+
+```sql
+stddev_pop([DISTINCT] expr) [FILTER (WHERE condition)]
+```
+
+#### Description
+
+The `STDDEV_POP` function calculates the population standard deviation of a set of numeric data. Standard deviation is a statistical measure of data dispersion, used to indicate the degree to which values in a dataset deviate from the mean.
+
+#### Parameter Description
+
+* `expr`: The numeric data for which the standard deviation needs to be calculated. Can be of type `TINYINT`, `SMALLINT`, `INT`, `BIGINT`, `FLOAT`, `DOUBLE`, or `DECIMAL`.
+* `DISTINCT`: Optional parameter indicating whether to calculate the standard deviation of the distinct set. If `DISTINCT` is set, the function only calculates the standard deviation of non-duplicate data.
+
+#### Return Result
+
+* Returns a `DOUBLE` type value representing the calculation result.
+* If all input values are `NULL`, returns `NULL`.
+
+#### Usage Examples
+
+**Example 1**: Calculate the population standard deviation of a set of numeric data
+
+```sql
+SELECT stddev_pop(col) FROM VALUES (1), (2), (3), (3), (NULL) AS tab(col);
++-------------------+
+| `stddev_pop`(col) |
++-------------------+
+| 0.82915619758885  |
++-------------------+
+```
+
+**Example 2**: Calculate the population standard deviation after deduplication
+
+```sql
+SELECT stddev_pop(DISTINCT col) FROM VALUES (1), (2), (3), (3), (NULL) AS tab(col);
++----------------------------+
+| `stddev_pop`(DISTINCT col) |
++----------------------------+
+| 0.816496580927726          |
++----------------------------+
+```
+
+**Example 3**: Use the FILTER clause to conditionally calculate the population standard deviation
+
+```sql
+SELECT stddev_pop(col) FILTER (WHERE col > 1) FROM VALUES (1), (2), (3), (4) AS tab(col);
++----------------------------------------------+
+| `stddev_pop`(col) FILTER (WHERE (col > 1))   |
++----------------------------------------------+
+| 0.816496580927726                            |
++----------------------------------------------+
+```
+
+**Example 4**: Combine FILTER clause and DISTINCT to calculate the conditional population standard deviation
+
+```sql
+SELECT stddev_pop(DISTINCT col) FILTER (WHERE col <= 3) FROM VALUES (1), (2), (3), (3), (4) AS tab(col);
++-----------------------------------------------------------+
+| `stddev_pop`(DISTINCT col) FILTER (WHERE (col <= 3))      |
++-----------------------------------------------------------+
+| 0.816496580927726                                         |
++-----------------------------------------------------------+
+```
+
+With the above examples, you can flexibly use the `STDDEV_POP` function to calculate the population standard deviation of a dataset according to your actual needs.