비트 함수

비트 함수는 UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64 중 임의의 두 타입 조합에 대해 동작합니다. 일부 함수는 String 및 FixedString 타입도 지원합니다.

결과 타입은 인수들 중 최대 비트 수와 동일한 비트를 가진 정수입니다. 인수 중 하나라도 부호 있는 타입이면 결과는 부호 있는 숫자가 됩니다. 인수가 부동 소수점 숫자인 경우 Int64로 형변환됩니다.

bitAnd

도입된 버전: v1.1.0

두 값에 대해 비트 AND 연산을 수행합니다.

구문

bitAnd(a, b)

인자

a — 첫 번째 값. (U)Int* 또는 Float*
b — 두 번째 값. (U)Int* 또는 Float*

반환값

비트 단위 연산 a AND b의 결과를 반환합니다.

예시

사용 예시

CREATE TABLE bits
(
    `a` UInt8,
    `b` UInt8
)
ENGINE = Memory;

INSERT INTO bits VALUES (0, 0), (0, 1), (1, 0), (1, 1);

SELECT
    a,
    b,
    bitAnd(a, b)
FROM bits

┌─a─┬─b─┬─bitAnd(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            0 │
│ 1 │ 0 │            0 │
│ 1 │ 1 │            1 │
└───┴───┴──────────────┘

bitCount

도입된 버전: v20.3.0

숫자의 이진 표현에서 1로 설정된 비트 수를 계산합니다.

구문

bitCount(x)

인수(Arguments)

x — 정수 또는 부동 소수점 값. (U)Int* 또는 Float*

반환 값

x에서 값이 1인 비트의 개수를 반환합니다. UInt8.

참고

이 함수는 입력 값을 더 큰 타입으로 변환하지 않습니다(부호 확장(sign extension)). 예를 들어, bitCount(toUInt8(-1)) = 8입니다.

예시

사용 예시

SELECT bin(333), bitCount(333);

┌─bin(333)─────────┬─bitCount(333)─┐
│ 0000000101001101 │             5 │
└──────────────────┴───────────────┘

bitHammingDistance

도입 버전: v21.1.0

두 수의 비트 표현 사이의 해밍 거리를 반환합니다. 부분적으로 중복된 문자열을 탐지하기 위해 SimHash 함수와 함께 사용할 수 있습니다. 거리가 작을수록 문자열이 더 유사합니다.

구문

bitHammingDistance(x, y)

인수

x — 해밍 거리(Hamming distance) 계산을 위한 첫 번째 수. (U)Int* 또는 Float*
y — 해밍 거리(Hamming distance) 계산을 위한 두 번째 수. (U)Int* 또는 Float*

반환 값

x와 y의 해밍 거리를 UInt8 값으로 반환합니다.

예시

사용 예시

SELECT bitHammingDistance(111, 121);

┌─bitHammingDistance(111, 121)─┐
│                            3 │
└──────────────────────────────┘

bitNot

도입 버전: v1.1.0

비트 단위 NOT 연산을 수행합니다.

구문

bitNot(a)

인수

a — 비트 NOT 연산을 적용할 값입니다. (U)Int* 또는 Float* 또는 String

반환 값

~a, 즉 비트가 반전된 a의 결과를 반환합니다.

예시

사용 예시

SELECT
    CAST('5', 'UInt8') AS original,
    bin(original) AS original_binary,
    bitNot(original) AS result,
    bin(bitNot(original)) AS result_binary;

┌─original─┬─original_binary─┬─result─┬─result_binary─┐
│        5 │ 00000101        │    250 │ 11111010      │
└──────────┴─────────────────┴────────┴───────────────┘

bitOr

도입 버전: v1.1.0

두 값 간에 비트 단위 OR 연산을 수행합니다.

문법

bitOr(a, b)

인수

a — 첫 번째 값. (U)Int* 또는 Float*
b — 두 번째 값. (U)Int* 또는 Float*

반환 값

비트 연산 a OR b의 결과를 반환합니다.

예시

사용 예시

CREATE TABLE bits
(
    `a` UInt8,
    `b` UInt8
)
ENGINE = Memory;

INSERT INTO bits VALUES (0, 0), (0, 1), (1, 0), (1, 1);

SELECT
    a,
    b,
    bitOr(a, b)
FROM bits;

┌─a─┬─b─┬─bitOr(a, b)─┐
│ 0 │ 0 │           0 │
│ 0 │ 1 │           1 │
│ 1 │ 0 │           1 │
│ 1 │ 1 │           1 │
└───┴───┴─────────────┘

bitRotateLeft

도입 버전: v1.1.0

비트를 지정한 개수만큼 왼쪽으로 회전합니다. 밀려나간 비트는 다시 오른쪽으로 순환됩니다.

구문

bitRotateLeft(a, N)

인수

a — 회전할 값입니다. (U)Int8/16/32/64
N — 왼쪽으로 회전할 비트 위치 수입니다. UInt8/16/32/64

반환 값

a와 동일한 타입의 회전된 값을 반환합니다. (U)Int8/16/32/64

예시

사용 예시

SELECT 99 AS a, bin(a), bitRotateLeft(a, 2) AS a_rotated, bin(a_rotated);

┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       141 │ 10001101       │
└────┴──────────┴───────────┴────────────────┘

bitRotateRight

도입된 버전: v1.1.0

비트를 지정한 개수만큼 오른쪽으로 회전합니다. 오른쪽으로 밀려 나간 비트는 왼쪽 끝으로 다시 돌아옵니다.

구문

bitRotateRight(a, N)

인자

a — 회전할 값입니다. (U)Int8/16/32/64
N — 오른쪽으로 회전할 비트 수입니다. UInt8/16/32/64

반환 값

a와 동일한 타입의 회전된 값을 반환합니다. (U)Int8/16/32/64

예시

사용 예시

SELECT 99 AS a, bin(a), bitRotateRight(a, 2) AS a_rotated, bin(a_rotated);

┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       216 │ 11011000       │
└────┴──────────┴───────────┴────────────────┘

bitShiftLeft

도입된 버전: v1.1.0

값의 이진 표현을 지정된 비트 수만큼 왼쪽으로 시프트합니다.

FixedString 또는 String은 하나의 멀티바이트 값으로 취급됩니다.

FixedString 값의 비트는 시프트되는 과정에서 범위를 벗어나면 버려집니다. 반대로 String 값은 추가 바이트가 붙어 확장되므로 비트가 손실되지 않습니다.

구문

bitShiftLeft(a, N)

인수

a — 시프트할 값입니다. (U)Int* 또는 String 또는 FixedString
N — 시프트할 위치의 개수입니다. UInt8/16/32/64

반환 값

a와 동일한 타입의 시프트된 값을 반환합니다.

예시

이진 인코딩을 사용하는 예시

SELECT 99 AS a, bin(a), bitShiftLeft(a, 2) AS a_shifted, bin(a_shifted);

┌──a─┬─bin(99)──┬─a_shifted─┬─bin(bitShiftLeft(99, 2))─┐
│ 99 │ 01100011 │       140 │ 10001100                 │
└────┴──────────┴───────────┴──────────────────────────┘

16진수 인코딩 사용 예

SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);

┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftLeft('abc', 4))─┐
│ abc │ 616263     │ &0        │ 06162630                    │
└─────┴────────────┴───────────┴─────────────────────────────┘

Fixed String 인코딩을 사용한 예시

SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);

┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftLeft(toFixedString('abc', 3), 4))─┐
│ abc │ 616263                       │ &0        │ 162630                                        │
└─────┴──────────────────────────────┴───────────┴───────────────────────────────────────────────┘

bitShiftRight

도입된 버전: v1.1.0

값의 이진 표현을 지정된 비트 수만큼 오른쪽으로 시프트합니다.

FixedString 또는 String은 하나의 멀티바이트 값으로 취급됩니다.

FixedString 값의 비트는 시프트되는 동안 버려집니다. 반대로 String 값은 추가 바이트로 확장되므로 비트가 손실되지 않습니다.

구문

bitShiftRight(a, N)

인수

a — 시프트할 값입니다. (U)Int* 또는 String 또는 FixedString
N — 시프트할 자리 수입니다. UInt8/16/32/64

반환 값

a와 동일한 타입의 시프트된 값을 반환합니다.

예시

바이너리 인코딩 사용 예제

SELECT 101 AS a, bin(a), bitShiftRight(a, 2) AS a_shifted, bin(a_shifted);

