Hbase rapidement compter le nombre de lignes

Utilisation RowCounter dans HBase
RowCounter est un travail de mapreduce pour compter toutes les lignes d'une table. C'est un bon utilitaire pour l'utiliser comme un test de cohérence pour s'assurer que HBase pouvez lire tous les blocs d'une table si il y a des préoccupations de métadonnées de l'incohérence. Il sera exécuté le mapreduce le tout dans un seul processus, mais il sera exécuté plus rapidement si vous avez une MapReduce cluster en place pour exploiter.

$ hbase org.apache.hadoop.hbase.mapreduce.RowCounter <tablename>

Usage: RowCounter [options] 
    <tablename> [          
        --starttime=[start] 
        --endtime=[end] 
        [--range=[startKey],[endKey]] 
        [<column1> <column2>...]
    ]

Si vous ne pouvez pas utiliser RowCounter pour quelque raison que ce soit, alors la combinaison de ces deux filtres de manière optimale afin d'obtenir un décompte:

FirstKeyOnlyFilter() AND KeyOnlyFilter()

La FirstKeyOnlyFilter entraînera le scanner ne revenant à la première colonne qualificatif qu'il trouve, contrairement au scanner le retour de tous les de la colonne qualificatifs dans la table, ce qui permettra de réduire au minimum le réseau de bande passante. Qu'en est simplement en la sélectionnant une colonne qualifier au retour? Cela pourrait fonctionner si vous pouviez garantir que la colonne qualificatif existe pour chaque ligne, mais si que n'est pas vrai, alors vous obtiendrez une inexactes comte.

La KeyOnlyFilter entraînera le scanner ne revenant à la famille de la colonne, et ne retourne aucune valeur pour la colonne de qualification. Cela réduit d'autant la bande passante du réseau, qui, dans le cas général ne serait pas en compte beaucoup de réduction, mais il peut être un cas limite où la première colonne choisie par le filtre précédent se trouve être une très grande valeur.

J'ai essayé de jouer avec les scan.setCaching mais les résultats étaient tous sur la place. Elle pourrait peut-être aider.

J'ai eu 16 millions de lignes entre un début et de fin que j'ai fait la pseudo-empirique:

Avec FirstKeyOnlyFilter et KeyOnlyFilter activé: 

