MongoDB中GeoPlaces父子关系及POI地理引用树结构校验问询

Alright, let's break down how to validate your POI's GeoPlace references and their tree structure step by step. I’ve worked through similar MongoDB tree validation problems before, so I’ll walk you through practical queries and logic you can use right away.

Before checking tree structure, make sure every ID in a POI's geography array actually points to a valid document in the GeoPlaces collection. Invalid references will break any tree checks you run later.

Try this aggregation query to hunt down POIs with missing GeoPlace references:

db.PointOfInterest.aggregate([
  // Unwind the geography array to check each reference one by one
  { $unwind: "$geography" },
  // Join with GeoPlaces to find entries with no matching document
  {
    $lookup: {
      from: "GeoPlaces",
      localField: "geography",
      foreignField: "_id", // Adjust this if your GeoPlaces use a different primary key
      as: "matchedGeoPlace"
    }
  },
  // Filter for cases where no match was found
  { $match: { matchedGeoPlace: { $size: 0 } } },
  // Group back to get full POI details along with invalid references
  {
    $group: {
      _id: "$_id",
      invalidReferences: { $addToSet: "$geography" },
      poiDetails: { $first: "$$ROOT" }
    }
  }
])

This will return all POIs that have stale or non-existent GeoPlace IDs in their geography array. Fix these first before moving on to tree validation.

Once all references are valid, we need to confirm these GeoPlace documents form a proper tree. A valid tree must meet these rules:

• Exactly one root node (no ParentId value, or ParentId is null/undefined)
• No cycles (a node can’t be its own ancestor)
• Every non-root node has exactly one valid parent within the referenced set
• All nodes are reachable from the root

2.1 Pull the Full Set of Referenced GeoPlaces #

Start by fetching all GeoPlace documents linked to a specific POI (replace POI_ID_HERE with your target POI's ID):

// Grab the target POI
const targetPOI = db.PointOfInterest.findOne({ _id: ObjectId("POI_ID_HERE") });
// Extract all referenced GeoPlace IDs
const referencedIds = targetPOI.geography;
// Fetch the full GeoPlace documents for these IDs
const referencedGeoPlaces = db.GeoPlaces.find({ _id: { $in: referencedIds } }).toArray();

2.2 Validate Core Tree Rules #

Use a mix of MongoDB queries and JavaScript logic to enforce the tree rules:

a. Check for Exactly One Root Node

Every valid tree needs exactly one root (no parent). Run this quick check:

const rootNodes = referencedGeoPlaces.filter(gp => !gp.ParentId || gp.ParentId === null);
if (rootNodes.length !== 1) {
  console.log(`Invalid tree: Found ${rootNodes.length} root nodes (expected exactly 1)`);
}

b. Detect Cycles & Invalid Parent References

Build a parent-child map and traverse each node to catch cycles or parents outside the referenced set:

const parentMap = new Map();
const idSet = new Set(referencedIds.map(id => id.toString()));

// Build a map of child ID -> parent ID
referencedGeoPlaces.forEach(gp => {
  if (gp.ParentId) {
    parentMap.set(gp._id.toString(), gp.ParentId.toString());
  }
});

// Check each node for cycles and valid parent references
for (const nodeId of idSet) {
  const visited = new Set();
  let current = nodeId;
  while (current) {
    if (visited.has(current)) {
      console.log(`Cycle detected involving node ID: ${current}`);
      break;
    }
    visited.add(current);
    current = parentMap.get(current);
    // Ensure parent is part of the POI's referenced set
    if (current && !idSet.has(current)) {
      console.log(`Node ${nodeId} has a parent ${current} not in the POI's reference list`);
      break;
    }
  }
}

c. Verify All Nodes Are Reachable From the Root

Make sure no nodes are disconnected from the main tree:

const rootId = rootNodes[0]._id.toString();
const reachableNodes = new Set();
const queue = [rootId];

// Traverse the tree starting from the root
while (queue.length > 0) {
  const currentId = queue.shift();
  reachableNodes.add(currentId);
  // Find all children of the current node in the referenced set
  const children = referencedGeoPlaces.filter(gp => gp.ParentId && gp.ParentId.toString() === currentId);
  children.forEach(child => {
    const childId = child._id.toString();
    if (!reachableNodes.has(childId)) {
      queue.push(childId);
    }
  });
}

// Check if all referenced nodes are reachable
if (reachableNodes.size !== idSet.size) {
  const unreachable = [...idSet].filter(id => !reachableNodes.has(id));
  console.log(`Unreachable nodes found: ${unreachable.join(", ")}`);
}

If the referenced GeoPlaces form a valid tree, you might want to add custom checks based on your use case. Here are common examples:

• GeoLevel Alignment: Ensure each node’s level matches the GeoLevels collection (e.g., root nodes at level 1, children at level 2, etc.):

  // Fetch all GeoLevels and build a level map
  const geoLevels = db.GeoLevels.find().toArray();
  const levelMap = new Map(geoLevels.map(gl => [gl._id.toString(), gl.level]));
  
  referencedGeoPlaces.forEach(gp => {
    const nodeLevel = levelMap.get(gp.geoLevelId.toString());
    const parent = referencedGeoPlaces.find(p => p._id.toString() === gp.ParentId?.toString());
    if (parent) {
      const parentLevel = levelMap.get(parent.geoLevelId.toString());
      if (nodeLevel !== parentLevel + 1) {
        console.log(`Node ${gp._id} has invalid level: expected ${parentLevel + 1}, got ${nodeLevel}`);
      }
    } else {
      // Adjust the expected root level to match your schema
      if (nodeLevel !== 1) {
        console.log(`Root node ${gp._id} has invalid level: expected 1, got ${nodeLevel}`);
      }
    }
  });
  

• Duplicate References: Ensure no GeoPlace is referenced multiple times in a single POI's geography array:

  const seenIds = new Set();
  const duplicates = targetPOI.geography.filter(id => {
    const idStr = id.toString();
    if (seenIds.has(idStr)) return true;
    seenIds.add(idStr);
    return false;
  });
  if (duplicates.length > 0) {
    console.log(`Duplicate references found: ${duplicates.map(id => id.toString()).join(", ")}`);
  }
  

• Subtree Integrity: Verify the tree is a valid subtree of the main GeoPlaces tree (all nodes trace back to a root in the full GeoPlaces collection, not just the POI's referenced root).

内容的提问来源于stack exchange，提问作者Thomas Bruyer