Enterprise Edition Architecture / Query Engine and How Native Core Semantics Differ from Standard

1. AtlasMart problem: the same query shape does not imply the same execution model

AtlasMart already knows Standard Native Core queries. A team proposes Enterprise because it wants more expressive queries. If they simply flip the edition label and keep all Standard assumptions, they can accidentally turn a query that would have required an index into a collection scan, misread cost because Enterprise bills bytes through Read/Write Units, or expect Pipeline queries to retain Core realtime/offline behavior. The first task is therefore architectural: define the operation family before discussing syntax.

Learning outcomes

2. One Enterprise Native database, two operation families

Core operations keep familiar document CRUD and method-chaining query semantics. In Enterprise they still support realtime listeners and mobile/web offline persistence, but the storage engine does not automatically create single-field indexes and does not require every query to be indexed. Pipeline operations use a stage-ordered query interface with expressions, projections, transformations, aggregations and sub-pipeline capabilities. Pipeline is not a hidden optimizer mode under a normal Core query; your code chooses the interface.

3. Why optional indexing changes reasoning

In Standard, indexes are part of query validity: single-field indexes are automatic and compound access patterns may require explicit composite indexes. Enterprise changes the failure mode. With no suitable index, a query can scan data and still return the correct result. That is convenient for prototyping but dangerous if “it worked” is treated as performance evidence. The data returned can be identical while latency and Read Units diverge dramatically as the collection grows.

4. Billing model: bytes processed, not simply documents counted

Enterprise read operations are charged in 4 KiB Read Unit tranches and writes in 1 KiB Write Unit tranches. Scan operations can process indexes and/or documents, so a query may process substantially more data than it returns. Full-text and geospatial search add specialized charges. Query Explain is therefore both a performance and billing tool. In the mandatory lab we simulate bytes only to teach the arithmetic; the simulator is never labeled as a bill.

import fs from "node:fs/promises";const products = JSON.parse(await fs.readFile("atlasmart-enterprise-fixture.json", "utf8"));const bytes = x => Buffer.byteLength(JSON.stringify(x), "utf8");const readUnits = n => Math.max(1, Math.ceil(n / 4096));function simulateQuery({sellerId, minStock, indexed}) {  const matched = products.filter(p => p.sellerId === sellerId && p.stock >= minStock);  const scanned = indexed ? products.filter(p => p.sellerId === sellerId) : products;  const scannedBytes = scanned.reduce((s,p)=>s+bytes(p),0);  return { indexed, scannedDocs: scanned.length, returnedDocs: matched.length,           simulatedScannedBytes: scannedBytes, simulatedReadUnits: readUnits(scannedBytes),           ids: matched.map(x=>x.id) };}console.log(simulateQuery({sellerId:"seller-a", minStock:5, indexed:false}));console.log(simulateQuery({sellerId:"seller-a", minStock:5, indexed:true}));// This is a deterministic teaching model, NOT Firestore Query Explain output or a bill.

5. Enterprise emulator profile: what it proves

{  "firestore": {    "rules": "firestore.rules",    "indexes": "firestore.indexes.json",    "edition": "enterprise"  },  "emulators": {    "firestore": { "host": "127.0.0.1", "port": 8180, "edition": "enterprise" },    "ui": { "enabled": true, "host": "127.0.0.1", "port": 4100 },    "singleProjectMode": true  }}

[  {"id":"p-1001","sellerId":"seller-a","category":"cameras","name":"Trail Camera","price":99,"stock":8,"rating":4.6,"published":true},  {"id":"p-1002","sellerId":"seller-a","category":"accessories","name":"USB-C Hub","price":49,"stock":3,"rating":4.4,"published":true},  {"id":"p-1003","sellerId":"seller-b","category":"sensors","name":"Temp Sensor","price":39,"stock":12,"rating":4.7,"published":true},  {"id":"p-1004","sellerId":"seller-b","category":"gateways","name":"Edge Gateway","price":149,"stock":1,"rating":4.2,"published":true},  {"id":"p-1005","sellerId":"seller-c","category":"cameras","name":"PoE Camera","price":199,"stock":5,"rating":4.8,"published":true},  {"id":"p-1006","sellerId":"seller-a","category":"power","name":"Bench PSU","price":89,"stock":9,"rating":4.5,"published":true}]