Avec la mise en cache pas ensemble (c'est à dire, la valeur par défaut), il a fallu 188 secondes. 
Avec la mise en cache à 1, il a fallu 188 secondes 
Avec la mise en cache défini sur 10, il a fallu 200 secondes 
Avec la mise en cache fixée à 100, il a fallu 187 secondes 
Avec la mise en cache à 1000, il a fallu 183 secondes. 
Avec la mise en cache 10000, il a fallu 199 secondes. 
Avec la mise en cache fixé à 100000, il a fallu 199 secondes. 

Avec FirstKeyOnlyFilter et KeyOnlyFilter désactivé: 

Avec la mise en cache pas, (c'est à dire, la valeur par défaut), il a fallu 309 secondes 

Je n'ai pas pris la peine de faire les tests appropriés de cela, mais il semble clair que le FirstKeyOnlyFilter et KeyOnlyFilter sont bonnes.

En outre, les cellules de ce tableau sont très petits, donc je pense que les filtres aurait été encore mieux sur une autre table.

---

Voici un exemple de code Java:

importer java.io.IOException; 

import org.apache.hadoop.conf.Configuration; 
import org.apache.hadoop.hbase.HBaseConfiguration; 
import org.apache.hadoop.hbase.client.HTable; 
import org.apache.hadoop.hbase.client.Résultat; 
import org.apache.hadoop.hbase.client.ResultScanner; 
import org.apache.hadoop.hbase.client.D'analyse; 
import org.apache.hadoop.hbase.util.D'octets; 

import org.apache.hadoop.hbase.le filtre.RowFilter; 
import org.apache.hadoop.hbase.le filtre.KeyOnlyFilter; 
import org.apache.hadoop.hbase.le filtre.FirstKeyOnlyFilter; 
import org.apache.hadoop.hbase.le filtre.Liste de filtres; 

import org.apache.hadoop.hbase.le filtre.CompareFilter.CompareOp; 
import org.apache.hadoop.hbase.le filtre.RegexStringComparator; 

public class HBaseCount { 
public static void main(String[] args) throws IOException { 
Configuration config = HBaseConfiguration.create(); 

HTable tableau = new HTable(config, "ma_table"); 

Scanner scan = new Scanner( 
Octets.toBytes("foo"), les Octets.toBytes("foo~") 
); 

if (args.length == 1) { 
la numérisation.setCaching(Integer.valueOf(args[0])); 
} 
Système.out.println("analyse de la mise en cache est" + scan.getCaching()); 

Filtre allFilters = new liste de filtres(); 
allFilters.addFilter(nouveau FirstKeyOnlyFilter()); 
allFilters.addFilter(nouveau KeyOnlyFilter()); 

la numérisation.setFilter(allFilters); 

ResultScanner scanner = table.getScanner(scan); 

int count = 0; 

long start = System.currentTimeMillis(); 

try { 
pour (Résultat rr = scanner.next(); rr != null; rr = scanner.next()) { 
compteur += 1; 
if (count % de 100000 == 0) System.out.println(count); 
} 
} finally { 
scanner.close(); 
} 

long fin = Système.currentTimeMillis(); 

long délai = fin - début; 

Système.out.println("temps Écoulé a été" + (elapsedTime/1000F)); 

} 
} 

---

Ici est un pychbase exemple de code:

 de pychbase importation de Connexion 
c = Connexion() 
t = c.tableau('ma_table') 
# Sous le capot, cette applique la FirstKeyOnlyFilter et KeyOnlyFilter 
# similaire à la happybase exemple ci-dessous 
imprimer t.count(row_prefix="foo") 

---

Ici est un Happybase exemple de code:

 de happybase importation de Connexion 
c = Connexion(...) 
t = c.tableau('ma_table') 
count = 0 
pour _ t.scan(filtre='FirstKeyOnlyFilter() ET KeyOnlyFilter()'): 
count += 1 

imprimer le comte 

---

Grâce à @Tuckr et @KennyCason pour l'astuce.

Simple, Efficace et Efficiente de la façon de compter les ligne dans HBASE:

1. Chaque fois que vous insérez une ligne de déclenchement de cette API qui va incrémenter cette cellule particulière.

   Htable.incrementColumnValue(Bytes.toBytes("count"), Bytes.toBytes("details"), Bytes.toBytes("count"), 1);
   

2. De vérifier le nombre de lignes présentes dans le tableau. Suffit d'utiliser "Get" ou "scan" de l'API pour cette Ligne particulière "compter".

En utilisant cette Méthode, vous pouvez obtenir le nombre de lignes en moins d'une milliseconde.

Vous pouvez utiliser le coprocesseur de ce qui est disponible depuis HBase de 0,92. Voir Coprocesseur et AggregateProtocol et exemple

U peut trouver un exemple de exemple ici:

/**
     * Used to get the number of rows of the table
     * @param tableName
     * @param familyNames
     * @return the number of rows
     * @throws IOException
     */
    public long countRows(String tableName, String... familyNames) throws IOException {
        long rowCount = 0;
        Configuration configuration = connection.getConfiguration();
        //Increase RPC timeout, in case of a slow computation
        configuration.setLong("hbase.rpc.timeout", 600000);
        //Default is 1, set to a higher value for faster scanner.next(..)
        configuration.setLong("hbase.client.scanner.caching", 1000);

        AggregationClient aggregationClient = new AggregationClient(configuration);
        try {
            Scan scan = new Scan();
            if (familyNames != null && familyNames.length > 0) {
                for (String familyName : familyNames) {
                    scan.addFamily(Bytes.toBytes(familyName));
                }
            }
            rowCount = aggregationClient.rowCount(TableName.valueOf(tableName), new LongColumnInterpreter(), scan);
        } catch (Throwable e) {
            throw new IOException(e);
        }
        return rowCount;
    }

Deux façons Travaillé pour moi de me nombre de lignes de table hbase avec la Vitesse

Scénario #1

Si hbase la taille de la table est petite, puis connectez-vous à hbase shell avec d'utilisateur valide et d'exécuter

>count '<tablename>'

Exemple

>count 'employee'

6 row(s) in 0.1110 seconds

Scénario #2

Si hbase la taille de la table est grande,alors exécuter intégré RowCounter carte de réduire l'emploi:
Connexion à hadoop machine avec d'utilisateur valide et de l'exécuter:

/$HBASE_HOME/bin/hbase org.apache.hadoop.hbase.mapreduce.RowCounter '<tablename>'

Exemple:

 /$HBASE_HOME/bin/hbase org.apache.hadoop.hbase.mapreduce.RowCounter 'employee'

     ....
     ....
     ....
     Virtual memory (bytes) snapshot=22594633728
                Total committed heap usage (bytes)=5093457920
        org.apache.hadoop.hbase.mapreduce.RowCounter$RowCounterMapper$Counters
                ROWS=6
        File Input Format Counters
                Bytes Read=0
        File Output Format Counters
                Bytes Written=0