| <?xml version="1.0" encoding="UTF-8"?><!-- |
| Licensed to the Apache Software Foundation (ASF) under one |
| or more contributor license agreements. See the NOTICE file |
| distributed with this work for additional information |
| regarding copyright ownership. The ASF licenses this file |
| to you under the Apache License, Version 2.0 (the |
| "License"); you may not use this file except in compliance |
| with the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, |
| software distributed under the License is distributed on an |
| "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| KIND, either express or implied. See the License for the |
| specific language governing permissions and limitations |
| under the License. |
| --> |
| <!DOCTYPE concept PUBLIC "-//OASIS//DTD DITA Concept//EN" "concept.dtd"> |
| <concept id="math_functions"> |
| |
| <title>Impala Mathematical Functions</title> |
| <titlealts audience="PDF"><navtitle>Mathematical Functions</navtitle></titlealts> |
| <prolog> |
| <metadata> |
| <data name="Category" value="Impala"/> |
| <data name="Category" value="Impala Functions"/> |
| <data name="Category" value="SQL"/> |
| <data name="Category" value="Data Analysts"/> |
| <data name="Category" value="Developers"/> |
| <data name="Category" value="Querying"/> |
| </metadata> |
| </prolog> |
| |
| <conbody> |
| |
| <p> |
| Mathematical functions, or arithmetic functions, perform numeric calculations that are typically more complex |
| than basic addition, subtraction, multiplication, and division. For example, these functions include |
| trigonometric, logarithmic, and base conversion operations. |
| </p> |
| |
| <note> |
| In Impala, exponentiation uses the <codeph>pow()</codeph> function rather than an exponentiation operator |
| such as <codeph>**</codeph>. |
| </note> |
| |
| <p conref="../shared/impala_common.xml#common/related_info"/> |
| |
| <p> |
| The mathematical functions operate mainly on these data types: <xref href="impala_int.xml#int"/>, |
| <xref href="impala_bigint.xml#bigint"/>, <xref href="impala_smallint.xml#smallint"/>, |
| <xref href="impala_tinyint.xml#tinyint"/>, <xref href="impala_double.xml#double"/>, |
| <xref href="impala_float.xml#float"/>, and <xref href="impala_decimal.xml#decimal"/>. For the operators that |
| perform the standard operations such as addition, subtraction, multiplication, and division, see |
| <xref href="impala_operators.xml#arithmetic_operators"/>. |
| </p> |
| |
| <p> |
| Functions that perform bitwise operations are explained in <xref href="impala_bit_functions.xml#bit_functions"/>. |
| </p> |
| |
| <p> |
| <b>Function reference:</b> |
| </p> |
| |
| <p> |
| Impala supports the following mathematical functions: |
| </p> |
| |
| <dl> |
| <dlentry rev="1.4.0" id="abs"> |
| |
| <dt rev="1.4.0 2.0.1"> |
| <codeph>abs(numeric_type a)</codeph> |
| <!-- <codeph>abs(double a), abs(decimal(p,s) a)</codeph> --> |
| </dt> |
| |
| <dd rev="1.4.0"> |
| <indexterm audience="hidden">abs() function</indexterm> |
| <b>Purpose:</b> Returns the absolute value of the argument. |
| <p rev="2.0.1" conref="../shared/impala_common.xml#common/return_type_same"/> |
| <p> |
| <b>Usage notes:</b> Use this function to ensure all return values are positive. This is different than |
| the <codeph>positive()</codeph> function, which returns its argument unchanged (even if the argument |
| was negative). |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="acos"> |
| |
| <dt> |
| <codeph>acos(double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">acos() function</indexterm> |
| <b>Purpose:</b> Returns the arccosine of the argument. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="asin"> |
| |
| <dt> |
| <codeph>asin(double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">asin() function</indexterm> |
| <b>Purpose:</b> Returns the arcsine of the argument. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="atan"> |
| |
| <dt> |
| <codeph>atan(double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">atan() function</indexterm> |
| <b>Purpose:</b> Returns the arctangent of the argument. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="atan2" rev="2.3.0 IMPALA-1771"> |
| |
| <dt rev="2.3.0 IMPALA-1771"> |
| <codeph>atan2(double a, double b)</codeph> |
| </dt> |
| |
| <dd rev="2.3.0 IMPALA-1771"> |
| <indexterm audience="hidden">atan2() function</indexterm> |
| <b>Purpose:</b> Returns the arctangent of the two arguments, with the signs of the arguments used to determine the |
| quadrant of the result. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="bin"> |
| |
| <dt> |
| <codeph>bin(bigint a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">bin() function</indexterm> |
| <b>Purpose:</b> Returns the binary representation of an integer value, that is, a string of 0 and 1 |
| digits. |
| <p> |
| <b>Return type:</b> <codeph>string</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry rev="1.4.0" id="ceil"> |
| |
| <dt rev="1.4.0"> |
| <codeph>ceil(double a)</codeph>, |
| <codeph>ceil(decimal(p,s) a)</codeph>, |
| <codeph id="ceiling">ceiling(double a)</codeph>, |
| <codeph>ceiling(decimal(p,s) a)</codeph>, |
| <codeph id="dceil" rev="2.3.0">dceil(double a)</codeph>, |
| <codeph rev="2.3.0">dceil(decimal(p,s) a)</codeph> |
| </dt> |
| |
| <dd rev="1.4.0"> |
| <indexterm audience="hidden">ceil() function</indexterm> |
| <b>Purpose:</b> Returns the smallest integer that is greater than or equal to the argument. |
| <p> |
| <b>Return type:</b> <codeph>int</codeph> or <codeph>decimal(p,s)</codeph> depending on the type of the |
| input argument |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="conv"> |
| |
| <dt> |
| <codeph>conv(bigint num, int from_base, int to_base), conv(string num, int from_base, int |
| to_base)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">conv() function</indexterm> |
| <b>Purpose:</b> Returns a string representation of an integer value in a particular base. The input value |
| can be a string, for example to convert a hexadecimal number such as <codeph>fce2</codeph> to decimal. To |
| use the return value as a number (for example, when converting to base 10), use <codeph>CAST()</codeph> |
| to convert to the appropriate type. |
| <p> |
| <b>Return type:</b> <codeph>string</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="cos"> |
| |
| <dt> |
| <codeph>cos(double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">cos() function</indexterm> |
| <b>Purpose:</b> Returns the cosine of the argument. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="cosh" rev="2.3.0 IMPALA-1771"> |
| |
| <dt rev="2.3.0 IMPALA-1771"> |
| <codeph>cosh(double a)</codeph> |
| </dt> |
| |
| <dd rev="2.3.0 IMPALA-1771"> |
| <indexterm audience="hidden">cosh() function</indexterm> |
| <b>Purpose:</b> Returns the hyperbolic cosine of the argument. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="cot" rev="2.3.0 IMPALA-1771"> |
| |
| <dt rev="2.3.0 IMPALA-1771"> |
| <codeph>cot(double a)</codeph> |
| </dt> |
| |
| <dd rev="2.3.0 IMPALA-1771"> |
| <indexterm audience="hidden">cot() function</indexterm> |
| <b>Purpose:</b> Returns the cotangent of the argument. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| <p conref="../shared/impala_common.xml#common/added_in_230"/> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="degrees"> |
| |
| <dt> |
| <codeph>degrees(double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">degrees() function</indexterm> |
| <b>Purpose:</b> Converts argument value from radians to degrees. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="e"> |
| |
| <dt> |
| <codeph>e()</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">e() function</indexterm> |
| <b>Purpose:</b> Returns the |
| <xref href="https://en.wikipedia.org/wiki/E_(mathematical_constant" scope="external" format="html">mathematical |
| constant e</xref>. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="exp"> |
| |
| <dt> |
| <codeph>exp(double a)</codeph>, |
| <codeph rev="2.3.0" id="dexp">dexp(double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">exp() function</indexterm> |
| <b>Purpose:</b> Returns the |
| <xref href="https://en.wikipedia.org/wiki/E_(mathematical_constant" scope="external" format="html">mathematical |
| constant e</xref> raised to the power of the argument. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry rev="2.3.0" id="factorial"> |
| |
| <dt rev="2.3.0"> |
| <codeph>factorial(integer_type a)</codeph> |
| </dt> |
| <dd rev="2.3.0"> |
| <indexterm audience="hidden">factorial() function</indexterm> |
| <b>Purpose:</b> Computes the <xref href="https://en.wikipedia.org/wiki/Factorial" scope="external" format="html">factorial</xref> of an integer value. |
| It works with any integer type. |
| <p conref="../shared/impala_common.xml#common/added_in_230"/> |
| <p> |
| <b>Usage notes:</b> You can use either the <codeph>factorial()</codeph> function or the <codeph>!</codeph> operator. |
| The factorial of 0 is 1. Likewise, the <codeph>factorial()</codeph> function returns 1 for any negative value. |
| The maximum positive value for the input argument is 20; a value of 21 or greater overflows the |
| range for a <codeph>BIGINT</codeph> and causes an error. |
| </p> |
| <p> |
| <b>Return type:</b> <codeph>bigint</codeph> |
| </p> |
| <p conref="../shared/impala_common.xml#common/added_in_230"/> |
| <codeblock>select factorial(5); |
| +--------------+ |
| | factorial(5) | |
| +--------------+ |
| | 120 | |
| +--------------+ |
| |
| select 5!; |
| +-----+ |
| | 5! | |
| +-----+ |
| | 120 | |
| +-----+ |
| |
| select factorial(0); |
| +--------------+ |
| | factorial(0) | |
| +--------------+ |
| | 1 | |
| +--------------+ |
| |
| select factorial(-100); |
| +-----------------+ |
| | factorial(-100) | |
| +-----------------+ |
| | 1 | |
| +-----------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="floor"> |
| |
| <dt> |
| <codeph>floor(double a)</codeph>, |
| <codeph>floor(decimal(p,s) a)</codeph>, |
| <codeph rev="2.3.0" id="dfloor">dfloor(double a)</codeph>, |
| <codeph rev="2.3.0">dfloor(decimal(p,s) a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">floor() function</indexterm> |
| <b>Purpose:</b> Returns the largest integer that is less than or equal to the argument. |
| <p> |
| <b>Return type:</b> <codeph>bigint</codeph> or <codeph>decimal(p,s)</codeph> depending on the type of |
| the input argument |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="fmod"> |
| |
| <dt> |
| <codeph>fmod(double a, double b), fmod(float a, float b)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">fmod() function</indexterm> |
| <b>Purpose:</b> Returns the modulus of a floating-point number. Equivalent to the <codeph>%</codeph> arithmetic operator. |
| <p> |
| <b>Return type:</b> <codeph>float</codeph> or <codeph>double</codeph>, depending on type of arguments |
| </p> |
| <p conref="../shared/impala_common.xml#common/added_in_111"/> |
| <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/> |
| <p> |
| Because this function operates on <codeph>DOUBLE</codeph> or <codeph>FLOAT</codeph> |
| values, it is subject to potential rounding errors for values that cannot be |
| represented precisely. Prefer to use whole numbers, or values that you know |
| can be represented precisely by the <codeph>DOUBLE</codeph> or <codeph>FLOAT</codeph> |
| types. |
| </p> |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| <p> |
| The following examples show equivalent operations with the <codeph>fmod()</codeph> |
| function and the <codeph>%</codeph> arithmetic operator, for values not subject |
| to any rounding error. |
| </p> |
| <codeblock>select fmod(10,3); |
| +-------------+ |
| | fmod(10, 3) | |
| +-------------+ |
| | 1 | |
| +-------------+ |
| |
| select fmod(5.5,2); |
| +--------------+ |
| | fmod(5.5, 2) | |
| +--------------+ |
| | 1.5 | |
| +--------------+ |
| |
| select 10 % 3; |
| +--------+ |
| | 10 % 3 | |
| +--------+ |
| | 1 | |
| +--------+ |
| |
| select 5.5 % 2; |
| +---------+ |
| | 5.5 % 2 | |
| +---------+ |
| | 1.5 | |
| +---------+ |
| </codeblock> |
| <p> |
| The following examples show operations with the <codeph>fmod()</codeph> |
| function for values that cannot be represented precisely by the |
| <codeph>DOUBLE</codeph> or <codeph>FLOAT</codeph> types, and thus are |
| subject to rounding error. <codeph>fmod(9.9,3.0)</codeph> returns a value |
| slightly different than the expected 0.9 because of rounding. |
| <codeph>fmod(9.9,3.3)</codeph> returns a value quite different from |
| the expected value of 0 because of rounding error during intermediate |
| calculations. |
| </p> |
| <codeblock>select fmod(9.9,3.0); |
| +--------------------+ |
| | fmod(9.9, 3.0) | |
| +--------------------+ |
| | 0.8999996185302734 | |
| +--------------------+ |
| |
| select fmod(9.9,3.3); |
| +-------------------+ |
| | fmod(9.9, 3.3) | |
| +-------------------+ |
| | 3.299999713897705 | |
| +-------------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry rev="1.2.2" id="fnv_hash"> |
| |
| <dt rev="1.2.2"> |
| <codeph>fnv_hash(type v)</codeph>, |
| </dt> |
| |
| <dd rev="1.2.2"> |
| <indexterm audience="hidden">fnv_hash() function</indexterm> |
| <b>Purpose:</b> Returns a consistent 64-bit value derived from the input argument, for convenience of |
| implementing hashing logic in an application. |
| <p> |
| <b>Return type:</b> <codeph>BIGINT</codeph> |
| </p> |
| <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/> |
| <p> |
| You might use the return value in an application where you perform load balancing, bucketing, or some |
| other technique to divide processing or storage. |
| </p> |
| <p> |
| Because the result can be any 64-bit value, to restrict the value to a particular range, you can use an |
| expression that includes the <codeph>ABS()</codeph> function and the <codeph>%</codeph> (modulo) |
| operator. For example, to produce a hash value in the range 0-9, you could use the expression |
| <codeph>ABS(FNV_HASH(x)) % 10</codeph>. |
| </p> |
| <p> |
| This function implements the same algorithm that Impala uses internally for hashing, on systems where |
| the CRC32 instructions are not available. |
| </p> |
| <p> |
| This function implements the |
| <xref href="http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function" scope="external" format="html">Fowler–Noll–Vo |
| hash function</xref>, in particular the FNV-1a variation. This is not a perfect hash function: some |
| combinations of values could produce the same result value. It is not suitable for cryptographic use. |
| </p> |
| <p> |
| Similar input values of different types could produce different hash values, for example the same |
| numeric value represented as <codeph>SMALLINT</codeph> or <codeph>BIGINT</codeph>, |
| <codeph>FLOAT</codeph> or <codeph>DOUBLE</codeph>, or <codeph>DECIMAL(5,2)</codeph> or |
| <codeph>DECIMAL(20,5)</codeph>. |
| </p> |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| <codeblock>[localhost:21000] > create table h (x int, s string); |
| [localhost:21000] > insert into h values (0, 'hello'), (1,'world'), (1234567890,'antidisestablishmentarianism'); |
| [localhost:21000] > select x, fnv_hash(x) from h; |
| +------------+----------------------+ |
| | x | fnv_hash(x) | |
| +------------+----------------------+ |
| | 0 | -2611523532599129963 | |
| | 1 | 4307505193096137732 | |
| | 1234567890 | 3614724209955230832 | |
| +------------+----------------------+ |
| [localhost:21000] > select s, fnv_hash(s) from h; |
| +------------------------------+---------------------+ |
| | s | fnv_hash(s) | |
| +------------------------------+---------------------+ |
| | hello | 6414202926103426347 | |
| | world | 6535280128821139475 | |
| | antidisestablishmentarianism | -209330013948433970 | |
| +------------------------------+---------------------+ |
| [localhost:21000] > select s, abs(fnv_hash(s)) % 10 from h; |
| +------------------------------+-------------------------+ |
| | s | abs(fnv_hash(s)) % 10.0 | |
| +------------------------------+-------------------------+ |
| | hello | 8 | |
| | world | 6 | |
| | antidisestablishmentarianism | 4 | |
| +------------------------------+-------------------------+</codeblock> |
| <p> |
| For short argument values, the high-order bits of the result have relatively low entropy: |
| </p> |
| <codeblock>[localhost:21000] > create table b (x boolean); |
| [localhost:21000] > insert into b values (true), (true), (false), (false); |
| [localhost:21000] > select x, fnv_hash(x) from b; |
| +-------+---------------------+ |
| | x | fnv_hash(x) | |
| +-------+---------------------+ |
| | true | 2062020650953872396 | |
| | true | 2062020650953872396 | |
| | false | 2062021750465500607 | |
| | false | 2062021750465500607 | |
| +-------+---------------------+</codeblock> |
| <p> |
| <b>Added in:</b> Impala 1.2.2 |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry rev="1.4.0" id="greatest"> |
| |
| <dt rev="1.4.0"> |
| <codeph>greatest(bigint a[, bigint b ...])</codeph>, <codeph>greatest(double a[, double b ...])</codeph>, |
| <codeph>greatest(decimal(p,s) a[, decimal(p,s) b ...])</codeph>, <codeph>greatest(string a[, string b |
| ...])</codeph>, <codeph>greatest(timestamp a[, timestamp b ...])</codeph> |
| </dt> |
| |
| <dd rev="1.4.0"> |
| <indexterm audience="hidden">greatest() function</indexterm> |
| <b>Purpose:</b> Returns the largest value from a list of expressions. |
| <p conref="../shared/impala_common.xml#common/return_same_type"/> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="hex"> |
| |
| <dt> |
| <codeph>hex(bigint a), hex(string a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">hex() function</indexterm> |
| <b>Purpose:</b> Returns the hexadecimal representation of an integer value, or of the characters in a |
| string. |
| <p> |
| <b>Return type:</b> <codeph>string</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry rev="1.4.0" id="is_inf"> |
| |
| <dt rev="1.4.0"> |
| <codeph>is_inf(double a)</codeph>, |
| </dt> |
| |
| <dd rev="1.4.0"> |
| <indexterm audience="hidden">is_inf() function</indexterm> |
| <b>Purpose:</b> Tests whether a value is equal to the special value <q>inf</q>, signifying infinity. |
| <p> |
| <b>Return type:</b> <codeph>boolean</codeph> |
| </p> |
| <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/> |
| <p conref="../shared/impala_common.xml#common/infinity_and_nan"/> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry rev="1.4.0" id="is_nan"> |
| |
| <dt rev="1.4.0"> |
| <codeph>is_nan(double a)</codeph>, |
| </dt> |
| |
| <dd rev="1.4.0"> |
| <indexterm audience="hidden">is_nan() function</indexterm> |
| <b>Purpose:</b> Tests whether a value is equal to the special value <q>NaN</q>, signifying <q>not a |
| number</q>. |
| <p> |
| <b>Return type:</b> <codeph>boolean</codeph> |
| </p> |
| <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/> |
| <p conref="../shared/impala_common.xml#common/infinity_and_nan"/> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry rev="1.4.0" id="least"> |
| |
| <dt rev="1.4.0"> |
| <codeph>least(bigint a[, bigint b ...])</codeph>, <codeph>least(double a[, double b ...])</codeph>, |
| <codeph>least(decimal(p,s) a[, decimal(p,s) b ...])</codeph>, <codeph>least(string a[, string b |
| ...])</codeph>, <codeph>least(timestamp a[, timestamp b ...])</codeph> |
| </dt> |
| |
| <dd rev="1.4.0"> |
| <indexterm audience="hidden">least() function</indexterm> |
| <b>Purpose:</b> Returns the smallest value from a list of expressions. |
| <p conref="../shared/impala_common.xml#common/return_same_type"/> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="ln"> |
| |
| <dt> |
| <codeph>ln(double a)</codeph>, |
| <codeph rev="2.3.0" id="dlog1">dlog1(double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">ln() function</indexterm> |
| <indexterm audience="hidden">dlog1() function</indexterm> |
| <b>Purpose:</b> Returns the |
| <xref href="https://en.wikipedia.org/wiki/Natural_logarithm" scope="external" format="html">natural |
| logarithm</xref> of the argument. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="log"> |
| |
| <dt> |
| <codeph>log(double base, double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">log() function</indexterm> |
| <b>Purpose:</b> Returns the logarithm of the second argument to the specified base. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="log10"> |
| |
| <dt> |
| <codeph>log10(double a)</codeph>, |
| <codeph rev="2.3.0" id="dlog10">dlog10(double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">log10() function</indexterm> |
| <indexterm audience="hidden">dlog10() function</indexterm> |
| <b>Purpose:</b> Returns the logarithm of the argument to the base 10. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="log2"> |
| |
| <dt> |
| <codeph>log2(double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">log2() function</indexterm> |
| <b>Purpose:</b> Returns the logarithm of the argument to the base 2. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry rev="1.4.0" id="max_int"> |
| |
| <dt rev="1.4.0"> |
| <codeph>max_int(), <ph id="max_tinyint">max_tinyint()</ph>, <ph id="max_smallint">max_smallint()</ph>, |
| <ph id="max_bigint">max_bigint()</ph></codeph> |
| </dt> |
| |
| <dd rev="1.4.0"> |
| <indexterm audience="hidden">max_int() function</indexterm> |
| <indexterm audience="hidden">max_tinyint() function</indexterm> |
| <indexterm audience="hidden">max_smallint() function</indexterm> |
| <indexterm audience="hidden">max_bigint() function</indexterm> |
| <b>Purpose:</b> Returns the largest value of the associated integral type. |
| <p> |
| <b>Return type:</b> The same as the integral type being checked. |
| </p> |
| <p> |
| <!-- Repeated usage text between max_ and min_ functions, could turn into a conref. --> |
| <b>Usage notes:</b> Use the corresponding <codeph>min_</codeph> and <codeph>max_</codeph> functions to |
| check if all values in a column are within the allowed range, before copying data or altering column |
| definitions. If not, switch to the next higher integral type or to a <codeph>DECIMAL</codeph> with |
| sufficient precision. |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry rev="1.4.0" id="min_int"> |
| |
| <dt rev="1.4.0"> |
| <codeph>min_int(), <ph id="min_tinyint">min_tinyint()</ph>, <ph id="min_smallint">min_smallint()</ph>, |
| <ph id="min_bigint">min_bigint()</ph></codeph> |
| </dt> |
| |
| <dd rev="1.4.0"> |
| <indexterm audience="hidden">min_int() function</indexterm> |
| <indexterm audience="hidden">min_tinyint() function</indexterm> |
| <indexterm audience="hidden">min_smallint() function</indexterm> |
| <indexterm audience="hidden">min_bigint() function</indexterm> |
| <b>Purpose:</b> Returns the smallest value of the associated integral type (a negative number). |
| <p> |
| <b>Return type:</b> The same as the integral type being checked. |
| </p> |
| <p> |
| <b>Usage notes:</b> Use the corresponding <codeph>min_</codeph> and <codeph>max_</codeph> functions to |
| check if all values in a column are within the allowed range, before copying data or altering column |
| definitions. If not, switch to the next higher integral type or to a <codeph>DECIMAL</codeph> with |
| sufficient precision. |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="mod" rev="2.2.0"> |
| |
| <dt rev="2.2.0"> |
| <codeph>mod(<varname>numeric_type</varname> a, <varname>same_type</varname> b)</codeph> |
| </dt> |
| |
| <dd rev="2.2.0"> |
| <indexterm audience="hidden">mod() function</indexterm> |
| <b>Purpose:</b> Returns the modulus of a number. Equivalent to the <codeph>%</codeph> arithmetic operator. |
| Works with any size integer type, any size floating-point type, and <codeph>DECIMAL</codeph> |
| with any precision and scale. |
| <p conref="../shared/impala_common.xml#common/return_type_same"/> |
| <p conref="../shared/impala_common.xml#common/added_in_220"/> |
| <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/> |
| <p> |
| Because this function works with <codeph>DECIMAL</codeph> values, prefer it over <codeph>fmod()</codeph> |
| when working with fractional values. It is not subject to the rounding errors that make |
| <codeph>fmod()</codeph> problematic with floating-point numbers. |
| The <codeph>%</codeph> arithmetic operator now uses the <codeph>mod()</codeph> function |
| in cases where its arguments can be interpreted as <codeph>DECIMAL</codeph> values, |
| increasing the accuracy of that operator. |
| </p> |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| <p> |
| The following examples show how the <codeph>mod()</codeph> function works for |
| whole numbers and fractional values, and how the <codeph>%</codeph> operator |
| works the same way. In the case of <codeph>mod(9.9,3)</codeph>, |
| the type conversion for the second argument results in the first argument |
| being interpreted as <codeph>DOUBLE</codeph>, so to produce an accurate |
| <codeph>DECIMAL</codeph> result requires casting the second argument |
| or writing it as a <codeph>DECIMAL</codeph> literal, 3.0. |
| </p> |
| <codeblock>select mod(10,3); |
| +-------------+ |
| | fmod(10, 3) | |
| +-------------+ |
| | 1 | |
| +-------------+ |
| |
| select mod(5.5,2); |
| +--------------+ |
| | fmod(5.5, 2) | |
| +--------------+ |
| | 1.5 | |
| +--------------+ |
| |
| select 10 % 3; |
| +--------+ |
| | 10 % 3 | |
| +--------+ |
| | 1 | |
| +--------+ |
| |
| select 5.5 % 2; |
| +---------+ |
| | 5.5 % 2 | |
| +---------+ |
| | 1.5 | |
| +---------+ |
| |
| select mod(9.9,3.3); |
| +---------------+ |
| | mod(9.9, 3.3) | |
| +---------------+ |
| | 0.0 | |
| +---------------+ |
| |
| select mod(9.9,3); |
| +--------------------+ |
| | mod(9.9, 3) | |
| +--------------------+ |
| | 0.8999996185302734 | |
| +--------------------+ |
| |
| select mod(9.9, cast(3 as decimal(2,1))); |
| +-----------------------------------+ |
| | mod(9.9, cast(3 as decimal(2,1))) | |
| +-----------------------------------+ |
| | 0.9 | |
| +-----------------------------------+ |
| |
| select mod(9.9,3.0); |
| +---------------+ |
| | mod(9.9, 3.0) | |
| +---------------+ |
| | 0.9 | |
| +---------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry rev="1.4.0" id="negative"> |
| |
| <dt rev="2.0.1"> |
| <codeph>negative(numeric_type a)</codeph> |
| <!-- <codeph>negative(int a), negative(double a), negative(decimal(p,s) a)</codeph> --> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">negative() function</indexterm> |
| <b>Purpose:</b> Returns the argument with the sign reversed; returns a positive value if the argument was |
| already negative. |
| <p rev="2.0.1" conref="../shared/impala_common.xml#common/return_type_same"/> |
| <!-- |
| <p> |
| <b>Return type:</b> <codeph>int</codeph>, <codeph>double</codeph>, |
| or <codeph>decimal(p,s)</codeph> depending on type of argument |
| </p> |
| --> |
| <p> |
| <b>Usage notes:</b> Use <codeph>-abs(a)</codeph> instead if you need to ensure all return values are |
| negative. |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="pi"> |
| |
| <dt rev="1.4.0"> |
| <codeph>pi()</codeph> |
| </dt> |
| |
| <dd rev="1.4.0"> |
| <indexterm audience="hidden">pi() function</indexterm> |
| <b>Purpose:</b> Returns the constant pi. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="pmod"> |
| |
| <dt> |
| <codeph>pmod(bigint a, bigint b), pmod(double a, double b)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">pmod() function</indexterm> |
| <b>Purpose:</b> Returns the positive modulus of a number. |
| Primarily for <xref href="https://issues.apache.org/jira/browse/HIVE-656" scope="external" format="html">HiveQL compatibility</xref>. |
| <p> |
| <b>Return type:</b> <codeph>int</codeph> or <codeph>double</codeph>, depending on type of arguments |
| </p> |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| <p> |
| The following examples show how the <codeph>fmod()</codeph> function sometimes returns a negative value |
| depending on the sign of its arguments, and the <codeph>pmod()</codeph> function returns the same value |
| as <codeph>fmod()</codeph>, but sometimes with the sign flipped. |
| </p> |
| <codeblock>select fmod(-5,2); |
| +-------------+ |
| | fmod(-5, 2) | |
| +-------------+ |
| | -1 | |
| +-------------+ |
| |
| select pmod(-5,2); |
| +-------------+ |
| | pmod(-5, 2) | |
| +-------------+ |
| | 1 | |
| +-------------+ |
| |
| select fmod(-5,-2); |
| +--------------+ |
| | fmod(-5, -2) | |
| +--------------+ |
| | -1 | |
| +--------------+ |
| |
| select pmod(-5,-2); |
| +--------------+ |
| | pmod(-5, -2) | |
| +--------------+ |
| | -1 | |
| +--------------+ |
| |
| select fmod(5,-2); |
| +-------------+ |
| | fmod(5, -2) | |
| +-------------+ |
| | 1 | |
| +-------------+ |
| |
| select pmod(5,-2); |
| +-------------+ |
| | pmod(5, -2) | |
| +-------------+ |
| | -1 | |
| +-------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry rev="1.4.0" id="positive"> |
| |
| <dt rev="2.0.1"> |
| <codeph>positive(numeric_type a)</codeph> |
| <!-- <codeph>positive(int a), positive(double a), positive(decimal(p,s) a</codeph> --> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">positive() function</indexterm> |
| <b>Purpose:</b> Returns the original argument unchanged (even if the argument is negative). |
| <p rev="2.0.1" conref="../shared/impala_common.xml#common/return_type_same"/> |
| <!-- |
| <p> |
| <b>Return type:</b> <codeph>int</codeph>, <codeph>double</codeph>, |
| or <codeph>decimal(p,s)</codeph> depending on type of argument |
| </p> |
| --> |
| <p> |
| <b>Usage notes:</b> Use <codeph>abs()</codeph> instead if you need to ensure all return values are |
| positive. |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="pow"> |
| |
| <dt rev="1.4.0"> |
| <codeph>pow(double a, double p)</codeph>, |
| <codeph id="power">power(double a, double p)</codeph>, |
| <codeph rev="2.3.0" id="dpow">dpow(double a, double p)</codeph>, |
| <codeph rev="2.3.0" id="fpow">fpow(double a, double p)</codeph> |
| </dt> |
| |
| <dd rev="1.4.0"> |
| <indexterm audience="hidden">pow() function</indexterm> |
| <indexterm audience="hidden">power() function</indexterm> |
| <indexterm audience="hidden">dpow() function</indexterm> |
| <indexterm audience="hidden">fpow() function</indexterm> |
| <b>Purpose:</b> Returns the first argument raised to the power of the second argument. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry rev="1.4.0" id="precision"> |
| |
| <dt rev="1.4.0"> |
| <codeph>precision(<varname>numeric_expression</varname>)</codeph> |
| </dt> |
| |
| <dd rev="1.4.0"> |
| <indexterm audience="hidden">precision() function</indexterm> |
| <b>Purpose:</b> Computes the precision (number of decimal digits) needed to represent the type of the |
| argument expression as a <codeph>DECIMAL</codeph> value. |
| <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/> |
| <p> |
| Typically used in combination with the <codeph>scale()</codeph> function, to determine the appropriate |
| <codeph>DECIMAL(<varname>precision</varname>,<varname>scale</varname>)</codeph> type to declare in a |
| <codeph>CREATE TABLE</codeph> statement or <codeph>CAST()</codeph> function. |
| </p> |
| <p> |
| <b>Return type:</b> <codeph>int</codeph> |
| </p> |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| <p conref="../shared/impala_common.xml#common/precision_scale_example"/> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="quotient"> |
| |
| <dt> |
| <codeph>quotient(bigint numerator, bigint denominator)</codeph>, |
| <codeph>quotient(double numerator, double denominator)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">quotient() function</indexterm> |
| <b>Purpose:</b> Returns the first argument divided by the second argument, discarding any fractional |
| part. Avoids promoting integer arguments to <codeph>DOUBLE</codeph> as happens with the <codeph>/</codeph> SQL |
| operator. <ph rev="IMPALA-278">Also includes an overload that accepts <codeph>DOUBLE</codeph> arguments, |
| discards the fractional part of each argument value before dividing, and again returns <codeph>BIGINT</codeph>. |
| With integer arguments, this function works the same as the <codeph>DIV</codeph> operator.</ph> |
| <p> |
| <b>Return type:</b> <codeph>bigint</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="radians"> |
| |
| <dt> |
| <codeph>radians(double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">radians() function</indexterm> |
| <b>Purpose:</b> Converts argument value from degrees to radians. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="rand"> |
| |
| <dt> |
| <codeph>rand()</codeph>, <codeph>rand(int seed)</codeph>, |
| <codeph rev="2.3.0" id="random">random()</codeph>, |
| <codeph rev="2.3.0">random(int seed)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">rand() function</indexterm> |
| <b>Purpose:</b> Returns a random value between 0 and 1. After <codeph>rand()</codeph> is called with a |
| seed argument, it produces a consistent random sequence based on the seed value. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| <p> |
| <b>Usage notes:</b> Currently, the random sequence is reset after each query, and multiple calls to |
| <codeph>rand()</codeph> within the same query return the same value each time. For different number |
| sequences that are different for each query, pass a unique seed value to each call to |
| <codeph>rand()</codeph>. For example, <codeph>select rand(unix_timestamp()) from ...</codeph> |
| </p> |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| <p> |
| The following examples show how <codeph>rand()</codeph> can produce sequences of varying predictability, |
| so that you can reproduce query results involving random values or generate unique sequences of random |
| values for each query. |
| When <codeph>rand()</codeph> is called with no argument, it generates the same sequence of values each time, |
| regardless of the ordering of the result set. |
| When <codeph>rand()</codeph> is called with a constant integer, it generates a different sequence of values, |
| but still always the same sequence for the same seed value. |
| If you pass in a seed value that changes, such as the return value of the expression <codeph>unix_timestamp(now())</codeph>, |
| each query will use a different sequence of random values, potentially more useful in probability calculations although |
| more difficult to reproduce at a later time. Therefore, the final two examples with an unpredictable seed value |
| also include the seed in the result set, to make it possible to reproduce the same random sequence later. |
| </p> |
| <codeblock>select x, rand() from three_rows; |
| +---+-----------------------+ |
| | x | rand() | |
| +---+-----------------------+ |
| | 1 | 0.0004714746030380365 | |
| | 2 | 0.5895895192351144 | |
| | 3 | 0.4431900859080209 | |
| +---+-----------------------+ |
| |
| select x, rand() from three_rows order by x desc; |
| +---+-----------------------+ |
| | x | rand() | |
| +---+-----------------------+ |
| | 3 | 0.0004714746030380365 | |
| | 2 | 0.5895895192351144 | |
| | 1 | 0.4431900859080209 | |
| +---+-----------------------+ |
| |
| select x, rand(1234) from three_rows order by x; |
| +---+----------------------+ |
| | x | rand(1234) | |
| +---+----------------------+ |
| | 1 | 0.7377511392057646 | |
| | 2 | 0.009428468537250751 | |
| | 3 | 0.208117277924026 | |
| +---+----------------------+ |
| |
| select x, rand(1234) from three_rows order by x desc; |
| +---+----------------------+ |
| | x | rand(1234) | |
| +---+----------------------+ |
| | 3 | 0.7377511392057646 | |
| | 2 | 0.009428468537250751 | |
| | 1 | 0.208117277924026 | |
| +---+----------------------+ |
| |
| select x, unix_timestamp(now()), rand(unix_timestamp(now())) |
| from three_rows order by x; |
| +---+-----------------------+-----------------------------+ |
| | x | unix_timestamp(now()) | rand(unix_timestamp(now())) | |
| +---+-----------------------+-----------------------------+ |
| | 1 | 1440777752 | 0.002051228658320023 | |
| | 2 | 1440777752 | 0.5098743483004506 | |
| | 3 | 1440777752 | 0.9517714925817081 | |
| +---+-----------------------+-----------------------------+ |
| |
| select x, unix_timestamp(now()), rand(unix_timestamp(now())) |
| from three_rows order by x desc; |
| +---+-----------------------+-----------------------------+ |
| | x | unix_timestamp(now()) | rand(unix_timestamp(now())) | |
| +---+-----------------------+-----------------------------+ |
| | 3 | 1440777761 | 0.9985985015512437 | |
| | 2 | 1440777761 | 0.3251255333074953 | |
| | 1 | 1440777761 | 0.02422675025846192 | |
| +---+-----------------------+-----------------------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="round"> |
| |
| <dt> |
| <codeph>round(double a)</codeph>, |
| <codeph>round(double a, int d)</codeph>, |
| <codeph rev="1.4.0">round(decimal a, int_type d)</codeph>, |
| <codeph rev="2.3.0" id="dround">dround(double a)</codeph>, |
| <codeph rev="2.3.0">dround(double a, int d)</codeph>, |
| <codeph rev="2.3.0">dround(decimal(p,s) a, int_type d)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">round() function</indexterm> |
| <indexterm audience="hidden">dround() function</indexterm> |
| <b>Purpose:</b> Rounds a floating-point value. By default (with a single argument), rounds to the nearest |
| integer. Values ending in .5 are rounded up for positive numbers, down for negative numbers (that is, |
| away from zero). The optional second argument specifies how many digits to leave after the decimal point; |
| values greater than zero produce a floating-point return value rounded to the requested number of digits |
| to the right of the decimal point. |
| <p rev="1.4.0"> |
| <b>Return type:</b> <codeph>bigint</codeph> for single <codeph>double</codeph> argument. |
| <codeph>double</codeph> for two-argument signature when second argument greater than zero. |
| For <codeph>DECIMAL</codeph> values, the smallest |
| <codeph>DECIMAL(<varname>p</varname>,<varname>s</varname>)</codeph> type with appropriate precision and |
| scale. |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry rev="1.4.0" id="scale"> |
| |
| <dt rev="1.4.0"> |
| <codeph>scale(<varname>numeric_expression</varname>)</codeph> |
| </dt> |
| |
| <dd rev="1.4.0"> |
| <indexterm audience="hidden">scale() function</indexterm> |
| <b>Purpose:</b> Computes the scale (number of decimal digits to the right of the decimal point) needed to |
| represent the type of the argument expression as a <codeph>DECIMAL</codeph> value. |
| <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/> |
| <p> |
| Typically used in combination with the <codeph>precision()</codeph> function, to determine the |
| appropriate <codeph>DECIMAL(<varname>precision</varname>,<varname>scale</varname>)</codeph> type to |
| declare in a <codeph>CREATE TABLE</codeph> statement or <codeph>CAST()</codeph> function. |
| </p> |
| <p> |
| <b>Return type:</b> <codeph>int</codeph> |
| </p> |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| <p conref="../shared/impala_common.xml#common/precision_scale_example"/> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="sign"> |
| |
| <dt> |
| <codeph>sign(double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">sign() function</indexterm> |
| <b>Purpose:</b> Returns -1, 0, or 1 to indicate the signedness of the argument value. |
| <p> |
| <b>Return type:</b> <codeph>int</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="sin"> |
| |
| <dt> |
| <codeph>sin(double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">sin() function</indexterm> |
| <b>Purpose:</b> Returns the sine of the argument. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="sinh" rev="2.3.0 IMPALA-1771"> |
| |
| <dt rev="2.3.0 IMPALA-1771"> |
| <codeph>sinh(double a)</codeph> |
| </dt> |
| |
| <dd rev="2.3.0 IMPALA-1771"> |
| <indexterm audience="hidden">sinh() function</indexterm> |
| <b>Purpose:</b> Returns the hyperbolic sine of the argument. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="sqrt"> |
| |
| <dt> |
| <codeph>sqrt(double a)</codeph>, |
| <codeph rev="2.3.0" id="dsqrt">dsqrt(double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">sqrt() function</indexterm> |
| <indexterm audience="hidden">dsqrt() function</indexterm> |
| <b>Purpose:</b> Returns the square root of the argument. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="tan"> |
| |
| <dt> |
| <codeph>tan(double a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">tan() function</indexterm> |
| <b>Purpose:</b> Returns the tangent of the argument. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="tanh" rev="2.3.0 IMPALA-1771"> |
| |
| <dt rev="2.3.0 IMPALA-1771"> |
| <codeph>tanh(double a)</codeph> |
| </dt> |
| |
| <dd rev="2.3.0 IMPALA-1771"> |
| <indexterm audience="hidden">tanh() function</indexterm> |
| <b>Purpose:</b> Returns the hyperbolic tangent of the argument. |
| <p> |
| <b>Return type:</b> <codeph>double</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry rev="2.3.0" id="truncate"> |
| |
| <dt rev="2.3.0"> |
| <codeph>truncate(double_or_decimal a[, digits_to_leave])</codeph>, |
| <ph id="dtrunc"><codeph>dtrunc(double_or_decimal a[, digits_to_leave])</codeph></ph> |
| </dt> |
| |
| <dd rev="2.3.0"> |
| <indexterm audience="hidden">truncate() function</indexterm> |
| <indexterm audience="hidden">dtrunc() function</indexterm> |
| <b>Purpose:</b> Removes some or all fractional digits from a numeric value. |
| With no argument, removes all fractional digits, leaving an integer value. |
| The optional argument specifies the number of fractional digits to include |
| in the return value, and only applies with the argument type is <codeph>DECIMAL</codeph>. |
| <codeph>truncate()</codeph> and <codeph>dtrunc()</codeph> are aliases for the same function. |
| <p> |
| <b>Return type:</b> <codeph>decimal</codeph> for <codeph>DECIMAL</codeph> arguments; |
| <codeph>bigint</codeph> for <codeph>DOUBLE</codeph> arguments |
| </p> |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| <codeblock>select truncate(3.45) |
| +----------------+ |
| | truncate(3.45) | |
| +----------------+ |
| | 3 | |
| +----------------+ |
| |
| select truncate(-3.45) |
| +-----------------+ |
| | truncate(-3.45) | |
| +-----------------+ |
| | -3 | |
| +-----------------+ |
| |
| select truncate(3.456,1) |
| +--------------------+ |
| | truncate(3.456, 1) | |
| +--------------------+ |
| | 3.4 | |
| +--------------------+ |
| |
| select dtrunc(3.456,1) |
| +------------------+ |
| | dtrunc(3.456, 1) | |
| +------------------+ |
| | 3.4 | |
| +------------------+ |
| |
| select truncate(3.456,2) |
| +--------------------+ |
| | truncate(3.456, 2) | |
| +--------------------+ |
| | 3.45 | |
| +--------------------+ |
| |
| select truncate(3.456,7) |
| +--------------------+ |
| | truncate(3.456, 7) | |
| +--------------------+ |
| | 3.4560000 | |
| +--------------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="unhex"> |
| |
| <dt> |
| <codeph>unhex(string a)</codeph> |
| </dt> |
| |
| <dd> |
| <indexterm audience="hidden">unhex() function</indexterm> |
| <b>Purpose:</b> Returns a string of characters with ASCII values corresponding to pairs of hexadecimal |
| digits in the argument. |
| <p> |
| <b>Return type:</b> <codeph>string</codeph> |
| </p> |
| </dd> |
| |
| </dlentry> |
| </dl> |
| </conbody> |
| </concept> |
