@clickzetta/cz-cli-darwin-x64 0.3.95 → 0.3.100

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/abs.md

@@ -0,0 +1,44 @@
+### ABS 
+#### Description
+The `ABS` function is used to calculate the absolute value of a given numerical expression. Whether the input value is positive or negative, the `ABS` function can return the corresponding non-negative value.
+
+#### Syntax
+```sql
+ABS(expr)
+```
+#### Parameters
+- `expr`: A numeric expression for which the absolute value needs to be calculated. It can be `smallint`, `tinyint`, `int`, `bigint`, `decimal`, `double`, or `float`.
+
+#### Return Value
+Returns the absolute value of the parameter `expr`. The return type is the same as the input parameter type.
+
+#### Example Usage
+1. Calculate the absolute value of a negative integer:
+```sql
+SELECT ABS(-10); -- Returns 10
+```
+2. Calculate the absolute value of a positive integer:
+```sql
+SELECT ABS(5); -- Returns 5
+```
+3. Calculate the absolute value of a decimal:
+```sql
+SELECT ABS(-3.14); -- The return result is 3.14
+```
+4. Calculate the absolute value of a negative number with a decimal point:
+```sql
+SELECT ABS(-0.5); -- Returns 0.5
+```
+5. Calculate the absolute value of a `decimal` type:
+```sql
+SELECT ABS(-123.456); -- Returns the result 123.456
+```
+6. Use the `ABS` function in a query to get the absolute value of employee salaries:
+```sql
+SELECT employee_name, ABS(salary - 100) AS adjusted_salary
+FROM employees;
+-- In the returned results, each employee's `adjusted_salary` will display as the absolute value of the difference between the salary and 100
+```
+#### Notes
+- When `expr` is `NULL`, the `ABS` function will return `NULL`.
+- The `ABS` function can be used in conjunction with other SQL functions, such as when sorting or filtering queries.

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/acos.md

@@ -0,0 +1,37 @@
+# ACOS
+
+## Overview
+
+Calculate the arc cosine of the input value, returning a value in radians in the range [0, π].
+
+## Syntax
+
+```Plain
+ACOS(<expr>)
+```
+
+## Parameters
+
+- `<expr>`: DOUBLE type, value range [-1, 1]; other numeric types are implicitly converted to DOUBLE. Returns NaN if out of range. Returns NULL if `<expr>` is NULL.
+
+## Usage Examples
+
+```sql
+SELECT acos(-1);
+-- 3.141592653589793
+
+SELECT acos(0);
+-- 1.5707963267948966
+
+SELECT acos(1);
+-- 0
+
+SELECT acos(2);
+-- NaN
+```
+
+## Related Documentation
+
+- [ASIN](asin.md) — Arc sine
+- [ATAN](atan.md) — Arc tangent
+- [COS](cos.md) — Cosine

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/acosh.md

@@ -0,0 +1,39 @@
+### ACOSH 
+#### Description
+The `ACOSH` function is used to calculate the inverse hyperbolic cosine of a given value. This function accepts a `DOUBLE` type parameter and returns a `DOUBLE` type numerical result.
+
+#### Syntax
+```
+ACOSH(expr)
+```
+#### Parameters
+- `expr`: The `DOUBLE` type value for which the inverse hyperbolic cosine needs to be calculated.
+
+#### Return Value
+Returns the inverse hyperbolic cosine of the parameter `expr`, with the result type being `DOUBLE`.
+
+#### Example Usage
+1. Calculate the inverse hyperbolic cosine of `2`:
+```
+SELECT ACOSH(2); -- The result is approximately 1.3169578969248166
+```
+2. Calculate the inverse hyperbolic cosine of `1` (the result is `0`, because `1` is the minimum value for the `ACOSH` function):
+```
+SELECT ACOSH(1); -- The result is 0.0
+```
+3. Calculate the inverse hyperbolic cosine of a decimal value close to `0`:
+```
+SELECT ACOSH(0.0001); -- Result is approximately NaN
+```
+4. Calculate the inverse hyperbolic cosine of a negative number (result is `NaN` because the `ACOSH` function only accepts positive number arguments):
+```
+SELECT ACOSH(-1); -- The result is NaN
+```
+5. Calculate the inverse hyperbolic cosine of multiple values in a query:
+```
+SELECT ACOSH(2.5), ACOSH(3.7), ACOSH(0.5); -- The results are approximately 1.566799236972411, 1.9826969446812033, and NaN respectively
+```
+#### Notes
+- The `ACOSH` function only accepts positive number parameters. If a negative number or zero is passed, it will return `NaN` (Not a Number).
+- When the parameter value is close to `0`, the inverse hyperbolic cosine value becomes very large. In practical applications, attention should be paid to the issue of numerical overflow.
+- The `ACOSH` function and the `COSH` function are inverse operations of each other. The `COSH` function is used to calculate the hyperbolic cosine value, while the `ACOSH` function is used to calculate its inverse operation result.

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/asin.md

