> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8a08bda2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> 비트 함수 문서

# 비트 함수

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

결과 타입은 인수 중 최대 비트 수와 같은 비트 수를 갖는 정수입니다. 인수 중 하나 이상이 부호 있는 타입이면 결과도 부호 있는 수가 됩니다. 인수가 부동소수점 수이면 `Int64`로 캐스팅됩니다.

{/*AUTOGENERATED_START*/}

<div id="bitAnd">
  ## bitAnd
</div>

Introduced in: v1.1.0

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

**구문**

```sql theme={null}
bitAnd(a, b)
```

**인수**

* `a` — 첫 번째 값. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
* `b` — 두 번째 값. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)

**반환 값**

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

**예시**

**사용 예시**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─a─┬─b─┬─bitAnd(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            0 │
│ 1 │ 0 │            0 │
│ 1 │ 1 │            1 │
└───┴───┴──────────────┘
```

<div id="bitCount">
  ## bitCount
</div>

도입 버전: v20.3.0

숫자를 이진수로 표현했을 때 값이 1인 비트의 개수를 계산합니다.

**구문**

```sql theme={null}
bitCount(x)
```

**인수**

* `x` — 정수 또는 부동소수점 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)

**반환 값**

`x`에서 값이 1인 비트의 개수를 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint).

<Note>
  이 함수는 입력 값을 더 큰 타입으로 변환하지 않습니다([sign extension](https://en.wikipedia.org/wiki/Sign_extension)).
  예를 들어, `bitCount(toUInt8(-1)) = 8`입니다.
</Note>

**예시**

**사용 예시**

```sql title=Query theme={null}
SELECT bin(333), bitCount(333);
```

```response title=Response theme={null}
┌─bin(333)─────────┬─bitCount(333)─┐
│ 0000000101001101 │             5 │
└──────────────────┴───────────────┘
```

<div id="bitHammingDistance">
  ## bitHammingDistance
</div>

도입 버전: v21.1.0

두 숫자의 비트 표현 간 [Hamming Distance](https://en.wikipedia.org/wiki/Hamming_distance)를 반환합니다.
준중복 문자열을 탐지하는 데 [`SimHash`](/ko/reference/functions/regular-functions/hash-functions#ngramSimHash) 함수와 함께 사용할 수 있습니다.
거리가 작을수록 문자열은 서로 더 유사합니다.

**구문**

```sql theme={null}
bitHammingDistance(x, y)
```

**인수**

* `x` — 해밍 거리 계산에 사용되는 첫 번째 숫자입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
* `y` — 해밍 거리 계산에 사용되는 두 번째 숫자입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)

**반환 값**

`x`와 `y` 사이의 해밍 거리를 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)

**예시**

**사용 예시**

```sql title=Query theme={null}
SELECT bitHammingDistance(111, 121);
```

```response title=Response theme={null}
┌─bitHammingDistance(111, 121)─┐
│                            3 │
└──────────────────────────────┘
```

<div id="bitNot">
  ## bitNot
</div>

도입된 버전: v1.1.0

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

**구문**

```sql theme={null}
bitNot(a)
```

**인수**

* `a` — 비트 단위 NOT 연산을 적용할 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float) 또는 [`String`](/ko/reference/data-types/string)

**반환 값**

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

**예시**

**사용 예시**

```sql title=Query theme={null}
SELECT
    CAST('5', 'UInt8') AS original,
    bin(original) AS original_binary,
    bitNot(original) AS result,
    bin(bitNot(original)) AS result_binary;
```

```response title=Response theme={null}
┌─original─┬─original_binary─┬─result─┬─result_binary─┐
│        5 │ 00000101        │    250 │ 11111010      │
└──────────┴─────────────────┴────────┴───────────────┘
```

<div id="bitOr">
  ## bitOr
</div>

도입 버전: v1.1.0

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

**구문**

```sql theme={null}
bitOr(a, b)
```

**인수**

* `a` — 첫 번째 값. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
* `b` — 두 번째 값. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)

**반환 값**

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

**예시**

**사용 예시**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─a─┬─b─┬─bitOr(a, b)─┐
│ 0 │ 0 │           0 │
│ 0 │ 1 │           1 │
│ 1 │ 0 │           1 │
│ 1 │ 1 │           1 │
└───┴───┴─────────────┘
```

<div id="bitRotateLeft">
  ## bitRotateLeft
</div>

도입 버전: v1.1.0

비트를 지정된 수만큼 왼쪽으로 회전합니다. 밀려난 비트는 오른쪽으로 순환합니다.

**구문**

```sql theme={null}
bitRotateLeft(a, N)
```

**인수**

* `a` — 회전할 값입니다. [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint)
* `N` — 왼쪽으로 회전할 비트 수입니다. [`UInt8/16/32/64`](/ko/reference/data-types/int-uint)

**반환 값**

`a`와 같은 타입의 회전된 값을 반환합니다. [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint)

**예시**

**사용 예시**

```sql title=Query theme={null}
SELECT 99 AS a, bin(a), bitRotateLeft(a, 2) AS a_rotated, bin(a_rotated);
```

```response title=Response theme={null}
┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       141 │ 10001101       │
└────┴──────────┴───────────┴────────────────┘
```

<div id="bitRotateRight">
  ## bitRotateRight
</div>

도입 버전: v1.1.0

비트를 지정된 수만큼 오른쪽으로 순환 이동합니다. 밀려난 비트는 왼쪽 끝으로 다시 들어갑니다.

**구문**

```sql theme={null}
bitRotateRight(a, N)
```

**인수**

* `a` — 회전할 값입니다. [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint)
* `N` — 오른쪽으로 회전할 칸 수입니다. [`UInt8/16/32/64`](/ko/reference/data-types/int-uint)

**반환 값**

`a`와 동일한 타입의 회전된 값을 반환합니다. [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint)

**예시**

**사용 예시**

```sql title=Query theme={null}
SELECT 99 AS a, bin(a), bitRotateRight(a, 2) AS a_rotated, bin(a_rotated);
```

```response title=Response theme={null}
┌──a─┬─bin(a)───┬─a_rotated─┬─bin(a_rotated)─┐
│ 99 │ 01100011 │       216 │ 11011000       │
└────┴──────────┴───────────┴────────────────┘
```

<div id="bitShiftLeft">
  ## bitShiftLeft
</div>

도입 버전: v1.1.0

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

`FixedString` 또는 `String`은 하나의 다중 바이트 값으로 처리됩니다.

`FixedString` 값의 비트는 왼쪽으로 밀려나면서 손실됩니다.
반대로 `String` 값은 추가 바이트로 확장되므로 비트가 손실되지 않습니다.

**구문**

```sql theme={null}
bitShiftLeft(a, N)
```

**인수**

* `a` — 시프트할 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring)
* `N` — 시프트할 위치 수입니다. [`UInt8/16/32/64`](/ko/reference/data-types/int-uint)

