D'Autres Fonctions 

hôte() 

Renvoie une chaîne avec le nom de l'hôte sur lequel cette fonction a été exécutée. Pour le traitement distribué, c'est le nom du serveur distant, si la fonction est exécutée sur un serveur distant.

getMacro 

Obtient une valeur nommée à partir macro la section de la configuration du serveur.

Syntaxe

getMacro(name);

Paramètre

  • name — Name to retrieve from the macros section. Chaîne.

Valeur renvoyée

  • Valeur de la macro spécifiée.

Type: Chaîne.

Exemple

Exemple macros section dans le fichier de configuration du serveur:

<macros>
    <test>Value</test>
</macros>

Requête:

SELECT getMacro('test');

Résultat:

┌─getMacro('test')─┐
│ Value            │
└──────────────────┘

Une méthode alternative pour obtenir la même valeur:

SELECT * FROM system.macros
WHERE macro = 'test';
┌─macro─┬─substitution─┐
│ test  │ Value        │
└───────┴──────────────┘

FQDN 

Retourne le nom de domaine pleinement qualifié.

Syntaxe

fqdn();

Cette fonction est insensible à la casse.

Valeur renvoyée

  • Chaîne avec le nom de domaine complet.

Type: String.

Exemple

Requête:

SELECT FQDN();

Résultat:

┌─FQDN()──────────────────────────┐
│ clickhouse.ru-central1.internal │
└─────────────────────────────────┘

basename 

Extrait la partie finale d'une chaîne après la dernière barre oblique ou barre oblique inverse. Cette fonction est souvent utilisée pour extraire le nom de fichier d'un chemin.

basename( expr )

Paramètre

  • expr — Expression resulting in a Chaîne type de valeur. Tous les antislashs doivent être échappés dans la valeur résultante.

Valeur Renvoyée

