MongoDB Global (alcance) Uso variable en la instalación de múltiples fragmentos

Question

Estoy diseñando el sistema que debería poder procesar millones de documentos e informar sobre ellos de diferentes maneras. MAGODB MAP \ Reducir la tarea es lo que estoy tratando de implementar (actualmente realiza alguna investigación sobre eso). La estructura de documentos muy básica es

db.test.insert(
{
        "_id" : ObjectId("4f6063601caf46303c36eb27"),
        "verbId" : NumberLong(1506281),
        "sentences" : [
                {
                        "sId" : NumberLong(2446630),
                        "sentiment" : 2,
                        "categories" : [
                                NumberLong(3257),
                                NumberLong(3221),
                                NumberLong(3291)
                        ]
                },
                {
                        "sId" : NumberLong(2446631),
                        "sentiment" : 0,
                        "categories" : [
                                NumberLong(2785),
                                NumberLong(2762),
                                NumberLong(2928),
                                NumberLong(2952)
                        ]
                },
                {
                        "sId" : NumberLong(2446632),
                        "sentiment" : 0,
                        "categories" : [
                                NumberLong(-2393)
                        ]
                },
                {
                        "sId" : NumberLong(2446633),
                        "sentiment" : 0,
                        "categories" : [
                                NumberLong(-2393)
                        ]
                }
        ]
})

para que cada documento contenga oraciones, que pueda pertenecer a diferentes categorías. El informe que estoy tratando de obtener es el número de oraciones en la categoría (con porcentaje de verbatims).

Estoy haciendo el siguiente Mapa-Reducir trabajos con Finalizar Método para contar diferentes promedios.

var map = function() {
        var docCategories = new Array();
        var catValues = new Array();
        for (var i = 0; i < this.sentences.length; i++) { //iterate over sentences.
            sentence = this.sentences[i];
            for (var j = 0; j < sentence.categories.length; j++) {//iterate over categories
                catId= sentence.categories[j].toNumber();
                if (docCategories.indexOf(catId) < 0) {
                    docCategories.push(catId);
                    catValues.push({sentiment : sentence.sentiment, sentenceCnt: 1});
                } else {
                    categoryIdx = docCategories.indexOf(catId);
                    catValue = catValues[categoryIdx];
                    catValue.sentiment = catValue.sentiment + sentence.sentiment;
                    catValue.sentenceCnt = catValue.sentenceCnt + 1;
                }
            }

        }
        totalCount++; //here we do try to count distinctCases see scope.
        for (var i = 0; i < docCategories.length; i ++) {
            emit(docCategories[i], {count: 1, sentenceCnt: catValues[i].sentenceCnt, sentiment: catValues[i].sentiment, totalCnt : totalCount});
        }

    };

var reduce = function(key, values) {
    var res = {count : 0, sentenceCnt : 0, sentiment : 0};
    for ( var i = 0; i < values.length; i ++ ) {
        res.count += values[i].count;
        res.sentenceCnt += values[i].sentenceCnt;
        res.sentiment += values[i].sentiment;
    }

    return res;
};

var finalize = function(category, values) {
    values.sentimentAvg = values.sentiment / values.sentenceCnt; 
    values.percentOfVerbatim = values.count / totalCount //scope variable (global)
    return values;
};


var res = db.runCommand( { mapreduce:'test',
                  map:map,
                  reduce:reduce,
                  out: 'cat_volume',
                  finalize:finalize,
                  scope:{totalCount : 0},
                });

La parte más interesante aquí es que estoy usando TotalCount, para contar el número de verbatims que estoy emitiendo. TotalCount es la variable de alcance (global). Todo salió bien en una instalación de mongodb, pero al ir a las instancias de un fragmento Estoy obteniendo "infinito" para Porcendefverbatim .

En realidad, en ese caso, TotalCount sería solo db.test.count () (número de documentos) pero en el futuro, voy a agregar diferentes condiciones para los documentos ser contar. Hacer cualquier otra consulta es muy indeseable ya que DB es muy pesado.

¿Hay otros enfoques para usar variables globales (alcance) en la instalación de MongoDB de Multi-Instance? ¿O debería usar algo más?

Answer 1

Las variables de alcance son no compartidas entre los fragmentos.Puedes tratarlo como constante global.Actualizaciones al valor no será visible para mapear o reducir las funciones que se ejecutan en diferentes fragmentos.

Answer 2

Finalmente he encontrado la forma en que cuente el número de documentos que estoy emitiendo. La única manera que funcionó para mí está emitiendo documentyid, y puso IDS en la matriz de reducción. En el lado del cliente (estoy escribiendo el programa Java), tengo que contar todos los identificadores distintos. Entonces, mientras haces el mapa, hago emites

emit(docCategories[i], {verbIds : [this.verbId.toNumber()], count: 1, sentenceCnt: catValues[i].sentenceCnt, sentiment: catValues[i].sentiment, totalCnt : totalCount});

Reducir la función es lo siguiente:

var reduce = function(key, values) {
    var res = {verbIds : [], count : 0, sentenceCnt : 0, sentiment : 0};
    for ( var i = 0; i < values.length; i ++ ) {
//      res.verbIds = res.verbIds.concat(values[i].verbIds); //works slow
        for ( var j = 0; j < values[i].verbIds.length; j ++ ) {
            res.verbIds.push(values[i].verbIds[j]);
        }
        res.count += values[i].count;
        res.sentenceCnt += values[i].sentenceCnt;
        res.sentiment += values[i].sentiment;
    }

    return res;
};

El programa lateral Java solo cuenta las identificaciones distintas sobre todos los resultados.

En realidad para la ejecución de documentos de 1.1M se ralentiza significativamente