메인 콘텐츠로 건너뛰기
비트 함수는 UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64 중 임의의 두 타입 조합에 대해 동작합니다. 일부 함수는 String 및 FixedString 타입도 지원합니다. 결과 타입은 인수 중 최대 비트 수와 같은 비트 수를 갖는 정수입니다. 인수 중 하나 이상이 부호 있는 타입이면 결과도 부호 있는 수가 됩니다. 인수가 부동소수점 수이면 Int64로 캐스팅됩니다.

​
bitAnd

Introduced in: v1.1.0 두 값에 대해 비트 단위 AND 연산을 수행합니다. 구문 
bitAnd(a, b)
인수 반환 값 비트 단위 AND 연산 a AND b의 결과를 반환합니다. 예시 사용 예시
Query
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
Response
┌─a─┬─b─┬─bitAnd(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            0 │
│ 1 │ 0 │            0 │
│ 1 │ 1 │            1 │
└───┴───┴──────────────┘

​
bitCount

도입 버전: v20.3.0 숫자를 이진수로 표현했을 때 값이 1인 비트의 개수를 계산합니다. 구문 
bitCount(x)
인수
  • x — 정수 또는 부동소수점 값입니다. (U)Int* 또는 Float*
반환 값 x에서 값이 1인 비트의 개수를 반환합니다. UInt8.
이 함수는 입력 값을 더 큰 타입으로 변환하지 않습니다(sign extension). 예를 들어, bitCount(toUInt8(-1)) = 8입니다.
예시 사용 예시
Query
SELECT bin(333), bitCount(333);
Response
┌─bin(333)─────────┬─bitCount(333)─┐
│ 0000000101001101 │             5 │
└──────────────────┴───────────────┘

​
bitHammingDistance

도입 버전: v21.1.0 두 숫자의 비트 표현 간 Hamming Distance를 반환합니다. 준중복 문자열을 탐지하는 데 SimHash 함수와 함께 사용할 수 있습니다. 거리가 작을수록 문자열은 서로 더 유사합니다. 구문 
bitHammingDistance(x, y)
인수
  • x — 해밍 거리 계산에 사용되는 첫 번째 숫자입니다. (U)Int* 또는 Float*
  • y — 해밍 거리 계산에 사용되는 두 번째 숫자입니다. (U)Int* 또는 Float*
반환 값 x와 y 사이의 해밍 거리를 반환합니다. UInt8 예시 사용 예시
Query
SELECT bitHammingDistance(111, 121);
Response
┌─bitHammingDistance(111, 121)─┐
│                            3 │
└──────────────────────────────┘

​
bitNot

도입된 버전: v1.1.0 비트 단위 NOT 연산을 수행합니다. 구문 
bitNot(a)
인수
  • a — 비트 단위 NOT 연산을 적용할 값입니다. (U)Int* 또는 Float* 또는 String
반환 값 ~a, 즉 a의 비트를 반전한 결과를 반환합니다. 예시 사용 예시
Query
SELECT
    CAST('5', 'UInt8') AS original,
    bin(original) AS original_binary,
    bitNot(original) AS result,
    bin(bitNot(original)) AS result_binary;
Response
┌─original─┬─original_binary─┬─result─┬─result_binary─┐
│        5 │ 00000101        │    250 │ 11111010      │
└──────────┴─────────────────┴────────┴───────────────┘

​
bitOr

도입 버전: v1.1.0 두 값에 대해 비트 단위 OR 연산을 수행합니다. 구문 
bitOr(a, b)
인수 반환 값 비트 단위 OR 연산 a OR b의 결과를 반환합니다. 예시 사용 예시
Query
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;
Response
┌─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 예시 사용 예시
Query
SELECT 99 AS a, bin(a), bitRotateLeft(a, 2) AS a_rotated, bin(a_rotated);
Response
┌──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 예시 사용 예시
Query
SELECT 99 AS a, bin(a), bitRotateRight(a, 2) AS a_rotated, bin(a_rotated);
Response
┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       216 │ 11011000       │
└────┴──────────┴───────────┴────────────────┘

​
bitShiftLeft

도입 버전: v1.1.0 값의 이진 표현을 지정된 비트 수만큼 왼쪽으로 이동합니다. FixedString 또는 String은 하나의 다중 바이트 값으로 처리됩니다. FixedString 값의 비트는 왼쪽으로 밀려나면서 손실됩니다. 반대로 String 값은 추가 바이트로 확장되므로 비트가 손실되지 않습니다. 구문 
bitShiftLeft(a, N)
인수 반환 값 a와 동일한 타입의 시프트 결과를 반환합니다. 예시 이진 인코딩 사용 예시
Query
SELECT 99 AS a, bin(a), bitShiftLeft(a, 2) AS a_shifted, bin(a_shifted);
Response
┌──a─┬─bin(99)──┬─a_shifted─┬─bin(bitShiftLeft(99, 2))─┐
│ 99 │ 01100011 │       140 │ 10001100                 │
└────┴──────────┴───────────┴──────────────────────────┘
16진수 인코딩 사용 예시
Query
SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
Response
┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftLeft('abc', 4))─┐
│ abc │ 616263     │ &0        │ 06162630                    │
└─────┴────────────┴───────────┴─────────────────────────────┘
Fixed String 인코딩 사용 예시
Query
SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
Response
┌─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와 동일한 타입의 시프트된 값을 반환합니다. 예시 이진 인코딩 사용 예시
Query
SELECT 101 AS a, bin(a), bitShiftRight(a, 2) AS a_shifted, bin(a_shifted);
Response
┌───a─┬─bin(101)─┬─a_shifted─┬─bin(bitShiftRight(101, 2))─┐
│ 101 │ 01100101 │        25 │ 00011001                   │
└─────┴──────────┴───────────┴────────────────────────────┘
16진수 인코딩 사용 예시
Query
SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
Response
┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftRight('abc', 12))─┐
│ abc │ 616263     │           │ 0616                          │
└─────┴────────────┴───────────┴───────────────────────────────┘
Fixed String 인코딩 사용 예시
Query
SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftRight(a, 12) AS a_shifted, hex(a_shifted);
Response
┌─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 예시 사용 예시
Query
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));
Response
┌─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 임의의 숫자를 받아 이진수 형태로 변환한 뒤, 지정된 위치의 비트 값을 반환합니다. 비트는 오른쪽에서 왼쪽으로, 0부터 세기 시작합니다. 구문 
bitTest(a, i)
인수 반환 값 a의 이진 표현에서 위치 i에 있는 비트 값을 반환합니다. UInt8 예시 사용 예시
Query
SELECT bin(2), bitTest(2, 1);
Response
┌─bin(2)───┬─bitTest(2, 1)─┐
│ 00000010 │             1 │
└──────────┴───────────────┘