@@ -0,0 +1,38 @@
+### ASIN 
+
+#### Function Description
+The `asin` function is used to calculate the arcsine of a given number, which is the angle whose sine is equal to the given value. This function is widely used in fields such as mathematics, physics, and engineering.
+
+#### Syntax
+```
+asin(expr)
+```
+#### Parameters
+- `expr`: The value for which the arcsine needs to be calculated, of type double.
+
+#### Return Value
+Returns the calculated arcsine value, of type double.
+
+#### Usage Instructions
+- When the value of `expr` is between -1 and 1 (inclusive of -1 and 1), the `asin` function can return a valid arcsine value.
+- When the value of `expr` is less than -1 or greater than 1, the `asin` function will return `NaN` (Not a Number).
+
+#### Example
+```
+-- Calculate the arcsine of 0
+> SELECT asin(0);
+0.0
+
+-- Calculate the arcsine of 0.5
+> SELECT asin(0.5);
+0.5235987755982989
+
+-- Calculate the arcsine of -1
+> SELECT asin(-1);
+-1.5707963267948966
+
+-- Calculate the arcsine of a value greater than 1, returns NaN
+> SELECT asin(2);
+NaN
+```
+Through the above examples, you can see the application of the `asin` function in different scenarios. Please note that when the input value is not within the range of -1 to 1, the function will return `NaN`. In practical applications, please ensure that the input values are within the valid range to avoid errors.

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/asinh.md

@@ -0,0 +1,45 @@
+### ASINH
+
+#### Description
+The `ASINH` function is used to calculate the inverse hyperbolic sine of a given numeric expression. The inverse hyperbolic sine function is the inverse of the hyperbolic sine function, and its result will return a hyperbolic sine value related to the input value.
+
+#### Syntax
+```
+ASINH(expr)
+```
+#### Parameters
+- `expr`: The numerical expression for which the inverse hyperbolic sine value needs to be calculated, of type `DOUBLE`.
+
+#### Return Value
+Returns the inverse hyperbolic sine value related to the input expression, of type `DOUBLE`.
+
+#### Example Usage
+1. Calculate the inverse hyperbolic sine value of 0:
+```sql
+SELECT ASINH(0);
+-- Result: 0.0
+```
+In this example, the input value is 0, and its inverse hyperbolic sine value is also 0.
+
+2. Calculate the inverse hyperbolic sine value of -1:
+```sql
+SELECT ASINH(-1);
+-- Result: -0.8813735870195429
+```
+In this example, the input value is -1, and its inverse hyperbolic sine value is approximately -0.8814.
+
+3. Calculate the inverse hyperbolic sine value of a positive and a negative number:
+```sql
+SELECT ASINH(2), ASINH(-2);
+-- Result: 1.4436354751788103, -1.4436354751788103
+```
+In this example, we calculate the inverse hyperbolic sine of the positive number 2 and the negative number -2, resulting in 1.4431 and -1.4431, respectively.
+
+4. Calculate the inverse hyperbolic sine of a smaller negative number and a larger positive number:
+```sql
+SELECT ASINH(-0.1), ASINH(3);
+-- Result: -0.09983407889920758, 1.8184464592320668
+```
+In this example, we calculated the inverse hyperbolic sine values of the smaller negative number -0.1 and the larger positive number 3, resulting in -0.1001 and 1.8831, respectively.
+
+From the above example, you can see that the `ASINH` function can handle inputs of different positive and negative values and return the corresponding inverse hyperbolic sine values. This makes the `ASINH` function very useful in mathematical calculations and data analysis.

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/atan.md

