[Cosmos] cross partition continuation token

sdk/cosmosdb/cosmos/src/client/Item/Items.ts

@@ -147,6 +147,10 @@ export class Items {
    */
   public query<T>(query: string | SqlQuerySpec, options?: FeedOptions): QueryIterator<T>;
   public query<T>(query: string | SqlQuerySpec, options: FeedOptions = {}): QueryIterator<T> {
+    console.log("==========================================");
+    console.log("ITEMS.query() method called");
+    console.log("enableEncryption:", this.clientContext.enableEncryption);
+    console.log("==========================================");
     const path = getPathFromLink(this.container.url, ResourceType.item);
     const id = getIdFromLink(this.container.url);
 

sdk/cosmosdb/cosmos/src/documents/ContinuationToken/CompositeQueryContinuationToken.ts

@@ -0,0 +1,133 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { QueryRange } from "../../routing/QueryRange.js";
+import type { QueryRangeMapping } from "../../queryExecutionContext/QueryRangeMapping.js";
+
+/**
+ * @hidden
+ * Composite continuation token for parallel query execution across multiple partition ranges
+ */
+export interface CompositeQueryContinuationToken {
+  /**
+   * Resource ID of the container for which the continuation token is issued
+   */
+  rid: string;
+
+  /**
+   * List of query ranges with their continuation tokens
+   */
+  rangeMappings: QueryRangeWithContinuationToken[];
+
+  /**
+   * Current offset value for OFFSET/LIMIT queries
+   */
+  offset?: number;
+
+  /**
+   * Current limit value for OFFSET/LIMIT queries
+   */
+  limit?: number;
+}
+
+/**
+ * Creates a new CompositeQueryContinuationToken
+ * @hidden
+ */
+export function createCompositeQueryContinuationToken(
+  rid: string, 
+  rangeMappings: QueryRangeWithContinuationToken[], 
+  offset?: number,
+  limit?: number
+): CompositeQueryContinuationToken {
+  // const queryRanges = convertRangeMappingsToQueryRangesWithTokens(rangeMappings);
+
+  return {
+    rid,
+    rangeMappings: rangeMappings,
+    offset,
+    limit,
+  };
+}/**
+ * Adds a range mapping to the continuation token by converting it to QueryRange
+ * @hidden
+ */
+export function addRangeMappingToCompositeToken(token: CompositeQueryContinuationToken, rangeMapping: QueryRangeMapping): void {
+  // Convert the QueryRangeMapping to QueryRange before adding
+  const queryRange = convertRangeMappingToQueryRange(rangeMapping);
+  token.rangeMappings.push(queryRange);
+}
+
+/**
+ * Serializes the composite continuation token to a JSON string
+ * @hidden
+ */
+export function serializeCompositeToken(token: CompositeQueryContinuationToken): string {
+  return JSON.stringify(token);
+}
+
+/**
+ * Deserializes a JSON string to a CompositeQueryContinuationToken
+ * @hidden
+ */
+export function parseCompositeQueryContinuationToken(tokenString: string): CompositeQueryContinuationToken {
+  return JSON.parse(tokenString);
+}
+
+
+
+/**
+ * @hidden
+ * Represents a query range with its associated continuation token
+ */
+export interface QueryRangeWithContinuationToken {
+  /**
+   * The query range containing min/max boundaries (with EPK preference)
+   */
+  queryRange: QueryRange;
+
+  /**
+   * The continuation token for this specific range
+   */
+  continuationToken: string | null;
+}
+
+/**
+ * Converts QueryRangeMapping to QueryRangeWithContinuationToken, giving preference to EPK boundaries if present
+ * @param rangeMapping - The QueryRangeMapping to convert
+ * @returns QueryRangeWithContinuationToken with appropriate boundaries and continuation token
+ * @hidden
+ */
+export function convertRangeMappingToQueryRange(rangeMapping: QueryRangeMapping): QueryRangeWithContinuationToken {
+  if (!rangeMapping.partitionKeyRange) {
+    throw new Error("QueryRangeMapping must have a partitionKeyRange");
+  }
+
+  const pkRange = rangeMapping.partitionKeyRange;
+
+  // Prefer EPK boundaries if they exist, otherwise use logical boundaries
+  const minInclusive = pkRange.epkMin || pkRange.minInclusive;
+  const maxExclusive = pkRange.epkMax || pkRange.maxExclusive;
+
+  const queryRange = new QueryRange(
+    minInclusive,
+    maxExclusive,
+    true,  // minInclusive is always true for our use case
+    false  // maxInclusive is always false for our use case (maxExclusive)
+  );
+
+  return {
+    queryRange,
+    continuationToken: rangeMapping.continuationToken,
+  };
+}
+
+/**
+ * Converts an array of QueryRangeMapping to an array of QueryRangeWithContinuationToken
+ * @param rangeMappings - Array of QueryRangeMapping to convert
+ * @returns Array of QueryRangeWithContinuationToken with appropriate boundaries and continuation tokens
+ * @hidden
+ */
+export function convertRangeMappingsToQueryRangesWithTokens(rangeMappings: QueryRangeMapping[]): QueryRangeWithContinuationToken[] {
+  return rangeMappings.map(mapping => convertRangeMappingToQueryRange(mapping));
+}

sdk/cosmosdb/cosmos/src/documents/ContinuationToken/OrderByQueryContinuationToken.ts

@@ -0,0 +1,97 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import type { QueryRangeWithContinuationToken } from "./CompositeQueryContinuationToken.js";
+import type { QueryRangeMapping } from "../../queryExecutionContext/QueryRangeMapping.js";
+
+/**
+ * Continuation token for order by queries.
+ * @internal
+ */
+export interface OrderByQueryContinuationToken {
+  /**
+   * List of query ranges with their continuation tokens
+   */
+  rangeMappings: QueryRangeWithContinuationToken[];
+
+  /**
+   * Order by items for the query
+   */
+  orderByItems: any[];
+
+  /**
+   * Resource ID of the container for which the continuation token is issued
+   */
+  rid: string;
+
+  /**
+   * Number of items to skip in the query
+   */
+  skipCount: number;
+
+  /**
+   * Current offset value for OFFSET/LIMIT queries
+   */
+  offset?: number;
+
+  /**
+   * Current limit value for OFFSET/LIMIT queries
+   */
+  limit?: number;
+
+  /**
+   * Hash of the last document result for distinct order queries
+   * Used to ensure duplicates are not returned across continuation boundaries
+   */
+  hashedLastResult?: string;
+}
+
+/**
+ * Creates an OrderByQueryContinuationToken
+ * @internal
+ */
+export function createOrderByQueryContinuationToken(
+  rangeMappings: QueryRangeWithContinuationToken[],
+  orderByItems: any[],
+  rid: string,
+  skipCount: number,
+  offset?: number,
+  limit?: number,
+  hashedLastResult?: string
+): OrderByQueryContinuationToken {
+  return {
+    rangeMappings,
+    orderByItems,
+    rid,
+    skipCount,
+    offset,
+    limit,
+    hashedLastResult,
+  };
+}
+
+/**
+ * Serializes an OrderByQueryContinuationToken to a JSON string
+ * @internal
+ */
+export function serializeOrderByQueryContinuationToken(token: OrderByQueryContinuationToken): string {
+  return JSON.stringify(token);
+}
+
+/**
+ * Deserializes a JSON string to an OrderByQueryContinuationToken
+ * @internal
+ */
+export function parseOrderByQueryContinuationToken(tokenString: string): OrderByQueryContinuationToken {
+  return JSON.parse(tokenString);
+}
+
+/**
+ * Gets all range mappings from the OrderBy continuation token
+ * @param token - The OrderBy continuation token
+ * @returns Array of QueryRangeWithContinuationToken
+ * @internal
+ */
+export function getRangeMappingsFromOrderByToken(token: OrderByQueryContinuationToken): QueryRangeWithContinuationToken[] {
+  return token.rangeMappings || [];
+}

sdk/cosmosdb/cosmos/src/documents/ContinuationToken/PartitionRangeUpdate.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import type { QueryRange } from "../../index.js";
+
+/**
+ * Represents information about a partition range update that occurred during query execution.
+ * This includes the original range, new ranges after split/merge, and the continuation token.
+ * @hidden
+ */
+export interface PartitionRangeUpdate {
+  /** The original partition key range before the split/merge operation */
+  oldRange: QueryRange;
+  /** The new partition key ranges after the split/merge operation */
+  newRanges: QueryRange[];
+  /** The continuation token associated with this range update */
+  continuationToken: string;
+}
+
+/**
+ * A collection of partition range updates indexed by range keys.
+ * The key is typically in the format "minInclusive-maxExclusive".
+ * @hidden
+ */
+export type PartitionRangeUpdates = Record<string, PartitionRangeUpdate>;