Method #consolidateKeyed

packages/db-ivm/src/multiset.ts:96–163

* Private method for consolidating keyed multisets where keys are strings/numbers * and values are compared by reference equality. * * This method provides significant performance improvements over the hash-based approach * by using WeakMap for object reference tracking and avoiding expe

()

   * we unpack them and compare each element individually to maintain proper equality semantics.
   */
  #consolidateKeyed(): MultiSet<T> {
    const consolidated = new Map<string, number>()
    const values = new Map<string, T>()

    // Use global object ID generator for consistent reference equality

    /**
     * Special handler for tuples (arrays of length 2) commonly produced by join operations.
     * Unpacks the tuple and generates an ID based on both elements to ensure proper
     * consolidation of join results like ['A', null] and [null, 'X'].
     */
    const getTupleId = (tuple: Array<any>): string => {
      if (tuple.length !== 2) {
        throw new Error(`Expected tuple of length 2`)
      }
      const [first, second] = tuple
      return `${globalObjectIdGenerator.getStringId(first)}|${globalObjectIdGenerator.getStringId(second)}`
    }

    // Process each item in the multiset
    for (const [data, multiplicity] of this.#inner) {
      // Verify this is still a keyed item (should be [key, value] pair)
      if (!Array.isArray(data) || data.length !== 2) {
        // Found non-keyed item, fall back to unkeyed consolidation
        return this.#consolidateUnkeyed()
      }

      const [key, value] = data

      // Verify key is string or number as expected for keyed multisets
      if (typeof key !== `string` && typeof key !== `number`) {
        // Found non-string/number key, fall back to unkeyed consolidation
        return this.#consolidateUnkeyed()
      }

      // Generate value ID with special handling for join tuples
      let valueId: string
      if (Array.isArray(value) && value.length === 2) {
        // Special case: value is a tuple from join operations
        valueId = getTupleId(value)
      } else {
        // Regular case: use reference/value equality
        valueId = globalObjectIdGenerator.getStringId(value)
      }

      // Create composite key and consolidate
      const compositeKey = key + `|` + valueId
      consolidated.set(
        compositeKey,
        (consolidated.get(compositeKey) || 0) + multiplicity,
      )

      // Store the original data for the first occurrence
      if (!values.has(compositeKey)) {
        values.set(compositeKey, data as T)
      }
    }