@@ -0,0 +1,25 @@
+### ATAN
+
+```sql
+
+atan(expr)
+
+```
+#### Function
+
+Calculate the arctangent of expr
+
+#### Parameters
+
+* expr : double type
+
+#### Return Result
+
+double type
+
+#### Example
+```sql
+
+> SELECT atan(0);
+0.0
+```

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/atan2.md

@@ -0,0 +1,40 @@
+### ATAN2 
+```sql
+ATAN2(y, x)
+```
+####  Description
+The `ATAN2` function is used to calculate the arctangent value of two floating-point numbers `y` and `x`, with the return value in radians. Unlike the `ATAN` function, `ATAN2` can handle cases where `x` is zero or `y` and `x` have opposite signs, thus obtaining the correct quadrant result.
+
+#### Parameter Description
+* `y` (double type): The floating-point value of the y-axis coordinate.
+* `x` (double type): The floating-point value of the x-axis coordinate.
+
+#### Return Result
+Returns the arctangent value of `y/x`, with the type being double.
+
+#### Usage Example
+```sql
+-- Example 1
+SELECT ATAN2(0, 0); -- The result is 0.0 because the intersection of the two axes is at the origin
+
+-- Example 2
+SELECT ATAN2(1, 1); -- The result is approximately 0.7853981633974483, which is 45°, indicating the angle in the first quadrant
+
+-- Example 3
+SELECT ATAN2(-1, 1); -- The result is approximately -0.7853981633974483, which is -45°, indicating the angle in the second quadrant
+
+-- Example 4
+SELECT ATAN2(1, -1); -- The result is approximately 2.356194490192345, which is 135°, indicating the angle in the second quadrant
+
+-- Example 5
+SELECT ATAN2(-1, -1); -- The result is approximately -2.356194490192345, which is 180°, indicating the angle in the third quadrant
+
+-- Example 6
+SELECT ATAN2(1, 0); -- The result is approximately 1.570796326794896
+
+-- Example 7
+SELECT ATAN2(0, 1); -- The result is approximately 0.0 because y/x is on the y-axis
+
+-- Example 8
+SELECT ATAN2(0, -1); -- The result is approximately 3.141592653589793
+```

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/atanh.md

@@ -0,0 +1,22 @@
+### ATANH
+
+```sql
+atanh(expr)
+```
+#### Function
+
+Calculate the inverse hyperbolic tangent of expr
+
+#### Parameters
+
+* expr : double type
+
+#### Return Result
+
+double type
+
+#### Example
+```sql
+> SELECT atanh(0);
+0.0
+```

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/bround.md