Une chaîne de caractères qui contient:

  • La partie finale d'une chaîne après la dernière barre oblique ou barre oblique inverse.

    If the input string contains a path ending with slash or backslash, for example, `/` or `c:\`, the function returns an empty string.
    
  • La chaîne d'origine s'il n'y a pas de barres obliques ou de barres obliques inverses.

Exemple

SELECT 'some/long/path/to/file' AS a, basename(a)
┌─a──────────────────────┬─basename('some\\long\\path\\to\\file')─┐
│ some\long\path\to\file │ file                                   │
└────────────────────────┴────────────────────────────────────────┘
SELECT 'some\\long\\path\\to\\file' AS a, basename(a)
┌─a──────────────────────┬─basename('some\\long\\path\\to\\file')─┐
│ some\long\path\to\file │ file                                   │
└────────────────────────┴────────────────────────────────────────┘
SELECT 'some-file-name' AS a, basename(a)
┌─a──────────────┬─basename('some-file-name')─┐
│ some-file-name │ some-file-name             │
└────────────────┴────────────────────────────┘

visibleWidth (x) 

Calcule la largeur approximative lors de la sortie des valeurs vers la console au format texte (séparé par des tabulations).
Cette fonction est utilisée par le système pour implémenter de jolis formats.

NULL est représenté comme une chaîne correspondant à NULL dans Pretty format.

SELECT visibleWidth(NULL)
┌─visibleWidth(NULL)─┐
│                  4 │
└────────────────────┘

toTypeName (x) 

Renvoie une chaîne contenant le nom du type de l'argument passé.

Si NULL est passé à la fonction en entrée, puis il renvoie le Nullable(Nothing) type, ce qui correspond à un interne NULL représentation à ClickHouse.

la taille de bloc() 

Récupère la taille du bloc.
Dans ClickHouse, les requêtes sont toujours exécutées sur des blocs (ensembles de parties de colonne). Cette fonction permet d'obtenir la taille du bloc pour lequel vous l'avez appelé.

matérialiser (x) 

Transforme une constante dans une colonne contenant une seule valeur.
Dans ClickHouse, les colonnes complètes et les constantes sont représentées différemment en mémoire. Les fonctions fonctionnent différemment pour les arguments constants et les arguments normaux (un code différent est exécuté), bien que le résultat soit presque toujours le même. Cette fonction sert à déboguer ce comportement.

ignore(…) 

Accepte tous les arguments, y compris NULL. Renvoie toujours 0.
Cependant, l'argument est toujours évalué. Cela peut être utilisé pour les benchmarks.

sommeil(secondes) 

Dormir ‘seconds’ secondes sur chaque bloc de données. Vous pouvez spécifier un nombre entier ou un nombre à virgule flottante.

sleepEachRow (secondes) 

Dormir ‘seconds’ secondes sur chaque ligne. Vous pouvez spécifier un nombre entier ou un nombre à virgule flottante.

currentDatabase() 

Retourne le nom de la base de données actuelle.
Vous pouvez utiliser cette fonction dans les paramètres du moteur de table dans une requête CREATE TABLE où vous devez spécifier la base de données.

currentUser() 

Renvoie la connexion de l'utilisateur actuel. La connexion de l'utilisateur, cette requête initiée, sera renvoyée en cas de requête distibuted.

SELECT currentUser();

Alias: user(), USER().

Valeurs renvoyées

  • Connexion de l'utilisateur actuel.
  • Connexion de l'utilisateur qui a lancé la requête en cas de requête distribuée.

Type: String.

Exemple

Requête:

SELECT currentUser();

Résultat:

┌─currentUser()─┐
│ default       │
└───────────────┘

isConstant 

Vérifie si l'argument est une expression constante.

A constant expression means an expression whose resulting value is known at the query analysis (i.e. before execution). For example, expressions over littéral sont des expressions constantes.

La fonction est destinée au développement, au débogage et à la démonstration.

Syntaxe

isConstant(x)

Paramètre

  • x — Expression to check.

Valeurs renvoyées

  • 1x est constante.
  • 0x est non constante.

Type: UInt8.

Exemple

Requête:

SELECT isConstant(x + 1) FROM (SELECT 43 AS x)

Résultat:

┌─isConstant(plus(x, 1))─┐
│                      1 │
└────────────────────────┘

Requête:

WITH 3.14 AS pi SELECT isConstant(cos(pi))

Résultat:

┌─isConstant(cos(pi))─┐
│                   1 │
└─────────────────────┘

Requête:

SELECT isConstant(number) FROM numbers(1)

Résultat:

┌─isConstant(number)─┐
│                  0 │
└────────────────────┘

isFinite (x) 

Accepte Float32 et Float64 et renvoie UInt8 égal à 1 si l'argument n'est pas infini et pas un NaN, sinon 0.

isInfinite (x) 

Accepte Float32 et Float64 et renvoie UInt8 égal à 1 si l'argument est infini, sinon 0. Notez que 0 est retourné pour un NaN.

ifNotFinite 

Vérifie si la valeur à virgule flottante est finie.

Syntaxe

ifNotFinite(x,y)

Paramètre

  • x — Value to be checked for infinity. Type: Flottant*.
  • y — Fallback value. Type: Flottant*.

Valeur renvoyée

  • x si x est finie.
  • y si x n'est pas finie.

Exemple

Requête:

SELECT 1/0 as infimum, ifNotFinite(infimum,42)

Résultat:

┌─infimum─┬─ifNotFinite(divide(1, 0), 42)─┐
│     inf │                            42 │
└─────────┴───────────────────────────────┘

Vous pouvez obtenir un résultat similaire en utilisant opérateur ternaire: isFinite(x) ? x : y.

isNaN (x) 

Accepte Float32 et Float64 et renvoie UInt8 égal à 1 si l'argument est un NaN, sinon 0.

hasColumnInTable([‘hostname’[, ‘username’[, ‘password’]],] ‘database’, ‘table’, ‘column’) 

Accepte les chaînes constantes: nom de la base de données, nom de la table et nom de la colonne. Renvoie une expression constante UInt8 égale à 1 s'il y a une colonne, sinon 0. Si le paramètre hostname est défini, le test s'exécutera sur un serveur distant.
La fonction renvoie une exception si la table n'existe pas.
Pour les éléments imbriqués structure des données, la fonction vérifie l'existence d'une colonne. Pour la structure de données imbriquée elle-même, la fonction renvoie 0.

bar 

Permet de construire un diagramme unicode-art.

bar(x, min, max, width) dessine une bande avec une largeur proportionnelle à (x - min) et égale à width les caractères lors de la x = max.

Paramètre:

  • x — Size to display.
  • min, max — Integer constants. The value must fit in Int64.
  • width — Constant, positive integer, can be fractional.

La bande dessinée avec précision à un huitième d'un symbole.

Exemple:

SELECT
    toHour(EventTime) AS h,
    count() AS c,
    bar(c, 0, 600000, 20) AS bar
FROM test.hits
GROUP BY h
ORDER BY h ASC
┌──h─┬──────c─┬─bar────────────────┐
│  0 │ 292907 │ █████████▋         │
│  1 │ 180563 │ ██████             │
│  2 │ 114861 │ ███▋               │
│  3 │  85069 │ ██▋                │
│  4 │  68543 │ ██▎                │
│  5 │  78116 │ ██▌                │
│  6 │ 113474 │ ███▋               │
│  7 │ 170678 │ █████▋             │
│  8 │ 278380 │ █████████▎         │
│  9 │ 391053 │ █████████████      │
│ 10 │ 457681 │ ███████████████▎   │
│ 11 │ 493667 │ ████████████████▍  │
│ 12 │ 509641 │ ████████████████▊  │
│ 13 │ 522947 │ █████████████████▍ │
│ 14 │ 539954 │ █████████████████▊ │
│ 15 │ 528460 │ █████████████████▌ │
│ 16 │ 539201 │ █████████████████▊ │
│ 17 │ 523539 │ █████████████████▍ │
│ 18 │ 506467 │ ████████████████▊  │
│ 19 │ 520915 │ █████████████████▎ │
│ 20 │ 521665 │ █████████████████▍ │
│ 21 │ 542078 │ ██████████████████ │
│ 22 │ 493642 │ ████████████████▍  │
│ 23 │ 400397 │ █████████████▎     │
└────┴────────┴────────────────────┘

transformer 

Transforme une valeur en fonction explicitement définis cartographie de certains éléments à l'autre.
Il existe deux variantes de cette fonction:

de transformation(x, array_from, array_to, par défaut) 

x – What to transform.

array_from – Constant array of values for converting.

array_to – Constant array of values to convert the values in ‘from’ de.

default – Which value to use if ‘x’ n'est pas égale à une des valeurs de ‘from’.

array_from et array_to – Arrays of the same size.

Type:

transform(T, Array(T), Array(U), U) -> U

T et U peuvent être des types numériques, chaîne ou Date ou DateTime.
Lorsque la même lettre est indiquée (T ou U), pour les types numériques, il se peut qu'il ne s'agisse pas de types correspondants, mais de types ayant un type commun.
Par exemple, le premier argument peut avoir le type Int64, tandis que le second a le type Array(UInt16).

Si l' ‘x’ la valeur est égale à l'un des éléments dans la ‘array_from’ tableau, elle renvoie l'élément existant (qui est numéroté de même) de la ‘array_to’ tableau. Sinon, elle renvoie ‘default’. S'il y a plusieurs éléments correspondants dans ‘array_from’ il renvoie l'un des matches.

Exemple:

SELECT
    transform(SearchEngineID, [2, 3], ['Yandex', 'Google'], 'Other') AS title,
    count() AS c
FROM test.hits
WHERE SearchEngineID != 0
GROUP BY title
ORDER BY c DESC
┌─title─────┬──────c─┐
│ Yandex    │ 498635 │
│ Google    │ 229872 │
│ Other     │ 104472 │
└───────────┴────────┘

de transformation(x, array_from, array_to) 

Diffère de la première variation en ce que le ‘default’ l'argument est omis.
Si l' ‘x’ la valeur est égale à l'un des éléments dans la ‘array_from’ tableau, elle renvoie l'élément correspondant (qui est numéroté de même) de la ‘array_to’ tableau. Sinon, elle renvoie ‘x’.

Type:

transform(T, Array(T), Array(T)) -> T

Exemple:

SELECT
    transform(domain(Referer), ['yandex.ru', 'google.ru', 'vk.com'], ['www.yandex', 'example.com']) AS s,
    count() AS c
FROM test.hits
GROUP BY domain(Referer)
ORDER BY count() DESC
LIMIT 10
┌─s──────────────┬───────c─┐
│                │ 2906259 │
│ www.yandex     │  867767 │
│ ███████.ru     │  313599 │
│ mail.yandex.ru │  107147 │
│ ██████.ru      │  100355 │
│ █████████.ru   │   65040 │
│ news.yandex.ru │   64515 │
│ ██████.net     │   59141 │
│ example.com    │   57316 │
└────────────────┴─────────┘

formatReadableSize (x) 

Accepte la taille (nombre d'octets). Renvoie une taille arrondie avec un suffixe (KiB, MiB, etc.) comme une chaîne de caractères.

Exemple:

SELECT
    arrayJoin([1, 1024, 1024*1024, 192851925]) AS filesize_bytes,
    formatReadableSize(filesize_bytes) AS filesize
┌─filesize_bytes─┬─filesize───┐
│              1 │ 1.00 B     │
│           1024 │ 1.00 KiB   │
│        1048576 │ 1.00 MiB   │
│      192851925 │ 183.92 MiB │
└────────────────┴────────────┘

moins (a, b) 

Renvoie la plus petite valeur de a et b.

la plus grande(a, b) 

Renvoie la plus grande valeur de a et B.

le temps de disponibilité() 

Renvoie la disponibilité du serveur en quelques secondes.

version() 

Renvoie la version du serveur sous forme de chaîne.

fuseau() 

Retourne le fuseau horaire du serveur.

blockNumber 

Renvoie le numéro de séquence du bloc de données où se trouve la ligne.

rowNumberInBlock 

Renvoie le numéro de séquence de la ligne dans le bloc de données. Différents blocs de données sont toujours recalculés.

rowNumberInAllBlocks() 

Renvoie le numéro de séquence de la ligne dans le bloc de données. Cette fonction ne prend en compte que les blocs de données affectés.

voisin 

La fonction de fenêtre qui donne accès à une ligne à un décalage spécifié qui vient avant ou après la ligne actuelle d'une colonne donnée.

Syntaxe

neighbor(column, offset[, default_value])

Le résultat de la fonction dépend du touché des blocs de données et l'ordre des données dans le bloc.
Si vous créez une sous-requête avec ORDER BY et appelez la fonction depuis l'extérieur de la sous-requête, vous pouvez obtenir le résultat attendu.

Paramètre

  • column — A column name or scalar expression.
  • offset — The number of rows forwards or backwards from the current row of column. Int64.
  • default_value — Optional. The value to be returned if offset goes beyond the scope of the block. Type of data blocks affected.

Valeurs renvoyées

  • De la valeur pour column dans offset distance de la ligne actuelle si offset la valeur n'est pas en dehors des limites du bloc.
  • La valeur par défaut pour column si offset la valeur est en dehors des limites du bloc. Si default_value est donné, alors il sera utilisé.

Type: type de blocs de données affectés ou type de valeur par défaut.

Exemple

Requête:

SELECT number, neighbor(number, 2) FROM system.numbers LIMIT 10;

Résultat:

┌─number─┬─neighbor(number, 2)─┐
│      0 │                   2 │
│      1 │                   3 │
│      2 │                   4 │
│      3 │                   5 │
│      4 │                   6 │
│      5 │                   7 │
│      6 │                   8 │
│      7 │                   9 │
│      8 │                   0 │
│      9 │                   0 │
└────────┴─────────────────────┘

Requête:

SELECT number, neighbor(number, 2, 999) FROM system.numbers LIMIT 10;

Résultat:

┌─number─┬─neighbor(number, 2, 999)─┐
│      0 │                        2 │
│      1 │                        3 │
│      2 │                        4 │
│      3 │                        5 │
│      4 │                        6 │
│      5 │                        7 │
│      6 │                        8 │
│      7 │                        9 │
│      8 │                      999 │
│      9 │                      999 │
└────────┴──────────────────────────┘

Cette fonction peut être utilisée pour calculer une année à valeur métrique:

Requête:

WITH toDate('2018-01-01') AS start_date
SELECT
    toStartOfMonth(start_date + (number * 32)) AS month,
    toInt32(month) % 100 AS money,
    neighbor(money, -12) AS prev_year,
    round(prev_year / money, 2) AS year_over_year
FROM numbers(16)

Résultat:

┌──────month─┬─money─┬─prev_year─┬─year_over_year─┐
│ 2018-01-01 │    32 │         0 │              0 │
│ 2018-02-01 │    63 │         0 │              0 │
│ 2018-03-01 │    91 │         0 │              0 │
│ 2018-04-01 │    22 │         0 │              0 │
│ 2018-05-01 │    52 │         0 │              0 │
│ 2018-06-01 │    83 │         0 │              0 │
│ 2018-07-01 │    13 │         0 │              0 │
│ 2018-08-01 │    44 │         0 │              0 │
│ 2018-09-01 │    75 │         0 │              0 │
│ 2018-10-01 │     5 │         0 │              0 │
│ 2018-11-01 │    36 │         0 │              0 │
│ 2018-12-01 │    66 │         0 │              0 │
│ 2019-01-01 │    97 │        32 │           0.33 │
│ 2019-02-01 │    28 │        63 │           2.25 │
│ 2019-03-01 │    56 │        91 │           1.62 │
│ 2019-04-01 │    87 │        22 │           0.25 │
└────────────┴───────┴───────────┴────────────────┘

runningDifference(x) 

Calculates the difference between successive row values ​​in the data block.
Renvoie 0 pour la première ligne et la différence par rapport à la rangée précédente pour chaque nouvelle ligne.

Le résultat de la fonction dépend du touché des blocs de données et l'ordre des données dans le bloc.
Si vous créez une sous-requête avec ORDER BY et appelez la fonction depuis l'extérieur de la sous-requête, vous pouvez obtenir le résultat attendu.

Exemple:

SELECT
    EventID,
    EventTime,
    runningDifference(EventTime) AS delta
FROM
(
    SELECT
        EventID,
        EventTime
    FROM events
    WHERE EventDate = '2016-11-24'
    ORDER BY EventTime ASC
    LIMIT 5
)
┌─EventID─┬───────────EventTime─┬─delta─┐
│    1106 │ 2016-11-24 00:00:04 │     0 │
│    1107 │ 2016-11-24 00:00:05 │     1 │
│    1108 │ 2016-11-24 00:00:05 │     0 │
│    1109 │ 2016-11-24 00:00:09 │     4 │
│    1110 │ 2016-11-24 00:00:10 │     1 │
└─────────┴─────────────────────┴───────┘

Veuillez noter que la taille du bloc affecte le résultat. Avec chaque nouveau bloc, le runningDifference l'état est réinitialisé.

SELECT
    number,
    runningDifference(number + 1) AS diff
FROM numbers(100000)
WHERE diff != 1
┌─number─┬─diff─┐
│      0 │    0 │
└────────┴──────┘
┌─number─┬─diff─┐
│  65536 │    0 │
└────────┴──────┘
set max_block_size=100000 -- default value is 65536!

SELECT
    number,
    runningDifference(number + 1) AS diff
FROM numbers(100000)
WHERE diff != 1
┌─number─┬─diff─┐
│      0 │    0 │
└────────┴──────┘

runningDifferenceStartingWithFirstvalue 

De même que pour runningDifference la différence est la valeur de la première ligne, est retourné à la valeur de la première ligne, et chaque rangée suivante renvoie la différence de la rangée précédente.

MACNumToString (num) 

Accepte un numéro UInt64. Interprète comme une adresse MAC dans big endian. Renvoie une chaîne contenant l'adresse MAC correspondante au format AA:BB:CC: DD:EE: FF (Nombres séparés par deux points sous forme hexadécimale).

MACStringToNum (s) 

La fonction inverse de MACNumToString. Si l'adresse MAC a un format non valide, elle renvoie 0.

MACStringToOUI (s) 

Accepte une adresse MAC au format AA:BB:CC: DD:EE: FF (Nombres séparés par deux points sous forme hexadécimale). Renvoie les trois premiers octets sous la forme D'un nombre UInt64. Si l'adresse MAC a un format non valide, elle renvoie 0.

getSizeOfEnumType 

Retourne le nombre de champs dans Enum.

getSizeOfEnumType(value)

Paramètre:

  • value — Value of type Enum.

Valeurs renvoyées

  • Le nombre de champs avec Enum les valeurs d'entrée.
  • Une exception est levée si le type n'est pas Enum.

Exemple

SELECT getSizeOfEnumType( CAST('a' AS Enum8('a' = 1, 'b' = 2) ) ) AS x
┌─x─┐
│ 2 │
└───┘

blockSerializedSize 

Retourne la taille sur le disque (sans tenir compte de la compression).

blockSerializedSize(value[, value[, ...]])

Paramètre:

  • value — Any value.

Valeurs renvoyées

  • Le nombre d'octets qui seront écrites sur le disque pour le bloc de valeurs (sans compression).

Exemple

SELECT blockSerializedSize(maxState(1)) as x
┌─x─┐
│ 2 │
└───┘

toColumnTypeName 

Renvoie le nom de la classe qui représente le type de données de la colonne dans la RAM.

toColumnTypeName(value)

Paramètre:

  • value — Any type of value.

Valeurs renvoyées

  • Une chaîne avec le nom de la classe utilisée pour représenter value type de données dans la mémoire RAM.

Exemple de la différence entretoTypeName ' and ' toColumnTypeName

SELECT toTypeName(CAST('2018-01-01 01:02:03' AS DateTime))
┌─toTypeName(CAST('2018-01-01 01:02:03', 'DateTime'))─┐
│ DateTime                                            │
└─────────────────────────────────────────────────────┘
SELECT toColumnTypeName(CAST('2018-01-01 01:02:03' AS DateTime))
┌─toColumnTypeName(CAST('2018-01-01 01:02:03', 'DateTime'))─┐
│ Const(UInt32)                                             │
└───────────────────────────────────────────────────────────┘

L'exemple montre que le DateTime type de données est stocké dans la mémoire comme Const(UInt32).

dumpColumnStructure 

Affiche une description détaillée des structures de données en RAM

dumpColumnStructure(value)

Paramètre:

  • value — Any type of value.

Valeurs renvoyées

  • Une chaîne décrivant la structure utilisée pour représenter value type de données dans la mémoire RAM.

Exemple

SELECT dumpColumnStructure(CAST('2018-01-01 01:02:03', 'DateTime'))
┌─dumpColumnStructure(CAST('2018-01-01 01:02:03', 'DateTime'))─┐
│ DateTime, Const(size = 1, UInt32(size = 1))                  │
└──────────────────────────────────────────────────────────────┘

defaultValueOfArgumentType 

Affiche la valeur par défaut du type de données.

Ne pas inclure des valeurs par défaut pour les colonnes personnalisées définies par l'utilisateur.

defaultValueOfArgumentType(expression)

Paramètre:

  • expression — Arbitrary type of value or an expression that results in a value of an arbitrary type.

Valeurs renvoyées

  • 0 pour les nombres.
  • Chaîne vide pour les chaînes.
  • ᴺᵁᴸᴸ pour Nullable.

Exemple

SELECT defaultValueOfArgumentType( CAST(1 AS Int8) )
┌─defaultValueOfArgumentType(CAST(1, 'Int8'))─┐
│                                           0 │
└─────────────────────────────────────────────┘
SELECT defaultValueOfArgumentType( CAST(1 AS Nullable(Int8) ) )
┌─defaultValueOfArgumentType(CAST(1, 'Nullable(Int8)'))─┐
│                                                  ᴺᵁᴸᴸ │
└───────────────────────────────────────────────────────┘

reproduire 

Crée un tableau avec une seule valeur.

Utilisé pour la mise en œuvre interne de arrayJoin.

SELECT replicate(x, arr);

Paramètre:

  • arr — Original array. ClickHouse creates a new array of the same length as the original and fills it with the value x.
  • x — The value that the resulting array will be filled with.

Valeur renvoyée

Un tableau rempli de la valeur x.

Type: Array.

Exemple

Requête:

SELECT replicate(1, ['a', 'b', 'c'])

Résultat:

┌─replicate(1, ['a', 'b', 'c'])─┐
│ [1,1,1]                       │
└───────────────────────────────┘

filesystemAvailable 

Renvoie la quantité d'espace restant sur le système de fichiers où se trouvent les fichiers des bases de données. Il est toujours plus petit que l'espace libre total (filesystemFree) parce qu'un peu d'espace est réservé au système D'exploitation.

Syntaxe

filesystemAvailable()

Valeur renvoyée

  • La quantité d'espace restant disponible en octets.

Type: UInt64.

Exemple

Requête:

SELECT formatReadableSize(filesystemAvailable()) AS "Available space", toTypeName(filesystemAvailable()) AS "Type";

Résultat:

┌─Available space─┬─Type───┐
│ 30.75 GiB       │ UInt64 │
└─────────────────┴────────┘

filesystemFree 

Retourne montant total de l'espace libre sur le système de fichiers où les fichiers des bases de données. Voir aussi filesystemAvailable

Syntaxe

filesystemFree()

Valeur renvoyée

  • Quantité d'espace libre en octets.

Type: UInt64.

Exemple

Requête:

SELECT formatReadableSize(filesystemFree()) AS "Free space", toTypeName(filesystemFree()) AS "Type";

Résultat:

┌─Free space─┬─Type───┐
│ 32.39 GiB  │ UInt64 │
└────────────┴────────┘

filesystemCapacity 

Renvoie la capacité du système de fichiers en octets. Pour l'évaluation, la chemin le répertoire de données doit être configuré.

Syntaxe

filesystemCapacity()

Valeur renvoyée

  • Informations de capacité du système de fichiers en octets.

Type: UInt64.

Exemple

Requête:

SELECT formatReadableSize(filesystemCapacity()) AS "Capacity", toTypeName(filesystemCapacity()) AS "Type"

Résultat:

┌─Capacity──┬─Type───┐
│ 39.32 GiB │ UInt64 │
└───────────┴────────┘

finalizeAggregation 

Prend de l'état de la fonction d'agrégation. Renvoie le résultat de l'agrégation (état finalisé).

runningAccumulate 

Prend les membres de la fonction d'agrégation et renvoie une colonne avec des valeurs, sont le résultat de l'accumulation de ces états pour un ensemble de bloc de lignes, de la première à la ligne actuelle.
Par exemple, prend l'état de la fonction d'agrégat (exemple runningAccumulate(uniqState(UserID))), et pour chaque ligne de bloc, retourne le résultat de la fonction d'agrégat lors de la fusion des états de toutes les lignes précédentes et de la ligne actuelle.
Ainsi, le résultat de la fonction dépend de la partition des données aux blocs et de l'ordre des données dans le bloc.

joinGet 

La fonction vous permet d'extraire les données de la table de la même manière qu'à partir d'un dictionnaire.

Obtient les données de Rejoindre tables utilisant la clé de jointure spécifiée.

Ne prend en charge que les tables créées avec ENGINE = Join(ANY, LEFT, <join_keys>) déclaration.

Syntaxe

joinGet(join_storage_table_name, `value_column`, join_keys)

Paramètre

  • join_storage_table_name — an identificateur indique l'endroit où la recherche est effectuée. L'identificateur est recherché dans la base de données par défaut (voir paramètre default_database dans le fichier de config). Pour remplacer la base de données par défaut, utilisez USE db_name ou spécifiez la base de données et la table via le séparateur db_name.db_table voir l'exemple.
  • value_column — name of the column of the table that contains required data.
  • join_keys — list of keys.

Valeur renvoyée

Retourne la liste des valeurs correspond à la liste des clés.

Si certain n'existe pas dans la table source alors 0 ou null seront renvoyés basé sur join_use_nulls paramètre.

Plus d'infos sur join_use_nulls dans Opération de jointure.

Exemple

Table d'entrée:

CREATE DATABASE db_test
CREATE TABLE db_test.id_val(`id` UInt32, `val` UInt32) ENGINE = Join(ANY, LEFT, id) SETTINGS join_use_nulls = 1
INSERT INTO db_test.id_val VALUES (1,11)(2,12)(4,13)
┌─id─┬─val─┐
│  4 │  13 │
│  2 │  12 │
│  1 │  11 │
└────┴─────┘

Requête:

SELECT joinGet(db_test.id_val,'val',toUInt32(number)) from numbers(4) SETTINGS join_use_nulls = 1

Résultat:

┌─joinGet(db_test.id_val, 'val', toUInt32(number))─┐
│                                                0 │
│                                               11 │
│                                               12 │
│                                                0 │
└──────────────────────────────────────────────────┘

modelEvaluate(model_name, …) 

Évaluer le modèle externe.
Accepte un nom de modèle et le modèle de l'argumentation. Renvoie Float64.

throwIf (x [, custom_message]) 

Lever une exception si l'argument est non nul.
custom_message - est un paramètre optionnel: une chaîne constante, fournit un message d'erreur

SELECT throwIf(number = 3, 'Too many') FROM numbers(10);
↙ Progress: 0.00 rows, 0.00 B (0.00 rows/s., 0.00 B/s.) Received exception from server (version 19.14.1):
Code: 395. DB::Exception: Received from localhost:9000. DB::Exception: Too many.

identité 

Renvoie la même valeur qui a été utilisée comme argument. Utilisé pour le débogage et les tests, permet d'annuler l'utilisation de l'index et d'obtenir les performances de requête d'une analyse complète. Lorsque la requête est analysée pour une utilisation possible de l'index, l'analyseur ne regarde pas à l'intérieur identity fonction.

Syntaxe

identity(x)

Exemple

Requête:

SELECT identity(42)

Résultat:

┌─identity(42)─┐
│           42 │
└──────────────┘

randomPrintableASCII 

Génère une chaîne avec un ensemble aléatoire de ASCII caractères imprimables.

Syntaxe

randomPrintableASCII(length)

Paramètre

  • length — Resulting string length. Positive integer.
    If you pass `length < 0`, behavior of the function is undefined.
    

Valeur renvoyée

  • Chaîne avec un ensemble aléatoire de ASCII caractères imprimables.

Type: Chaîne

Exemple

SELECT number, randomPrintableASCII(30) as str, length(str) FROM system.numbers LIMIT 3
┌─number─┬─str────────────────────────────┬─length(randomPrintableASCII(30))─┐
│      0 │ SuiCOSTvC0csfABSw=UcSzp2.`rv8x │                               30 │
│      1 │ 1Ag NlJ &RCN:*>HVPG;PE-nO"SUFD │                               30 │
│      2 │ /"+<"wUTh:=LjJ Vm!c&hI*m#XTfzz │                               30 │
└────────┴────────────────────────────────┴──────────────────────────────────┘

Article Original

Rating: 4.7 - 3 votes

Was this content helpful?
★★★★★