Data Connect Emulator: Parallel gRPC queries fail with "unexpected message 'E'" in 15.4.0+

[samtsangbiz]

[REQUIRED] Environment info

firebase-tools:

• ❌ 15.5.1 - Issue present
• ❌ 15.4.0 - Issue present
• ✅ 15.3.1 - Works fine
• ✅ 14.27.0 - Works fine

Platform: macOS Darwin 25.2.0 (Apple Silicon)

Node.js: v22.x

Firebase iOS SDK: 11.10.0

[REQUIRED] Test case

Firebase Configuration (firebase.json):

{
  "emulators": {
    "dataconnect": {
      "port": 9399
    }
  },
  "dataconnect": {
    "source": "dataconnect"
  }
}

Schema (dataconnect/schema/schema.gql):

type Order @table {
  id: UUID! @default(expr: "uuidV4()")
  customerId: String!
  productId: String!
  orderType: String!
  createdAt: Date!
}

type Customer @table {
  id: String! @primaryKey
  name: String!
  email: String
}

type Product @table {
  id: String! @primaryKey
  name: String!
  category: String
}

Queries (dataconnect/connector/queries.gql):

# Multiple queries executed in parallel from iOS app
query ListOrderStats90d($limit: Int = 10) @auth(level: USER_ANON) {
  orderStats90ds(orderBy: {orderCount: DESC}, limit: $limit, 
    where: {orderType: {eq: "PURCHASE"}}) {
    customer { id name }
    orderType
    orderCount
  }
}

query ListCategoryStats1d($limit: Int = 5) @auth(level: USER_ANON) {
  categoryStats1ds(orderBy: {orderCount: DESC}, limit: $limit) {
    category
    orderCount
    totalCount
    percentage
  }
}

query ListTopCustomers90d($limit: Int = 5) @auth(level: USER_ANON) {
  topCustomers90ds(orderBy: {totalSpent: DESC}, limit: $limit) {
    customer { id name }
    totalSpent
    orderCount
  }
}

# ... 5+ additional similar queries for dashboard

[REQUIRED] Steps to reproduce

1. Install firebase-tools 15.4.0 or later (issue introduced in this version)
2. Start emulator: firebase emulators:start
3. Connect iOS app using Firebase Data Connect Swift SDK via gRPC
4. Execute 5+ GraphQL queries in parallel from the iOS app (e.g., on Dashboard load)
5. Observe that some queries fail randomly while others succeed

[REQUIRED] Expected behavior

All parallel queries should execute successfully and return data. The emulator should handle concurrent gRPC connections gracefully, similar to how production Cloud SQL handles them.

[REQUIRED] Actual behavior

When multiple gRPC queries are executed in parallel from an iOS app, the PGLite embedded database's connection pool becomes saturated, causing random query failures.

1. Connection pool warnings in Data Connect logs:

W0203 14:33:20.351079 execute.go:49 Database ping is slow 61.426209ms
stats: OpenConnections:6, InUse:6, Idle:0

2. Query failures with error (dataconnect-debug.log):

W0203 14:33:20.390336 engine.go:209 ExecuteQuery ListCategoryStats1d: failed. Connector: app
Errors: [message:"SQL execution failed" extensions:{code:INTERNAL 
  debug_details:"SQL runtime error: pq: unexpected message 'E'; expected ReadyForQuery..."}]

3. iOS Swift SDK errors (Xcode console):

11.10.0 - [FirebaseDataConnect][I-FDC000000] executeQuery(): <private> 
grpc call FAILED with {DataConnectOperationError, 
errors: Optional("SQL execution failed") 
originatingError: Optional(Swift.DecodingError.valueNotFound(Swift.Array<Any>, 
  Swift.DecodingError.Context(codingPath: [CodingKeys(stringValue: "orderStats90ds", intValue: nil)], 
  debugDescription: "Cannot get unkeyed decoding container -- found null value instead", 
  underlyingError: nil)))}.

11.10.0 - [FirebaseDataConnect][I-FDC000000] executeQuery(): <private> 
grpc call FAILED with {DataConnectOperationError, 
errors: Optional("SQL execution failed") 
originatingError: Optional(Swift.DecodingError.valueNotFound(Swift.Array<Any>, 
  Swift.DecodingError.Context(codingPath: [CodingKeys(stringValue: "categoryStats1ds", intValue: nil)], 
  debugDescription: "Cannot get unkeyed decoding container -- found null value instead", 
  underlyingError: nil)))}.