@@ -0,0 +1,42 @@
+### BROUND
+
+####  Description
+The Round Half to Even function (BROUND) is used to round a numeric expression `expr` to a specified number of decimal places `d` and return the processed numeric result. This function follows the round half to even rule and is applicable to various numeric types, including float, double, decimal, smallint, tinyint, int, and bigint.
+
+#### Parameter Description
+- `expr` (required): The numeric expression that needs to be processed using the round half to even rule.
+- `d` (optional): The number of decimal places to retain, of int type, supports negative values, with a default value of 0.
+
+#### Return Result
+Returns the processed numeric result, with the same type as the input `expr`.
+
+#### Usage Example
+1. Retain one decimal place:
+```sql
+SELECT BROUND(3.14, 1); -- The result is 3.1
+SELECT BROUND(3.15, 1); -- The result is 3.2
+```
+2. Keep two decimal places:
+```sql
+SELECT BROUND(3.164, 2); -- The result is 3.16
+SELECT BROUND(3.264, 2); -- The result is 3.26
+```
+3. Retain negative decimal places (thousands):
+```sql
+SELECT BROUND(3141592, -3); -- Result is 3142000
+```
+4. Default number of decimal places retained (0 places):
+```sql
+SELECT BROUND(2.5); -- Result is 2
+```
+5. Handling decimal type:
+```sql
+SELECT BROUND(123.4567, 2) AS result; -- The result is 123.46
+```
+6. Handling Different Numeric Types:
+```sql
+SELECT BROUND(12345, -2) AS result; -- The result is 12300 
+SELECT BROUND(123.456, -1) AS result; -- The result is 120 
+```
+### Summary
+The round half to even function (BROUND) is a practical numerical processing function that can perform round half to even calculations on various types of numbers. By specifying the number of decimal places to retain, users can flexibly handle various numerical scenarios.

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/cbrt.md

@@ -0,0 +1,56 @@
+### CBRT 
+#### Description
+The CBRT function is used to calculate the cube root of a given value. This function accepts a parameter of type double and returns a calculation result of type double.
+
+#### Syntax
+```
+CBRT(expr)
+```
+#### Parameters
+- `expr`: The double type value for which the cube root needs to be calculated.
+
+#### Return Result
+Returns the cube root of the parameter `expr`, with the result type being double.
+
+#### Example Usage
+1. Calculate the cube root of 27:
+```
+SELECT CBRT(27.0);
+```
+Results:
+```
+3.0000000000000004
+```
+2. Calculate the cube root of a negative number (e.g., -8):
+```
+SELECT CBRT(-8.0);
+```
+Results:
+```
+-2.0
+```
+3. Calculate the cube root of a decimal number (e.g., 0.027):
+```
+SELECT CBRT(0.027);
+```
+Results:
+```
+0.29999999999999993
+```
+4. Calculate the cube root of a larger number (for example, 1000000):
+```
+SELECT CBRT(1000000);
+```
+Results:
+```
+100.0
+```
+5. Calculate the cube roots of multiple values in a single query:
+```
+SELECT CBRT(27.0), CBRT(64.0), CBRT(-125.0);
+```
+Results:
+```
+3.0000000000000004, 4.0, -5.0
+```
+From the above example, it can be seen that the CBRT function can be flexibly applied to various scenarios, helping users quickly calculate the cube root of the required value.

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/ceil.md

@@ -0,0 +1,45 @@
+### CEIL
+```
+ceil(expr [, d])
+```
+####  Description
+The CEIL function is used to return the result of rounding up the numeric parameter `expr` to the nearest decimal place at the `d`-th position after the decimal point. When `d` is negative, it means rounding to the left of the decimal point.
+#### Parameter Description
+- `expr`: The numeric parameter that needs to be rounded up. It can be of type float, double, tinyint, smallint, int, or bigint. The current version does not support the decimal type.
+- `d`: Optional parameter that indicates the number of decimal places to retain. The default value is 0, which means no decimal places are retained. `d` can be a positive or negative number.
+#### Return Result
+Returns a value of the same type as `expr`.
+#### Usage Example
+```sql
+-- Returns the result of rounding up -0.1
+SELECT ceil(-0.1);
+-- Result: 0
+
+-- Returns the result of rounding up 5
+SELECT ceil(5);
+-- Result: 5
+
+-- Returns the result of rounding up 5123.123 to one decimal place
+SELECT ceil(5123.123, 1);
+-- Result: 5123.2
+
+-- Returns the result of rounding up 5123.123 to one place to the left of the decimal
+SELECT ceil(5123.123, -1);
+-- Result: 5130
+
+-- Returns the result of rounding up 12345.6789 to two decimal places
+SELECT ceil(12345.6789, 2);
+-- Result: 12345.68
+
+-- Returns the result of rounding up -123.456 to three decimal places
+SELECT ceil(-123.456, 3);
+-- Result: -123.456
+
+-- Returns the result of rounding up 0 to two decimal places
+SELECT ceil(0, 2);
+-- Result: 0
+```
+#### Notes
+- When `d` is a non-integer, it will automatically be rounded down to the nearest integer.
+- When `d` is 0, the CEIL function will return the integer part, and the decimal part will be discarded.
+- When `expr` is negative, the CEIL function will return a smaller negative result.

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/ceiling.md

