ClickHouse/docs/fr/sql-reference/functions/bit-functions.md
Ivan Blinkov cd14f9ebcb
SQL reference refactoring (#10857)
* split up select.md

* array-join.md basic refactoring

* distinct.md basic refactoring

* format.md basic refactoring

* from.md basic refactoring

* group-by.md basic refactoring

* having.md basic refactoring

* additional index.md refactoring

* into-outfile.md basic refactoring

* join.md basic refactoring

* limit.md basic refactoring

* limit-by.md basic refactoring

* order-by.md basic refactoring

* prewhere.md basic refactoring

* adjust operators/index.md links

* adjust sample.md links

* adjust more links

* adjust operatots links

* fix some links

* adjust aggregate function article titles

* basic refactor of remaining select clauses

* absolute paths in make_links.sh

* run make_links.sh

* remove old select.md locations

* translate docs/es

* translate docs/fr

* translate docs/fa

* remove old operators.md location

* change operators.md links

* adjust links in docs/es

* adjust links in docs/es

* minor texts adjustments

* wip

* update machine translations to use new links

* fix changelog

* es build fixes

* get rid of some select.md links

* temporary adjust ru links

* temporary adjust more ru links

* improve curly brace handling

* adjust ru as well

* fa build fix

* ru link fixes

* zh link fixes

* temporary disable part of anchor checks
2020-05-15 07:34:54 +03:00

5.4 KiB
Raw Blame History

machine_translated machine_translated_rev toc_priority toc_title
true 72537a2d52 48 Bit

Peu De Fonctions

Les fonctions Bit fonctionnent pour n'importe quelle paire de types de UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32 ou Float64.

Le type de résultat est un entier avec des bits égaux aux bits maximum de ses arguments. Si au moins l'un des arguments est signé, le résultat est un signé nombre. Si un argument est un nombre à virgule flottante, Il est converti en Int64.

bitAnd (a, b)

bitOr (a, b)

bitXor (a, b)

bitNot (a)

bitShiftLeft (A, b)

bitShiftRight (A, b)

bitRotateLeft (a, b)

bitRotateRight (a, b)

bitTest

Prend tout entier et le convertit en forme binaire renvoie la valeur d'un bit à la position spécifiée. Le compte à rebours commence à partir de 0 de la droite vers la gauche.

Syntaxe

SELECT bitTest(number, index)

Paramètre

  • number integer number.
  • index position of bit.

Valeurs renvoyées

Renvoie une valeur de bit à la position spécifiée.

Type: UInt8.

Exemple

Par exemple, le nombre 43 dans le système numérique de base-2 (binaire) est 101011.

Requête:

SELECT bitTest(43, 1)

Résultat:

┌─bitTest(43, 1)─┐
│              1 │
└────────────────┘

Un autre exemple:

Requête:

SELECT bitTest(43, 2)

Résultat:

┌─bitTest(43, 2)─┐
│              0 │
└────────────────┘

bitTestAll

Renvoie le résultat de logique de conjonction (Et opérateur) de tous les bits à des positions données. Le compte à rebours commence à partir de 0 de la droite vers la gauche.

La conjonction pour les opérations bit à bit:

0 AND 0 = 0

0 AND 1 = 0

1 AND 0 = 0

1 AND 1 = 1

Syntaxe

SELECT bitTestAll(number, index1, index2, index3, index4, ...)

Paramètre

  • number integer number.
  • index1, index2, index3, index4 positions of bit. For example, for set of positions (index1, index2, index3, index4) est vrai si et seulement si toutes ses positions sont remplies (index1index2, ⋀ index3index4).

Valeurs renvoyées

Retourne le résultat de la conjonction logique.

Type: UInt8.

Exemple

Par exemple, le nombre 43 dans le système numérique de base-2 (binaire) est 101011.

Requête:

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

Résultat:

┌─bitTestAll(43, 0, 1, 3, 5)─┐
│                          1 │
└────────────────────────────┘

Un autre exemple:

Requête:

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

Résultat:

┌─bitTestAll(43, 0, 1, 3, 5, 2)─┐
│                             0 │
└───────────────────────────────┘

bitTestAny

Renvoie le résultat de disjonction logique (Ou opérateur) de tous les bits à des positions données. Le compte à rebours commence à partir de 0 de la droite vers la gauche.

La disjonction pour les opérations binaires:

0 OR 0 = 0

0 OR 1 = 1

1 OR 0 = 1

1 OR 1 = 1

Syntaxe

SELECT bitTestAny(number, index1, index2, index3, index4, ...)

Paramètre

  • number integer number.
  • index1, index2, index3, index4 positions of bit.

Valeurs renvoyées

Renvoie le résultat de la disjuction logique.

Type: UInt8.

Exemple

Par exemple, le nombre 43 dans le système numérique de base-2 (binaire) est 101011.

Requête:

SELECT bitTestAny(43, 0, 2)

Résultat:

┌─bitTestAny(43, 0, 2)─┐
│                    1 │
└──────────────────────┘

Un autre exemple:

Requête:

SELECT bitTestAny(43, 4, 2)

Résultat:

┌─bitTestAny(43, 4, 2)─┐
│                    0 │
└──────────────────────┘

bitCount

Calcule le nombre de bits mis à un dans la représentation binaire d'un nombre.

Syntaxe

bitCount(x)

Paramètre

  • xEntier ou virgule flottante nombre. La fonction utilise la représentation de la valeur en mémoire. Il permet de financer les nombres à virgule flottante.

Valeur renvoyée

  • Nombre de bits défini sur un dans le numéro d'entrée.

La fonction ne convertit pas la valeur d'entrée en un type plus grand (l'extension du signe). Ainsi, par exemple, bitCount(toUInt8(-1)) = 8.

Type: UInt8.

Exemple

Prenez par exemple le numéro 333. Sa représentation binaire: 0000000101001101.

Requête:

SELECT bitCount(333)

Résultat:

┌─bitCount(333)─┐
│             5 │
└───────────────┘

Article Original