Table de chaîne triée (SSTABLE) ou B + Tree pour un index de base de données?
Utilisation de deux bases de données pour illustrer cet exemple: Couchdb et Cassandra .
COUCHDB
CouchDB utilise un arbre B + pour les index de documents (à l'aide de ne modification intelligente pour fonctionner dans leur environnement à l'annexe unique) - plus spécifiquement que les documents sont modifiés (insertion/mise à jour/supprimer), ils sont ajoutés à la base de données en cours d'exécution. Fichier ainsi que une feuille complète -> Node Chemin de l'arborescence B + de tous les nœuds effectués par la révision mise à jour juste après le document.
Ces révisions de l'index des repas à la pièce sont inlinées à côté des modifications telles que l'indice complet est une union des modifications de l'index les plus récentes ajoutées à la fin du fichier ainsi que des pièces supplémentaires dans le fichier de données qui sont toujours pertinentes et contestées. t été modifié encore.
Recherche sur le B + Tree est O (logn).
Cassandra
Cassandra conserve des clés d'enregistrement triés, en mémoire, dans des tables (pensons à eux comme des tableaux pour cette question) et les écrit comme séparé (triés) Tables de chaîne triées de temps à autre.
Nous pouvons penser à la collection de toutes ces tables en tant que "index" (de ce que je comprends).
Cassandra est tenu de compact/combiner ces tables à chaîne de tri de temps à autre, créant une représentation de fichier plus complète de l'index.
Recherche ne matrice triée est O (logn).
question
En supposant un niveau similaire de complexité entre le maintien de morceaux partiels B + arbores dans Couchdb par rapport à des indices de chaîne de tri partiels dans Cassandra et étant donné que fournir O(logn) Temps de recherche que vous pensez faire une meilleure représentation d'un index de base de données et pourquoi?
Je suis spécifiquement curieux s'il y a un détail de mise en œuvre sur l'un sur l'autre qui le fait en particulier attrayant ou si elles sont à la fois un lavage et que vous choisissez simplement la structure de données que vous préférez travailler avec/fait fonctionner plus de sens pour le développeur.
Merci pour les pensées.
Lors de la comparaison d'un indice BTTREE à un indice SSTABLE, vous devez envisager la complexité de l'écriture:
Lors de l'écriture de manière aléatoire vers un BTTREE Copy-On-Ecrivez, vous encourrez des lectures aléatoires (pour effectuer la copie du nœud et du chemin de la feuille). Ainsi, tandis que les écritures sont séquentielles sur le disque, pour des ensembles de données supérieurs à la RAM, ces lectures aléatoires deviendront rapidement le cou de la bouteille. Pour un index de type SSTAble, aucun tel lecture ne se produit sur l'écriture - il n'y aura que les écritures séquentielles.
Vous devriez également considérer que dans le pire cas, chaque mise à jour d'un BTRee pourrait entraîner log_b n ios - c'est-à-dire que vous pourriez finir par écrire 3 ou 4 blocs pour chaque touche. Si la taille de la clé est beaucoup moins que la taille du bloc, cela est extrêmement coûteux. Pour un index de type SSTAble, chaque écriture IO contiendra autant de clés fraîches que possible, de sorte que le IO coûts pour chaque clé ressemble plus à 1/B.
Dans la pratique, cela fait des milliers de fois de fois plus rapides (pour des écritures aléatoires) que les btrees.
Lorsque vous envisagez des détails sur la mise en œuvre, nous avons trouvé qu'il est beaucoup plus facile d'implémenter des index de type SSTAble (presque) sans verrouillage, où les stratégies de verrouillage des Btratistes sont devenues assez compliquées.
Vous devriez également retenir vos coûts de lecture. Vous êtes correct qu'un BTTREE est O (log_b n) iOS aléatoire pour des lectures de points aléatoires, mais un index de type SSTAble est en réalité O (#stables. Log_b n). Sans un schéma de fusion décent, #stales est proportionnelle à N. Il y a diverses astuces pour se faire arrondir (en utilisant des filtres de bloom, par exemple), mais ceux-ci ne vous aident pas avec de petites interrogations aléatoires et aléatoires. C'est ce que nous avons trouvé avec Cassandra:
Cassandra sous charge d'écriture lourde
C'est pourquoi le château, notre moteur de stockage (GPL), fusionne légèrement différemment et peut atteindre beaucoup mieux (o (log ^ 2 n)) Plage des requêtes de la plage avec une légère compromis dans la performance d'écriture (O (log ^ 2 n/B))). En pratique, nous trouvons qu'il s'agissait d'être plus rapide que l'indice ststable de Cassandra pour les écrit également.
Si vous voulez en savoir plus à ce sujet, j'ai expliqué comment cela fonctionne:
Certaines choses qui devraient également être mentionnées sur chaque approche:
B-arbres
- Les opérations de lecture/écriture sont censées être logarithmiques
O(logn). Toutefois, une seule base de données écrit peut entraîner plusieurs écrivies dans le système de stockage . Par exemple, lorsqu'un nœud est plein, il doit être divisé et cela signifie qu'il y aura 2 écrit pour les 2 nouveaux nœuds et 1 écriture supplémentaire pour mettre à jour le nœud parent. Vous pouvez voir comment cela pourrait augmenter si le nœud parent était également complet. - Habituellement, les arbres B sont des stocks de manière à ce que chaque nœud ait la taille d'une page. Cela crée un phénomène appelé Amplification d'écriture , où même si un octet unique doit être mis à jour, une page entière est écrite.
- écrit sont généralement aléatoires (non séquentielle), ainsi plus lent spécialement pour magnétiques disques.
Stsables
- Les stsables sont généralement utilisés dans l'approche suivante. Il y a une structure en mémoire, appelée mémote, comme vous l'avez décrit. De temps en temps, cette structure est rinçue sur le disque à une sstable. En conséquence, Toutes les écrivies vont sur le mémorable, mais les lectures peuvent ne pas être dans le mémêche actuel, auquel cas ils sont recherchés dans les SSTABLES PERSISTED .
- En conséquence, les écritures sont
O(logn). Cependant, gardez toujours à l'esprit qu'ils sont faits en mémoire, ils devraient donc être des ordres de grandeur plus rapidement que les opérations logarithmiques sur le disque des arbres B. Par souci d'exhaustivité, nous devrions mentionner que les écrivies sont également écrites à un journal à l'avance pour la récupération des crash. Mais, étant donné que ceux-ci sont tous écrit séquentiels, ils devraient être beaucoup plus efficaces que les écritures aléatoires des arbres B . - Lorsque des lectures de la mémoire sont servies de la mémoire (== --- ==) devraient également être beaucoup plus rapides . Mais, quand il est nécessaire de regarder dans les plus âgés, les lectures de Ststables basées sur un disque peuvent potentiellement devenir assez plus lentes que les arbres B. Il existe plusieurs optimisations autour de cela, telles que l'utilisation de filtres de fleurs, pour vérifier si une SSTABLE contient une valeur sans effectuer des lectures de disque.
- Comme vous l'avez dit, il y a aussi un processus d'arrière-plan, appelé compactage , utilisé pour fusionner SSTABLES. Cela aide à éliminer les valeurs supprimées et à prévenir la fragmentation, mais cela peut entraîner une charge d'écriture importante, affectant le débit d'écriture des opérations entrantes.
Comme il devient évident, une comparaison entre ces 2 approches est beaucoup plus compliquée. Dans une tentative extrêmement simplifiée de fournir une comparaison concrète, je pense que nous pourrions dire que:
- Les Stsables offrent un très meilleur débit d'écriture que les arbres B. Cependant, ils devraient avoir un comportement moins stable, en raison de compactions en cours. Un exemple de ceci peut être vu dans cette comparaison de référence .
- Les arbres B sont généralement préférés pour les cas d'utilisation, où des sémantiques de transaction sont nécessaires. En effet, chaque clé ne peut être trouvée qu'en un seul endroit (contrairement à la SSTAble, où elle pourrait exister dans plusieurs SSTABLES de valeurs obsolètes dans certaines d'entre elles) et aussi parce que l'on pourrait représenter une gamme de valeurs dans le cadre de la arbre. Cela signifie qu'il est plus facile d'effectuer des mécanismes de verrouillage de niveau clé et de niveau de plage.
Les références
Les arbres LSM sont meilleurs que les arbres B sur le moteur de stockage structuré. Il convertit une écriture aléatoire sur Aof d'une manière. Voici un arbre LSM SRC: https://github.com/shuttler/lsmtree