@@ -0,0 +1,47 @@
+# CEIL
+
+The `CEILING` function returns the smallest integer greater than or equal to the specified value. In other words, it rounds the given value up to the nearest integer. This is useful when you need to ensure a value is not below a certain threshold.
+
+#### Syntax
+
+```Plain
+CEILING(value)
+```
+
+#### Parameters
+
+* `value`: The numeric value to round up. Can be an integer, floating-point number, or other numeric type.
+
+#### Return Value
+
+* Returns the smallest integer greater than or equal to `value`. The result type is typically an integer.
+
+#### Examples
+
+1. **Basic example**:
+
+```SQL
+SELECT CEILING(3.2) AS result;
++--------+
+| result |
++--------+
+| 4      |
++--------+
+```
+
+2. **Negative number example**:
+
+```SQL
+SELECT CEILING(-2.7) AS result;
++--------+
+| result |
++--------+
+| -2     |
++--------+
+```
+
+#### Notes
+
+* The return value of `CEILING` is always an integer type.
+* For positive numbers, `CEILING` rounds up to the next integer; for negative numbers, it returns the less negative integer (i.e., the one closer to zero).
+* If the input value is already an integer, `CEILING` returns that integer unchanged.

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/ceilling.md

@@ -0,0 +1,41 @@
+#### Description
+
+The `CEILING` function is used to return the smallest integer greater than or equal to a specified value. In other words, it rounds the given value up to the nearest integer. This is particularly useful in situations where you need to ensure that a value is not less than a certain threshold.
+
+#### Syntax
+```Plain
+CEILING(value)
+```
+#### Parameters
+
+* `value`: The value to be rounded up, which can be an integer, a floating-point number, or other numeric types.
+
+#### Return Results
+
+* Returns the smallest integer greater than or equal to `value`. The result is typically an integer.
+
+#### Usage Example
+
+1. **Basic Example**:
+```SQL
+SELECT CEILING(3.2) AS result;
++--------+
+| result |
++--------+
+| 4      |
++--------+
+```
+2. **Negative Number Example**:
+```SQL
+SELECT CEILING(-2.7) AS result;
++--------+
+| result |
++--------+
+| -2     |
++--------+
+```
+#### Notes
+
+* The return value of the `CEILING` function is always an integer type.
+* For positive numbers, the `CEILING` function rounds up to the next integer; for negative numbers, it returns the smaller integer (i.e., the integer closer to zero).
+* If the input value is already an integer, the `CEILING` function will return the integer itself.

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/cos.md

@@ -0,0 +1,40 @@
+### Cosine Function (COS)
+```sql
+COS(expr)
+```
+#### Function Description
+The cosine function `COS` is used to calculate the cosine value of a given angle (parameter `expr`). This function is widely used in fields such as mathematics, physics, and engineering, especially when solving problems related to periodic changes.
+
+#### Parameter Description
+- `expr` (type double): The angle for which the cosine value needs to be calculated, in radians. If the input angle is in degrees, it needs to be converted to radians first. Degrees can be converted to radians by multiplying by π/180.
+
+#### Return Result
+Returns the cosine value of the parameter `expr`, with the result type being double.
+
+#### Usage Example
+1. Calculate the cosine value of 0 radians:
+```sql
+SELECT COS(0);
+// Result: 1.0
+```
+2. Calculate the cosine of 90 degrees (π/2 radians):
+```sql
+SELECT COS(PI()/2);
+// Result: 0
+```
+3. Calculate the cosine of 180 degrees (π radians):
+```sql
+SELECT COS(PI());
+// Result: -1
+```
+4. Calculate the cosine value of 270 degrees (3π/2 radians):
+```sql
+SELECT COS(3*PI()/2);
+// Result: 0
+```
+5. Calculate the cosine value of a negative angle (-π/4 radians):
+```sql
+SELECT COS(-PI()/4);
+// Result: approximately 0.7071
+```
+Through the above example, you can understand how to use the cosine function `COS` to calculate the cosine values of different angles. In practical applications, you can calculate the cosine values of any angle as needed to solve various problems related to periodic changes.

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/cosh.md

