$graphLookup

Nuevo a partir de la versión 8.0.2.

La fase de $graphLookup agregación de Amazon DocumentDB realiza una búsqueda recursiva en una colección. Para cada documento de entrada, $graphLookup comienza con uno o más valores y hace coincidir repetidamente un campo de conexión con un campo de destino, siguiendo la cadena de documentos coincidentes hasta que no haya más coincidencias o se alcance una profundidad de recursión opcional. Esto resulta útil para analizar datos jerárquicos o similares a gráficos, como las estructuras jerárquicas organizativas, los árboles de categorías o las relaciones de red.

Parámetros

• from: la colección de destino para buscar de forma recursiva. La from colección debe estar en la misma base de datos.

• startWith: la expresión que especifica el valor o los valores con los que iniciar la búsqueda recursiva. Este valor se compara con el connectToField de los documentos de la from colección. Si startWith se evalúa como una matriz, la búsqueda se ejecuta desde todos los elementos de la matriz al mismo tiempo.

• connectFromField: el nombre del campo cuyo valor se usa para conectarse al siguiente documento de la búsqueda recursiva. Si el valor es una matriz, cada elemento se sigue de forma individual a lo largo del recorrido.

• connectToField: el nombre del campo de la from colección que se compara con el valor de. connectFromField

• as: el nombre del campo de matriz agregado a cada documento de salida. Este campo contiene los documentos encontrados durante la búsqueda recursiva. Para obtener información sobre el orden de estos documentos, consulte el elemento Ordenamiento de los resultados en la siguiente sección Comportamiento.

• maxDepth: un entero no negativo que especifica el número máximo de iteraciones recursivas que se deben realizar después de la búsqueda inicial. Este parámetro es opcional. Un valor de 0 realiza únicamente la coincidencia inicial y no la recursión. Si lo omitemaxDepth, la búsqueda continúa de forma recursiva hasta que no haya más documentos coincidentes.

• depthField: el nombre del campo que se va a agregar a cada documento de la as matriz que contiene la profundidad de recursión con la que se encontró el documento. Este parámetro es opcional. La profundidad se representa como un NumberLong y comienza en cero, por lo que la búsqueda inicial corresponde a una profundidad de0.

• restrictSearchWithMatch: documento que especifica una condición de coincidencia adicional que se aplica a los documentos de la búsqueda. Este parámetro es opcional. La condición usa la misma sintaxis de consulta que en una $match etapa y no puede incluir expresiones de agregación.

nota

La $graphLookup etapa está sujeta a un límite de memoria de 100 MB y no es compatibleallowDiskUse:true. Una operación que supera este límite devuelve un error. Si la agregación incluye otras etapas, la allowDiskUse:true opción permanece en vigor para esas etapas.

Comportamiento

• Cross-collection transversal: from defina la colección en la que desea buscar. Puede ser la misma colección en la que se ejecuta la canalización o una colección diferente en la misma base de datos.

• Orden de los resultados: los documentos de la as matriz no se devuelven en un orden garantizado.

Ejemplo (MongoDB Shell)

En el siguiente ejemplo, se utiliza $graphLookup para rebasar la jerarquía jerárquica de los empleados y, para cada empleado, mostrar la cadena completa de gerentes por encima de ellos.

Los siguientes comandos, que se ejecutan en el shell mongosh, insertan ejemplos de documentos de empleados que establecen una jerarquía jerárquica:

db.employees.insertMany([
  { _id: 1, name: "Dev", reportsTo: "Eliot" },
  { _id: 2, name: "Eliot", reportsTo: "Ron" },
  { _id: 3, name: "Ron", reportsTo: "Andrew" },
  { _id: 4, name: "Andrew", reportsTo: "Asya" },
  { _id: 5, name: "Asya" }
]);

La siguiente agregación muestra la cadena de administración completa de cada empleado de una nueva reportingHierarchy matriz:

db.employees.aggregate([
  {
    $graphLookup: {
      from: "employees",
      startWith: "$reportsTo",
      connectFromField: "reportsTo",
      connectToField: "name",
      as: "reportingHierarchy",
      depthField: "level"
    }
  }
]);

Esta operación devuelve el siguiente resultado:

[
  {
    _id: 1,
    name: 'Dev',
    reportsTo: 'Eliot',
    reportingHierarchy: [
      { _id: 2, name: 'Eliot', reportsTo: 'Ron', level: 0 },
      { _id: 3, name: 'Ron', reportsTo: 'Andrew', level: 1 },
      { _id: 4, name: 'Andrew', reportsTo: 'Asya', level: 2 },
      { _id: 5, name: 'Asya', level: 3 }
    ]
  },
  {
    _id: 2,
    name: 'Eliot',
    reportsTo: 'Ron',
    reportingHierarchy: [
      { _id: 3, name: 'Ron', reportsTo: 'Andrew', level: 0 },
      { _id: 4, name: 'Andrew', reportsTo: 'Asya', level: 1 },
      { _id: 5, name: 'Asya', level: 2 }
    ]
  },
  {
    _id: 3,
    name: 'Ron',
    reportsTo: 'Andrew',
    reportingHierarchy: [
      { _id: 4, name: 'Andrew', reportsTo: 'Asya', level: 0 },
      { _id: 5, name: 'Asya', level: 1 }
    ]
  },
  {
    _id: 4,
    name: 'Andrew',
    reportsTo: 'Asya',
    reportingHierarchy: [
      { _id: 5, name: 'Asya', level: 0 }
    ]
  },
  {
    _id: 5,
    name: 'Asya',
    reportingHierarchy: []
  }
]

