Ce moteur permet d’intégrer ClickHouse à RocksDB.
CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster]
(
name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1],
name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2],
...
) ENGINE = EmbeddedRocksDB([ttl, rocksdb_dir, read_only]) PRIMARY KEY(primary_key_name)
[ SETTINGS name=value, ... ]
ttl - durée de vie des valeurs. Le TTL est exprimé en secondes. Si le TTL vaut 0, une instance RocksDB standard est utilisée (sans TTL).rocksdb_dir - chemin vers le répertoire d’une instance RocksDB existante ou chemin de destination de l’instance RocksDB créée. Ouvre la table avec le rocksdb_dir spécifié.read_only - lorsque read_only est défini sur true, le mode lecture seule est utilisé. Pour un stockage avec TTL, la compaction ne sera pas déclenchée (ni manuellement ni automatiquement), donc aucune entrée expirée ne sera supprimée.primary_key_name – n’importe quel nom de colonne dans la liste des colonnes.primary key doit être spécifiée ; elle ne prend en charge qu’une seule colonne. La clé primaire sera sérialisée au format binaire comme rocksdb key.- les colonnes autres que la clé primaire seront sérialisées au format binaire comme valeur
rocksdb, dans l’ordre correspondant.
- les requêtes avec filtrage sur la clé via
equals ou in seront optimisées en recherche de plusieurs clés dans rocksdb.
Réglages du moteur :
optimize_for_bulk_insert – la table est optimisée pour les insertions en masse (le pipeline d’insertion créera des fichiers SST et les importera dans la base de données rocksdb au lieu d’écrire dans les memtables) ; valeur par défaut : 1.bulk_insert_block_size - taille minimale des fichiers SST (en nombre de lignes) créés par insertion en masse ; valeur par défaut : 1048449.
Exemple :
CREATE TABLE test
(
`key` String,
`v1` UInt32,
`v2` String,
`v3` Float32
)
ENGINE = EmbeddedRocksDB
PRIMARY KEY key
system.rocksdb, qui fournit des statistiques sur rocksdb :
SELECT
name,
value
FROM system.rocksdb
┌─name──────────────────────┬─value─┐
│ no.file.opens │ 1 │
│ number.block.decompressed │ 1 │
└───────────────────────────┴───────┘
<rocksdb>
<options>
<max_background_jobs>8</max_background_jobs>
</options>
<column_family_options>
<num_levels>2</num_levels>
</column_family_options>
<tables>
<table>
<name>TABLE</name>
<options>
<max_background_jobs>8</max_background_jobs>
</options>
<column_family_options>
<num_levels>2</num_levels>
</column_family_options>
</table>
</tables>
</rocksdb>
count(). Pour activer cette
optimisation, définissez optimize_trivial_approximate_count_query = 1. Ce paramètre affecte également system.tables pour le moteur EmbeddedRocksDB ;
activez-le pour voir des valeurs approximatives de total_rows et total_bytes.
Opérations prises en charge
EmbeddedRocksDB, si la clé existe déjà, la valeur est mise à jour ; sinon, une nouvelle clé est créée.
Exemple :
INSERT INTO test VALUES ('some key', 1, 'value', 3.2);
DELETE ou de TRUNCATE.
DELETE FROM test WHERE key LIKE 'some%' AND v1 > 1;
ALTER TABLE test DELETE WHERE key LIKE 'some%' AND v1 > 1;
ALTER TABLE. La clé primaire ne peut pas être modifiée.
ALTER TABLE test UPDATE v1 = v1 * 10 + 2 WHERE key LIKE 'some%' AND v3 > 3.1;
direct spéciale avec des tables EmbeddedRocksDB est prise en charge.
Cette jointure directe évite de construire une table de hachage en mémoire et accède
directement aux données dans EmbeddedRocksDB.
Avec de grosses jointures, l’utilisation de la mémoire peut être nettement plus faible avec les jointures directes,
car la table de hachage n’est pas créée.
Pour activer les jointures directes :
SET join_algorithm = 'direct, hash'
Lorsque join_algorithm est défini sur direct, hash, les jointures directes seront utilisées
lorsque c’est possible, et hash sinon.
Créer et peupler une table EmbeddedRocksDB
CREATE TABLE rdb
(
`key` UInt32,
`value` Array(UInt32),
`value2` String
)
ENGINE = EmbeddedRocksDB
PRIMARY KEY key
INSERT INTO rdb
SELECT
toUInt32(sipHash64(number) % 10) AS key,
[key, key+1] AS value,
('val2' || toString(key)) AS value2
FROM numbers_mt(10);
Créer et peupler une table pour effectuer une jointure avec la table rdb
CREATE TABLE t2
(
`k` UInt16
)
ENGINE = TinyLog
INSERT INTO t2 SELECT number AS k
FROM numbers_mt(10)
Définissez l’algorithme de jointure à direct
SET join_algorithm = 'direct'
Un INNER JOIN
SELECT *
FROM
(
SELECT k AS key
FROM t2
) AS t2
INNER JOIN rdb ON rdb.key = t2.key
ORDER BY key ASC
┌─key─┬─rdb.key─┬─value──┬─value2─┐
│ 0 │ 0 │ [0,1] │ val20 │
│ 2 │ 2 │ [2,3] │ val22 │
│ 3 │ 3 │ [3,4] │ val23 │
│ 6 │ 6 │ [6,7] │ val26 │
│ 7 │ 7 │ [7,8] │ val27 │
│ 8 │ 8 │ [8,9] │ val28 │
│ 9 │ 9 │ [9,10] │ val29 │
└─────┴─────────┴────────┴────────┘