❌ DataConnect OrderStats Error: {DataConnectOperationError, 
errors: nil 
originatingError: Optional({DataConnectOperationError, 
errors: Optional("SQL execution failed") 
originatingError: Optional(Swift.DecodingError.valueNotFound(Swift.Array<Any>, 
  Swift.DecodingError.Context(codingPath: [CodingKeys(stringValue: "orderStats90ds", intValue: nil)], 
  debugDescription: "Cannot get unkeyed decoding container -- found null value instead", 
  underlyingError: nil)))})}

❌ Dashboard: Failed to load order stats - queryFailed({DataConnectOperationError, 
errors: nil 
originatingError: Optional({DataConnectOperationError, 
errors: Optional("SQL execution failed") 
originatingError: Optional(Swift.DecodingError.valueNotFound(Swift.Array<Any>, 
  Swift.DecodingError.Context(codingPath: [CodingKeys(stringValue: "orderStats90ds", intValue: nil)], 
  debugDescription: "Cannot get unkeyed decoding container -- found null value instead", 
  underlyingError: nil)))})})

Key observation: Some queries succeed (✅) while others fail (❌) in the same request batch - this is a race condition based on connection pool availability:

✅ Dashboard: Loaded 5 top customers
✅ Dashboard: Loaded 5 recent orders
❌ Dashboard: Failed to load order stats - queryFailed(...)
❌ Dashboard: Failed to load category stats - queryFailed(...)

Workaround

Downgrade to firebase-tools 15.3.1 or earlier resolves the issue completely.

npm install -g firebase-tools@15.3.1

Additional Context

• Regression introduced in 15.4.0: Version 15.3.1 works fine, 15.4.0 and later are broken
• HTTP requests work fine: Single queries via curl always succeed
• Production works fine: Cloud SQL handles parallel queries without issues
• Race condition behavior: Which queries fail depends on timing - random failures
• Related issue: May be related to Data Connect Emulator ECONNRESET crashes from PGLite prepared statement loss #9146 (ECONNRESET crashes from PGLite)

Version Comparison

firebase-tools	Status	Notes
15.5.1	❌ Broken	Connection pool saturation
15.4.0	❌ Broken	Bug introduced here
15.3.1	✅ Working	Last stable version
14.27.0	✅ Working	Also stable

[aalej]

Thanks @samtsangbiz for the thorough report and for sharing your observations! Based on the info, it does look like the issue is caused by the recent Data Connect emulator upgrade in v15.4.0, since the last version where you didn't encounter the issue is v15.3.1.

At the moment, I'm having some issues trying to repro this, could you provide more information about your schema.gql? Specifically, how you are performing the aggregation, is it something like

type OrderStats90d
  @view(
    sql: """
    SELECT
      customer_id,
      order_type,
      COUNT(*) as order_count
    FROM "order"
    WHERE created_at >= NOW() - INTERVAL '90 days'
    GROUP BY customer_id, order_type
    """
  ) {
  customer: Customer
  orderType: String
  orderCount: Int
}

I'll also check this with our engineering team as they may have a better idea on what is causing the error

Errors: [message:"SQL execution failed" extensions:{code:INTERNAL 
  debug_details:"SQL runtime error: pq: unexpected message 'E'; expected ReadyForQuery..."}]

[mickeywu]

I'm also encountering this issue, can confirm downgrading to 15.3.1 is the latest version that doesn't throw the error. I don't believe this is Swift specific as I'm seeing it via the Web SDK.

Production still works totally fine, issue only happens in the emulator.

[samtsangbiz]

Hi @aalej,

Thanks for looking into this! Here's our schema information with the aggregation patterns.

Base Tables (schema.gql)

  type Customer @table(key: "id") {
    id: String! @col(dataType: "varchar(10)")
    name: String! @col(dataType: "varchar(200)")
    industry: String @col(dataType: "varchar(100)") @index
    email: String
  }

  type Order @table(key: "uniqueKey")
    @index(fields: ["orderType", "createdAtDate"], order: [ASC, DESC]) {
    uniqueKey: String! @col(dataType: "varchar(50)")
    customer: Customer!
    orderType: String! @col(dataType: "varchar(20)")  # PURCHASE, SALE, REFUND
    createdAt: Timestamp!
    createdAtDate: Date @col(name: "created_at_date")  # Pre-computed for efficient filtering
    totalValue: Float @col(dataType: "numeric(20,2)")
    quantity: Int64!
  }

Aggregation Views (view.gql)

We use SQL @view directives with CTEs and window functions. Here are our patterns:

1. Order Stats (with period-over-period comparison)

