Add validate (dry-run) mode to JDBC connection string

Introduce `mode=validate`, a dry-run flavor alongside `mode=apply`. Every
DDL statement (CREATE, DROP, FIRE/PAUSE/RESUME) is fully parsed, planned,
and validated — including deployer-level validation — but no real object
is created, updated, or deleted.

A dry-run still evolves the in-memory Calcite schema so a series of
statements validates against each other: e.g. a dry-run DROP VIEW followed
by a query against that view fails validation, even though no real View was
deleted. To make this explicit, DdlMode's old `mutable()` is split into two
axes: `executeDeployers` (the real side effect) and `persistsSchema`
(whether in-memory changes are kept). VALIDATE persists schema but deploys
nothing; SPECIFY (the `!specify` renderer) restores. With respect to
OR REPLACE, validate is apply-like and never errors on an existing object.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: ryannedolan

docs/user-guide/ddl-reference.md

@@ -50,6 +50,34 @@ remains imperative and explicit. Detection of *incompatible* metadata changes
 `CREATE` and `CREATE OR REPLACE` apply the new definition regardless. Use
 caution when changing schemas of in-flight pipelines.
 
+## Dry-run: validate mode
+
+`mode=validate` is a dry-run. Every statement — `CREATE`, `DROP`, and the
+trigger verbs (`FIRE`/`PAUSE`/`RESUME`) — is fully parsed, planned, and
+validated (including deployer-level validation), but **no real object is ever
+created, updated, or deleted.** A statement that would succeed reports
+`(0 rows modified)`; a statement that would fail validation raises the same
+error a real run would. Use it to check a script against a live environment
+without touching anything:
+
+```
+jdbc:hoptimator://...;mode=validate
+```
+
+With respect to `OR REPLACE`, `validate` behaves like `apply`: an
+already-existing resource is treated as an in-place update, so a plain
+`CREATE` over an existing object validates cleanly instead of erroring.
+
+Crucially, a dry-run still evolves the **in-memory** schema as it goes, so a
+series of statements is validated against each other: a dry-run `DROP VIEW`
+followed by a query against that view fails validation, even though no real
+`View` object was deleted. Only the deployment is skipped, never the
+in-memory bookkeeping. (This is what distinguishes `validate` from the
+one-shot `!specify` preview, which renders a single statement's YAML and then
+restores the schema.) `validate`, `apply`, and `create` are mutually
+exclusive; pick one per connection.
+
+
 ## CREATE VIEW
 
 ```

hoptimator-jdbc/src/main/java/com/linkedin/hoptimator/jdbc/HoptimatorDdlExecutor.java

@@ -130,7 +130,11 @@ public void execute(SqlCreateView create, CalcitePrepare.Context context) {
           throw new DdlException(create,
               "View " + pair.right + " already exists. Use CREATE OR REPLACE to update.");
         }
-        pair.left.removeFunction(pair.right);
+        // Apply the in-memory schema change whenever the mode persists it (CREATE/UPDATE deploy
+        // for real; VALIDATE keeps it in-memory only). SPECIFY render is not reached here.
+        if (mode.persistsSchema()) {
+          pair.left.removeFunction(pair.right);
+        }
       }
     }
 
@@ -152,14 +156,20 @@ public void execute(SqlCreateView create, CalcitePrepare.Context context) {
       deployers = DeploymentService.deployers(view, connection);
       ValidationService.validateOrThrow(deployers, connection);
       logger.info("Validated view {}", viewName);
+      // CREATE→create, UPDATE→update, VALIDATE (dry-run)→deploy nothing. In every case the
+      // in-memory view is registered (VALIDATE persists it without deploying), so a later
+      // statement in the same script sees it.
       if (mode == HoptimatorDdlUtils.DdlMode.UPDATE) {
         logger.info("Deploying update view {}", viewName);
-        DeploymentService.update(deployers);
-      } else {
+      } else if (mode == HoptimatorDdlUtils.DdlMode.CREATE) {
         logger.info("Deploying create view {}", viewName);
-        DeploymentService.create(deployers);
+      } else {
+        logger.info("Validating (dry-run) view {}; skipping deployment", viewName);
+      }
+      mode.executeDeployers(deployers, connection);
+      if (mode != HoptimatorDdlUtils.DdlMode.VALIDATE) {
+        logger.info("Deployed view {}", viewName);
       }
-      logger.info("Deployed view {}", viewName);
       schemaPlus.add(viewName, viewTable);
       logger.info("Added view {} to schema {}", viewName, schemaPlus.getName());
     } catch (SQLException | RuntimeException e) {
@@ -243,12 +253,17 @@ public void execute(SqlCreateTrigger create, CalcitePrepare.Context context) {
       HoptimatorDdlUtils.DdlMode mode = HoptimatorDdlUtils.effectiveMode(create.getReplace(), connection);
       if (mode == HoptimatorDdlUtils.DdlMode.UPDATE) {
         logger.info("Updating trigger {}", name);
-        DeploymentService.update(deployers);
-      } else {
+      } else if (mode == HoptimatorDdlUtils.DdlMode.CREATE) {
         logger.info("Creating trigger {}", name);
-        DeploymentService.create(deployers);
+      } else {
+        logger.info("Validating (dry-run) trigger {}; skipping deployment", name);
+      }
+      // CREATE→create, UPDATE→update, VALIDATE (dry-run)→no-op. Triggers are not part of the
+      // Calcite schema, so there is no in-memory state to persist.
+      mode.executeDeployers(deployers, connection);
+      if (mode != HoptimatorDdlUtils.DdlMode.VALIDATE) {
+        logger.info("Deployed trigger {}", name);
       }
-      logger.info("Deployed trigger {}", name);
       logger.info("CREATE TRIGGER {} completed", name);
     } catch (Exception e) {
       if (deployers != null) {
@@ -336,7 +351,11 @@ public void execute(SqlFireTrigger fire, CalcitePrepare.Context context) {
     try {
       logger.info("Firing trigger {} with {} option(s)", name, options.size() - 1);
       deployers = DeploymentService.deployers(trigger, connection);
-      DeploymentService.update(deployers);
+      if (HoptimatorDdlUtils.isValidateMode(connection)) {
+        logger.info("Validated FIRE TRIGGER (dry-run) {}; skipping deployment", name);
+      } else {
+        DeploymentService.update(deployers);
+      }
       logger.info("FIRE TRIGGER {} completed", name);
     } catch (Exception e) {
       if (deployers != null) {
@@ -366,8 +385,12 @@ public void execute(SqlDropTrigger drop, CalcitePrepare.Context context) {
     try {
       logger.info("Deleting trigger {}", name);
       deployers = DeploymentService.deployers(trigger, connection);
-      DeploymentService.delete(deployers);
-      logger.info("Deleted trigger {}", name);
+      if (HoptimatorDdlUtils.isValidateMode(connection)) {
+        logger.info("Validated DROP TRIGGER (dry-run) {}; skipping deletion", name);
+      } else {
+        DeploymentService.delete(deployers);
+        logger.info("Deleted trigger {}", name);
+      }
       logger.info("DROP TRIGGER {} completed", name);
     } catch (Exception e) {
       if (deployers != null) {
@@ -403,7 +426,11 @@ private void updateTriggerPausedState(SqlNode sqlNode, SqlIdentifier triggerName
     try {
       logger.info("Updating trigger {} with paused state: {}", name, paused);
       deployers = DeploymentService.deployers(trigger, connection);
-      DeploymentService.update(deployers);
+      if (HoptimatorDdlUtils.isValidateMode(connection)) {
+        logger.info("Validated paused-state update (dry-run) for trigger {}; skipping deployment", name);
+      } else {
+        DeploymentService.update(deployers);
+      }
       logger.info("Successfully updated trigger {} with paused state: {}", name, paused);
     } catch (Exception e) {
       if (deployers != null) {
@@ -450,6 +477,7 @@ public void execute(SqlDropObject drop, CalcitePrepare.Context context) {
     tablePath.add(tableName);
 
     Collection<Deployer> deployers = null;
+    final boolean dryRun = HoptimatorDdlUtils.isValidateMode(connection);
     try {
       if (table instanceof MaterializedViewTable) {
         if (!(drop instanceof SqlDropMaterializedView)) {
@@ -459,8 +487,14 @@ public void execute(SqlDropObject drop, CalcitePrepare.Context context) {
         MaterializedViewTable materializedViewTable = (MaterializedViewTable) table;
         View view = new View(tablePath, materializedViewTable.viewSql());
         deployers = DeploymentService.deployers(view, connection);
-        logger.info("Deleting materialized view {}", tableName);
-        DeploymentService.delete(deployers);
+        if (dryRun) {
+          logger.info("Validated DROP (dry-run) for materialized view {}; skipping deletion", tableName);
+        } else {
+          logger.info("Deleting materialized view {}", tableName);
+          DeploymentService.delete(deployers);
+        }
+        // Always evolve the in-memory schema — even in a dry-run, dropping the view must make a
+        // subsequent reference to it fail validation, regardless of whether a real object existed.
         schemaPlus.removeTable(tableName);
         logger.info("Removed materialized table {} from schema {}", tableName, schemaPlus.getName());
       } else if (table instanceof ViewTable) {
@@ -471,8 +505,12 @@ public void execute(SqlDropObject drop, CalcitePrepare.Context context) {
         ViewTable viewTable = (ViewTable) table;
         View view = new View(tablePath, viewTable.getViewSql());
         deployers = DeploymentService.deployers(view, connection);
-        logger.info("Deleting view {}", tableName);
-        DeploymentService.delete(deployers);
+        if (dryRun) {
+          logger.info("Validated DROP (dry-run) for view {}; skipping deletion", tableName);
+        } else {
+          logger.info("Deleting view {}", tableName);
+          DeploymentService.delete(deployers);
+        }
         schemaPlus.removeTable(tableName);
         logger.info("Removed view {} from schema {}", tableName, schemaPlus.getName());
       } else if (table instanceof HoptimatorJdbcTable || table instanceof TemporaryTable) {
@@ -491,11 +529,15 @@ public void execute(SqlDropObject drop, CalcitePrepare.Context context) {
         }
         // Pre-delete dependency guard. PendingDelete is the explicit "delete intent" signal
         // — only validators that key off it (the K8s dep checker) fire here. The check throws
-        // before any deployer-level state change.
+        // before any deployer-level state change. This validation runs in dry-run too.
         ValidationService.validateOrThrow(new PendingDelete<>(source), connection);
         deployers = DeploymentService.deployers(source, connection);
-        logger.info("Deleting table {}", tableName);
-        DeploymentService.delete(deployers);
+        if (dryRun) {
+          logger.info("Validated DROP (dry-run) for table {}; skipping deletion", tableName);
+        } else {
+          logger.info("Deleting table {}", tableName);
+          DeploymentService.delete(deployers);
+        }
         schemaPlus.removeTable(tableName);
         logger.info("Removed table {} from schema {}", tableName, schemaPlus.getName());
       } else {