**반환 값**

`a`와 동일한 타입의 시프트 결과를 반환합니다.

**예시**

**이진 인코딩 사용 예시**

```sql title=Query theme={null}
SELECT 99 AS a, bin(a), bitShiftLeft(a, 2) AS a_shifted, bin(a_shifted);
```

```response title=Response theme={null}
┌──a─┬─bin(99)──┬─a_shifted─┬─bin(bitShiftLeft(99, 2))─┐
│ 99 │ 01100011 │       140 │ 10001100                 │
└────┴──────────┴───────────┴──────────────────────────┘
```

**16진수 인코딩 사용 예시**

```sql title=Query theme={null}
SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftLeft('abc', 4))─┐
│ abc │ 616263     │ &0        │ 06162630                    │
└─────┴────────────┴───────────┴─────────────────────────────┘
```

**Fixed String 인코딩 사용 예시**

```sql title=Query theme={null}
SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftLeft(toFixedString('abc', 3), 4))─┐
│ abc │ 616263                       │ &0        │ 162630                                        │
└─────┴──────────────────────────────┴───────────┴───────────────────────────────────────────────┘
```

<div id="bitShiftRight">
  ## bitShiftRight
</div>

도입 버전: v1.1.0

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

`FixedString` 또는 `String`은 단일 다중 바이트 값으로 처리됩니다.

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