​
bitTestAll

도입 버전: v1.1.0 지정된 위치의 모든 비트에 대한 논리곱 (AND 연산자) 결과를 반환합니다. 비트 위치는 오른쪽에서 왼쪽으로 세며, 0부터 시작합니다. 두 비트의 논리 AND 결과는 두 입력 비트가 모두 true일 때에만 true입니다. 구문 
bitTestAll(a, index1[, index2, ... , indexN])
인수 반환 값 논리곱 결과를 UInt8로 반환합니다. 예시 사용 예시 1
Query
SELECT bitTestAll(43, 0, 1, 3, 5);
Response
┌─bin(43)──┬─bitTestAll(43, 0, 1, 3, 5)─┐
│ 00101011 │                          1 │
└──────────┴────────────────────────────┘
사용 예시 2
Query
SELECT bitTestAll(43, 0, 1, 3, 5, 2);
Response
┌─bin(43)──┬─bitTestAll(4⋯1, 3, 5, 2)─┐
│ 00101011 │                        0 │
└──────────┴──────────────────────────┘

​
bitTestAny

도입 버전: v1.1.0 숫자의 지정된 위치에 있는 모든 비트에 대한 논리합(OR 연산자) 결과를 반환합니다. 비트는 0부터 시작하며 오른쪽에서 왼쪽으로 셉니다. 두 비트의 논리 OR는 입력 비트 중 하나 이상이 참이면 참입니다. 구문 
bitTestAny(a, index1[, index2, ... , indexN])
인수 반환 값 논리합 결과를 반환합니다. UInt8 예시 사용 예시 1
Query
SELECT bitTestAny(43, 0, 2);
Response
┌─bin(43)──┬─bitTestAny(43, 0, 2)─┐
│ 00101011 │                    1 │
└──────────┴──────────────────────┘
사용 예시 2
Query
SELECT bitTestAny(43, 4, 2);
Response
┌─bin(43)──┬─bitTestAny(43, 4, 2)─┐
│ 00101011 │                    0 │
└──────────┴──────────────────────┘

​
bitXor

도입 버전: v1.1.0 두 값에 대해 비트 단위 XOR(배타적 논리합) 연산을 수행합니다. 구문 
bitXor(a, b)
인수 반환 값 비트 연산 a XOR b의 결과를 반환합니다. 예시 사용 예시
Query
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;
Response
┌─a─┬─b─┬─bitXor(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            1 │
│ 1 │ 0 │            1 │
│ 1 │ 1 │            0 │
└───┴───┴──────────────┘
마지막 수정일 2026년 6월 10일