> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-3a82795f.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` 型もサポートしています。

結果の型は、引数の中で最大のビット数を持つ整数型になります。少なくとも 1 つの引数が符号付きの場合、結果は符号付き整数になります。引数が浮動小数点数の場合は、Int64 にキャストされます。

{/*AUTOGENERATED_START*/}

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

導入バージョン: v1.1.0

2つの値に対してビット単位のAND演算を行います。

**構文**

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

**引数**

* `a` — 1つ目の値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `b` — 2つ目の値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)

**戻り値**

ビット単位の演算 `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*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)

**戻り値**

`x` のうち、1 に設定されているビットの数を返します。[`UInt8`](/ja/reference/data-types/int-uint)。

<Note>
  この関数は、入力値をより大きい型に変換しません ([符号拡張](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

2 つの数値のビット表現間の [ハミング距離](https://en.wikipedia.org/wiki/Hamming_distance) を返します。
ほぼ重複した文字列の検出には、[`SimHash`](/ja/reference/functions/regular-functions/hash-functions#ngramSimHash) 関数と組み合わせて使用できます。
距離が小さいほど、文字列同士はより類似しています。

**構文**

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

**引数**

* `x` — ハミング距離の計算に使用する1番目の数値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `y` — ハミング距離の計算に使用する2番目の数値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)

**戻り値**

`x` と `y` のハミング距離を返します [`UInt8`](/ja/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*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float) または [`String`](/ja/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

2つの値の間でビット単位の OR 演算を実行します。

**構文**

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

**引数**

* `a` — 1番目の値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `b` — 2番目の値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)

**戻り値**

ビット単位の演算 `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`](/ja/reference/data-types/int-uint)
* `N` — 左にローテーションする位置数。[`UInt8/16/32/64`](/ja/reference/data-types/int-uint)

**戻り値**

`a` と同じ型の、ローテーション後の値を返します。[`(U)Int8/16/32/64`](/ja/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`](/ja/reference/data-types/int-uint)
* `N` — 右方向に回転させる位置数。[`UInt8/16/32/64`](/ja/reference/data-types/int-uint)

**戻り値**

`a` と同じ型の回転後の値を返します。[`(U)Int8/16/32/64`](/ja/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` は、1 つの複数バイト値として扱われます。

`FixedString` の値は、シフトによって外に押し出されたビットが失われます。
一方、`String` の値は追加のバイトで拡張されるため、ビットは失われません。

**構文**

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

**引数**

* `a` — シフト対象の値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
* `N` — シフトする位置数。[`UInt8/16/32/64`](/ja/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` は、1 つのマルチバイト値として扱われます。

`FixedString` の値では、シフトによって外に出たビットは失われます。
一方、`String` の値は追加のバイトで拡張されるため、ビットは失われません。

**構文**

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

**引数**

* `a` — シフト対象の値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
* `N` — シフトする位置数。[`UInt8/16/32/64`](/ja/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`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring)
* `offset` —
  開始ビット位置を指定します (1 始まり) 。
* 正の値: 文字列の先頭から数えます。
* 負の値: 文字列の末尾から数えます。

  [`(U)Int8/16/32/64`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `length` —
  省略可能。抽出するビット数です。
* 正の値: `length` ビットを抽出します。
* 負の値: `offset` から `(string_length - |length|)` までを抽出します。
* 省略時: `offset` から文字列の末尾までを抽出します。
* `length` が 8 の倍数でない場合、結果の右側は 0 で埋められます。
  [`(U)Int8/16/32/64`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)

**戻り値**

抽出されたビットを含む文字列を返します。ビットは 2 進数列として表されます。結果は常にバイト境界 (8 ビットの倍数) に合わせてパディングされます [`String`](/ja/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

任意の数値を [2 進数表現](https://en.wikipedia.org/wiki/Binary_number) に変換し、指定した位置のビットの値を返します。位置は右から左へ、0 から数えます。

**構文**

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

**引数**

* `a` — 変換する数値。[`(U)Int8/16/32/64`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `i` — 返すビットの位置。[`(U)Int8/16/32/64`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)

**戻り値**

`a` のバイナリ表現における位置 `i` のビット値を返します。[`UInt8`](/ja/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 から数えます。

2 つのビットの論理 AND は、両方の入力ビットが true の場合に限り true になります。

**構文**

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

**引数**

* `a` — 整数値。[`(U)Int8/16/32/64`](/ja/reference/data-types/int-uint)
* `index1, ...` — 1 つ以上のビットの位置。[`(U)Int8/16/32/64`](/ja/reference/data-types/int-uint)

**戻り値**

論理積の結果を [`UInt8`](/ja/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 から始まり、右から左に数えます。

2 つのビットの論理 OR は、入力ビットの少なくとも一方が `true` であれば `true` になります。

**構文**

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

**引数**

* `a` — 整数値。[`(U)Int8/16/32/64`](/ja/reference/data-types/int-uint)
* `index1, ...` — 1 つ以上のビット位置。[`(U)Int8/16/32/64`](/ja/reference/data-types/int-uint)

**戻り値**

論理和の結果を返します。[`UInt8`](/ja/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

2 つの値に対して、ビット単位の排他的論理和 (XOR) 演算を実行します。

**構文**

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

**引数**

* `a` — 1 つ目の値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/reference/data-types/float)
* `b` — 2 つ目の値。[`(U)Int*`](/ja/reference/data-types/int-uint) または [`Float*`](/ja/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 │
└───┴───┴──────────────┘
```