Consultar datos localizados en MongoDB

Nov 09 2020

Tener datos 'localizados' como este:

{
  "cs": [
    {
      "cID": "00001",
      "title": {
        "en": "title en1",
        "de": "title de1"
      },
      "desc": {
        "en": "desc en1",
        "de": "desc de1"
      },
      "startDate": 20210801,
      "endDate": 20210809,
      "numDays": 8
    },
    {
      "cID": "00002",
      "title": {
        "en": "title en2",
        "de": "title de2"
      },
      "desc": {
        "en": "desc en2",
        "de": "desc de2"
      },
      "startDate": 20210701,
      "endDate": 20210715,
      "numDays": 14
    }
  ]
}

¿Cuál sería la mejor manera de consultar esto teniendo en cuenta la configuración regional del usuario (pasada a la consulta como parámetro)? Por ejemplo, si se pasó "en", la consulta debería devolver esto para "cID": "00001":

    {
      "cID": "00001",
      "title": "title en1",
      "desc": "desc en1",
      "startDate": 20210801,
      "endDate": 20210809,
      "numDays": 8
    }

Idealmente, la consulta debería ser 'genérica' y no filtrar específicamente los objetos 'título' y 'desc'.

Yo sé eso:

db.cs.find({
  "cID": "00001"
},
{
  "_id": 0,
  "cID": 1,
  "title": "$title.en", "desc": "$desc.en",
  "startDate": 1,
  "endDate": 1,
  "numDays": 1
})

me dará:

[
  {
    "cID": "00001",
    "desc": "desc en1",
    "endDate": 2.0210809e+07,
    "numDays": 8,
    "startDate": 2.0210801e+07,
    "title": "title en1"
  }
]

pero sería complicado manejarlo con muchas configuraciones regionales y diferentes modelos de datos en diferentes consultas.

Zona de juegos de Mongo: https://mongoplayground.net/p/9erh-VYiOO4

Respuestas

1 turivishal Nov 21 2020 at 21:44

Puedes probar,

  • $reducepara iterar el ciclo de la titlematriz, $condpara hacer coincidir localy devolver el resultado de la coincidencia con el valor, el mismo proceso para la matriz de descripción
 {
    $addFields: { title: { $reduce: {
          input: "$title", initialValue: "", in: { $cond: [{ $eq: ["$$this.locale", "pl"] }, "$$this.value", "$$value"]
          }
        }
      },
      description: {
        $reduce: { input: "$description",
          initialValue: "",
          in: {
            $cond: [{ $eq: ["$$this.locale", "pl"] }, "$$this.value", "$$value"]
          }
        }
      }
    }
  }

para la opción genérica, puede hacer una función con dos parámetros, el primero es el campo de entrada con $signo y el segundo es la configuración regional:

function languageFilter(inputField, locale) {
  return {
    $reduce: { input: inputField, initialValue: "", in: { $cond: [{ $eq: ["$$this.locale", locale] }, "$$this.value", "$$value"]
      }
    }
  };
}

Su consulta final sería:

let locale = "pl";
db.cs.aggregate([
  { $match: { cID: "00001" } }, { $addFields: {
      title: languageFilter("$title", locale) description: languageFilter("$description", locale)
    }
  }
]);
2 chridam Nov 09 2020 at 04:02

Para crear una consulta genérica, se necesitaría el marco de agregación, ya que tiene algunos operadores útiles para ayudarlo con esto. Para empezar, necesitaría convertir el documento incrustado en una matriz de pares clave / valor y luego filtrar la matriz en el campo clave pasando la configuración regional como parámetro.

Por ejemplo, convierta el documento

  "title": {
    "en": "title en2",
    "de": "title de2"
  },

a una matriz

  "title": [
    { "k": "en", '"v": "title en2" },
    { "k": "de", "v": "title de2" }
  ],

utilizando el $objectToArrayoperador. Luego puede filtrar esta matriz en el campo clave usando el $filteroperador como

{
    '$filter': { 'input': { '$objectToArray': '$title' }, 'cond': { '$eq': ['$$this.k', locale] }
    }
}

donde la variable locale se deriva del parámetro pasado.

Una vez que tenga la matriz filtrada, obtener el campo de valor requiere que el $arrayElemAtoperador se aplique en la clave de valor como

{ 
    '$arrayElemAt': ['$title.v', 0]
}

Entonces, al final, tendrá que ejecutar una tubería como esta:

var locale = 'en';

db.cs.aggregate([
    { '$match': { "cID" : "00001" } }, { '$addFields': {
        'title': {
            '$filter': { 'input': { '$objectToArray': '$title' }, 'cond': { '$eq': ['$$this.k', locale] } } }, 'desc': { '$filter': {
                'input': { '$objectToArray': '$desc' },
                'cond': { '$eq': ['$$this.k', locale] }
            }
        }
    } },

    { '$addFields': { 'title': { '$arrayElemAt': ['$title.v', 0] }, 'desc': { '$arrayElemAt': ['$desc.v', 0]
        }
    } }
]);

Y con algo de refactorización:

var locale = 'en';
var getFilterOperatorExpression = function (field) {
    return {
        '$filter': {
            'input': { '$objectToArray': '$'+ field },
            'cond': { '$eq': ['$$this.k', locale] }
        }
    }
};
var getValueOperatorExpression = function (field) { 
    return { 
        '$arrayElemAt': ['$'+ field +'.v', 0]
    }
};

db.cs.aggregate([
    { '$match': { "cID" : "00001" } }, { '$addFields': {
        'title': getFilterOperatorExpression('title'),
        'desc': getFilterOperatorExpression('desc'),
    } },

    { '$addFields': {
        'title': getValueOperatorExpression('title'),
        'desc': getValueOperatorExpression('desc')
    } }
]);