7
votes

Pourquoi l'auteur proposa-t-il le schéma HBASE grand-mince sur une courte-large à l'échelle de l'intérieur?

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
+----------+-------------+------+-----+---------+-------+


0 commentaires

3 Réponses :


0
votes

"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. "

des "données larges et étroites", wikipedia https://fr.wikipedia.org/wiki/ Wide_and_narrow_data [Accès au 29.12.16]

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.

Cordialement,


0 commentaires

5
votes

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> xxx pré>

maintenant si vous souhaitez ajouter un produit supplémentaire, vous devez procéder comme suit: p>

  • Modifier la table. Cela peut être très coûteux sur une grande table à faire, causant des pannes li>
  • Mettez à jour les prix causant beaucoup de serrures de rangée li>
  • Modifier les requêtes. Les requêtes sont utilisées partout. Ils doivent tous comptabiliser la colonne supplémentaire, en particulier si SELECT * code> est utilisé. LI>
  • Modifier le code de mise en œuvre. Il y a une colonne supplémentaire, des boucles bâclées pourraient se briser. Les magasins Itérateurs doivent être modifiés pour rendre compte du produit supplémentaire. LI>
  • Les choses se casseront pendant longtemps après la modification si la base logicielle est un peu vieillie. Li>
  • Mettez à jour les références codées en couleur aux noms de table li> ul>

    TAX: P>

    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
    
    • Ajoutez du produit aux produits de la table Li>
    • Ajouter des entrées dans les prix du tableau pour la périodeDDate> MAINTENANT () LI> ul>

      É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>


0 commentaires

1
votes

Votre citation est du livre "Apprendre HBASE" . La citation est inexacte, mais c'est la bonne nouvelle :)

Voir comment l'auteur décrit vraiment grand-mince mince

dans une conception de table , la table augmente plus rapidement que vers le côté droit. [...]

Rowkey (userid + horodatage) | Blogentriescf: entrées ----------------------------------------- + ------ ---------------------------

Écrivain A TIMESTAMP1 | HBaseenry
Écrivain B TIMESTAMP2 | Hadoopien de
Écrivain A TIMESTAMP3 | Hadoopien de
... | ...

Notez que les touches de la ligne sont hors de la commande qui est différente de votre exemple qui explique la confusion. Cet exemple explique le besoin d'exemple pour Crittera à

traverser de nombreuses lignes.

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).

Les diviseurs HBASE ont lieu sur des lignes, des données relatives à un utilisateur spécifique se trouvent sur un serveur de région.

Cette partie semble logiquement liée à courte-large ...

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.


3 commentaires

Juste pour m'assurer que je comprends bien correctement. La citation de l'auteur j'ai fourni avec précision est en fait incorrect ? De plus, étant donné que Tall-mince 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 est meilleur? Pour écrire lourd, Tall-mince 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?