**구문**

```sql theme={null}
bitShiftRight(a, N)
```

**인수**

* `a` — 시프트할 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring)
* `N` — 시프트할 위치의 수입니다. [`UInt8/16/32/64`](/ko/reference/data-types/int-uint)

**반환 값**

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

**예시**

**이진 인코딩 사용 예시**

```sql title=Query theme={null}
SELECT 101 AS a, bin(a), bitShiftRight(a, 2) AS a_shifted, bin(a_shifted);
```

```response title=Response theme={null}
┌───a─┬─bin(101)─┬─a_shifted─┬─bin(bitShiftRight(101, 2))─┐
│ 101 │ 01100101 │        25 │ 00011001                   │
└─────┴──────────┴───────────┴────────────────────────────┘
```

**16진수 인코딩 사용 예시**

```sql title=Query theme={null}
SELECT 'abc' AS a, hex(a), bitShiftLeft(a, 4) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex('abc')─┬─a_shifted─┬─hex(bitShiftRight('abc', 12))─┐
│ abc │ 616263     │           │ 0616                          │
└─────┴────────────┴───────────┴───────────────────────────────┘
```

**Fixed String 인코딩 사용 예시**

```sql title=Query theme={null}
SELECT toFixedString('abc', 3) AS a, hex(a), bitShiftRight(a, 12) AS a_shifted, hex(a_shifted);
```

```response title=Response theme={null}
┌─a───┬─hex(toFixedString('abc', 3))─┬─a_shifted─┬─hex(bitShiftRight(toFixedString('abc', 3), 12))─┐
│ abc │ 616263                       │           │ 000616                                          │
└─────┴──────────────────────────────┴───────────┴─────────────────────────────────────────────────┘
```

<div id="bitSlice">
  ## bitSlice
</div>

도입 버전: v22.2.0

'offset' 인덱스에 있는 비트부터 시작하는, 길이가 'length' 비트인 부분 문자열을 반환합니다.

**구문**

```sql theme={null}
bitSlice(s, offset[, length])
```

**인수**

* `s` — 슬라이스할 `String` 또는 `FixedString`입니다. [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring)
* `offset` —
  시작 비트 위치(1부터 시작하는 인덱스)입니다.