npx firebase-tools@15.30.0 emulators:start \  --config firebase.enterprise.json \  --only firestore \  --project demo-atlasmart-firestore

The configuration deliberately uses port 8180 rather than the course-wide Standard port 8080. It proves that the Local Emulator Suite can run an Enterprise-edition Firestore emulator profile and lets you inspect AtlasMart documents with Core operations. It does not prove managed Query Explain output, production billing, index build time, service limits, or complete Pipeline feature parity.

6. Core query continuity

process.env.FIRESTORE_EMULATOR_HOST = "127.0.0.1:8180";process.env.GCLOUD_PROJECT = "demo-atlasmart-firestore";import { initializeApp } from "firebase-admin/app";import { getFirestore } from "firebase-admin/firestore";initializeApp({ projectId: process.env.GCLOUD_PROJECT });const db = getFirestore();const snap = await db.collection("catalogItems")  .where("sellerId", "==", "seller-a")  .where("stock", ">=", 5)  .orderBy("stock", "desc")  .get();console.log(snap.docs.map(d => [d.id, d.get("stock")]));// Expected fixture result: p-1006 (9), p-1001 (8).

7. Pipeline is an explicit second path

import { field } from "@google-cloud/firestore/pipelines";const p = db.pipeline()  .collection("catalogItems")  .where(field("sellerId").equal("seller-a"))  .where(field("stock").greaterThanOrEqual(5))  .sort(field("stock").descending())  .select("name", "stock", "price");const result = await p.execute();for (const row of result.results) console.log(row.data());// Run only against an Enterprise Native database where Pipeline operations are supported.

8. Security/trust boundary remains explicit

Mobile/web requests remain subject to Firebase Authentication context and Firestore Security Rules. Privileged server libraries use IAM/ADC and bypass Rules, so Pipeline expressiveness does not eliminate application-layer authorization. Pipeline Security Rules also have a narrower set of filter expressions that the Rules engine can recognize as query constraints; a complex expression being valid in the query engine does not imply the Rules engine can prove it safe.

9. Feature-status discipline

Verification checklist

• Enterprise emulator runs on 8180/4100 with no Standard-lab collision.
• Core fixture query returns the expected AtlasMart rows.
• Local scan simulator labels its values simulated, not production metrics.
• No lesson claims that an unindexed Enterprise query is efficient just because it succeeds.
• Pipeline realtime/offline, DML Preview, search Preview, and MongoDB compatibility boundaries are explicit.

Production judgment and bridge to Lesson 2

Enterprise is not automatically “Standard plus more features.” It changes indexing, billing and the query decision surface. If AtlasMart needs familiar realtime/offline application queries, Core can remain the right interface even inside Enterprise. If it needs server-side transformations or more expressive composition, Pipeline becomes a candidate—but only after query-plan, security and cost evidence. Lesson 2 builds that stage-by-stage mental model.

Knowledge check

1. What happens to an unindexed query in Enterprise Native?
2. Which operation family provides the familiar realtime/offline path in Enterprise Native?
3. Does a successful Pipeline query prove it is cheap?
4. Are Pipeline DML stages GA in this lesson baseline?
5. Is MongoDB compatibility the same thing as Pipeline operations?

Authoritative references

• Firebase · Overview of Firestore in Native mode (Core and Pipeline operations)
• Firebase · Standard vs Enterprise Native mode support
• Firebase · Get data with Pipeline operations
• Firebase · Perform joins with sub-pipelines
• Firebase · Query Explain for Enterprise
• Firebase · Enterprise Native index overview
• Firebase · Pipeline DML stages (Preview)
• Firebase · Pipeline search stage (Preview)
• Google Cloud · Firestore Enterprise pricing
• Firebase · Connect to the Firestore emulator / Enterprise edition configuration