type OrderStats90d @view(sql: """
   WITH recent_dates AS (
     SELECT ARRAY(
       SELECT DISTINCT created_at_date
       FROM order
       ORDER BY 1 DESC
       LIMIT 3
     ) as dates
   ),
   date_bounds AS (
     SELECT
       CASE
         WHEN dates[1] = (NOW() AT TIME ZONE 'America/New_York')::date THEN dates[2]
         ELSE dates[1]
       END as day1
     FROM recent_dates
   ),
   period_stats AS (
     SELECT
       order_type,
       COUNT(*) FILTER (WHERE created_at_date BETWEEN (SELECT day1 - 89 FROM date_bounds) AND
  (SELECT day1 FROM date_bounds)) as current_count,
       COUNT(*) FILTER (WHERE created_at_date BETWEEN (SELECT day1 - 179 FROM date_bounds)
 AND (SELECT day1 - 90 FROM date_bounds)) as previous_count
     FROM order
     WHERE created_at_date >= (SELECT day1 - 179 FROM date_bounds)
     GROUP BY order_type
   )
   SELECT
     order_type,
     current_count as order_count,
     CASE WHEN previous_count = 0 THEN NULL
          ELSE ((current_count::FLOAT - previous_count::FLOAT) / previous_count::FLOAT) * 100
     END as percentage_change
   FROM period_stats
 """) {
   orderType: String
   orderCount: Int
   percentageChange: Float
 }

2. Industry Stats (with JOIN and window functions)

type IndustryStats90d @view(sql: """
   WITH recent_dates AS (
     SELECT ARRAY(
       SELECT DISTINCT created_at_date FROM order ORDER BY 1 DESC LIMIT 3
     ) as dates
   ),
   date_bounds AS (
     SELECT CASE WHEN dates[1] = (NOW() AT TIME ZONE 'America/New_York')::date THEN dates[2]
 ELSE dates[1] END as day1
     FROM recent_dates
   )
   SELECT
     c.industry,
     COUNT(*) as order_count,
     SUM(COUNT(*)) OVER () as total_count,
     (COUNT(*) * 100.0 / SUM(COUNT(*)) OVER ()) as percentage
   FROM order o
   JOIN customer c ON o.customer_id = c.id
   CROSS JOIN date_bounds
   WHERE o.created_at_date BETWEEN date_bounds.day1 - 89 AND date_bounds.day1
     AND o.order_type = 'PURCHASE'
   GROUP BY c.industry
 """) {
   industry: String
   orderCount: Int
   totalCount: Int
   percentage: Float
 }

3. Customer aggregation (GROUP BY with multiple columns)

type IndustryCustomerStats90d @view(sql: """
   WITH recent_dates AS (...),
   date_bounds AS (...)
   SELECT
     c.industry,
     o.customer_id,
     o.order_type,
     COALESCE(SUM(o.total_value), 0) as total_volume,
     COUNT(*) as order_count,
     COUNT(DISTINCT o.product_id) as product_count
   FROM order o
   JOIN customer c ON o.customer_id = c.id
   CROSS JOIN date_bounds
   WHERE o.created_at_date BETWEEN date_bounds.day1 - 89 AND date_bounds.day1
     AND c.industry IS NOT NULL
   GROUP BY c.industry, o.customer_id, o.order_type
   HAVING COUNT(*) > 0
 """) {
   industry: String
   customer: Customer
   orderType: String
   totalVolume: Float
   orderCount: Int
   productCount: Int
 }

Parallel Query Pattern (iOS App)

Our Dashboard view loads 8+ queries simultaneously via gRPC from the Swift SDK:

  // All fire in parallel on Dashboard load
  async let stats1d = listOrderStats1d()
  async let stats7d = listOrderStats7d()
  async let stats30d = listOrderStats30d()
  async let stats90d = listOrderStats90d()
  async let industryPurchase = listIndustryPurchaseStats90d()
  async let industrySale = listIndustrySaleStats90d()
  async let topCustomers = listTopCustomers90d()
  async let recentOrders = listRecentOrders()
  // ... await all

Error Pattern:

The failure is random and race-condition based:

• Some queries succeed ✅, others fail ❌ in the same batch
• Connection pool shows saturation: OpenConnections:6, InUse:6, Idle:0
• Error: pq: unexpected message 'E'; expected ReadyForQuery

[aalej]

Thanks for the additional info! I'm now able to reproduce the issue, will share the MCVE with our engineering team. It does seem like making multiple parallel queries that uses arguments is what's causing the issue.