┌───a─┬─bin(101)─┬─a_shifted─┬─bin(bitShiftRight(101, 2))─┐
│ 101 │ 01100101 │        25 │ 00011001                   │
└─────┴──────────┴───────────┴────────────────────────────┘

16진수 인코딩 사용 예

SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);

┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftRight('abc', 12))─┐
│ abc │ 616263     │           │ 0616                          │
└─────┴────────────┴───────────┴───────────────────────────────┘

고정 길이 문자열(Fixed String) 인코딩 사용 예시

SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftRight(a, 12) AS a_shifted, hex(a_shifted);

┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftRight(toFixedString('abc', 3), 12))─┐
│ abc │ 616263                       │           │ 000616                                          │
└─────┴──────────────────────────────┴───────────┴─────────────────────────────────────────────────┘

bitSlice

도입 버전: v22.2.0

'offset' 인덱스의 비트에서 시작하여 길이가 'length'비트인 비트 부분 문자열을 반환합니다.

문법

bitSlice(s, offset[, length])

인수

s — 슬라이스할 String 또는 FixedString입니다. String 또는 FixedString
offset — 시작 비트 위치(1부터 시작하는 인덱스)를 나타냅니다.
양수 값: 문자열의 시작부터 셉니다.
음수 값: 문자열의 끝에서부터 셉니다.

(U)Int8/16/32/64 또는 Float*
length — 선택 사항입니다. 추출할 비트 개수입니다.
양수 값: length 비트를 추출합니다.
음수 값: offset부터 (string_length - |length|)까지 추출합니다.
생략 시: offset부터 문자열 끝까지 추출합니다.
length가 8의 배수가 아니면, 결과는 오른쪽이 0으로 패딩됩니다. (U)Int8/16/32/64 또는 Float*

반환 값

추출된 비트를 이진 시퀀스로 표현한 문자열을 반환합니다. 결과는 항상 바이트 경계(8비트의 배수)에 맞추어 패딩됩니다. String

예시

사용 예시

SELECT bin('Hello'), bin(bitSlice('Hello', 1, 8));
SELECT bin('Hello'), bin(bitSlice('Hello', 1, 2));
SELECT bin('Hello'), bin(bitSlice('Hello', 1, 9));
SELECT bin('Hello'), bin(bitSlice('Hello', -4, 8));

┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', 1, 8))─┐
│ 0100100001100101011011000110110001101111 │ 01001000                     │
└──────────────────────────────────────────┴──────────────────────────────┘
┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', 1, 2))─┐
│ 0100100001100101011011000110110001101111 │ 01000000                     │
└──────────────────────────────────────────┴──────────────────────────────┘
┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', 1, 9))─┐
│ 0100100001100101011011000110110001101111 │ 0100100000000000             │
└──────────────────────────────────────────┴──────────────────────────────┘
┌─bin('Hello')─────────────────────────────┬─bin(bitSlice('Hello', -4, 8))─┐
│ 0100100001100101011011000110110001101111 │ 11110000                      │
└──────────────────────────────────────────┴───────────────────────────────┘

bitTest

도입 버전: v1.1.0

임의의 숫자를 2진수 형태로 변환한 다음, 지정된 위치에 있는 비트의 값을 반환합니다. 비트 위치는 오른쪽에서 왼쪽으로 0부터 셉니다.

구문

bitTest(a, i)

인수

a — 변환할 수. (U)Int8/16/32/64 또는 Float*
i — 반환할 비트의 위치. (U)Int8/16/32/64 또는 Float*