Cada documento del empleado obtiene una reportingHierarchy matriz que contiene los documentos del administrador coincidentes de forma recursiva. El level campo registra la profundidad de recursión a la que se encontró cada administrador. Asya no tiene ningún reportsTo valor, por lo que su reportingHierarchy matriz está vacía.

Ejemplo con maxDepth y restrict SearchWithMatch (MongoDB Shell)

El siguiente ejemplo recorre una red de conexiones entre personas y se utiliza maxDepth para limitar la recursión e restrictSearchWithMatch incluir solo los documentos que cumplen una condición adicional. La búsqueda busca las conexiones de una persona que está empezando, con una profundidad de hasta dos niveles, y solo conserva las personas cuya hobbies matriz contiene. golf

Los siguientes comandos, ejecutados en la consola mongosh, insertan documentos de ejemplo en los que cada persona friends señala hacia adelante a través de una cadena de conexiones unidireccional:

db.people.insertMany([
  { _id: 1, name: "Tanya", friends: [ "Carole", "Shirley" ], hobbies: [ "tennis", "golf" ] },
  { _id: 2, name: "Carole", friends: [ "Joseph" ], hobbies: [ "archery", "golf" ] },
  { _id: 3, name: "Joseph", friends: [ "Angelo" ], hobbies: [ "tennis", "golf" ] },
  { _id: 4, name: "Angelo", friends: [ "Miguel" ], hobbies: [ "travel", "golf" ] },
  { _id: 5, name: "Miguel", friends: [], hobbies: [ "golf" ] },
  { _id: 6, name: "Shirley", friends: [], hobbies: [ "frisbee" ] }
]);

La siguiente agregación parte de Tanya, recorre su red de conexiones hasta dos niveles de profundidad y solo incluye a las personas que la listan como pasatiempo: golf

db.people.aggregate([
  { $match: { name: "Tanya" } },
  {
    $graphLookup: {
      from: "people",
      startWith: "$friends",
      connectFromField: "friends",
      connectToField: "name",
      as: "golfConnections",
      maxDepth: 2,
      restrictSearchWithMatch: { hobbies: "golf" }
    }
  },
  { $project: { name: 1, "golfConnections.name": 1 } }
]);

Esta operación devuelve el siguiente resultado:

[
  {
    _id: 1,
    name: 'Tanya',
    golfConnections: [
      { name: 'Carole' },
      { name: 'Joseph' },
      { name: 'Angelo' }
    ]
  }
]

Solo golf se incluyen las conexiones cuya hobbies matriz contenga, y el recorrido se detiene después de dos niveles de recursión. Shirley está excluida porque no aparece en la listagolf, y Miguel está excluido porque está a tres niveles de Tanya, más allá del de. maxDepth 2 Como las conexiones forman una cadena unidireccional que nunca apunta a Tanya, el documento inicial no coincide durante la búsqueda recursiva.

Ejemplos de código

Para ver un ejemplo de código que crea la jerarquía de informes de los empleados a partir del primer ejemplo con un controlador MongoDB, seleccione la pestaña correspondiente al idioma que desee utilizar:

Node.js

const { MongoClient } = require('mongodb');

async function example() {
  const client = new MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false');

  try {
    await client.connect();
    const db = client.db('test');
    const employees = db.collection('employees');

    const result = await employees.aggregate([
      {
        $graphLookup: {
          from: 'employees',
          startWith: '$reportsTo',
          connectFromField: 'reportsTo',
          connectToField: 'name',
          as: 'reportingHierarchy',
          depthField: 'level'
        }
      }
    ]).toArray();

    console.log(JSON.stringify(result, null, 2));
  } catch (err) {
    console.error('Failed to run $graphLookup aggregation:', err.message);
  } finally {
    await client.close();
  }
}

example();

Python

from pymongo import MongoClient
from pymongo.errors import PyMongoError

def example():
    client = MongoClient('mongodb://<username>:<password>@<cluster-endpoint>:27017/?tls=true&tlsCAFile=global-bundle.pem&replicaSet=rs0&readPreference=secondaryPreferred&retryWrites=false')

    try:
        db = client['test']
        employees = db['employees']

        pipeline = [
            {
                "$graphLookup": {
                    "from": "employees",
                    "startWith": "$reportsTo",
                    "connectFromField": "reportsTo",
                    "connectToField": "name",
                    "as": "reportingHierarchy",
                    "depthField": "level"
                }
            }
        ]

        result = list(employees.aggregate(pipeline))

        for doc in result:
            print(doc)
    except PyMongoError as error:
        print(f"Failed to run $graphLookup aggregation: {error}")
    finally:
        client.close()

example()