* 양수 값: 문자열의 시작부터 셉니다.
* 음수 값: 문자열의 끝부터 셉니다.

  [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
* `length` —
  선택 사항입니다. 추출할 비트 수입니다.
* 양수 값: `length`비트를 추출합니다.
* 음수 값: `offset`부터 `(string_length - |length|)`까지 추출합니다.
* 생략 시: `offset`부터 문자열 끝까지 추출합니다.
* `length`가 8의 배수가 아니면 결과의 오른쪽이 0으로 채워집니다.
  [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)

**반환 값**

추출된 비트를 포함하는 문자열을 반환하며, 이 문자열은 이진 시퀀스로 표현됩니다. 결과는 항상 바이트 경계(8비트의 배수)에 맞게 채워집니다. [`String`](/ko/reference/data-types/string)

**예시**

**사용 예시**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─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                      │
└──────────────────────────────────────────┴───────────────────────────────┘
```

<div id="bitTest">
  ## bitTest
</div>

도입 버전: v1.1.0

임의의 숫자를 받아 [이진수 형태](https://en.wikipedia.org/wiki/Binary_number)로 변환한 뒤, 지정된 위치의 비트 값을 반환합니다. 비트는 오른쪽에서 왼쪽으로, 0부터 세기 시작합니다.

**구문**

```sql theme={null}
bitTest(a, i)
```

**인수**

* `a` — 변환할 숫자입니다. [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
* `i` — 반환할 비트의 위치입니다. [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)

**반환 값**

`a`의 이진 표현에서 위치 `i`에 있는 비트 값을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)

**예시**

**사용 예시**

```sql title=Query theme={null}
SELECT bin(2), bitTest(2, 1);
```

```response title=Response theme={null}
┌─bin(2)───┬─bitTest(2, 1)─┐
│ 00000010 │             1 │
└──────────┴───────────────┘
```

<div id="bitTestAll">
  ## bitTestAll
</div>

도입 버전: v1.1.0

지정된 위치의 모든 비트에 대한 [논리곱](https://en.wikipedia.org/wiki/Logical_conjunction) (AND 연산자) 결과를 반환합니다.
비트 위치는 오른쪽에서 왼쪽으로 세며, 0부터 시작합니다.

두 비트의 논리 AND 결과는 두 입력 비트가 모두 true일 때에만 true입니다.

**구문**

```sql theme={null}
bitTestAll(a, index1[, index2, ... , indexN])
```

**인수**

* `a` — 정수 값입니다. [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint)
* `index1, ...` — 하나 이상의 비트 위치입니다. [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint)

**반환 값**

논리곱 결과를 [`UInt8`](/ko/reference/data-types/int-uint)로 반환합니다.

**예시**

**사용 예시 1**

```sql title=Query theme={null}
SELECT bitTestAll(43, 0, 1, 3, 5);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAll(43, 0, 1, 3, 5)─┐
│ 00101011 │                          1 │
└──────────┴────────────────────────────┘
```

**사용 예시 2**

```sql title=Query theme={null}
SELECT bitTestAll(43, 0, 1, 3, 5, 2);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAll(4⋯1, 3, 5, 2)─┐
│ 00101011 │                        0 │
└──────────┴──────────────────────────┘
```

<div id="bitTestAny">
  ## bitTestAny
</div>

도입 버전: v1.1.0

숫자의 지정된 위치에 있는 모든 비트에 대한 [논리합](https://en.wikipedia.org/wiki/Logical_disjunction)(OR 연산자) 결과를 반환합니다.
비트는 0부터 시작하며 오른쪽에서 왼쪽으로 셉니다.

두 비트의 논리 OR는 입력 비트 중 하나 이상이 참이면 참입니다.

**구문**

```sql theme={null}
bitTestAny(a, index1[, index2, ... , indexN])
```

**인수**

* `a` — 정수 값입니다. [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint)
* `index1, ...` — 하나 이상의 비트 위치입니다. [`(U)Int8/16/32/64`](/ko/reference/data-types/int-uint)

**반환 값**

논리합 결과를 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)

**예시**

**사용 예시 1**

```sql title=Query theme={null}
SELECT bitTestAny(43, 0, 2);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAny(43, 0, 2)─┐
│ 00101011 │                    1 │
└──────────┴──────────────────────┘
```

**사용 예시 2**

```sql title=Query theme={null}
SELECT bitTestAny(43, 4, 2);
```

```response title=Response theme={null}
┌─bin(43)──┬─bitTestAny(43, 4, 2)─┐
│ 00101011 │                    0 │
└──────────┴──────────────────────┘
```

<div id="bitXor">
  ## bitXor
</div>

도입 버전: v1.1.0

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

**구문**

```sql theme={null}
bitXor(a, b)
```

**인수**

* `a` — 첫 번째 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)
* `b` — 두 번째 값입니다. [`(U)Int*`](/ko/reference/data-types/int-uint) 또는 [`Float*`](/ko/reference/data-types/float)

**반환 값**

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

**예시**

**사용 예시**

```sql title=Query theme={null}
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 title=Response theme={null}
┌─a─┬─b─┬─bitXor(a, b)─┐
│ 0 │ 0 │            0 │
│ 0 │ 1 │            1 │
│ 1 │ 0 │            1 │
│ 1 │ 1 │            0 │
└───┴───┴──────────────┘
```