반환 값

a의 이진 표현에서 위치 i에 있는 비트 값을 반환합니다. UInt8

예시

사용 예시

SELECT bin(2), bitTest(2, 1);

┌─bin(2)───┬─bitTest(2, 1)─┐
│ 00000010 │             1 │
└──────────┴───────────────┘

bitTestAll

도입된 버전: v1.1.0

지정된 위치의 모든 비트에 대해 논리곱 (AND 연산자) 결과를 반환합니다. 오른쪽에서 왼쪽 방향으로, 0부터 인덱스를 매깁니다.

두 비트 사이의 논리 AND는 두 입력 비트가 모두 참일 때, 그리고 그 경우에만 참입니다.

구문

bitTestAll(a, index1[, index2, ... , indexN])

인수

a — 정수 값입니다. (U)Int8/16/32/64
index1, ... — 하나 이상의 비트 위치입니다. (U)Int8/16/32/64

반환 값

논리곱 연산 결과를 반환합니다. UInt8

예시

사용 예시 1

SELECT bitTestAll(43, 0, 1, 3, 5);

┌─bin(43)──┬─bitTestAll(43, 0, 1, 3, 5)─┐
│ 00101011 │                          1 │
└──────────┴────────────────────────────┘

사용 예 2

SELECT bitTestAll(43, 0, 1, 3, 5, 2);

┌─bin(43)──┬─bitTestAll(4⋯1, 3, 5, 2)─┐
│ 00101011 │                        0 │
└──────────┴──────────────────────────┘

bitTestAny

도입된 버전: v1.1.0

숫자에서 지정된 위치의 모든 비트에 대한 논리합 (OR 연산자) 결과를 반환합니다. 비트 위치는 오른쪽에서 왼쪽 방향으로 0부터 번호가 매겨집니다.

두 비트 간의 논리 OR 연산은 입력 비트 중 하나라도 참이면 참이 됩니다.

구문

bitTestAny(a, index1[, index2, ... , indexN])

인수

a — 정수 값입니다. (U)Int8/16/32/64
index1, ... — 하나 이상의 비트 위치입니다. (U)Int8/16/32/64

반환 값

논리 합의 결과를 반환합니다. UInt8

예시

사용 예제 1

SELECT bitTestAny(43, 0, 2);

┌─bin(43)──┬─bitTestAny(43, 0, 2)─┐
│ 00101011 │                    1 │
└──────────┴──────────────────────┘

사용 예 2

SELECT bitTestAny(43, 4, 2);

┌─bin(43)──┬─bitTestAny(43, 4, 2)─┐
│ 00101011 │                    0 │
└──────────┴──────────────────────┘

bitXor

도입 버전: v1.1.0

두 값에 대해 비트 단위 배타적 OR(XOR) 연산을 수행합니다.

구문

bitXor(a, b)

매개변수

a — 첫 번째 값입니다. (U)Int* 또는 Float*
b — 두 번째 값입니다. (U)Int* 또는 Float*

반환 값

비트 연산 a XOR b의 결과를 반환합니다.

예시

사용 예시

CREATE TABLE bits
(
    `a` UInt8,
    `b` UInt8
)
ENGINE = Memory;

INSERT INTO bits VALUES (0, 0), (0, 1), (1, 0), (1, 1);

SELECT
    a,
    b,
    bitXor(a, b)
FROM bits;

┌─a─┬─b─┬─bitXor(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            1 │
│ 1 │ 0 │            1 │
│ 1 │ 1 │            0 │
└───┴───┴──────────────┘

bitAnd​

bitCount​

bitHammingDistance​

bitNot​

bitOr​

bitRotateLeft​

bitRotateRight​

bitShiftLeft​

bitShiftRight​

bitSlice​

bitTest​

bitTestAll​

bitTestAny​

bitXor​

bitAnd

bitCount

bitHammingDistance

bitNot

bitOr

bitRotateLeft

bitRotateRight

bitShiftLeft

bitShiftRight

bitSlice

bitTest

bitTestAll

bitTestAny

bitXor