@@ -0,0 +1,158 @@
+/*
+ * Copyright (2026) The Delta Lake Project Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.delta.cic
+
+/**
+ * Driver-side trait for the UC Identity Sequence Service: the backend that hands
+ * out non-overlapping ranges of identity values for Concurrent Identity Columns (CIC).
+ *
+ * Three operations are exposed:
+ *   - `createSequence`: registers a sequence under a caller-generated `sequenceId`.
+ *     The driver generates a unique sequenceId up front and stamps it into the column metadata
+ *     before the DDL commit. Used by `CREATE TABLE` with the CIC feature and by the
+ *     feature opt-in `ALTER TABLE ... SET TBLPROPERTIES`. Semantics are CreateOrGet:
+ *     a repeat call with matching `start`/`step` succeeds; a mismatch is an error.
+ *   - `reserveIds`: reserve a contiguous range of identity values for an
+ *     in-flight write. Returns the sequenceId, `[rangeStart, rangeEnd]` (inclusive)
+ *     and an echo of the immutable `step`. Callers verify the step matches the
+ *     schema-declared step to detect drifted state.
+ *   - `dropSequence`: retires a sequence the table no longer references (DROP FEATURE
+ *     downgrade, REPLACE re-stamp). Idempotent.
+ *
+ * Driver-only. Do not capture an instance in any closure that ships to executors.
+ */
+trait IdentitySequenceService {
+  /**
+   * Registers the sequence identified by the caller-supplied `req.sequenceId`.
+   * CreateOrGet: a create for an already-existing `sequenceId` succeeds when the
+   * stored `start`/`step` match the request and is an error otherwise. `step`
+   * must be non-zero; implementations reject a zero step.
+   *
+   * Returns nothing: callers already hold the requested `start`/`step` and stamp
+   * them into the schema metadata directly. Consistency is enforced by the
+   * service (an error on a mismatching recreate), not by inspecting a response.
+   */
+  def createSequence(req: CreateSequenceRequest): Unit
+
+  /**
+   * Reserves a contiguous `[rangeStart, rangeEnd]` (inclusive) range of `count`
+   * values from an existing sequence. `count` must be positive and reserving from
+   * an unknown `sequenceId` is an error. Implementations must never hand out a
+   * range that overlaps a previously reserved one, including when the underlying
+   * counter would overflow.
+   *
+   * The range follows the sign of `step` (descending when `step` is negative), so
+   * consumers must materialize values as `rangeStart + i * step` for `i` in
+   * `[0, count)`, not by iterating `rangeStart to rangeEnd`.
+   */
+  def reserveIds(req: ReserveIdsRequest): ReserveIdsResponse
+
+  /**
+   * Drops (retires) the sequence registered under `(req.tableId, req.sequenceId)`. Idempotent:
+   * dropping an unknown or already-retired sequence is a no-op. Reclaims a sequence a table no
+   * longer references (DROP FEATURE downgrade, REPLACE re-stamp) so the service-side counter does
+   * not leak. A dropped `(tableId, sequenceId)` must never be reused for live data; a re-converted
+   * or replaced table always mints a fresh id, so the monotonic counter can never collide.
+   */
+  def dropSequence(req: DropSequenceRequest): Unit
+}
+
+/**
+ * Thrown by an [[IdentitySequenceService]] backend when the service is administratively disabled.
+ */
+class IdentitySequenceServiceDisabledException(message: String, cause: Throwable = null)
+  extends RuntimeException(message, cause)
+
+/**
+ * Request to register an identity sequence.
+ *
+ * `sequenceId` is generated by the driver up front, stamped into the column metadata under
+ * `delta.identity.concurrent.sequenceId`, and passed here; the service does not mint it. The
+ * sequence is keyed by `(tableId, sequenceId)`.
+ *
+ * `tableId` is the table scope the sequence lives under. For a catalog-owned (UC
+ * coordinated-commits) table this is the UC table id (resolved via
+ * `ConcurrentIdentityColumnSchema.sequenceServiceTableId`: the
+ * `io.unitycatalog.tableId` table property). Because sequences are keyed by
+ * `tableId`, commands that replace the table in place (e.g. `CREATE OR REPLACE
+ * TABLE`) generate a new `tableId` and leave the old sequences orphaned -- the
+ * replacement table starts fresh, which is the right semantics. For testing
+ * only, the Delta table's own `metadata.id` can be used instead.
+ *
+ * `columnInformation` is audit/debugging-only; the caller passes the physical column name.
+ *
+ * @param sequenceId driver-generated unique id identifying the sequence
+ * @param tableId table scope (UC table id for catalog-owned tables, else the table's `metadata.id`)
+ * @param start start of sequence
+ * @param step step of sequence; must be non-zero
+ * @param columnInformation audit/debugging-only; the physical column name
+ */
+case class CreateSequenceRequest(
+    sequenceId: String,
+    tableId: String,
+    start: Long,
+    step: Long,
+    columnInformation: Option[String] = None)
+
+/**
+ * Request to reserve a contiguous range of IDs from an existing sequence.
+ *
+ * `(tableId, sequenceId)` names the counter, mirroring the UC wire contract: the
+ * backend keys sequences per table scope (a CLONE replicates a sequence id into the
+ * clone's table scope as an independent counter) and authorizes MODIFY on the table.
+ * `tableId` must be the same value the sequence was created under.
+ *
+ * `step` is the schema-declared step the caller expects. It travels on the UC reserve wire
+ * so the backend can sanity-check the granted range against it (the backend stays the owner
+ * of the step); the UC-backed implementation also verifies the range invariant
+ * `rangeEnd - rangeStart == step * (count - 1)` on the granted range and fills
+ * [[ReserveIdsResponse.step]]. The local stub validates it against the stored step, so a
+ * caller whose schema drifted from the registration fails loudly.
+ *
+ * @param sequenceId the caller-generated id the sequence was created under
+ * @param tableId table scope the sequence was created under (see
+ *                [[CreateSequenceRequest.tableId]])
+ * @param count number of identity values to reserve; must be positive
+ * @param step the schema-declared step of the identity column
+ */
+case class ReserveIdsRequest(sequenceId: String, tableId: String, count: Long, step: Long)
+
+/**
+ * Response from a reserve-ids request.
+ *
+ * Callers MUST verify `step` matches the step persisted in the schema metadata.
+ * A mismatch signals corrupted or drifted state (step is immutable at the
+ * service) and is a hard error.
+ *
+ * @param sequenceId echo of the request
+ * @param rangeStart first value in the reserved range (inclusive)
+ * @param rangeEnd last value in the reserved range (inclusive); for a negative
+ *                 `step` this is less than `rangeStart` (descending range)
+ * @param step echo of the immutable step
+ */
+case class ReserveIdsResponse(
+    sequenceId: String,
+    rangeStart: Long,
+    rangeEnd: Long,
+    step: Long)
+
+/**
+ * Request to drop (retire) an identity sequence. `(tableId, sequenceId)` names the counter, the
+ * same scope it was created and reserved under (see [[CreateSequenceRequest.tableId]]). Idempotent
+ * at the service: dropping an unknown or already-retired id is a no-op.
+ */
+case class DropSequenceRequest(sequenceId: String, tableId: String)
@@ -0,0 +1,47 @@
+/*
+ * Copyright (2026) The Delta Lake Project Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.delta.cic
+
+import org.apache.spark.sql.delta.sources.DeltaSQLConf
+import org.apache.spark.sql.delta.cic.IdentitySequenceService
+
+import org.apache.spark.sql.SparkSession
+import org.apache.spark.util.Utils
+
+/**
+ * Resolves the [[IdentitySequenceService]] backend for a session. When
+ * [[DeltaSQLConf.CONCURRENT_IDENTITY_COLUMN_SERVICE_CLASS_NAME]] is set, reflectively instantiates
+ * that class (no-arg constructor); whether a table uses a sequence service at all stays
+ * table-state-driven (the stamped sequence pointer).
+ *
+ * Otherwise there is no built-in backend, so it fails with a clear error directing the caller to
+ * configure a backend via the class-name config.
+ */
+object IdentitySequenceServices {
+  def resolve(spark: SparkSession): IdentitySequenceService = {
+    spark.conf.get(DeltaSQLConf.CONCURRENT_IDENTITY_COLUMN_SERVICE_CLASS_NAME) match {
+      case Some(className) if className.nonEmpty =>
+        Utils.classForName(className).getDeclaredConstructor().newInstance()
+          .asInstanceOf[IdentitySequenceService]
+      case _ =>
+        throw new UnsupportedOperationException(
+          "No concurrent identity-sequence backend is configured. Set " +
+            "spark.databricks.delta.identityColumn.concurrent.serviceClassName to an " +
+            "IdentitySequenceService implementation.")
+    }
+  }
+}
@@ -3618,6 +3618,15 @@ trait DeltaSQLConfBase extends DeltaSQLConfUtils {
       .checkValue(_ > 0, "maxColumnsPerTable must be positive")
       .createWithDefault(50)
 
+  val CONCURRENT_IDENTITY_COLUMN_SERVICE_CLASS_NAME =
+    buildConf("identityColumn.concurrent.serviceClassName")
+      .internal()
+      .doc("Optional override naming an IdentitySequenceService implementation (with a no-arg " +
+        "constructor) that IdentitySequenceServices.resolve instantiates reflectively instead of " +
+        "the default backend. Unit suites point it at the LocalIdentitySequenceService fake.")
+      .stringConf
+      .createOptional
+
   //////////////////
   // GeoSpatial
   //////////////////