| <?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="bit_functions" rev="2.3.0"> |
| |
| <title>Impala Bit Functions</title> |
| |
| <titlealts audience="PDF"> |
| |
| <navtitle>Bit 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 rev="2.3.0"> |
| Bit manipulation functions perform bitwise operations involved in scientific processing or |
| computer science algorithms. For example, these functions include setting, clearing, or |
| testing bits within an integer value, or changing the positions of bits with or without |
| wraparound. |
| </p> |
| |
| <p> |
| If a function takes two integer arguments that are required to be of the same type, the |
| smaller argument is promoted to the type of the larger one if required. For example, |
| <codeph>BITAND(1,4096)</codeph> treats both arguments as <codeph>SMALLINT</codeph>, |
| because 1 can be represented as a <codeph>TINYINT</codeph> but 4096 requires a |
| <codeph>SMALLINT</codeph>. |
| </p> |
| |
| <p> |
| Remember that all Impala integer values are signed. Therefore, when dealing with binary |
| values where the most significant bit is 1, the specified or returned values might be |
| negative when represented in base 10. |
| </p> |
| |
| <p> |
| Whenever any argument is <codeph>NULL</codeph>, either the input value, bit position, or |
| number of shift or rotate positions, the return value from any of these functions is also |
| <codeph>NULL</codeph> |
| </p> |
| |
| <p conref="../shared/impala_common.xml#common/related_info"/> |
| |
| <p> |
| The bit functions operate on all the integral data types: |
| <xref href="impala_int.xml#int"/>, <xref href="impala_bigint.xml#bigint"/>, |
| <xref href="impala_smallint.xml#smallint"/>, and |
| <xref href="impala_tinyint.xml#tinyint"/>. |
| </p> |
| |
| <p> |
| <b>Function reference:</b> |
| </p> |
| |
| <p> |
| Impala supports the following bit functions: |
| </p> |
| |
| <ul> |
| <li> |
| <xref href="#bit_functions/bitand">BITAND</xref> |
| </li> |
| |
| <li> |
| <xref href="#bit_functions/bitnot">BITNOT</xref> |
| </li> |
| |
| <li> |
| <xref href="#bit_functions/bitor">BITOR</xref> |
| </li> |
| |
| <li> |
| <xref href="#bit_functions/bitxor">BITXOR</xref> |
| </li> |
| |
| <li> |
| <xref href="#bit_functions/countset">COUNTSET</xref> |
| </li> |
| |
| <li> |
| <xref href="#bit_functions/getbit">GETBIT</xref> |
| </li> |
| |
| <li> |
| <xref href="#bit_functions/rotateleft">ROTATELEFT</xref> |
| </li> |
| |
| <li> |
| <xref href="#bit_functions/rotateright">ROTATERIGHT</xref> |
| </li> |
| |
| <li> |
| <xref href="#bit_functions/setbit">SETBIT</xref> |
| </li> |
| |
| <li> |
| <xref href="#bit_functions/shiftleft">SHIFTLEFT</xref> |
| </li> |
| |
| <li> |
| <xref href="#bit_functions/shiftright">SHIFTRIGHT</xref> |
| </li> |
| </ul> |
| |
| <dl> |
| <dlentry id="bitand"> |
| |
| <dt> |
| BITAND(integer_type a, same_type b) |
| </dt> |
| |
| <dd> |
| <b>Purpose:</b> Returns an integer value representing the bits that are set to 1 in |
| both of the arguments. If the arguments are of different sizes, the smaller is |
| promoted to the type of the larger. |
| <p> |
| <b>Usage notes:</b> The <codeph>BITAND()</codeph> function is equivalent to the |
| <codeph>&</codeph> binary operator. |
| </p> |
| |
| <p conref="../shared/impala_common.xml#common/return_type_same"/> |
| |
| <p conref="../shared/impala_common.xml#common/added_in_230"/> |
| |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| |
| <p> |
| The following examples show the results of ANDing integer values. 255 contains all 1 |
| bits in its lowermost 7 bits. 32767 contains all 1 bits in its lowermost 15 bits. |
| <!-- |
| Negative numbers have a 1 in the sign bit and the value is the |
| <xref href="https://en.wikipedia.org/wiki/Two%27s_complement" scope="external" format="html">two's complement</xref> |
| of the positive equivalent. |
| --> |
| You can use the <codeph>BIN()</codeph> function to check the binary representation |
| of any integer value, although the result is always represented as a 64-bit value. |
| If necessary, the smaller argument is promoted to the type of the larger one. |
| </p> |
| <codeblock>select bitand(255, 32767); /* 0000000011111111 & 0111111111111111 */ |
| +--------------------+ |
| | bitand(255, 32767) | |
| +--------------------+ |
| | 255 | |
| +--------------------+ |
| |
| select bitand(32767, 1); /* 0111111111111111 & 0000000000000001 */ |
| +------------------+ |
| | bitand(32767, 1) | |
| +------------------+ |
| | 1 | |
| +------------------+ |
| |
| select bitand(32, 16); /* 00010000 & 00001000 */ |
| +----------------+ |
| | bitand(32, 16) | |
| +----------------+ |
| | 0 | |
| +----------------+ |
| |
| select bitand(12,5); /* 00001100 & 00000101 */ |
| +---------------+ |
| | bitand(12, 5) | |
| +---------------+ |
| | 4 | |
| +---------------+ |
| |
| select bitand(-1,15); /* 11111111 & 00001111 */ |
| +----------------+ |
| | bitand(-1, 15) | |
| +----------------+ |
| | 15 | |
| +----------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="bitnot"> |
| |
| <dt> |
| BITNOT(integer_type a) |
| </dt> |
| |
| <dd> |
| <b>Purpose:</b> Inverts all the bits of the input argument. |
| <p> |
| <b>Usage notes:</b> The <codeph>BITNOT()</codeph> function is equivalent to the |
| <codeph>~</codeph> unary operator. |
| </p> |
| |
| <p conref="../shared/impala_common.xml#common/return_type_same"/> |
| |
| <p conref="../shared/impala_common.xml#common/added_in_230"/> |
| |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| |
| <p> |
| These examples illustrate what happens when you flip all the bits of an integer |
| value. The sign always changes. The decimal representation is one different between |
| the positive and negative values. |
| <!-- |
| because negative values are represented as the |
| <xref href="https://en.wikipedia.org/wiki/Two%27s_complement" scope="external" format="html">two's complement</xref> |
| of the corresponding positive value. |
| --> |
| </p> |
| <codeblock>select bitnot(127); /* 01111111 -> 10000000 */ |
| +-------------+ |
| | bitnot(127) | |
| +-------------+ |
| | -128 | |
| +-------------+ |
| |
| select bitnot(16); /* 00010000 -> 11101111 */ |
| +------------+ |
| | bitnot(16) | |
| +------------+ |
| | -17 | |
| +------------+ |
| |
| select bitnot(0); /* 00000000 -> 11111111 */ |
| +-----------+ |
| | bitnot(0) | |
| +-----------+ |
| | -1 | |
| +-----------+ |
| |
| select bitnot(-128); /* 10000000 -> 01111111 */ |
| +--------------+ |
| | bitnot(-128) | |
| +--------------+ |
| | 127 | |
| +--------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="bitor"> |
| |
| <dt> |
| BITOR(integer_type a, same_type b) |
| </dt> |
| |
| <dd> |
| <b>Purpose:</b> Returns an integer value representing the bits that are set to 1 in |
| either of the arguments. If the arguments are of different sizes, the smaller is |
| promoted to the type of the larger. |
| <p> |
| <b>Usage notes:</b> The <codeph>BITOR()</codeph> function is equivalent to the |
| <codeph>|</codeph> binary operator. |
| </p> |
| |
| <p conref="../shared/impala_common.xml#common/return_type_same"/> |
| |
| <p conref="../shared/impala_common.xml#common/added_in_230"/> |
| |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| |
| <p> |
| The following examples show the results of ORing integer values. |
| </p> |
| <codeblock>select bitor(1,4); /* 00000001 | 00000100 */ |
| +-------------+ |
| | bitor(1, 4) | |
| +-------------+ |
| | 5 | |
| +-------------+ |
| |
| select bitor(16,48); /* 00001000 | 00011000 */ |
| +---------------+ |
| | bitor(16, 48) | |
| +---------------+ |
| | 48 | |
| +---------------+ |
| |
| select bitor(0,7); /* 00000000 | 00000111 */ |
| +-------------+ |
| | bitor(0, 7) | |
| +-------------+ |
| | 7 | |
| +-------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="bitxor"> |
| |
| <dt> |
| BITXOR(integer_type a, same_type b) |
| </dt> |
| |
| <dd> |
| <b>Purpose:</b> Returns an integer value representing the bits that are set to 1 in |
| one but not both of the arguments. If the arguments are of different sizes, the |
| smaller is promoted to the type of the larger. |
| <p> |
| <b>Usage notes:</b> The <codeph>BITXOR()</codeph> function is equivalent to the |
| <codeph>^</codeph> binary operator. |
| </p> |
| |
| <p conref="../shared/impala_common.xml#common/return_type_same"/> |
| |
| <p conref="../shared/impala_common.xml#common/added_in_230"/> |
| |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| |
| <p> |
| The following examples show the results of XORing integer values. XORing a non-zero |
| value with zero returns the non-zero value. XORing two identical values returns |
| zero, because all the 1 bits from the first argument are also 1 bits in the second |
| argument. XORing different non-zero values turns off some bits and leaves others |
| turned on, based on whether the same bit is set in both arguments. |
| </p> |
| <codeblock>select bitxor(0,15); /* 00000000 ^ 00001111 */ |
| +---------------+ |
| | bitxor(0, 15) | |
| +---------------+ |
| | 15 | |
| +---------------+ |
| |
| select bitxor(7,7); /* 00000111 ^ 00000111 */ |
| +--------------+ |
| | bitxor(7, 7) | |
| +--------------+ |
| | 0 | |
| +--------------+ |
| |
| select bitxor(8,4); /* 00001000 ^ 00000100 */ |
| +--------------+ |
| | bitxor(8, 4) | |
| +--------------+ |
| | 12 | |
| +--------------+ |
| |
| select bitxor(3,7); /* 00000011 ^ 00000111 */ |
| +--------------+ |
| | bitxor(3, 7) | |
| +--------------+ |
| | 4 | |
| +--------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="countset"> |
| |
| <dt> |
| COUNTSET(integer_type a [, INT zero_or_one]) |
| </dt> |
| |
| <dd> |
| <b>Purpose:</b> By default, returns the number of 1 bits in the specified integer |
| value. If the optional second argument is set to zero, it returns the number of 0 bits |
| instead. |
| <p |
| conref="../shared/impala_common.xml#common/usage_notes_blurb"/> |
| |
| <p> |
| In discussions of information theory, this operation is referred to as the |
| <q><xref |
| href="https://en.wikipedia.org/wiki/Hamming_weight" |
| scope="external" format="html">population |
| count</xref></q> or <q>popcount</q>. |
| </p> |
| |
| <p conref="../shared/impala_common.xml#common/return_type_same"/> |
| |
| <p conref="../shared/impala_common.xml#common/added_in_230"/> |
| |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| |
| <p> |
| The following examples show how to count the number of 1 bits in an integer value. |
| </p> |
| <codeblock>select countset(1); /* 00000001 */ |
| +-------------+ |
| | countset(1) | |
| +-------------+ |
| | 1 | |
| +-------------+ |
| |
| select countset(3); /* 00000011 */ |
| +-------------+ |
| | countset(3) | |
| +-------------+ |
| | 2 | |
| +-------------+ |
| |
| select countset(16); /* 00010000 */ |
| +--------------+ |
| | countset(16) | |
| +--------------+ |
| | 1 | |
| +--------------+ |
| |
| select countset(17); /* 00010001 */ |
| +--------------+ |
| | countset(17) | |
| +--------------+ |
| | 2 | |
| +--------------+ |
| |
| select countset(7,1); /* 00000111 = 3 1 bits; the function counts 1 bits by default */ |
| +----------------+ |
| | countset(7, 1) | |
| +----------------+ |
| | 3 | |
| +----------------+ |
| |
| select countset(7,0); /* 00000111 = 5 0 bits; third argument can only be 0 or 1 */ |
| +----------------+ |
| | countset(7, 0) | |
| +----------------+ |
| | 5 | |
| +----------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="getbit"> |
| |
| <dt> |
| GETBIT(integer_type a, INT position) |
| </dt> |
| |
| <dd> |
| <b>Purpose:</b> Returns a 0 or 1 representing the bit at a specified position. The |
| positions are numbered right to left, starting at zero. The position argument cannot |
| be negative. |
| <p |
| conref="../shared/impala_common.xml#common/usage_notes_blurb"/> |
| |
| <p> |
| When you use a literal input value, it is treated as an 8-bit, 16-bit, and so on |
| value, the smallest type that is appropriate. The type of the input value limits the |
| range of the positions. Cast the input value to the appropriate type if you need to |
| ensure it is treated as a 64-bit, 32-bit, and so on value. |
| </p> |
| |
| <p conref="../shared/impala_common.xml#common/return_type_same"/> |
| |
| <p conref="../shared/impala_common.xml#common/added_in_230"/> |
| |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| |
| <p> |
| The following examples show how to test a specific bit within an integer value. |
| </p> |
| <codeblock>select getbit(1,0); /* 00000001 */ |
| +--------------+ |
| | getbit(1, 0) | |
| +--------------+ |
| | 1 | |
| +--------------+ |
| |
| select getbit(16,1) /* 00010000 */ |
| +---------------+ |
| | getbit(16, 1) | |
| +---------------+ |
| | 0 | |
| +---------------+ |
| |
| select getbit(16,4) /* 00010000 */ |
| +---------------+ |
| | getbit(16, 4) | |
| +---------------+ |
| | 1 | |
| +---------------+ |
| |
| select getbit(16,5) /* 00010000 */ |
| +---------------+ |
| | getbit(16, 5) | |
| +---------------+ |
| | 0 | |
| +---------------+ |
| |
| select getbit(-1,3); /* 11111111 */ |
| +---------------+ |
| | getbit(-1, 3) | |
| +---------------+ |
| | 1 | |
| +---------------+ |
| |
| select getbit(-1,25); /* 11111111 */ |
| ERROR: Invalid bit position: 25 |
| |
| select getbit(cast(-1 as int),25); /* 11111111111111111111111111111111 */ |
| +-----------------------------+ |
| | getbit(cast(-1 as int), 25) | |
| +-----------------------------+ |
| | 1 | |
| +-----------------------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="rotateleft"> |
| |
| <dt> |
| ROTATELEFT(integer_type a, INT positions) |
| </dt> |
| |
| <dd> |
| <b>Purpose:</b> Rotates an integer value left by a specified number of bits. As the |
| most significant bit is taken out of the original value, if it is a 1 bit, it is |
| <q>rotated</q> back to the least significant bit. Therefore, the final value has the |
| same number of 1 bits as the original value, just in different positions. In computer |
| science terms, this operation is a |
| <q><xref |
| href="https://en.wikipedia.org/wiki/Circular_shift" |
| scope="external" format="html">circular |
| shift</xref></q>. |
| <p |
| conref="../shared/impala_common.xml#common/usage_notes_blurb"/> |
| |
| <p> |
| Specifying a second argument of zero leaves the original value unchanged. Rotating a |
| -1 value by any number of positions still returns -1, because the original value has |
| all 1 bits and all the 1 bits are preserved during rotation. Similarly, rotating a 0 |
| value by any number of positions still returns 0. Rotating a value by the same |
| number of bits as in the value returns the same value. Because this is a circular |
| operation, the number of positions is not limited to the number of bits in the input |
| value. For example, rotating an 8-bit value by 1, 9, 17, and so on positions returns |
| an identical result in each case. |
| </p> |
| |
| <p conref="../shared/impala_common.xml#common/return_type_same"/> |
| |
| <p conref="../shared/impala_common.xml#common/added_in_230"/> |
| |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| <codeblock>select rotateleft(1,4); /* 00000001 -> 00010000 */ |
| +------------------+ |
| | rotateleft(1, 4) | |
| +------------------+ |
| | 16 | |
| +------------------+ |
| |
| select rotateleft(-1,155); /* 11111111 -> 11111111 */ |
| +---------------------+ |
| | rotateleft(-1, 155) | |
| +---------------------+ |
| | -1 | |
| +---------------------+ |
| |
| select rotateleft(-128,1); /* 10000000 -> 00000001 */ |
| +---------------------+ |
| | rotateleft(-128, 1) | |
| +---------------------+ |
| | 1 | |
| +---------------------+ |
| |
| select rotateleft(-127,3); /* 10000001 -> 00001100 */ |
| +---------------------+ |
| | rotateleft(-127, 3) | |
| +---------------------+ |
| | 12 | |
| +---------------------+ |
| |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="rotateright"> |
| |
| <dt> |
| ROTATERIGHT(integer_type a, INT positions) |
| </dt> |
| |
| <dd> |
| <b>Purpose:</b> Rotates an integer value right by a specified number of bits. As the |
| least significant bit is taken out of the original value, if it is a 1 bit, it is |
| <q>rotated</q> back to the most significant bit. Therefore, the final value has the |
| same number of 1 bits as the original value, just in different positions. In computer |
| science terms, this operation is a |
| <q><xref |
| href="https://en.wikipedia.org/wiki/Circular_shift" |
| scope="external" format="html">circular |
| shift</xref></q>. |
| <p |
| conref="../shared/impala_common.xml#common/usage_notes_blurb"/> |
| |
| <p> |
| Specifying a second argument of zero leaves the original value unchanged. Rotating a |
| -1 value by any number of positions still returns -1, because the original value has |
| all 1 bits and all the 1 bits are preserved during rotation. Similarly, rotating a 0 |
| value by any number of positions still returns 0. Rotating a value by the same |
| number of bits as in the value returns the same value. Because this is a circular |
| operation, the number of positions is not limited to the number of bits in the input |
| value. For example, rotating an 8-bit value by 1, 9, 17, and so on positions returns |
| an identical result in each case. |
| </p> |
| |
| <p conref="../shared/impala_common.xml#common/return_type_same"/> |
| |
| <p conref="../shared/impala_common.xml#common/added_in_230"/> |
| |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| <codeblock>select rotateright(16,4); /* 00010000 -> 00000001 */ |
| +--------------------+ |
| | rotateright(16, 4) | |
| +--------------------+ |
| | 1 | |
| +--------------------+ |
| |
| select rotateright(-1,155); /* 11111111 -> 11111111 */ |
| +----------------------+ |
| | rotateright(-1, 155) | |
| +----------------------+ |
| | -1 | |
| +----------------------+ |
| |
| select rotateright(-128,1); /* 10000000 -> 01000000 */ |
| +----------------------+ |
| | rotateright(-128, 1) | |
| +----------------------+ |
| | 64 | |
| +----------------------+ |
| |
| select rotateright(-127,3); /* 10000001 -> 00110000 */ |
| +----------------------+ |
| | rotateright(-127, 3) | |
| +----------------------+ |
| | 48 | |
| +----------------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="setbit"> |
| |
| <dt> |
| SETBIT(integer_type a, INT position [, INT zero_or_one]) |
| </dt> |
| |
| <dd> |
| <b>Purpose:</b> By default, changes a bit at a specified position to a 1, if it is not |
| already. If the optional third argument is set to zero, the specified bit is set to 0 |
| instead. |
| <p |
| conref="../shared/impala_common.xml#common/usage_notes_blurb"/> |
| If the bit at the specified position was already 1 (by default) or 0 (with a third |
| argument of zero), the return value is the same as the first argument. The positions |
| are numbered right to left, starting at zero. (Therefore, the return value could be |
| different from the first argument even if the position argument is zero.) The position |
| argument cannot be negative. |
| <p> |
| When you use a literal input value, it is treated as an 8-bit, 16-bit, and so on |
| value, the smallest type that is appropriate. The type of the input value limits the |
| range of the positions. Cast the input value to the appropriate type if you need to |
| ensure it is treated as a 64-bit, 32-bit, and so on value. |
| </p> |
| |
| <p conref="../shared/impala_common.xml#common/return_type_same"/> |
| |
| <p conref="../shared/impala_common.xml#common/added_in_230"/> |
| |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| <codeblock>select setbit(0,0); /* 00000000 -> 00000001 */ |
| +--------------+ |
| | setbit(0, 0) | |
| +--------------+ |
| | 1 | |
| +--------------+ |
| |
| select setbit(0,3); /* 00000000 -> 00001000 */ |
| +--------------+ |
| | setbit(0, 3) | |
| +--------------+ |
| | 8 | |
| +--------------+ |
| |
| select setbit(7,3); /* 00000111 -> 00001111 */ |
| +--------------+ |
| | setbit(7, 3) | |
| +--------------+ |
| | 15 | |
| +--------------+ |
| |
| select setbit(15,3); /* 00001111 -> 00001111 */ |
| +---------------+ |
| | setbit(15, 3) | |
| +---------------+ |
| | 15 | |
| +---------------+ |
| |
| select setbit(0,32); /* By default, 0 is a TINYINT with only 8 bits. */ |
| ERROR: Invalid bit position: 32 |
| |
| select setbit(cast(0 as bigint),32); /* For BIGINT, the position can be 0..63. */ |
| +-------------------------------+ |
| | setbit(cast(0 as bigint), 32) | |
| +-------------------------------+ |
| | 4294967296 | |
| +-------------------------------+ |
| |
| select setbit(7,3,1); /* 00000111 -> 00001111; setting to 1 is the default */ |
| +-----------------+ |
| | setbit(7, 3, 1) | |
| +-----------------+ |
| | 15 | |
| +-----------------+ |
| |
| select setbit(7,2,0); /* 00000111 -> 00000011; third argument of 0 clears instead of sets */ |
| +-----------------+ |
| | setbit(7, 2, 0) | |
| +-----------------+ |
| | 3 | |
| +-----------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="shiftleft"> |
| |
| <dt> |
| SHIFTLEFT(integer_type a, INT positions) |
| </dt> |
| |
| <dd> |
| <b>Purpose:</b> Shifts an integer value left by a specified number of bits. As the |
| most significant bit is taken out of the original value, it is discarded and the least |
| significant bit becomes 0. In computer science terms, this operation is a |
| <q><xref |
| href="https://en.wikipedia.org/wiki/Logical_shift" |
| scope="external" format="html">logical |
| shift</xref></q>. |
| <p |
| conref="../shared/impala_common.xml#common/usage_notes_blurb"/> |
| |
| <p> |
| The final value has either the same number of 1 bits as the original value, or |
| fewer. Shifting an 8-bit value by 8 positions, a 16-bit value by 16 positions, and |
| so on produces a result of zero. |
| </p> |
| |
| <p> |
| Specifying a second argument of zero leaves the original value unchanged. Shifting |
| any value by 0 returns the original value. Shifting any value by 1 is the same as |
| multiplying it by 2, as long as the value is small enough; larger values eventually |
| become negative when shifted, as the sign bit is set. Starting with the value 1 and |
| shifting it left by N positions gives the same result as 2 to the Nth power, or |
| <codeph>POW(2,<varname>N</varname>)</codeph>. |
| </p> |
| |
| <p conref="../shared/impala_common.xml#common/return_type_same"/> |
| |
| <p conref="../shared/impala_common.xml#common/added_in_230"/> |
| |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| <codeblock>select shiftleft(1,0); /* 00000001 -> 00000001 */ |
| +-----------------+ |
| | shiftleft(1, 0) | |
| +-----------------+ |
| | 1 | |
| +-----------------+ |
| |
| select shiftleft(1,3); /* 00000001 -> 00001000 */ |
| +-----------------+ |
| | shiftleft(1, 3) | |
| +-----------------+ |
| | 8 | |
| +-----------------+ |
| |
| select shiftleft(8,2); /* 00001000 -> 00100000 */ |
| +-----------------+ |
| | shiftleft(8, 2) | |
| +-----------------+ |
| | 32 | |
| +-----------------+ |
| |
| select shiftleft(127,1); /* 01111111 -> 11111110 */ |
| +-------------------+ |
| | shiftleft(127, 1) | |
| +-------------------+ |
| | -2 | |
| +-------------------+ |
| |
| select shiftleft(127,5); /* 01111111 -> 11100000 */ |
| +-------------------+ |
| | shiftleft(127, 5) | |
| +-------------------+ |
| | -32 | |
| +-------------------+ |
| |
| select shiftleft(-1,4); /* 11111111 -> 11110000 */ |
| +------------------+ |
| | shiftleft(-1, 4) | |
| +------------------+ |
| | -16 | |
| +------------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| |
| <dlentry id="shiftright"> |
| |
| <dt> |
| SHIFTRIGHT(integer_type a, INT positions) |
| </dt> |
| |
| <dd> |
| <b>Purpose:</b> Shifts an integer value right by a specified number of bits. As the |
| least significant bit is taken out of the original value, it is discarded and the most |
| significant bit becomes 0. In computer science terms, this operation is a |
| <q><xref |
| href="https://en.wikipedia.org/wiki/Logical_shift" |
| scope="external" format="html">logical |
| shift</xref></q>. |
| <p |
| conref="../shared/impala_common.xml#common/usage_notes_blurb"/> |
| |
| <p> |
| Therefore, the final value has either the same number of 1 bits as the original |
| value, or fewer. Shifting an 8-bit value by 8 positions, a 16-bit value by 16 |
| positions, and so on produces a result of zero. |
| </p> |
| |
| <p> |
| Specifying a second argument of zero leaves the original value unchanged. Shifting |
| any value by 0 returns the original value. Shifting any positive value right by 1 is |
| the same as dividing it by 2. Negative values become positive when shifted right. |
| </p> |
| |
| <p conref="../shared/impala_common.xml#common/return_type_same"/> |
| |
| <p conref="../shared/impala_common.xml#common/added_in_230"/> |
| |
| <p conref="../shared/impala_common.xml#common/example_blurb"/> |
| <codeblock>select shiftright(16,0); /* 00010000 -> 00010000 */ |
| +-------------------+ |
| | shiftright(16, 0) | |
| +-------------------+ |
| | 16 | |
| +-------------------+ |
| |
| select shiftright(16,4); /* 00010000 -> 00000001 */ |
| +-------------------+ |
| | shiftright(16, 4) | |
| +-------------------+ |
| | 1 | |
| +-------------------+ |
| |
| select shiftright(16,5); /* 00010000 -> 00000000 */ |
| +-------------------+ |
| | shiftright(16, 5) | |
| +-------------------+ |
| | 0 | |
| +-------------------+ |
| |
| select shiftright(-1,1); /* 11111111 -> 01111111 */ |
| +-------------------+ |
| | shiftright(-1, 1) | |
| +-------------------+ |
| | 127 | |
| +-------------------+ |
| |
| select shiftright(-1,5); /* 11111111 -> 00000111 */ |
| +-------------------+ |
| | shiftright(-1, 5) | |
| +-------------------+ |
| | 7 | |
| +-------------------+ |
| </codeblock> |
| </dd> |
| |
| </dlentry> |
| </dl> |
| |
| </conbody> |
| |
| </concept> |