@@ -0,0 +1,41 @@
+### COSH
+
+####  Description
+The `cosh` function is used to calculate the hyperbolic cosine value of a given numerical expression. The hyperbolic cosine function is a type of hyperbolic function, similar to the cosine function, but it is used to describe the geometry of hyperbolas.
+
+#### Syntax
+```
+cosh(expr)
+```
+#### Parameter Description
+- `expr`: The numerical expression for which the hyperbolic cosine needs to be calculated, of type `double`.
+
+#### Return Result
+Returns the calculated hyperbolic cosine value, of type `double`.
+
+#### Usage Example
+1. Calculate the hyperbolic cosine value of 0:
+   ```sql
+   SELECT cosh(0);
+   -> 1.0
+   ```
+2. Calculate the hyperbolic cosine of the value -1:
+   ```sql
+   SELECT cosh(-1);
+   -> 1.5430806348152437
+   ```
+3. Calculate the hyperbolic cosine of the number 2:
+   ```sql
+   SELECT cosh(2);
+   -> 3.7621956910836314
+   ```
+4. Calculate the hyperbolic cosine of each element in a column, for example `column_name`:
+   ```sql
+   SELECT cosh(column_name) FROM table_name;
+   ```
+This will return a new column containing the hyperbolic cosine of each element in the `column_name` column of the `table_name` table.
+
+#### Notes
+- For very large values, the result of the hyperbolic cosine function may exceed the numerical range, causing an overflow. In such cases, ensure to appropriately limit the range of input values.
+
+By using the `cosh` function, you can easily calculate the hyperbolic cosine in database queries, thereby applying hyperbolic geometric concepts in data analysis and processing.

package/bin/skills/lakehouse-doc-en/references/sql_functions/scalar_functions/math_functions/cot.md

@@ -0,0 +1,49 @@
+### COT
+```
+COT(expr)
+```
+####  Description
+The COT function is used to calculate the cotangent value of a given angle, i.e., cotangent. Cotangent is the reciprocal of tangent, i.e., cot(x) = 1/tan(x). This function has a wide range of applications in trigonometric calculations.
+
+#### Parameter Description
+* expr (type double): The angle for which the cotangent value needs to be calculated, in radians.
+
+#### Return Result
+The return type is double, representing the cotangent value of the given angle.
+
+#### Usage Example
+1. Calculate the cotangent value of 1 radian:
+```sql
+SELECT COT(1);
+```
+Results:
+```
+0.6420926159343306
+```
+2. Calculate the cotangent value of π/4 (45°):
+```sql
+SELECT COT(PI()/4);
+```
+Results:
+```
+1.0000000000000002
+```
+3. Calculate the cotangent value of 0 radians:
+```sql
+SELECT COT(0);
+```
+Results:
+```
+Infinity
+```
+4. Calculate the cotangent value of -π/2 (-90°):
+```sql
+SELECT COT(-PI()/2);
+```
+Results:
+```
+-6.123233995736766E-17
+```
+#### Notes
+* When the given angle is 0 or π (180°), the COT function will return infinity because the value of the tangent function is undefined at these angles.
+* When the given angle is an integer multiple of π (180°), the COT function will return 0 because the value of the tangent function is 0 at these angles.