Je lis sur Les conceptions de schéma Hbase de grande taille à l'échelle de grande taille EM> strong> et l'auteur propose ce qui suit que je ne comprends pas: Il est préférable de considérer le design grand-mince comme nous le savons aidera à
Récupération de données plus rapide en nous permettant de lire la famille unique de la colonne
Pour les entrées de blog utilisateur à la fois au lieu de traverser de nombreuses lignes.
De plus, étant donné que les diviseurs HBASE ont lieu sur des lignes, des données relatives à un
Un utilisateur spécifique peut être trouvé sur un serveur de région. P>
blockQuote> Leur proposé "EM> EM> Strong> d'un schéma de site de blog est ci-dessous (où il y a une ligne par écrivain et chaque nouvelle entrée de blog est une nouvelle colonne ): p>
+----------+-------------+------+-----+---------+-------+
| | BECF (Blog entry Column family)
+----------+-------------+------+-----+---------+-------+
| RowKey (UserID+TimeStamp) | BlogEntriesCF:Entries
+----------+-------------+------+-----+---------+-------+
| WriterATimeStamp1 | Entry1
| WriterATimeStamp2 | Entry2
| WriterATimeStamp3 | Entry3
| WriterBTimeStamp1 | EntryA
| WriterBTimeStamp2 | EntryB
+----------+-------------+------+-----+---------+-------+
3 Réponses :
"Les données étroites ou empilées sont présentées avec une colonne contenant toutes les valeurs et une autre colonne énumérant le contexte de la valeur. Ceci est souvent plus facile à mettre en œuvre, l'ajout d'un nouveau champ ne nécessite aucune modification de la structure de la structure du table, mais cela peut être plus difficile pour les gens de comprendre. " P>
des "données larges et étroites", wikipedia https://fr.wikipedia.org/wiki/ Wide_and_narrow_data [Accès au 29.12.16] P>
Je suppose que cela signifie que si vous voulez obtenir la liste pure de valeurs sans se soucier de leur contexte, vous vient de lire une colonne. Si vous vouliez faire cela dans des structures de données courtes, vous devez trouver la ligne et atteindre la colonne souhaitée, et que pour chaque ligne au lieu d'une seule lecture. P>
Cordialement, P>
Eh bien, la première chose que vous contournez est le verrouillage de la ligne.
Disons que vous avez une ligne large et que vous devez le mettre à jour. Cela signifie que cette ligne doit être verrouillée. Aucun autre écrivain ne peut le mettre à jour à ce moment-là car il est verrouillé. Ils doivent attendre que le verrouillage soit libéré. P>
avec de hautes et minces, les données sont contenues dans un champ de courte ligne, ce qui met à jour les problèmes pour les autres écrivains qui souhaitent mettre à jour leur truc, qui est dans une rangée séparée. p>
Le grand et le mince se prête également à faire des relations dynamiques, à développer les index userbase, plus rapides, à de meilleurs temps de réponse. P>
lisible humainement, ce n'est pas vraiment, mais pour les machines plus faciles à gérer avec, rejoindre, modifier, modifier des structures. P>
Si vous avez une interface de cartographie relationnelle d'objet (comme Java Hibernate, PHP Eloquant, etc.) Il devient absurdement facile de le faire dans les relations OneTomanany ou de nombreusesTomanany et Mettre à jour, modifier, interroger les objets dans son ensemble. p>
Tall and Thin permet également aux mêmes objets de données d'être facilement implémenté ailli ailleurs, sans avoir besoin de vues pour assainir / supprimer les données indésirables. p>
Par exemple: p>
J'ai une base de données des prix du produit A, du produit B, du produit C Les prix ont des dates qu'ils sont actifs correspondant aux saisons (Noël, etc.). Tous les produits de mon exemple sont régis par les mêmes saisons P>
large: p> maintenant si vous souhaitez ajouter un produit supplémentaire, vous devez procéder comme suit: p> TAX: P> Étant donné que tout est relationnel, le code traite déjà de la relation relationnelle et la lira comme tel, et il suffit de l'ajouter au flux de code existant. P> P>
SELECT * code> est utilisé. LI>
table: Products
id | product_name
1 | ProductA
2 | ProductB
3 | ProductC
table: Periods
id| name | date_from | date_to
1 | autumn | 22-10-2000| 22-11-2000
2 | xmas | 23-11-2000| 26-12-2000
3 | newyear | 27-12-2000| 22-01-2001
table: Prices
product_id | period_id | price
1 | 1 | 100
2 | 1 | 110
3 | 1 | 90
1 | 2 | 200
2 | 2 | 210
3 | 2 | 190
1 | 1 | 100
2 | 1 | 110
3 | 1 | 90
Votre citation est du livre "Apprendre HBASE" . La citation est inexacte, mais c'est la bonne nouvelle :) p>
Voir comment l'auteur décrit vraiment grand-mince mince fort> p>
dans une conception de table forte> forte>, la table augmente plus rapidement que vers le côté droit. [...] p>
Rowkey (userid + horodatage) | Blogentriescf: entrées ----------------------------------------- + ------ --------------------------- Notez que les touches de la ligne sont traverser de nombreuses lignes. P>
blockQuote>
Cependant, HBASE ne fonctionne pas comme ça, il trie en fait les clés avant de les écrire (les mutations techniquement non acheminées dans WAL, mais si tout va bien, WAL n'est pas utilisé, et s'il est utilisé, les mutations sont rejouées sur la mémoire qui détient les données de la région). P>
Les diviseurs HBASE ont lieu sur des lignes, des données relatives à un utilisateur spécifique se trouvent sur un serveur de région. P>
blockQuote>
Cette partie semble logiquement liée à Donc, pour résumer, je pense que cette partie du livre pourrait avoir besoin d'une critique.
Voir cet excellent Publication du blog de MAPR, pour un aperçu rapide de Hbase sous la hotte. P>
Écrivain A STRUT> TIMESTAMP1 | HBaseenry
Écrivain B STRUT> TIMESTAMP2 | Hadoopien de
Écrivain A STRUT> TIMESTAMP3 | Hadoopien de
... | ... p>
blockQuote>
Juste pour m'assurer que je comprends bien correctement. La citation de l'auteur j'ai fourni avec précision i> b> est en fait incorrect i> b>? De plus, étant donné que Tall-mince b> nécessite de traverser de nombreuses lignes, cela rendrait la récupération de données plus lente? En d'autres termes, pour la récupération, courte-large b> est meilleur? Pour écrire lourd, Tall-mince B> est meilleur car il ne nécessite pas de verrouillage? Merci.
Ok, d'abord, vous n'avez pas fourni de citation précise.Je regarde la version de safari. Ce que vous avez écrit est correct mais ce n'est pas la façon dont l'auteur le comprend. En ce qui concerne le schéma vs charge, c'est une question plus complexe car la numérisation peut être assez rapide. Parfois, il est préférable d'aller chercher quelques rangées de nombreuses machines puis récupérant une très large rangée de 600 Mo d'une machine. La meilleure chose à faire est d'essayer avec des données que vous avez ou génère quelque chose qui simulerait cela, espérons que cela aide ..
Il y a une largeur de rangée en fonction de votre configuration de cluster et de votre taille moyenne de la colonne en octets, où de courte-lumière devient moins efficace pour les lectures, puis de grande taille, a du sens?