diff --git a/Cargo.lock b/Cargo.lock
index d3c2156c043..d00b4b1eac3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1906,7 +1906,7 @@ dependencies = [
  "bitflags 2.10.0",
  "cexpr",
  "clang-sys",
- "itertools 0.11.0",
+ "itertools 0.13.0",
  "proc-macro2",
  "quote",
  "regex",
@@ -1924,7 +1924,7 @@ dependencies = [
  "bitflags 2.10.0",
  "cexpr",
  "clang-sys",
- "itertools 0.11.0",
+ "itertools 0.13.0",
  "proc-macro2",
  "quote",
  "regex",
@@ -1942,7 +1942,7 @@ dependencies = [
  "bitflags 2.10.0",
  "cexpr",
  "clang-sys",
- "itertools 0.11.0",
+ "itertools 0.13.0",
  "log",
  "prettyplease",
  "proc-macro2",
@@ -3678,6 +3678,18 @@ dependencies = [
  "datafusion-physical-expr-common",
 ]
 
+[[package]]
+name = "datafusion-functions-json"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13ff70cb2c1960f03ba647aa2813fb1efba4c33bc221d973dd4a462a6376359a"
+dependencies = [
+ "datafusion",
+ "jiter",
+ "log",
+ "paste",
+]
+
 [[package]]
 name = "datafusion-functions-nested"
 version = "53.1.0"
@@ -3976,7 +3988,7 @@ dependencies = [
 
 [[package]]
 name = "dbsp"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "anyhow",
  "arc-swap",
@@ -4066,7 +4078,7 @@ dependencies = [
 
 [[package]]
 name = "dbsp_adapters"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "actix",
  "actix-codec",
@@ -4210,7 +4222,7 @@ dependencies = [
 
 [[package]]
 name = "dbsp_nexmark"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "anyhow",
  "ascii_table",
@@ -5194,7 +5206,7 @@ dependencies = [
 
 [[package]]
 name = "fda"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "anyhow",
  "arrow",
@@ -5246,7 +5258,7 @@ dependencies = [
 
 [[package]]
 name = "feldera-adapterlib"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "actix-web",
  "anyhow",
@@ -5256,6 +5268,7 @@ dependencies = [
  "bytemuck",
  "chrono",
  "datafusion",
+ "datafusion-functions-json",
  "dbsp",
  "dyn-clone",
  "erased-serde 0.3.31",
@@ -5280,7 +5293,7 @@ dependencies = [
 
 [[package]]
 name = "feldera-buffer-cache"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "crossbeam-utils",
  "enum-map",
@@ -5308,7 +5321,7 @@ dependencies = [
 
 [[package]]
 name = "feldera-datagen"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "anyhow",
  "async-channel 2.5.0",
@@ -5334,7 +5347,7 @@ dependencies = [
 
 [[package]]
 name = "feldera-fxp"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "bytecheck",
  "dbsp",
@@ -5354,7 +5367,7 @@ dependencies = [
 
 [[package]]
 name = "feldera-iceberg"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "anyhow",
  "chrono",
@@ -5377,7 +5390,7 @@ dependencies = [
 
 [[package]]
 name = "feldera-ir"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "proptest",
  "proptest-derive",
@@ -5389,7 +5402,7 @@ dependencies = [
 
 [[package]]
 name = "feldera-macros"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "prettyplease",
  "proc-macro2",
@@ -5399,7 +5412,7 @@ dependencies = [
 
 [[package]]
 name = "feldera-observability"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "actix-http",
  "awc",
@@ -5414,7 +5427,7 @@ dependencies = [
 
 [[package]]
 name = "feldera-rest-api"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "chrono",
  "feldera-observability",
@@ -5433,7 +5446,7 @@ dependencies = [
 
 [[package]]
 name = "feldera-samply"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "crossbeam",
  "feldera-size-of",
@@ -5469,7 +5482,7 @@ dependencies = [
 
 [[package]]
 name = "feldera-sqllib"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "arcstr",
  "base58",
@@ -5513,7 +5526,7 @@ dependencies = [
 
 [[package]]
 name = "feldera-storage"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "anyhow",
  "crossbeam",
@@ -5536,7 +5549,7 @@ dependencies = [
 
 [[package]]
 name = "feldera-types"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "actix-web",
  "anyhow",
@@ -6567,7 +6580,7 @@ dependencies = [
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.57.0",
+ "windows-core 0.61.2",
 ]
 
 [[package]]
@@ -7084,6 +7097,21 @@ dependencies = [
  "jiff-tzdb",
 ]
 
+[[package]]
+name = "jiter"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "020ba671987d7444d251d3ee5340be1bf4606cd6c0b53e6f4066b5a1ee376b22"
+dependencies = [
+ "ahash 0.8.12",
+ "bitvec",
+ "lexical-parse-float",
+ "num-bigint",
+ "num-traits",
+ "pyo3",
+ "smallvec",
+]
+
 [[package]]
 name = "jni"
 version = "0.22.4"
@@ -7512,9 +7540,8 @@ dependencies = [
 
 [[package]]
 name = "marrow"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5240d6977234968ff9ad254bfa73aa397fb51e41dcb22b1eb85835e9295485b"
+version = "0.2.7"
+source = "git+https://github.com/ryzhyk/serde_arrow.git?rev=9555b34fb85d4323e4381ad5a09872c1696a0d34#9555b34fb85d4323e4381ad5a09872c1696a0d34"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -8813,7 +8840,7 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "pipeline-manager"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "actix-cors",
  "actix-files",
@@ -9590,7 +9617,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
 dependencies = [
  "anyhow",
- "itertools 0.11.0",
+ "itertools 0.14.0",
  "proc-macro2",
  "quote",
  "syn 2.0.117",
@@ -9603,7 +9630,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "27c6023962132f4b30eb4c172c91ce92d933da334c59c23cddee82358ddafb0b"
 dependencies = [
  "anyhow",
- "itertools 0.11.0",
+ "itertools 0.14.0",
  "proc-macro2",
  "quote",
  "syn 2.0.117",
@@ -9667,6 +9694,66 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "pyo3"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91fd8e38a3b50ed1167fb981cd6fd60147e091784c427b8f7183a7ee32c31c12"
+dependencies = [
+ "libc",
+ "num-bigint",
+ "num-traits",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e368e7ddfdeb98c9bca7f8383be1648fd84ab466bf2bc015e94008db6d35611e"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f29e10af80b1f7ccaf7f69eace800a03ecd13e883acfacc1e5d0988605f651e"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df6e520eff47c45997d2fc7dd8214b25dd1310918bbb2642156ef66a67f29813"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4cdc218d835738f81c2338f822078af45b4afdf8b2e33cbb5916f108b813acb"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn 2.0.117",
+]
+
 [[package]]
 name = "quad-rand"
 version = "0.2.3"
@@ -10023,7 +10110,7 @@ dependencies = [
 
 [[package]]
 name = "readers"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "async-std",
  "csv",
@@ -11304,9 +11391,8 @@ dependencies = [
 
 [[package]]
 name = "serde_arrow"
-version = "0.14.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26e4ac1bef72720318e2c67bd19b972d17084840f3188a585021828122c43c2c"
+version = "0.14.2"
+source = "git+https://github.com/ryzhyk/serde_arrow.git?rev=9555b34fb85d4323e4381ad5a09872c1696a0d34#9555b34fb85d4323e4381ad5a09872c1696a0d34"
 dependencies = [
  "arrow-array",
  "arrow-schema",
@@ -11722,7 +11808,7 @@ checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
 
 [[package]]
 name = "sltsqlvalue"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "dbsp",
  "feldera-sqllib",
@@ -12193,7 +12279,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "storage-test-compat"
-version = "0.322.0"
+version = "0.323.0"
 dependencies = [
  "dbsp",
  "derive_more 1.0.0",
@@ -12451,6 +12537,12 @@ dependencies = [
  "xattr",
 ]
 
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
 [[package]]
 name = "target-triple"
 version = "0.1.4"
diff --git a/Cargo.toml b/Cargo.toml
index 04dfef6851d..30b36a51762 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [workspace.package]
 authors = ["Feldera Team <dev@feldera.com>"]
-version = "0.322.0"
+version = "0.323.0"
 license = "MIT OR Apache-2.0"
 homepage = "https://github.com/feldera/feldera"
 repository = "https://github.com/feldera/feldera"
@@ -108,7 +108,9 @@ csv = "1.2.2"
 csv-core = "0.1.10"
 dashmap = "6.1.0"
 datafusion = "53.1"
-dbsp = { path = "crates/dbsp", version = "0.322.0" }
+dbsp = { path = "crates/dbsp", version = "0.323.0" }
+# JSON functions applied to strings.
+datafusion-functions-json = "0.53.1"
 dbsp_nexmark = { path = "crates/nexmark" }
 deadpool-postgres = "0.14.1"
 # Feldera fork of delta-rs: upstream tag `rust-v0.32.3` + 3 patches, on branch
@@ -136,20 +138,20 @@ erased-serde = "0.3.31"
 fake = "2.10"
 fastbloom = "0.14.0"
 fdlimit = "0.3.0"
-feldera-buffer-cache = { version = "0.322.0", path = "crates/buffer-cache" }
+feldera-buffer-cache = { version = "0.323.0", path = "crates/buffer-cache" }
 feldera-cloud1-client = "0.1.2"
 feldera-datagen = { path = "crates/datagen" }
-feldera-fxp = { version = "0.322.0", path = "crates/fxp", features = ["dbsp"] }
+feldera-fxp = { version = "0.323.0", path = "crates/fxp", features = ["dbsp"] }
 feldera-iceberg = { path = "crates/iceberg" }
-feldera-observability = { version = "0.322.0", path = "crates/feldera-observability" }
-feldera-macros = { version = "0.322.0", path = "crates/feldera-macros" }
-feldera-sqllib = { version = "0.322.0", path = "crates/sqllib" }
-feldera-storage = { version = "0.322.0", path = "crates/storage" }
-feldera-types = { version = "0.322.0", path = "crates/feldera-types" }
-feldera-rest-api = { version = "0.322.0", path = "crates/rest-api" }
-feldera-ir = { version = "0.322.0", path = "crates/ir" }
-feldera-adapterlib = { version = "0.322.0", path = "crates/adapterlib" }
-feldera-samply = { version = "0.322.0", path = "crates/samply" }
+feldera-observability = { version = "0.323.0", path = "crates/feldera-observability" }
+feldera-macros = { version = "0.323.0", path = "crates/feldera-macros" }
+feldera-sqllib = { version = "0.323.0", path = "crates/sqllib" }
+feldera-storage = { version = "0.323.0", path = "crates/storage" }
+feldera-types = { version = "0.323.0", path = "crates/feldera-types" }
+feldera-rest-api = { version = "0.323.0", path = "crates/rest-api" }
+feldera-ir = { version = "0.323.0", path = "crates/ir" }
+feldera-adapterlib = { version = "0.323.0", path = "crates/adapterlib" }
+feldera-samply = { version = "0.323.0", path = "crates/samply" }
 flate2 = "1.1.0"
 form_urlencoded = "1.2.0"
 fs_extra = "1.3.0"
@@ -253,7 +255,15 @@ schema_registry_converter = "4.2.0"
 semver = "1.0.27"
 serde = "1.0.213"
 serde_dynamo = { version = "4.3.0", features = ["aws-sdk-dynamodb+1"] }
-serde_arrow = { version = "0.14.1", features = ["arrow-58"] }
+# serde_arrow fork that recognizes the "+00:00" timezone Iceberg uses for
+# `timestamptz` columns (upstream 0.14.2 accepts only the name "UTC").
+# Remove the git source when https://github.com/chmp/serde_arrow/pull/320
+# is released. `version` keeps the crates that depend on serde_arrow
+# publishable to crates.io; cargo drops the git source when publishing.
+# The git source goes on the dependency rather than in a `[patch]` section
+# because patches do not apply to generated SQL pipeline workspaces, which
+# import this dependency through `crates/adapters`.
+serde_arrow = { version = "0.14.2", git = "https://github.com/ryzhyk/serde_arrow.git", rev = "9555b34fb85d4323e4381ad5a09872c1696a0d34", features = ["arrow-58"] }
 serde_bytes = "0.11.15"
 serde_json = { version = "1.0.132", features = ["arbitrary_precision"] }
 serde_json_path_to_error = "0.1.5"
diff --git a/crates/adapterlib/Cargo.toml b/crates/adapterlib/Cargo.toml
index 8b06684aba8..031a23575c0 100644
--- a/crates/adapterlib/Cargo.toml
+++ b/crates/adapterlib/Cargo.toml
@@ -42,6 +42,7 @@ num-derive = { workspace = true }
 tokio = { workspace = true, features = ["sync"] }
 xxhash-rust = { workspace = true, features = ["xxh3"] }
 datafusion = { workspace = true }
+datafusion-functions-json = { workspace = true }
 thiserror = { workspace = true }
 serde_json_path_to_error = { workspace = true }
 chrono = { workspace = true }
diff --git a/crates/adapterlib/src/utils/datafusion.rs b/crates/adapterlib/src/utils/datafusion.rs
index c828838d8d3..70fb60f14ca 100644
--- a/crates/adapterlib/src/utils/datafusion.rs
+++ b/crates/adapterlib/src/utils/datafusion.rs
@@ -219,11 +219,16 @@ where
         );
     let session_config = customize_config(session_config);
 
-    let state = SessionStateBuilder::new()
+    let mut state = SessionStateBuilder::new()
         .with_config(session_config)
         .with_runtime_env(runtime_env)
         .with_default_features()
         .build();
+    // JSON functions for querying VARIANT columns, which reach DataFusion
+    // as JSON-encoded strings. Note: the crate's `->` and `?` operators do
+    // not parse in the default (generic) SQL dialect; `->>` works.
+    datafusion_functions_json::register_all(&mut state)
+        .expect("registering JSON functions on a fresh session state cannot fail");
     SessionContext::from(state)
 }
 
@@ -364,6 +369,35 @@ pub fn columns_referenced_by_order_by(order_by: &str) -> Result<BTreeSet<String>
     Ok(columns)
 }
 
+/// Takes a column name from an external table schema and returns a quoted
+/// string that can be used in datafusion queries like `select "foo""bar" from my_table`.
+pub fn quote_sql_identifier<S: AsRef<str>>(ident: S) -> String {
+    format!("\"{}\"", ident.as_ref().replace("\"", "\"\""))
+}
+
+/// A set of column names compared case-insensitively. External table schemas
+/// (Delta, Iceberg) carry no case-sensitivity information, so names are stored
+/// and probed in lowercased form.
+///
+/// SQL is case-sensitive for quoted column names, but an external table cannot
+/// hold two columns with the same lowercase form, so collapsing to a single
+/// canonical form is safe here.
+#[derive(Default)]
+pub struct ColumnNameSet {
+    lowercase: BTreeSet<String>,
+}
+
+impl ColumnNameSet {
+    pub fn from_names(names: impl IntoIterator<Item = String>) -> Self {
+        let lowercase = names.into_iter().map(|c| c.to_lowercase()).collect();
+        Self { lowercase }
+    }
+
+    pub fn contains(&self, name: &str) -> bool {
+        self.lowercase.contains(&name.to_lowercase())
+    }
+}
+
 /// Convert a value of the timestamp column returned by a SQL query into a valid
 /// SQL expression.
 pub fn timestamp_to_sql_expression(column_type: &ColumnType, expr: &str) -> String {
@@ -704,6 +738,40 @@ mod tests {
         assert_eq!(ctx.copied_config().target_partitions(), 99);
     }
 
+    /// Every context built here must provide the JSON function family.
+    #[test]
+    fn create_session_context_registers_json_functions() {
+        let storage = TempStorage::new("feldera-datafusion-create-session-context-json-test");
+        let cfg = pipeline_config(
+            RuntimeConfig {
+                workers: 1,
+                ..Default::default()
+            },
+            Some(storage.path()),
+        );
+        let env = create_runtime_env(&cfg).unwrap();
+        let ctx = create_session_context(&cfg, env);
+        let state = ctx.state();
+        for function in [
+            "json_get",
+            "json_get_str",
+            "json_get_int",
+            "json_get_float",
+            "json_get_bool",
+            "json_get_json",
+            "json_get_array",
+            "json_as_text",
+            "json_contains",
+            "json_length",
+            "json_object_keys",
+        ] {
+            assert!(
+                state.scalar_functions().contains_key(function),
+                "JSON function '{function}' is not registered"
+            );
+        }
+    }
+
     /// Tripwire: `clean_stale_scratch_entries` refuses to walk a directory
     /// whose final component isn't `DATAFUSION_TEMP_DIR`, so a misuse can't
     /// recursively wipe an arbitrary path.
diff --git a/crates/adapters/src/adhoc.rs b/crates/adapters/src/adhoc.rs
index 44ead9b7d1c..893677715da 100644
--- a/crates/adapters/src/adhoc.rs
+++ b/crates/adapters/src/adhoc.rs
@@ -705,6 +705,137 @@ mod tests {
         assert_eq!(total_rows, 1);
     }
 
+    /// Ad-hoc queries can take apart VARIANT columns with the JSON function
+    /// family from `datafusion-functions-json`. VARIANT values reach
+    /// DataFusion as JSON-encoded Utf8 strings; the in-memory table below
+    /// stands in for a materialized table with a VARIANT column.
+    ///
+    /// The state must come from `create_session_context`, which registers
+    /// the functions; the plain `test_state()` used elsewhere in this
+    /// module does not have them.
+    #[tokio::test]
+    async fn json_functions_work_in_adhoc_queries() {
+        use datafusion::arrow::array::{Array, Int64Array, StringArray};
+        use datafusion::arrow::datatypes::{DataType, Field, Schema};
+        use datafusion::datasource::MemTable;
+        use feldera_adapterlib::utils::datafusion::{create_runtime_env, create_session_context};
+        use feldera_types::config::{PipelineConfig, RuntimeConfig};
+
+        // Tripwire: stock DataFusion does not know these functions; they
+        // must come from the registration in `create_session_context`. If
+        // this starts failing, DataFusion gained native JSON functions and
+        // the `datafusion-functions-json` dependency may be redundant.
+        let err = execute_sql_with_state(test_state(), "SELECT json_get_str('{}', 'a')")
+            .await
+            .expect_err("stock DataFusion should not provide json_get_str");
+        assert!(
+            format!("{err}").contains("json_get_str"),
+            "unexpected error: {err}"
+        );
+
+        let config = PipelineConfig {
+            global: RuntimeConfig {
+                workers: 1,
+                ..Default::default()
+            },
+            multihost: None,
+            name: None,
+            given_name: None,
+            storage_config: None,
+            secrets_dir: None,
+            inputs: Default::default(),
+            outputs: Default::default(),
+            program_ir: None,
+        };
+        let runtime_env = create_runtime_env(&config).unwrap();
+        let ctx = create_session_context(&config, runtime_env);
+
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("id", DataType::Int64, false),
+            Field::new("val", DataType::Utf8, true),
+        ]));
+        let batch = RecordBatch::try_new(
+            schema.clone(),
+            vec![
+                Arc::new(Int64Array::from(vec![1, 2, 3])),
+                Arc::new(StringArray::from(vec![
+                    Some(r#"{"name":"Bob","scores":[8,10],"active":true}"#),
+                    Some(r#"{"name":"Ann","scores":[3],"extra":{"x":5}}"#),
+                    None,
+                ])),
+            ],
+        )
+        .unwrap();
+        let mem = MemTable::try_new(schema, vec![vec![batch]]).unwrap();
+        ctx.register_table("t", Arc::new(mem)).unwrap();
+
+        // Typed getters in the projection. A missing key ('scores' has one
+        // element in row 2; indexes are 0-based) and a NULL document both
+        // yield NULL.
+        let batches = collect_rows(
+            ctx.state(),
+            "SELECT json_get_str(val, 'name') AS name, \
+             json_get_int(val, 'scores', 1) AS second_score \
+             FROM t ORDER BY id",
+        )
+        .await;
+        let names = batches[0]
+            .column(0)
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .expect("string column");
+        assert_eq!(names.value(0), "Bob");
+        assert_eq!(names.value(1), "Ann");
+        assert!(names.is_null(2));
+        let scores = batches[0]
+            .column(1)
+            .as_any()
+            .downcast_ref::<Int64Array>()
+            .expect("int64 column");
+        assert_eq!(scores.value(0), 10);
+        assert!(scores.is_null(1));
+        assert!(scores.is_null(2));
+
+        // JSON predicates filter on document contents.
+        for (query, expected_id) in [
+            ("SELECT id FROM t WHERE json_contains(val, 'extra')", 2),
+            (
+                "SELECT id FROM t WHERE json_get_bool(val, 'active') = TRUE",
+                1,
+            ),
+        ] {
+            let batches = collect_rows(ctx.state(), query).await;
+            let ids = batches[0]
+                .column(0)
+                .as_any()
+                .downcast_ref::<Int64Array>()
+                .expect("int64 column");
+            assert_eq!(ids.len(), 1, "query: {query}");
+            assert_eq!(ids.value(0), expected_id, "query: {query}");
+        }
+
+        // The `->>` operator and casting `json_get` to a concrete type.
+        let batches = collect_rows(
+            ctx.state(),
+            "SELECT val->>'name' AS name, \
+             CAST(json_get(val, 'scores', 0) AS BIGINT) AS first_score \
+             FROM t WHERE json_get_str(val, 'name') = 'Bob'",
+        )
+        .await;
+        let names = batches[0]
+            .column(0)
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .expect("string column");
+        assert_eq!(names.value(0), "Bob");
+        let scores = batches[0]
+            .column(1)
+            .as_any()
+            .downcast_ref::<Int64Array>()
+            .expect("int64 column");
+        assert_eq!(scores.value(0), 8);
+    }
+
     /// Selecting from a non-materialized source fails during *physical
     /// planning* — when the scan node is built — not during scan execution.
     /// `execute_adhoc_stream` must surface that as an `Err`, letting the HTTP
diff --git a/crates/adapters/src/integrated/delta_table/input.rs b/crates/adapters/src/integrated/delta_table/input.rs
index 75fe65db27b..ce054f1ac65 100644
--- a/crates/adapters/src/integrated/delta_table/input.rs
+++ b/crates/adapters/src/integrated/delta_table/input.rs
@@ -39,10 +39,10 @@ use feldera_adapterlib::format::{ParseError, StagedInputBuffer};
 use feldera_adapterlib::metrics::{ConnectorMetrics, ValueType};
 use feldera_adapterlib::transport::{InputQueueEntry, Resume, Watermark, parse_resume_info};
 use feldera_adapterlib::utils::datafusion::{
-    array_to_string, columns_referenced_by_expression, columns_referenced_by_order_by,
-    create_session_context_with, execute_query_collect, execute_singleton_query,
-    timestamp_to_sql_expression, validate_sql_expression, validate_sql_order_by,
-    validate_timestamp_column,
+    ColumnNameSet, array_to_string, columns_referenced_by_expression,
+    columns_referenced_by_order_by, create_session_context_with, execute_query_collect,
+    execute_singleton_query, quote_sql_identifier, timestamp_to_sql_expression,
+    validate_sql_expression, validate_sql_order_by, validate_timestamp_column,
 };
 use feldera_storage::tokio::TOKIO_DEDICATED_IO;
 use feldera_types::adapter_stats::ConnectorHealth;
@@ -112,12 +112,6 @@ const DEFAULT_MAX_CONCURRENT_READERS: usize = 6;
 /// connector initialization.
 static MAX_CONCURRENT_READERS: AtomicUsize = AtomicUsize::new(0);
 
-/// Takes a column name from a DeltaLake schema and returns a quoted string
-/// that can be used in datafusion queries like `select "foo""bar" from my_table`.
-fn quote_sql_identifier<S: AsRef<str>>(ident: S) -> String {
-    format!("\"{}\"", ident.as_ref().replace("\"", "\"\""))
-}
-
 /// Format a DataFusion error, appending actionable guidance when the
 /// underlying variant is `ResourcesExhausted` (the shared memory pool ran
 /// out). `find_root` walks past `Context(...)` / `ArrowError(...)` wrappers
@@ -883,29 +877,6 @@ struct CatchupFollowState {
     transaction: Option<Option<String>>,
 }
 
-/// A set of column names compared case-insensitively. Delta schemas carry no
-/// case-sensitivity information, so names are stored and probed in lowercased
-/// form (mirrors the long-standing matching in [`used_columns`](DeltaTableInputEndpointInner::used_columns)).
-///
-/// SQL is case-sensitive for quoted column names, but an external table cannot
-/// hold two columns with the same lowercase form, so collapsing to a single
-/// canonical form is safe here.
-#[derive(Default)]
-struct ColumnNameSet {
-    lowercase: BTreeSet<String>,
-}
-
-impl ColumnNameSet {
-    fn from_names(names: impl IntoIterator<Item = String>) -> Self {
-        let lowercase = names.into_iter().map(|c| c.to_lowercase()).collect();
-        Self { lowercase }
-    }
-
-    fn contains(&self, name: &str) -> bool {
-        self.lowercase.contains(&name.to_lowercase())
-    }
-}
-
 struct DeltaTableInputEndpointInner {
     endpoint_name: String,
     schema: Relation,
@@ -1090,8 +1061,7 @@ impl DeltaTableInputEndpointInner {
     fn skip_unused_columns(&self) -> bool {
         // Old-style: property in the connector configuration.
         // New-style: property in the table definition.
-        self.config.skip_unused_columns
-            || self.schema.get_property("skip_unused_columns") == Some("true")
+        self.config.skip_unused_columns || self.schema.skip_unused_columns()
     }
 
     fn new_follow_transaction_label(&self) -> Option<Option<String>> {
diff --git a/crates/adapters/src/static_compile/catalog.rs b/crates/adapters/src/static_compile/catalog.rs
index c7a2e4585a2..2189233d93e 100644
--- a/crates/adapters/src/static_compile/catalog.rs
+++ b/crates/adapters/src/static_compile/catalog.rs
@@ -101,6 +101,24 @@ impl Catalog {
                 .shard_workers_accumulate(hosts[ordinal].workers.clone())
                 .into_parts();
 
+            // The output gather is collaborative: every host shards its slice of
+            // the view to the owning host's workers, which accumulate and emit
+            // it. The accumulator's `enable_count` is per-host and is enabled
+            // only when an output connector attaches, which in a multihost
+            // pipeline happens only on the owning host (connectors, including
+            // dynamic HTTP `listen`, are assigned to one host). A non-owning
+            // host would therefore leave its accumulator disabled and send an
+            // empty batch instead of its slice, silently dropping every view
+            // record computed on that host.
+            //
+            // Enable the accumulator on every host so the gather is always
+            // complete. Materialized views already get this via the integral's
+            // `into_enabled_stream`; do the same for the delta gather. This
+            // gathers a view even when it has no connector; a future
+            // optimization could propagate the owning host's connector state to
+            // the other hosts to skip that work.
+            enabled_count.enable();
+
             let integral = if integrate {
                 Some(
                     stream.shard_workers_accumulate_integrate_trace(hosts[ordinal].workers.clone()),
diff --git a/crates/adapters/src/test.rs b/crates/adapters/src/test.rs
index 93d28f6b47b..4e64e0c3f46 100644
--- a/crates/adapters/src/test.rs
+++ b/crates/adapters/src/test.rs
@@ -59,14 +59,16 @@ use crate::catalog::InputCollectionHandle;
 use crate::format::get_input_format;
 use crate::transport::input_transport_config_to_endpoint;
 pub use data::{
-    DatabricksPeople, DeltaTestStruct, EmbeddedStruct, IcebergTestStruct, KeyStruct,
-    S3TablesTestStruct, TestStruct, TestStruct2, generate_test_batch, generate_test_batches,
-    generate_test_batches_with_weights,
+    DatabricksPeople, DeltaTestStruct, EmbeddedStruct, IcebergSubsetTestStruct, IcebergTestStruct,
+    KeyStruct, S3TablesTestStruct, TestStruct, TestStruct2, generate_test_batch,
+    generate_test_batches, generate_test_batches_with_weights,
 };
 use dbsp::circuit::{CircuitConfig, NodeId};
 use dbsp::utils::Tup2;
 use feldera_types::format::json::{JsonFlavor, JsonLines, JsonParserConfig, JsonUpdateFormat};
-use feldera_types::program_schema::{Field, Relation, SqlIdentifier};
+use feldera_types::program_schema::{
+    Field, PropertyValue, Relation, SourcePosition, SqlIdentifier,
+};
 pub use mock_dezset::{
     MockDeZSet, MockUpdate, wait_for_output_count, wait_for_output_ordered,
     wait_for_output_unordered,
@@ -242,6 +244,44 @@ where
         + for<'de> DeserializeWithContext<'de, SqlSerdeConfig, Variant>
         + Sync,
 {
+    test_circuit_with_properties::<T>(config, schema, &[], persistent_output_ids)
+}
+
+/// Like [`test_circuit`], but sets the given properties on the input relations,
+/// the way the SQL compiler records table-level `WITH` properties (e.g.,
+/// `skip_unused_columns`) in the program schema.
+pub fn test_circuit_with_properties<T>(
+    config: CircuitConfig,
+    schema: &[Field],
+    input_properties: &[(&str, &str)],
+    persistent_output_ids: &[Option<&str>],
+) -> (DBSPHandle, Box<dyn CircuitCatalog>)
+where
+    T: DBData
+        + SerializeWithContext<SqlSerdeConfig>
+        + for<'de> DeserializeWithContext<'de, SqlSerdeConfig, Variant>
+        + Sync,
+{
+    let zero_position = SourcePosition {
+        start_line_number: 0,
+        start_column: 0,
+        end_line_number: 0,
+        end_column: 0,
+    };
+    let input_properties: BTreeMap<String, PropertyValue> = input_properties
+        .iter()
+        .map(|(key, value)| {
+            (
+                key.to_string(),
+                PropertyValue {
+                    value: value.to_string(),
+                    key_position: zero_position,
+                    value_position: zero_position,
+                },
+            )
+        })
+        .collect();
+
     let schema = schema.to_vec();
     let persistent_output_ids = persistent_output_ids
         .iter()
@@ -264,7 +304,7 @@ where
                 format!("test_input{i}").into(),
                 schema.clone(),
                 false,
-                BTreeMap::new(),
+                input_properties.clone(),
             ))
             .unwrap();
 
diff --git a/crates/adapters/src/test/data.rs b/crates/adapters/src/test/data.rs
index 86c7c9789cd..691e3574cf2 100644
--- a/crates/adapters/src/test/data.rs
+++ b/crates/adapters/src/test/data.rs
@@ -6,7 +6,7 @@ use arrow::datatypes::{DataType, Schema, TimeUnit};
 use dbsp::utils::Tup2;
 use feldera_macros::IsNone;
 use feldera_sqllib::{
-    ByteArray, Date, F32, F64, SqlDecimal, SqlString, Time, Timestamp, Uuid, Variant,
+    ByteArray, Date, F32, F64, SqlDecimal, SqlString, Time, Timestamp, TimestampTz, Uuid, Variant,
 };
 use feldera_types::program_schema::{ColumnType, Field, Relation, SqlIdentifier};
 use feldera_types::{
@@ -784,6 +784,7 @@ pub struct IcebergTestStruct {
     //pub uuid: ByteArray,
     pub fixed: ByteArray,
     pub varbin: ByteArray,
+    pub tstz: TimestampTz,
 }
 
 impl Arbitrary for IcebergTestStruct {
@@ -808,6 +809,8 @@ impl Arbitrary for IcebergTestStruct {
                 0u64..24 * 3600 * 1_000_000_000,
                 // Generate timestamps within a 1-year range
                 1704070800i64..1735693200,
+                // Generate timestamptz within a 1-year range (microseconds since epoch)
+                1704070800_000_000i64..1735693200_000_000,
             ),
             // String in the range "0".."1000"
             (
@@ -822,10 +825,10 @@ impl Arbitrary for IcebergTestStruct {
         )
             .prop_map(
                 |(
-                    (b, i, l, r, d, dec_num, dec_scale, dt, tm, ts),
+                    (b, i, l, r, d, dec_num, dec_scale, dt, tm, ts, tstz),
                     (s, /*uuid,*/ fixed, varbin),
                 ): (
-                    (bool, i32, i64, f32, f64, i128, u32, i32, u64, i64),
+                    (bool, i32, i64, f32, f64, i128, u32, i32, u64, i64, i64),
                     (i32, /*Vec<u8>,*/ Vec<u8>, Vec<u8>),
                 )| {
                     IcebergTestStruct {
@@ -842,6 +845,7 @@ impl Arbitrary for IcebergTestStruct {
                         // uuid: ByteArray::from_vec(uuid),
                         fixed: ByteArray::from_vec(fixed),
                         varbin: ByteArray::new(&varbin),
+                        tstz: TimestampTz::from_microseconds(tstz),
                     }
                 },
             )
@@ -869,6 +873,11 @@ impl IcebergTestStruct {
             // arrow::datatypes::Field::new("uuid", DataType::FixedSizeBinary(16), false),
             arrow::datatypes::Field::new("fixed", DataType::FixedSizeBinary(5), false),
             arrow::datatypes::Field::new("varbin", DataType::Binary, false),
+            arrow::datatypes::Field::new(
+                "tstz",
+                DataType::Timestamp(TimeUnit::Microsecond, Some("UTC".into())),
+                false,
+            ),
         ]))
     }
 
@@ -887,6 +896,7 @@ impl IcebergTestStruct {
             // Field::new("uuid".into(), ColumnType::fixed(16, false)),
             Field::new("fixed".into(), ColumnType::fixed(5, false)),
             Field::new("varbin".into(), ColumnType::varbinary(false)),
+            Field::new("tstz".into(), ColumnType::timestamp_tz(false)),
         ]
     }
 
@@ -906,6 +916,7 @@ impl IcebergTestStruct {
             // Field::new("uuid".into(), ColumnType::fixed(16, false)),
             Field::new("fixed".into(), ColumnType::fixed(5, false)),
             Field::new("varbin".into(), ColumnType::varbinary(false)),
+            Field::new("tstz".into(), ColumnType::timestamp_tz(false)),
         ];
 
         fields
@@ -922,7 +933,7 @@ impl IcebergTestStruct {
     }
 }
 
-serialize_table_record!(IcebergTestStruct[12]{
+serialize_table_record!(IcebergTestStruct[13]{
     b["b"]: bool,
     i["i"]: i32,
     l["l"]: i64,
@@ -935,10 +946,11 @@ serialize_table_record!(IcebergTestStruct[12]{
     s["s"]: String,
     // uuid["uuid"]: ByteArray,
     fixed["fixed"]: ByteArray,
-    varbin["varbin"]: ByteArray
+    varbin["varbin"]: ByteArray,
+    tstz["tstz"]: TimestampTz
 });
 
-deserialize_table_record!(IcebergTestStruct["IcebergTestStruct", Variant, 12] {
+deserialize_table_record!(IcebergTestStruct["IcebergTestStruct", Variant, 13] {
     (b, "b", false, bool, |_| None),
     (i, "i", false, i32, |_| None),
     (l, "l", false, i64, |_| None),
@@ -951,7 +963,8 @@ deserialize_table_record!(IcebergTestStruct["IcebergTestStruct", Variant, 12] {
     (s, "s", false, String, |_| None),
     // (uuid, "uuid", false, ByteArray, None),
     (fixed, "fixed", false, ByteArray, |_| None),
-    (varbin, "varbin", false, ByteArray, |_| None)
+    (varbin, "varbin", false, ByteArray, |_| None),
+    (tstz, "tstz", false, TimestampTz, |_| None)
 });
 
 /// Records in the Amazon S3 Tables integration-test table (`dev.test_table`).
@@ -1003,6 +1016,57 @@ deserialize_table_record!(S3TablesTestStruct["S3TablesTestStruct", Variant, 3] {
     (created_at, "created_at", true, Option<Timestamp>, |_| Some(None))
 });
 
+/// SQL table that declares a subset of [`IcebergTestStruct`]'s columns, for
+/// testing that the Iceberg connector only reads declared columns.
+///
+/// `l` is nullable and marked unused, so the connector skips it (and the
+/// deserializer NULL-fills it) when the `skip_unused_columns` table property
+/// is set.
+#[derive(
+    Debug,
+    Default,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    serde::Serialize,
+    Clone,
+    Hash,
+    SizeOf,
+    rkyv::Archive,
+    rkyv::Serialize,
+    rkyv::Deserialize,
+    IsNone,
+)]
+#[archive_attr(derive(Ord, Eq, PartialEq, PartialOrd))]
+pub struct IcebergSubsetTestStruct {
+    pub i: i32,
+    pub s: String,
+    pub l: Option<i64>,
+}
+
+impl IcebergSubsetTestStruct {
+    pub fn schema() -> Vec<Field> {
+        vec![
+            Field::new("i".into(), ColumnType::int(false)),
+            Field::new("s".into(), ColumnType::varchar(false)),
+            Field::new("l".into(), ColumnType::bigint(true)).with_unused(true),
+        ]
+    }
+}
+
+serialize_table_record!(IcebergSubsetTestStruct[3]{
+    i["i"]: i32,
+    s["s"]: String,
+    l["l"]: Option<i64>
+});
+
+deserialize_table_record!(IcebergSubsetTestStruct["IcebergSubsetTestStruct", Variant, 3] {
+    (i, "i", false, i32, |_| None),
+    (s, "s", false, String, |_| None),
+    (l, "l", false, Option<i64>, |_| Some(None))
+});
+
 /// Struct will all types supported by the DeltaLake connector.
 #[derive(
     Debug,
diff --git a/crates/adapters/src/test/iceberg.rs b/crates/adapters/src/test/iceberg.rs
index 990056c55c5..f596071d9fb 100644
--- a/crates/adapters/src/test/iceberg.rs
+++ b/crates/adapters/src/test/iceberg.rs
@@ -8,7 +8,7 @@ use crossbeam::channel::Receiver;
 use dbsp::DBData;
 use feldera_sqllib::Variant;
 #[cfg(feature = "iceberg-tests-fs")]
-use feldera_sqllib::{ByteArray, F32, F64};
+use feldera_sqllib::{ByteArray, F32, F64, Timestamp, TimestampTz};
 use feldera_types::{
     program_schema::Field,
     serde_with_context::{DeserializeWithContext, SerializeWithContext, SqlSerdeConfig},
@@ -23,6 +23,8 @@ use tracing_subscriber::{EnvFilter, layer::SubscriberExt, util::SubscriberInitEx
 #[cfg(feature = "iceberg-tests-fs")]
 use std::io::Write;
 
+#[cfg(feature = "iceberg-tests-fs")]
+use super::IcebergSubsetTestStruct;
 #[cfg(any(
     feature = "iceberg-tests-fs",
     feature = "iceberg-tests-glue",
@@ -31,7 +33,7 @@ use std::io::Write;
 use super::IcebergTestStruct;
 #[cfg(feature = "iceberg-tests-s3tables")]
 use super::S3TablesTestStruct;
-use super::test_circuit;
+use super::test_circuit_with_properties;
 
 fn init_logging() {
     let _ = tracing_subscriber::registry()
@@ -64,7 +66,14 @@ fn data_to_ndjson(data: Vec<IcebergTestStruct>) -> NamedTempFile {
 }
 
 /// Read a snapshot of an Iceberg table with records of type `T` to a temporary JSON file.
-fn iceberg_snapshot_to_json<T>(schema: &[Field], config: &HashMap<String, String>) -> NamedTempFile
+///
+/// `table_properties` are set on the input relation, the way table-level SQL
+/// `WITH` properties (e.g., `skip_unused_columns`) reach the connector.
+fn iceberg_snapshot_to_json<T>(
+    schema: &[Field],
+    table_properties: &[(&str, &str)],
+    config: &HashMap<String, String>,
+) -> NamedTempFile
 where
     T: DBData
         + SerializeWithContext<SqlSerdeConfig>
@@ -81,8 +90,12 @@ where
     let mut config = config.clone();
     config.insert("mode".to_string(), "snapshot".to_string());
 
-    let (input_pipeline, err_receiver) =
-        iceberg_input_pipeline::<T>(schema, &config, &json_file.path().display().to_string());
+    let (input_pipeline, err_receiver) = iceberg_input_pipeline::<T>(
+        schema,
+        table_properties,
+        &config,
+        &json_file.path().display().to_string(),
+    );
     input_pipeline.start();
     wait(
         || input_pipeline.status().pipeline_complete() || err_receiver.len() > 0,
@@ -102,6 +115,7 @@ where
 /// Build a pipeline that reads from an Iceberg table and writes to a JSON file.
 fn iceberg_input_pipeline<T>(
     schema: &[Field],
+    table_properties: &[(&str, &str)],
     config: &HashMap<String, String>,
     output_file_path: &str,
 ) -> (Controller, Receiver<String>)
@@ -147,11 +161,26 @@ where
     .unwrap();
 
     let schema = schema.to_vec();
+    let table_properties: Vec<(String, String)> = table_properties
+        .iter()
+        .map(|(k, v)| (k.to_string(), v.to_string()))
+        .collect();
 
     let (err_sender, err_receiver) = crossbeam::channel::unbounded();
 
     let controller = Controller::with_test_config(
-        move |workers| Ok(test_circuit::<T>(workers, &schema, &[None])),
+        move |workers| {
+            let table_properties: Vec<(&str, &str)> = table_properties
+                .iter()
+                .map(|(k, v)| (k.as_str(), v.as_str()))
+                .collect();
+            Ok(test_circuit_with_properties::<T>(
+                workers,
+                &schema,
+                &table_properties,
+                &[None],
+            ))
+        },
         &config,
         Box::new(move |e, _| {
             let msg = format!("iceberg_input_test: error: {e}");
@@ -187,6 +216,7 @@ fn data(n_records: usize) -> Vec<IcebergTestStruct> {
             // uuid: ByteArray::new([0u8; 16].as_slice()),
             fixed: ByteArray::new([0u8; 5].as_slice()),
             varbin: ByteArray::new([0u8; 5].as_slice()),
+            tstz: TimestampTz::from(Timestamp::from_naiveDateTime(time)),
         });
 
         time += std::time::Duration::from_secs(1);
@@ -222,17 +252,15 @@ fn iceberg_localfs_input_test_ordered_with_filter() {
     );
 }
 
+/// Create a local Iceberg table populated with `data` and return its metadata
+/// location. With `extra_columns`, the table gets columns that no test SQL
+/// schema declares (see `--extra-columns` in `create_test_table_s3.py`).
 #[cfg(feature = "iceberg-tests-fs")]
-fn iceberg_localfs_input_test(
-    extra_config: &[(String, String)],
-    filter: &dyn Fn(&IcebergTestStruct) -> bool,
-) {
-    let data = data(1_000_000);
-
+fn create_localfs_table(data: &[IcebergTestStruct], extra_columns: bool) -> String {
     let table_dir = tempfile::TempDir::new().unwrap();
     let table_path = table_dir.path().display().to_string();
 
-    let ndjson_file = data_to_ndjson(data.clone());
+    let ndjson_file = data_to_ndjson(data.to_vec());
     println!("wrote test data to {}", ndjson_file.path().display());
 
     // Uncomment to inspect output parquet files produced by the test.
@@ -241,11 +269,16 @@ fn iceberg_localfs_input_test(
     let script_path = "../iceberg/src/test/create_test_table_s3.py";
 
     // Run the Python script using the Python interpreter
-    let output = std::process::Command::new("python3")
+    let mut command = std::process::Command::new("python3");
+    command
         .arg(script_path)
         .arg("--catalog=sql")
         .arg(format!("--warehouse-path={table_path}"))
-        .arg(format!("--json-file={}", ndjson_file.path().display()))
+        .arg(format!("--json-file={}", ndjson_file.path().display()));
+    if extra_columns {
+        command.arg("--extra-columns");
+    }
+    let output = command
         .output()
         .map_err(|e| {
             format!("Error running '{script_path}' script to generate an Iceberg table: {e}")
@@ -262,15 +295,26 @@ fn iceberg_localfs_input_test(
     }
 
     // The script should print table metadata location on the last line.
-    let metadata_path = String::from_utf8(output.stdout.clone())
+    String::from_utf8(output.stdout.clone())
         .unwrap()
         .lines()
         .last()
         .unwrap()
-        .to_string();
+        .to_string()
+}
+
+#[cfg(feature = "iceberg-tests-fs")]
+fn iceberg_localfs_input_test(
+    extra_config: &[(String, String)],
+    filter: &dyn Fn(&IcebergTestStruct) -> bool,
+) {
+    let data = data(1_000_000);
+
+    let metadata_path = create_localfs_table(&data, false);
 
     let mut json_file = iceberg_snapshot_to_json::<IcebergTestStruct>(
         &IcebergTestStruct::schema_with_lateness(),
+        &[],
         &[("metadata_location".to_string(), metadata_path.to_string())]
             .into_iter()
             .chain(extra_config.into_iter().cloned())
@@ -290,6 +334,66 @@ fn iceberg_localfs_input_test(
     assert_eq!(zset, expected_zset);
 }
 
+/// Read a table through a SQL declaration that names only a few of its
+/// columns, while the table also holds columns (including a `uuid` one, a
+/// type no test struct models) that the connector must ignore because it
+/// selects the declared columns instead of `*`.
+///
+/// With `skip_unused` (the `skip_unused_columns` table property), the
+/// connector must additionally not read the nullable `l` column, which the
+/// SQL schema marks unused, so `l` comes out NULL. This variant fails if the
+/// connector falls back to reading all columns.
+#[cfg(feature = "iceberg-tests-fs")]
+fn iceberg_localfs_input_subset_test(skip_unused: bool) {
+    let data = data(100_000);
+
+    let metadata_path = create_localfs_table(&data, true);
+
+    let table_properties: &[(&str, &str)] = if skip_unused {
+        &[("skip_unused_columns", "true")]
+    } else {
+        &[]
+    };
+
+    let mut json_file = iceberg_snapshot_to_json::<IcebergSubsetTestStruct>(
+        &IcebergSubsetTestStruct::schema(),
+        table_properties,
+        &[("metadata_location".to_string(), metadata_path)]
+            .into_iter()
+            .collect::<HashMap<_, _>>(),
+    );
+
+    let expected_zset = dbsp::OrdZSet::from_tuples(
+        (),
+        data.into_iter()
+            .map(|x| IcebergSubsetTestStruct {
+                i: x.i,
+                s: x.s,
+                l: if skip_unused { None } else { Some(x.l) },
+            })
+            .map(|x| dbsp::utils::Tup2(dbsp::utils::Tup2(x, ()), 1))
+            .collect(),
+    );
+    let zset = file_to_zset::<IcebergSubsetTestStruct>(json_file.as_file_mut());
+
+    assert_eq!(zset, expected_zset);
+}
+
+/// The connector reads only the columns the SQL table declares.
+#[test]
+#[cfg(feature = "iceberg-tests-fs")]
+fn iceberg_localfs_input_test_subset_schema() {
+    iceberg_localfs_input_subset_test(false);
+}
+
+/// The `skip_unused_columns` table property also drops declared-but-unused
+/// columns from the read.
+#[test]
+#[cfg(feature = "iceberg-tests-fs")]
+fn iceberg_localfs_input_test_skip_unused_columns() {
+    iceberg_localfs_input_subset_test(true);
+}
+
 #[test]
 #[cfg(feature = "iceberg-tests-glue")]
 fn iceberg_glue_s3_input_test() {
@@ -297,6 +401,7 @@ fn iceberg_glue_s3_input_test() {
     // Read delta table unordered.
     let mut json_file = iceberg_snapshot_to_json::<IcebergTestStruct>(
         &IcebergTestStruct::schema_with_lateness(),
+        &[],
         &[
             ("catalog_type".to_string(), "glue".to_string()),
             (
@@ -305,7 +410,7 @@ fn iceberg_glue_s3_input_test() {
             ),
             (
                 "table_name".to_string(),
-                "iceberg_test.test_table".to_string(),
+                "iceberg_test.test_table_v2".to_string(),
             ),
             (
                 "glue.access-key-id".to_string(),
@@ -354,6 +459,7 @@ fn iceberg_s3tables_input_test() {
     // `AWS_ACCESS_KEY_ID`/`AWS_SECRET_ACCESS_KEY`(/`AWS_SESSION_TOKEN`) exported.
     let mut json_file = iceberg_snapshot_to_json::<S3TablesTestStruct>(
         &S3TablesTestStruct::schema(),
+        &[],
         &[
             ("catalog_type".to_string(), "s3tables".to_string()),
             (
@@ -381,6 +487,7 @@ fn iceberg_rest_s3_input_test() {
     // Read delta table unordered.
     let mut json_file = iceberg_snapshot_to_json::<IcebergTestStruct>(
         &IcebergTestStruct::schema_with_lateness(),
+        &[],
         &[
             ("catalog_type".to_string(), "rest".to_string()),
             ("rest.uri".to_string(), "http://localhost:8181".to_string()),
@@ -390,7 +497,7 @@ fn iceberg_rest_s3_input_test() {
             ),
             (
                 "table_name".to_string(),
-                "iceberg_test.test_table".to_string(),
+                "iceberg_test.test_table_v2".to_string(),
             ),
             (
                 "s3.access-key-id".to_string(),
diff --git a/crates/dbsp/src/circuit/circuit_builder.rs b/crates/dbsp/src/circuit/circuit_builder.rs
index 91f59bccf5a..e07d24b8860 100644
--- a/crates/dbsp/src/circuit/circuit_builder.rs
+++ b/crates/dbsp/src/circuit/circuit_builder.rs
@@ -3939,31 +3939,12 @@ where
         SndOp: SinkOperator<I>,
         RcvOp: SourceOperator<O>,
     {
-        let sender_id = self.add_node(|id| {
-            self.log_circuit_event(&CircuitEvent::operator(
-                GlobalNodeId::child_of(self, id),
-                sender.name(),
-                sender.location(),
-            ));
-
-            let node = SinkNode::new(sender, input_stream.clone(), self.clone(), id);
-            self.connect_stream(input_stream, id, input_preference);
-            (node, id)
-        });
-
-        let output_stream = self.add_node(|id| {
-            self.log_circuit_event(&CircuitEvent::operator(
-                GlobalNodeId::child_of(self, id),
-                receiver.name(),
-                receiver.location(),
-            ));
-
-            let node = SourceNode::new(receiver, self.clone(), id);
-            let output_stream = node.output_stream();
-            (node, output_stream)
-        });
-
-        self.add_dependency(sender_id, output_stream.local_node_id());
+        let sender_id = self.add_sink_with_preference(sender, input_stream, input_preference);
+        let output_stream = self.add_source(receiver);
+        self.add_dependency(
+            sender_id.local_node_id().unwrap(),
+            output_stream.local_node_id(),
+        );
         output_stream
     }
 
diff --git a/crates/dbsp/src/circuit/runtime.rs b/crates/dbsp/src/circuit/runtime.rs
index 8e24494cb96..9720ffe1dff 100644
--- a/crates/dbsp/src/circuit/runtime.rs
+++ b/crates/dbsp/src/circuit/runtime.rs
@@ -7,7 +7,7 @@ use crate::SchedulerError;
 use crate::circuit::checkpointer::Checkpointer;
 use crate::circuit::dbsp_handle::StepSize;
 use crate::error::Error as DbspError;
-use crate::operator::communication::Exchange;
+use crate::operator::communication::{Exchange, ExchangeActivity};
 use crate::storage::backend::StorageBackend;
 use crate::storage::file::format::Compression;
 use crate::storage::file::writer::Parameters;
@@ -1383,7 +1383,8 @@ where
         match Runtime::runtime() {
             Some(runtime) if Runtime::num_workers() > 1 => {
                 let exchange_id = runtime.sequence_next().try_into().unwrap();
-                let exchange = Exchange::with_runtime(&runtime, exchange_id);
+                let exchange =
+                    Exchange::with_runtime(&runtime, exchange_id, ExchangeActivity::AllSteps);
                 let identifier = Arc::new(format!("broadcast {name} (exchange {exchange_id})"));
 
                 Self::MultiThreaded {
@@ -1426,8 +1427,9 @@ where
                             .await;
 
                         exchange
-                            .receive_all(|data| serde_json::from_slice(&data).unwrap())
+                            .receive_all(|data| serde_json::from_slice(&data).unwrap(), None)
                             .await
+                            .0
                     })
                     .await
                     .ok_or(SchedulerError::Killed)
diff --git a/crates/dbsp/src/operator/communication.rs b/crates/dbsp/src/operator/communication.rs
index ec1eb6b591a..73ab4ef33cc 100644
--- a/crates/dbsp/src/operator/communication.rs
+++ b/crates/dbsp/src/operator/communication.rs
@@ -3,6 +3,9 @@ mod gather;
 mod shard;
 
 pub(crate) use exchange::{
-    Exchange, ExchangeClients, ExchangeDelivery, ExchangeDirectory, ExchangeId, pop_flushed,
+    Exchange, ExchangeClients, ExchangeDelivery, ExchangeDirectory, ExchangeId, MessageType,
+    pop_flushed,
+};
+pub use exchange::{
+    ExchangeActivity, ExchangeReceiver, ExchangeSender, Mailbox, new_exchange_operators,
 };
-pub use exchange::{ExchangeReceiver, ExchangeSender, Mailbox, new_exchange_operators};
diff --git a/crates/dbsp/src/operator/communication/exchange.rs b/crates/dbsp/src/operator/communication/exchange.rs
index b6c2e6d289f..71f22513b01 100644
--- a/crates/dbsp/src/operator/communication/exchange.rs
+++ b/crates/dbsp/src/operator/communication/exchange.rs
@@ -23,6 +23,7 @@ use crate::{
 };
 use binrw::{BinRead, BinWrite};
 use crossbeam_utils::CachePadded;
+use enum_map::{Enum, EnumMap};
 use feldera_samply::Span;
 use feldera_storage::fbuf::FBuf;
 use itertools::Itertools;
@@ -239,6 +240,45 @@ struct ExchangeMessage {
     data: Vec<FBuf>,
 }
 
+/// Distinguishes messages by size.
+///
+/// We segregate big and small messages into separate queues so that simple
+/// broadcast and consensus messages don't get delayed behind bigger messages.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Enum)]
+pub(crate) enum MessageSize {
+    /// A big message.
+    Big,
+
+    /// A small message.
+    Small,
+}
+
+impl MessageSize {
+    /// Constructs `MessageSize` from a count of `bytes`.
+    pub(crate) fn from_bytes(bytes: usize) -> Self {
+        if bytes <= 4096 {
+            Self::Small
+        } else {
+            Self::Big
+        }
+    }
+}
+
+/// Categorizes an [ExchangeMessage].
+///
+/// We segregate messages in different categories into different queues so that
+/// messages in one category do not delay those in other categories.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Enum)]
+pub(crate) enum MessageType {
+    /// Messages sent via synchronous exchange.
+    Synchronous(
+        /// Message size.
+        MessageSize,
+    ),
+    /// Messages sent via streaming exchange.
+    Streaming,
+}
+
 pub struct ExchangeClient {
     tx: ByteBoundedSender,
 }
@@ -342,6 +382,10 @@ impl ExchangeClient {
             })
             .expect("remote exchange failed")
     }
+
+    pub async fn wait(&self) {
+        self.tx.bound.wait().await;
+    }
 }
 
 /// Uniquely identifies an `Exchange` or `ShardedAccumulator` within a circuit.
@@ -484,9 +528,11 @@ pub struct ExchangeClients {
     /// tries to send data to one.
     listener: OnceCell<Option<ExchangeListener>>,
 
-    /// Maps from a range of worker IDs to the RPC client used to contact those
+    /// Maps from a range of worker IDs to the RPC clients used to contact those
     /// workers.  Only worker IDs for remote workers appear in the map.
-    clients: Vec<(Host, OnceCell<ExchangeClient>)>,
+    ///
+    /// We use one RPC client per [MessageType] per [Host].
+    clients: Vec<(Host, EnumMap<MessageType, OnceCell<ExchangeClient>>)>,
 }
 
 impl ExchangeClients {
@@ -509,14 +555,14 @@ impl ExchangeClients {
             clients: runtime
                 .layout()
                 .other_hosts()
-                .map(|host| (host.clone(), OnceCell::new()))
+                .map(|host| (host.clone(), Default::default()))
                 .collect(),
         }
     }
 
     /// Returns a client for `worker`, which must be a remote worker ID, first
     /// establishing a connection if there isn't one yet.
-    pub async fn connect(&self, worker: usize) -> &ExchangeClient {
+    pub async fn connect(&self, worker: usize, message_type: MessageType) -> &ExchangeClient {
         self.listener
             .get_or_init(|| async {
                 if let Some(runtime) = self.runtime.upgrade()
@@ -540,9 +586,20 @@ impl ExchangeClients {
             .iter()
             .find(|(host, _client)| host.workers.contains(&worker))
             .unwrap();
-        cell.get_or_init(|| ExchangeClient::new(host.address, &host.workers))
+        cell[message_type]
+            .get_or_init(|| ExchangeClient::new(host.address, &host.workers))
             .await
     }
+
+    pub async fn wait(&self) {
+        for (_, clients) in &self.clients {
+            for client in clients.values() {
+                if let Some(client) = client.get() {
+                    client.wait().await;
+                }
+            }
+        }
+    }
 }
 
 struct CallbackInner {
@@ -703,6 +760,9 @@ pub(crate) struct Exchange<T> {
 
     /// The number of bytes serialized.
     deserialized_bytes: AtomicUsize,
+
+    /// When the exchange is active.
+    activity: ExchangeActivity,
 }
 
 // Stop Rust from complaining about unused field.
@@ -763,6 +823,7 @@ where
         clients: Arc<ExchangeClients>,
         exchange_id: ExchangeId,
         directory: &ExchangeDirectory,
+        activity: ExchangeActivity,
     ) -> Arc<Self> {
         let npeers = Runtime::num_workers();
         let mailboxes: Vec<Mutex<Option<Mailbox<T>>>> =
@@ -788,6 +849,7 @@ where
             mailboxes,
             deserialization_usecs: AtomicU64::new(0),
             deserialized_bytes: AtomicUsize::new(0),
+            activity,
         });
 
         directory.insert(exchange_id, exchange.clone());
@@ -806,39 +868,6 @@ where
         sender * self.npeers + receiver
     }
 
-    /// True if all `receiver`'s incoming mailboxes contain data.
-    ///
-    /// Once this function returns true, a subsequent `try_receive_all`
-    /// operation is guaranteed for `receiver`.
-    fn ready_to_receive(&self, receiver: usize) -> bool {
-        debug_assert!(receiver < self.npeers);
-        self.receiver_counters[receiver].load(Ordering::Acquire) == self.npeers
-    }
-
-    /// Register callback to be invoked whenever the `ready_to_receive`
-    /// condition becomes true.
-    ///
-    /// The callback can be setup at most once (e.g., when a scheduler attaches
-    /// to the circuit) and cannot be unregistered.  Notifications delivered
-    /// before the callback is registered are lost.  The client should call
-    /// `ready_to_receive` after installing the callback to check
-    /// the status.
-    ///
-    /// After the callback has been registered, notifications are delivered with
-    /// at-least-once semantics: a notification is generated whenever the
-    /// status changes from not ready to ready, but spurious notifications
-    /// can occur occasionally.  The user must check the status explicitly
-    /// by calling `ready_to_receive` or be prepared that `receive_all`
-    /// can fail.
-    pub(crate) fn register_receiver_callback<F>(&self, receiver: usize, cb: F)
-    where
-        F: Fn() + Send + Sync + 'static,
-    {
-        debug_assert!(receiver < self.npeers);
-
-        self.receiver_callbacks[receiver].set_callback(cb);
-    }
-
     /// Locks and returns the mailbox for the sender/receiver pair.
     fn mailbox(&self, sender: usize, receiver: usize) -> MutexGuard<'_, Option<Mailbox<T>>> {
         self.mailboxes[self.mailbox_index(sender, receiver)]
@@ -849,7 +878,11 @@ where
     /// Create a new `Exchange` instance if an instance with the same id
     /// (created by another thread) does not yet exist within `runtime`.
     /// The number of peers will be set to `runtime.num_workers()`.
-    pub(crate) fn with_runtime(runtime: &Runtime, exchange_id: ExchangeId) -> Arc<Self> {
+    pub(crate) fn with_runtime(
+        runtime: &Runtime,
+        exchange_id: ExchangeId,
+        activity: ExchangeActivity,
+    ) -> Arc<Self> {
         // It's tempting to move the following calls to create the
         // `ExchangeDirectory` and `ExchangeClients` into `Exchange::new`, but
         // don't do it: all three of these access `runtime.local_store` and
@@ -859,7 +892,7 @@ where
         runtime
             .local_store()
             .entry(ExchangeCacheId::new(exchange_id))
-            .or_insert_with(|| Exchange::new(runtime, clients, exchange_id, &directory))
+            .or_insert_with(|| Exchange::new(runtime, clients, exchange_id, &directory, activity))
             .value()
             .clone()
     }
@@ -987,16 +1020,19 @@ where
                         })
                         .collect_vec();
 
+                    let message_type = MessageType::Synchronous(MessageSize::from_bytes(
+                        items.iter().map(|fbuf| fbuf.len()).sum(),
+                    ));
+
                     // We discard the return value that could allow us to wait
                     // for the channel tx buffer to drain, because exchange is
                     // synchronous, meaning that it will drain before we send
                     // the next message.
-                    let _ = self.clients.connect(receivers.start).await.send(
-                        global_node_id.clone(),
-                        self.exchange_id,
-                        sender,
-                        items,
-                    );
+                    let _ = self
+                        .clients
+                        .connect(receivers.start, message_type)
+                        .await
+                        .send(global_node_id.clone(), self.exchange_id, sender, items);
                 }
             }
         }
@@ -1004,7 +1040,16 @@ where
 
     /// Read all incoming messages for this worker, waiting for data to arrive
     /// as needed.
-    pub(crate) async fn receive_all<D>(&self, deserialize: D) -> Vec<T>
+    ///
+    /// When the data is ready, but before reading it, this method swaps
+    /// `start_wait_usecs` with 0 and returns the old value along with the data.
+    /// This allows the caller to obtain the waiting time incurred just after it
+    /// became ready.
+    pub(crate) async fn receive_all<D>(
+        &self,
+        deserialize: D,
+        start_wait_usecs: Option<&AtomicU64>,
+    ) -> (Vec<T>, Option<u64>)
     where
         D: Fn(AlignedVec) -> T,
     {
@@ -1024,6 +1069,11 @@ where
             }
         }
 
+        let start_wait_usecs = start_wait_usecs.and_then(|v| {
+            let start_wait_usecs = v.swap(0, Ordering::Acquire);
+            (start_wait_usecs != 0).then_some(start_wait_usecs)
+        });
+
         let mut data = Vec::with_capacity(self.npeers);
         for sender in 0..self.npeers {
             let mailbox = self.mailbox(sender, receiver).take().unwrap();
@@ -1035,7 +1085,7 @@ where
             }
         }
 
-        data
+        (data, start_wait_usecs)
     }
 }
 
@@ -1062,6 +1112,19 @@ where
     }
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+enum Phase {
+    Active,
+    Flush,
+    Commit,
+}
+
+impl Phase {
+    fn is_inactive(&self, activity: ExchangeActivity) -> bool {
+        *self == Phase::Commit && activity == ExchangeActivity::InputOnly
+    }
+}
+
 /// Operator that partitions incoming data across all workers.
 ///
 /// This operator works in tandem with [`ExchangeReceiver`], which reassembles
@@ -1100,13 +1163,6 @@ where
 ///                    ExchangeSender  ExchangeReceiver
 /// ```
 ///
-/// `ExchangeSender` is an asynchronous operator., i.e.,
-/// [`ExchangeSender::is_async`] returns `true`.  It becomes schedulable
-/// ([`ExchangeSender::ready`] returns `true`) once all peers have retrieved
-/// values written by the operator in the previous clock cycle.  The scheduler
-/// should use [`ExchangeSender::register_ready_callback`] to get notified when
-/// the operator becomes schedulable.
-///
 /// `ExchangeSender` doesn't have a public constructor and must be instantiated
 /// using the [`new_exchange_operators`] function, which creates an
 /// [`ExchangeSender`]/[`ExchangeReceiver`] pair of operators and connects them
@@ -1182,7 +1238,7 @@ where
 /// use dbsp::{
 ///     operator::{communication::new_exchange_operators, Generator},
 ///     circuit::{WorkerLocation, WorkerLocations},
-///     operator::communication::Mailbox,
+///     operator::communication::{ExchangeActivity, Mailbox},
 ///     Circuit, RootCircuit, Runtime,
 ///     storage::file::to_bytes_dyn,
 ///     trace::aligned_deserialize,
@@ -1218,6 +1274,7 @@ where
 ///             },
 ///             |data| aligned_deserialize(&data[..]),///             // Reassemble received values into a vector.
 ///             |v: &mut Vec<usize>, n| v.push(n),
+///             ExchangeActivity::AllSteps,
 ///         ).unwrap();
 ///
 ///         // Add exchange operators to the circuit.
@@ -1259,7 +1316,7 @@ where
     // Input batch sizes.
     input_batch_stats: BatchSizeStats,
 
-    flushed: bool,
+    phase: Phase,
 
     // The instant when the sender produced its outputs, and the
     // receiver starts waiting for all other workers to produce their
@@ -1286,7 +1343,7 @@ where
             outputs: Vec::with_capacity(Runtime::num_workers()),
             exchange,
             input_batch_stats: BatchSizeStats::new(),
-            flushed: false,
+            phase: Phase::Active,
             start_wait_usecs,
             phantom: PhantomData,
         }
@@ -1324,8 +1381,12 @@ where
         true
     }
 
+    fn start_transaction(&mut self) {
+        self.phase = Phase::Active;
+    }
+
     fn flush(&mut self) {
-        self.flushed = true;
+        self.phase = Phase::Flush;
     }
 }
 
@@ -1340,6 +1401,16 @@ where
     }
 
     async fn eval_owned(&mut self, input: D) {
+        if self.phase.is_inactive(self.exchange.activity) {
+            return;
+        };
+        let flushed = if self.phase == Phase::Flush {
+            self.phase = Phase::Commit;
+            true
+        } else {
+            false
+        };
+
         self.input_batch_stats.add_batch(input.num_entries_deep());
 
         debug_assert!(self.ready());
@@ -1350,16 +1421,14 @@ where
 
         let data = self.outputs.drain(..).map(|mailbox| match mailbox {
             Mailbox::Tx(mut data) => {
-                data.push(self.flushed as u8);
+                data.push(flushed as u8);
                 Mailbox::Tx(data)
             }
             Mailbox::Rx(_) => unreachable!(),
-            Mailbox::Plain(item) => Mailbox::Plain((item, self.flushed)),
+            Mailbox::Plain(item) => Mailbox::Plain((item, flushed)),
         });
 
         self.exchange.send_all(&self.global_node_id, data).await;
-
-        self.flushed = false;
     }
 
     fn input_preference(&self) -> OwnershipPreference {
@@ -1375,18 +1444,10 @@ where
 /// peer.
 ///
 /// See [`ExchangeSender`] documentation for details.
-///
-/// `ExchangeReceiver` is an asynchronous operator., i.e.,
-/// [`ExchangeReceiver::is_async`] returns `true`.  It becomes schedulable
-/// ([`ExchangeReceiver::ready`] returns `true`) once all peers have sent values
-/// for this worker in the current clock cycle.  The scheduler should use
-/// [`ExchangeReceiver::register_ready_callback`] to get notified when the
-/// operator becomes schedulable.
 pub struct ExchangeReceiver<IF, T, L, D>
 where
     T: Send + 'static + Clone,
 {
-    worker_index: usize,
     location: OperatorLocation,
     init: IF,
     deserialize: D,
@@ -1396,6 +1457,7 @@ where
     flush_complete: bool,
     start_wait_usecs: Arc<AtomicU64>,
     total_wait_time: Arc<AtomicU64>,
+    phase: Phase,
 
     // Output batch sizes.
     output_batch_stats: BatchSizeStats,
@@ -1406,7 +1468,6 @@ where
     T: Send + 'static + Clone + Debug,
 {
     pub(crate) fn new(
-        worker_index: usize,
         location: OperatorLocation,
         exchange: Arc<Exchange<(T, bool)>>,
         init: IF,
@@ -1414,10 +1475,7 @@ where
         deserialize: D,
         combine: L,
     ) -> Self {
-        debug_assert!(worker_index < Runtime::num_workers());
-
         Self {
-            worker_index,
             location,
             init,
             combine,
@@ -1428,12 +1486,9 @@ where
             output_batch_stats: BatchSizeStats::new(),
             start_wait_usecs,
             total_wait_time: Arc::new(AtomicU64::new(0)),
+            phase: Phase::Active,
         }
     }
-
-    fn is_ready(&self) -> bool {
-        self.exchange.ready_to_receive(self.worker_index)
-    }
 }
 
 impl<IF, T, L, D> Operator for ExchangeReceiver<IF, T, L, D>
@@ -1464,50 +1519,12 @@ where
         });
     }
 
-    fn is_async(&self) -> bool {
+    fn fixedpoint(&self, _scope: Scope) -> bool {
         true
     }
 
-    fn register_ready_callback<F>(&mut self, cb: F)
-    where
-        F: Fn() + Send + Sync + 'static,
-    {
-        let start_wait_usecs = self.start_wait_usecs.clone();
-        let total_wait_time = self.total_wait_time.clone();
-        let exchange = self.exchange.clone();
-        let worker_index = self.worker_index;
-
-        let cb = move || {
-            if exchange.ready_to_receive(worker_index) {
-                // The callback can be invoked multiple times per step.
-                // Reset start_wait_usecs to 0 to make sure we don't double-count.
-                let start = start_wait_usecs.swap(0, Ordering::Acquire);
-                if start != 0 {
-                    let end = current_time_usecs();
-                    if end > start {
-                        let wait_time_usecs = end - start;
-                        // if worker_index == 0 {
-                        //     info!(
-                        //         "{worker_index}: {} +{wait_time_usecs}",
-                        //         exchange.exchange_id()
-                        //     );
-                        // }
-                        total_wait_time.fetch_add(wait_time_usecs, Ordering::AcqRel);
-                    }
-                }
-            }
-            cb()
-        };
-        self.exchange
-            .register_receiver_callback(self.worker_index, cb)
-    }
-
-    fn ready(&self) -> bool {
-        self.is_ready()
-    }
-
-    fn fixedpoint(&self, _scope: Scope) -> bool {
-        true
+    fn start_transaction(&mut self) {
+        self.phase = Phase::Active;
     }
 
     fn flush(&mut self) {
@@ -1542,7 +1559,10 @@ where
     D: Fn(AlignedVec) -> T + Send + Sync + 'static,
 {
     async fn eval(&mut self) -> O {
-        debug_assert!(self.ready());
+        if self.phase.is_inactive(self.exchange.activity) {
+            return (self.init)();
+        }
+
         let deserialize = |mut vec: AlignedVec| {
             let flushed = pop_flushed(&mut vec);
             let value = (self.deserialize)(vec);
@@ -1550,7 +1570,16 @@ where
         };
 
         let mut combined = (self.init)();
-        let res = self.exchange.receive_all(deserialize).await;
+        let (res, start_wait_usecs) = self
+            .exchange
+            .receive_all(deserialize, Some(&self.start_wait_usecs))
+            .await;
+        if let Some(start_wait_usecs) = start_wait_usecs {
+            self.total_wait_time.fetch_add(
+                current_time_usecs().saturating_sub(start_wait_usecs),
+                Ordering::Release,
+            );
+        }
         for (data, flushed) in res {
             if flushed {
                 self.flush_count += 1;
@@ -1566,6 +1595,7 @@ where
 
             self.flush_complete = true;
             self.flush_count = 0;
+            self.phase = Phase::Commit;
         }
 
         self.output_batch_stats
@@ -1588,6 +1618,28 @@ impl TypedMapKey<LocalStoreMarker> for DirectoryId {
     type Value = ExchangeDirectory;
 }
 
+/// The microsteps during which an exchange is active.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum ExchangeActivity {
+    /// The exchange is active in every microstep.
+    ///
+    /// This includes pre-commit and commit microstep.
+    AllSteps,
+
+    /// The exchange is active only during pre-commit microsteps.
+    ///
+    /// This allows for optimizations for exchanges used for sharding data from
+    /// input operators, which don't exchange any data during commit.
+    ///
+    /// # Limitation
+    ///
+    /// The current implementation only works for operators that flush in the
+    /// same (micro)step in every worker.  This is true for input operators,
+    /// which flush as soon as the transaction starts committing, but it is not
+    /// necessarily true for other operators.
+    InputOnly,
+}
+
 /// Create an [`ExchangeSender`]/[`ExchangeReceiver`] operator pair.
 ///
 /// See [`ExchangeSender`] documentation for details and example usage.
@@ -1619,6 +1671,7 @@ pub fn new_exchange_operators<TI, TO, TE, IF, PL, CL, D>(
     partition: PL,
     deserialize: D,
     combine: CL,
+    activity: ExchangeActivity,
 ) -> Option<(ExchangeSender<TI, TE, PL>, ExchangeReceiver<IF, TE, CL, D>)>
 where
     TO: Clone,
@@ -1632,11 +1685,10 @@ where
         return None;
     }
     let runtime = Runtime::runtime().unwrap();
-    let worker_index = Runtime::worker_index();
 
     let exchange_id = runtime.sequence_next().try_into().unwrap();
     let start_wait_usecs = Arc::new(AtomicU64::new(0));
-    let exchange = Exchange::with_runtime(&runtime, exchange_id);
+    let exchange = Exchange::with_runtime(&runtime, exchange_id, activity);
     let sender = ExchangeSender::new(
         location,
         exchange.clone(),
@@ -1644,7 +1696,6 @@ where
         partition,
     );
     let receiver = ExchangeReceiver::new(
-        worker_index,
         location,
         exchange,
         init,
@@ -1670,7 +1721,7 @@ mod tests {
         },
         operator::{
             Generator,
-            communication::{Mailbox, new_exchange_operators},
+            communication::{ExchangeActivity, Mailbox, new_exchange_operators},
         },
         storage::file::{to_bytes, to_bytes_dyn},
         trace::aligned_deserialize,
@@ -1691,7 +1742,8 @@ mod tests {
     // value `(sender, n)` to each receiver, where `sender` is the sender's
     // worker number in round `n`.
     fn circuit() {
-        let exchange = Exchange::with_runtime(&Runtime::runtime().unwrap(), 0);
+        let exchange =
+            Exchange::with_runtime(&Runtime::runtime().unwrap(), 0, ExchangeActivity::AllSteps);
         TOKIO.block_on(async {
             let sender = Runtime::worker_index();
             let n_workers = Runtime::num_workers();
@@ -1703,8 +1755,8 @@ mod tests {
                     })
                     .await;
 
-                let received = exchange
-                    .receive_all(|data| aligned_deserialize(&data[..]))
+                let (received, _) = exchange
+                    .receive_all(|data| aligned_deserialize(&data[..]), None)
                     .await;
 
                 let expected = (0..n_workers).map(|worker| (worker, round)).collect_vec();
@@ -1821,6 +1873,7 @@ mod tests {
                 },
                 |data| aligned_deserialize(&data[..]),
                 |v: &mut Vec<usize>, n| v.push(n),
+                ExchangeActivity::AllSteps,
             )
             .unwrap();
 
diff --git a/crates/dbsp/src/operator/dynamic.rs b/crates/dbsp/src/operator/dynamic.rs
index 5bf472b5f1e..f35b4db6108 100644
--- a/crates/dbsp/src/operator/dynamic.rs
+++ b/crates/dbsp/src/operator/dynamic.rs
@@ -34,6 +34,7 @@ pub mod time_series;
 pub mod trace;
 pub(crate) mod upsert;
 
+pub use communication::shard::Sharder;
 pub(crate) use communication::shard::shard_batch;
 
 /// The "standard" indexed Z-set type used by monomorphic
diff --git a/crates/dbsp/src/operator/dynamic/balance/accumulate_trace_balanced.rs b/crates/dbsp/src/operator/dynamic/balance/accumulate_trace_balanced.rs
index 06b87e61ab6..ec2ca8fb3a4 100644
--- a/crates/dbsp/src/operator/dynamic/balance/accumulate_trace_balanced.rs
+++ b/crates/dbsp/src/operator/dynamic/balance/accumulate_trace_balanced.rs
@@ -20,7 +20,7 @@ use crate::{
     operator::{
         Z1,
         async_stream_operators::{StreamingTernarySinkOperator, StreamingTernarySinkWrapper},
-        communication::{Exchange, ExchangeReceiver},
+        communication::{Exchange, ExchangeActivity, ExchangeReceiver},
         dynamic::{
             accumulate_trace::{AccumulateBoundsId, AccumulateTraceAppend, AccumulateZ1Trace},
             balance::{
@@ -145,13 +145,12 @@ where
                     // during the current transaction. It will be set to `true` exactly once per transaction.
                     // Once all senders are flushed, the receiver can report itself as flushed too.
                     let exchange: Arc<Exchange<(B, bool)>> =
-                        Exchange::with_runtime(&runtime, exchange_id);
+                        Exchange::with_runtime(&runtime, exchange_id, ExchangeActivity::AllSteps);
 
                     // Exchange receiver
                     let batch_factories_clone = batch_factories.clone();
 
                     let receiver = circuit.add_source(ExchangeReceiver::new(
-                        worker_index,
                         Some(location),
                         exchange.clone(),
                         || Vec::new(),
diff --git a/crates/dbsp/src/operator/dynamic/communication/gather.rs b/crates/dbsp/src/operator/dynamic/communication/gather.rs
index ce2c962ae82..40eb252178b 100644
--- a/crates/dbsp/src/operator/dynamic/communication/gather.rs
+++ b/crates/dbsp/src/operator/dynamic/communication/gather.rs
@@ -8,7 +8,7 @@ use crate::{
         runtime::{WorkerLocation, WorkerLocations},
     },
     circuit_cache_key,
-    operator::communication::{Mailbox, new_exchange_operators},
+    operator::communication::{ExchangeActivity, Mailbox, new_exchange_operators},
     trace::{Batch, deserialize_indexed_wset, merge_batches, serialize_indexed_wset},
 };
 use arc_swap::ArcSwap;
@@ -159,6 +159,7 @@ where
                             },
                             move |data| deserialize_indexed_wset(&factories_clone, &data),
                             |batches: &mut Vec<B>, batch: B| batches.push(batch),
+                            ExchangeActivity::AllSteps,
                         )
                         .unwrap();
 
diff --git a/crates/dbsp/src/operator/dynamic/communication/shard.rs b/crates/dbsp/src/operator/dynamic/communication/shard.rs
index 44f43d59c54..f1e212d6f71 100644
--- a/crates/dbsp/src/operator/dynamic/communication/shard.rs
+++ b/crates/dbsp/src/operator/dynamic/communication/shard.rs
@@ -16,7 +16,7 @@ use crate::{
     },
     circuit_cache_key,
     dynamic::{Data, DataTrait, DynPair, DynPairs, Factory},
-    operator::communication::{Mailbox, new_exchange_operators},
+    operator::communication::{ExchangeActivity, Mailbox, new_exchange_operators},
     storage::file::SerializerInner,
     trace::{
         Batch, BatchReader, Builder, IndexedWSetSerializer, deserialize_indexed_wset, merge_batches,
@@ -35,68 +35,59 @@ fn all_workers() -> Range<usize> {
     0..Runtime::num_workers()
 }
 
-impl<C, IB> Stream<C, IB>
+/// Builder for sharding a batch or pairs.
+pub struct Sharder<'a, C, B> {
+    stream: &'a Stream<C, B>,
+    workers: Range<usize>,
+    activity: ExchangeActivity,
+}
+
+impl<'a, C, B> Sharder<'a, C, B>
 where
     C: Circuit,
-    IB: BatchReader<Time = ()> + Clone,
 {
-    /// See [`Stream::shard`].
-    #[track_caller]
-    pub fn dyn_shard(&self, factories: &IB::Factories) -> Stream<C, IB>
-    where
-        IB: Batch + Send,
-    {
-        // `shard_generic` returns `None` if there is only one worker thread
-        // and hence sharding is a no-op.  In this case, we simply return the
-        // input stream.  This allows us to use `shard` unconditionally without
-        // incurring any overhead in the single-threaded case.
-        self.dyn_shard_generic(factories)
-            .unwrap_or_else(|| self.clone())
+    /// Sets `workers` as the range of workers to shard to.  This is useful for
+    /// sharding to workers on one particular host in a multihost pipeline.  By
+    /// default, sharding happens across all workers.
+    pub fn with_workers(self, workers: Range<usize>) -> Self {
+        Self { workers, ..self }
     }
 
-    /// See [`Stream::shard_workers`].
+    /// Returns the sharder configured to be active during `activity`.  The
+    /// default is [ExchangeActivity::AllSteps]
+    pub fn with_activity(self, activity: ExchangeActivity) -> Self {
+        Self { activity, ..self }
+    }
+
+    /// Shards the stream with output to a batch of the same kind.
     #[track_caller]
-    pub fn dyn_shard_workers(
-        &self,
-        workers: Range<usize>,
-        factories: &IB::Factories,
-    ) -> Stream<C, IB>
+    pub fn shard(self, factories: &B::Factories) -> Stream<C, B>
     where
-        IB: Batch + Send,
+        B: Batch<Time = ()> + Clone + Send,
     {
-        // `shard_generic_workers` returns `None` if there is only one worker
-        // thread and hence sharding is a no-op.  In this case, we simply return
-        // the input stream.  This allows us to use `shard_workers`
-        // unconditionally without incurring any overhead in the single-threaded
-        // case.
-        self.dyn_shard_generic_workers(workers, factories)
-            .unwrap_or_else(|| self.clone())
+        self.shard_generic_ref(factories)
+            .unwrap_or_else(|| self.stream.clone())
     }
+}
 
-    /// Like [`Self::dyn_shard`], but can assemble the results into any output batch
-    /// type `OB`.
-    ///
-    /// Returns `None` when the circuit is not running inside a multithreaded
-    /// runtime or is running in a runtime with a single worker thread.
+impl<'a, C, IB> Sharder<'a, C, IB>
+where
+    C: Circuit,
+    IB: BatchReader<Time = ()> + Clone,
+{
+    /// Shards the stream with output to batch type `OB`.  If the stream doesn't
+    /// need to be sharded because there is only a single worker, returns
+    /// `None`.
     #[track_caller]
-    pub fn dyn_shard_generic<OB>(&self, factories: &OB::Factories) -> Option<Stream<C, OB>>
+    pub fn shard_generic<OB>(self, factories: &OB::Factories) -> Option<Stream<C, OB>>
     where
         OB: Batch<Key = IB::Key, Val = IB::Val, Time = (), R = IB::R> + Send,
     {
-        self.dyn_shard_generic_workers(all_workers(), factories)
+        self.shard_generic_ref(factories)
     }
 
-    /// Like [`Self::dyn_shard`], but can assemble the results into any output batch
-    /// type `OB`.
-    ///
-    /// Returns `None` when the circuit is not running inside a multithreaded
-    /// runtime or is running in a runtime with a single worker thread.
     #[track_caller]
-    pub fn dyn_shard_generic_workers<OB>(
-        &self,
-        workers: Range<usize>,
-        factories: &OB::Factories,
-    ) -> Option<Stream<C, OB>>
+    fn shard_generic_ref<OB>(&self, factories: &OB::Factories) -> Option<Stream<C, OB>>
     where
         OB: Batch<Key = IB::Key, Val = IB::Val, Time = (), R = IB::R> + Send,
     {
@@ -105,9 +96,10 @@ where
         }
         let location = Location::caller();
         let output = self
+            .stream
             .circuit()
             .cache_get_or_insert_with(
-                ShardId::new((self.stream_id(), workers.clone())),
+                ShardId::new((self.stream.stream_id(), self.workers.clone())),
                 move || {
                     // As a minor optimization, we reuse this array across all invocations
                     // of the sharding operator.
@@ -115,10 +107,10 @@ where
                     let factories_clone2 = factories.clone();
                     let factories_clone3 = factories.clone();
                     let factories_clone4 = factories.clone();
-                    let workers_clone = workers.clone();
-                    let workers_clone2 = workers.clone();
+                    let workers_clone = self.workers.clone();
+                    let workers_clone2 = self.workers.clone();
 
-                    let output = self.circuit().region("shard", || {
+                    let output = self.stream.circuit().region("shard", || {
                         let (sender, receiver) = new_exchange_operators(
                             Some(location),
                             || Vec::new(),
@@ -133,26 +125,30 @@ where
                             },
                             move |data| deserialize_indexed_wset(&factories_clone4, &data),
                             |batches: &mut Vec<OB>, batch: OB| batches.push(batch),
+                            self.activity,
                         )
                         .unwrap();
 
-                        self.circuit()
-                            .add_exchange(sender, receiver, self)
+                        self.stream
+                            .circuit()
+                            .add_exchange(sender, receiver, self.stream)
                             .apply_owned_named("merge shards", move |batches| {
                                 merge_batches(&factories_clone2, batches, &None, &None)
                             })
                     });
 
-                    self.circuit().cache_insert(
+                    self.stream.circuit().cache_insert(
                         ShardId::new((output.stream_id(), workers_clone2)),
                         output.clone(),
                     );
 
-                    self.circuit()
-                        .cache_insert(UnshardId::new(output.stream_id()), self.clone());
+                    self.stream
+                        .circuit()
+                        .cache_insert(UnshardId::new(output.stream_id()), self.stream.clone());
 
                     output.set_persistent_id(
-                        self.get_persistent_id()
+                        self.stream
+                            .get_persistent_id()
                             .map(|name| format!("{name}.shard"))
                             .as_deref(),
                     )
@@ -164,19 +160,20 @@ where
     }
 }
 
-impl<C, K, V> Stream<C, Vec<Box<DynPairs<K, V>>>>
+impl<'a, C, K, V> Sharder<'a, C, Vec<Box<DynPairs<K, V>>>>
 where
     C: Circuit,
     K: DataTrait + ?Sized,
     V: DataTrait + ?Sized,
 {
+    /// Shards a vector of pairs across workers.
     #[track_caller]
-    pub fn dyn_shard_pairs(
-        &self,
+    pub fn shard_pairs(
+        self,
         pairs_factory: &'static dyn Factory<DynPairs<K, V>>,
     ) -> Stream<C, Vec<Box<DynPairs<K, V>>>> {
-        if self.is_sharded() {
-            return self.clone();
+        if self.stream.is_sharded() {
+            return self.stream.clone();
         }
 
         let location = Location::caller();
@@ -186,19 +183,24 @@ where
             Vec::new,
             move |input_pairs: Vec<Box<DynPairs<K, V>>>,
                   output_pairs: &mut Vec<Mailbox<Box<DynPairs<K, V>>>>| {
-                shard_pairs(input_pairs, &all_workers(), output_pairs, pairs_factory);
+                shard_pairs(input_pairs, &self.workers, output_pairs, pairs_factory);
             },
             move |data| deserialize_pairs(&data, pairs_factory),
             |output_pairs: &mut Vec<Box<DynPairs<K, V>>>, batch: Box<DynPairs<K, V>>| {
                 output_pairs.push(batch);
             },
+            self.activity,
         )
         .unwrap();
 
-        let output = self.circuit().add_exchange(sender, receiver, self);
+        let output = self
+            .stream
+            .circuit()
+            .add_exchange(sender, receiver, self.stream);
 
         output.set_persistent_id(
-            self.get_persistent_id()
+            self.stream
+                .get_persistent_id()
                 .map(|name| format!("{name}.shard"))
                 .as_deref(),
         );
@@ -206,6 +208,93 @@ where
     }
 }
 
+impl<C, B> Stream<C, B> {
+    /// Constructs a [Sharder] builder for sharding a batch or pairs with
+    /// flexible configuration.
+    pub fn dyn_sharder(&self) -> Sharder<'_, C, B> {
+        Sharder {
+            stream: self,
+            activity: ExchangeActivity::AllSteps,
+            workers: all_workers(),
+        }
+    }
+}
+
+impl<C, IB> Stream<C, IB>
+where
+    C: Circuit,
+    IB: BatchReader<Time = ()> + Clone,
+{
+    /// See [`Stream::shard`].
+    #[track_caller]
+    pub fn dyn_shard(&self, factories: &IB::Factories) -> Stream<C, IB>
+    where
+        IB: Batch + Send,
+    {
+        self.dyn_sharder().shard(factories)
+    }
+
+    /// See [`Stream::shard_workers`].
+    #[track_caller]
+    pub fn dyn_shard_workers(
+        &self,
+        workers: Range<usize>,
+        factories: &IB::Factories,
+    ) -> Stream<C, IB>
+    where
+        IB: Batch + Send,
+    {
+        self.dyn_sharder().with_workers(workers).shard(factories)
+    }
+
+    /// Like [`Self::dyn_shard`], but can assemble the results into any output batch
+    /// type `OB`.
+    ///
+    /// Returns `None` when the circuit is not running inside a multithreaded
+    /// runtime or is running in a runtime with a single worker thread.
+    #[track_caller]
+    pub fn dyn_shard_generic<OB>(&self, factories: &OB::Factories) -> Option<Stream<C, OB>>
+    where
+        OB: Batch<Key = IB::Key, Val = IB::Val, Time = (), R = IB::R> + Send,
+    {
+        self.dyn_sharder().shard_generic(factories)
+    }
+
+    /// Like [`Self::dyn_shard`], but can assemble the results into any output batch
+    /// type `OB`.
+    ///
+    /// Returns `None` when the circuit is not running inside a multithreaded
+    /// runtime or is running in a runtime with a single worker thread.
+    #[track_caller]
+    pub fn dyn_shard_generic_workers<OB>(
+        &self,
+        workers: Range<usize>,
+        factories: &OB::Factories,
+    ) -> Option<Stream<C, OB>>
+    where
+        OB: Batch<Key = IB::Key, Val = IB::Val, Time = (), R = IB::R> + Send,
+    {
+        self.dyn_sharder()
+            .with_workers(workers)
+            .shard_generic(factories)
+    }
+}
+
+impl<C, K, V> Stream<C, Vec<Box<DynPairs<K, V>>>>
+where
+    C: Circuit,
+    K: DataTrait + ?Sized,
+    V: DataTrait + ?Sized,
+{
+    #[track_caller]
+    pub fn dyn_shard_pairs(
+        &self,
+        pairs_factory: &'static dyn Factory<DynPairs<K, V>>,
+    ) -> Stream<C, Vec<Box<DynPairs<K, V>>>> {
+        self.dyn_sharder().shard_pairs(pairs_factory)
+    }
+}
+
 fn deserialize_pairs<K, V>(
     data: &[u8],
     pairs_factory: &'static dyn Factory<DynPairs<K, V>>,
@@ -535,17 +624,25 @@ where
     /// across workers, otherwise this will cause the dataflow to yield
     /// incorrect results
     pub fn mark_sharded(&self) -> Self {
-        self.circuit().cache_insert(
-            ShardId::new((self.stream_id(), all_workers())),
-            self.clone(),
-        );
+        self.mark_sharded_workers(all_workers())
+    }
+
+    pub fn mark_sharded_workers(&self, workers: Range<usize>) -> Self {
+        self.circuit()
+            .cache_insert(ShardId::new((self.stream_id(), workers)), self.clone());
         self.clone()
     }
 
     /// Returns `true` if a sharded version of the current stream exists
     pub fn has_sharded_version(&self) -> bool {
+        self.has_workers_sharded_version(all_workers())
+    }
+
+    /// Returns `true` if a version of the current stream sharded to `workers`
+    /// exists.
+    pub fn has_workers_sharded_version(&self, workers: Range<usize>) -> bool {
         self.circuit()
-            .cache_contains(&ShardId::<C, T>::new((self.stream_id(), all_workers())))
+            .cache_contains(&ShardId::<C, T>::new((self.stream_id(), workers)))
     }
 
     pub fn get_sharded_version(&self) -> Option<Self> {
diff --git a/crates/dbsp/src/operator/dynamic/input.rs b/crates/dbsp/src/operator/dynamic/input.rs
index ed79ff25197..e655f60e120 100644
--- a/crates/dbsp/src/operator/dynamic/input.rs
+++ b/crates/dbsp/src/operator/dynamic/input.rs
@@ -10,6 +10,7 @@ use crate::{
     },
     operator::{
         Input, InputHandle, Update,
+        communication::ExchangeActivity,
         dynamic::{
             input_upsert::{
                 DynUpdate, InputUpsertFactories, InputUpsertWithWaterlineFactories, PatchFunc,
@@ -390,7 +391,11 @@ impl RootCircuit {
             // This adds small overhead to tables that don't get materialized and hence don't need to get sharded.
             // If this proves to be a problem in practice, we can add a variant of this function that doesn't shard
             // its output stream for use with non-materializes tables.
-            let stream = self.add_source(input).dyn_shard(&factories.zset_factories);
+            let stream = self
+                .add_source(input)
+                .dyn_sharder()
+                .with_activity(ExchangeActivity::InputOnly)
+                .shard(&factories.zset_factories);
 
             let zset_handle = <CollectionHandle<DynPair<K, DynUnit>, DynZWeight>>::new(
                 factories.pair_factory,
@@ -474,7 +479,9 @@ impl RootCircuit {
         //       |--->[some other operator]
         let stream = self
             .add_source(input)
-            .dyn_shard(&factories.indexed_zset_factories);
+            .dyn_sharder()
+            .with_activity(ExchangeActivity::InputOnly)
+            .shard(&factories.indexed_zset_factories);
 
         let zset_handle = <CollectionHandle<K, DynPair<V, DynZWeight>>>::new(
             factories.pair_factory,
diff --git a/crates/dbsp/src/operator/dynamic/sharded_accumulator.rs b/crates/dbsp/src/operator/dynamic/sharded_accumulator.rs
index af793f00e2e..38b066325de 100644
--- a/crates/dbsp/src/operator/dynamic/sharded_accumulator.rs
+++ b/crates/dbsp/src/operator/dynamic/sharded_accumulator.rs
@@ -6,6 +6,7 @@ use std::{
     panic::Location,
     pin::Pin,
     sync::{Arc, Mutex, MutexGuard},
+    time::Instant,
 };
 
 use feldera_samply::Span;
@@ -16,7 +17,7 @@ use size_of::{HumanBytes, SizeOf, TotalSize};
 use crate::{
     Circuit, NumEntries, Runtime, Scope, Stream,
     circuit::{
-        GlobalNodeId, OwnershipPreference, StepSize, WorkerLocation, WorkerLocations,
+        GlobalNodeId, NodeId, OwnershipPreference, StepSize, WorkerLocation, WorkerLocations,
         circuit_builder::StreamId,
         metadata::{
             ALLOCATED_MEMORY_BYTES, BatchSizeStats, INPUT_BATCHES_STATS, MEMORY_ALLOCATIONS_COUNT,
@@ -28,7 +29,8 @@ use crate::{
     circuit_cache_key,
     operator::{
         communication::{
-            ExchangeClients, ExchangeDelivery, ExchangeDirectory, ExchangeId, pop_flushed,
+            ExchangeClients, ExchangeDelivery, ExchangeDirectory, ExchangeId, MessageType,
+            pop_flushed,
         },
         dynamic::{
             accumulator::{Accumulation, EnableCount},
@@ -40,7 +42,9 @@ use crate::{
 
 circuit_cache_key!(local StreamingExchangeCacheId<B: Batch>(ExchangeId => Arc<ShardedAccumulator<B>>));
 
-circuit_cache_key!(ShardedAccumulatorId<C, B: Batch>(StreamId => Accumulation<Stream<C, Option<Spine<B>>>>));
+circuit_cache_key!(ShardedAccumulatorId<C, B: Batch>((StreamId, Range<usize>) => Accumulation<Stream<C, Option<Spine<B>>>>));
+
+circuit_cache_key!(ShardedAccumulatorRemoteWaiterId(() => NodeId));
 
 impl<C, B> Stream<C, B>
 where
@@ -57,51 +61,7 @@ where
     where
         B: Batch<Time = ()>,
     {
-        if let Some(sharded) = self.get_sharded_version() {
-            sharded.dyn_accumulate(factories)
-        } else if Runtime::num_workers() == 1 {
-            self.dyn_accumulate(factories)
-        } else if Runtime::with_dev_tweaks(|d| !d.streaming_exchange()) {
-            self.dyn_shard(factories).dyn_accumulate(factories)
-        } else {
-            self.circuit()
-                .cache_get_or_insert_with(ShardedAccumulatorId::new(self.stream_id()), || {
-                    let runtime = Runtime::runtime().unwrap();
-                    match runtime.get_step_size() {
-                        StepSize::Microsteps => {
-                            let exchange_id: ExchangeId =
-                                runtime.sequence_next().try_into().unwrap();
-                            let exchange = ShardedAccumulator::<B>::with_runtime(
-                                &runtime,
-                                Runtime::worker_index(),
-                                exchange_id,
-                                factories,
-                            );
-                            let enable_count = exchange.enable_count.clone();
-                            let stream = self
-                                .circuit()
-                                .add_exchange(
-                                    ShardedAccumulatorSender::new(
-                                        Some(Location::caller()),
-                                        exchange.clone(),
-                                    ),
-                                    ShardedAccumulatorReceiver::new(
-                                        Some(Location::caller()),
-                                        exchange,
-                                    ),
-                                    self,
-                                )
-                                .mark_sharded();
-                            Accumulation {
-                                stream,
-                                enable_count,
-                            }
-                        }
-                        StepSize::FullSteps => self.dyn_shard(factories).dyn_accumulate(factories),
-                    }
-                })
-                .clone()
-        }
+        self.dyn_shard_workers_accumulate(factories, 0..Runtime::num_workers())
     }
 
     #[track_caller]
@@ -113,13 +73,71 @@ where
     where
         B: Batch<Time = ()>,
     {
-        if Runtime::num_workers() == 1 {
-            self.dyn_accumulate(factories)
-        } else if Runtime::with_dev_tweaks(|d| !d.streaming_exchange()) {
-            self.dyn_shard_workers(workers, factories)
-                .dyn_accumulate(factories)
+        if !self.has_workers_sharded_version(workers.clone())
+            && Runtime::with_dev_tweaks(|d| d.streaming_exchange())
+            && let Some(runtime) = Runtime::runtime()
+            && runtime.layout().n_workers() > 1
+            && runtime.get_step_size() == StepSize::Microsteps
+        {
+            let remote_waiter_node_id = if runtime.layout().is_multihost() {
+                let clients = ExchangeClients::for_runtime(&runtime);
+                Some(*self.circuit().cache_get_or_insert_with(
+                    ShardedAccumulatorRemoteWaiterId::new(()),
+                    move || {
+                        let waiter = self
+                            .circuit()
+                            .add_source(ShardedAccumulatorRemoteWaiter::new(clients.clone()));
+                        waiter.local_node_id()
+                    },
+                ))
+            } else {
+                None
+            };
+
+            self.circuit()
+                .cache_get_or_insert_with(
+                    ShardedAccumulatorId::new((self.stream_id(), workers.clone())),
+                    || {
+                        let exchange_id: ExchangeId = runtime.sequence_next().try_into().unwrap();
+                        let exchange = ShardedAccumulator::<B>::with_runtime(
+                            &runtime,
+                            Runtime::worker_index(),
+                            workers.clone(),
+                            exchange_id,
+                            factories,
+                        );
+                        let enable_count = exchange.enable_count.clone();
+                        let local_waiter =
+                            self.circuit()
+                                .add_source(ShardedAccumulatorLocalWaiter::new(
+                                    Some(Location::caller()),
+                                    exchange.clone(),
+                                ));
+                        let receiver = self
+                            .circuit()
+                            .add_exchange(
+                                ShardedAccumulatorSender::new(
+                                    Some(Location::caller()),
+                                    exchange.clone(),
+                                ),
+                                ShardedAccumulatorReceiver::new(Some(Location::caller()), exchange),
+                                self,
+                            )
+                            .mark_sharded_workers(workers.clone());
+                        self.circuit()
+                            .add_dependency(receiver.local_node_id(), local_waiter.local_node_id());
+                        if let Some(remote_waiter_node_id) = remote_waiter_node_id {
+                            self.circuit()
+                                .add_dependency(receiver.local_node_id(), remote_waiter_node_id);
+                        }
+                        Accumulation {
+                            stream: receiver,
+                            enable_count,
+                        }
+                    },
+                )
+                .clone()
         } else {
-            // TODO: implement using streaming exchange.
             self.dyn_shard_workers(workers, factories)
                 .dyn_accumulate(factories)
         }
@@ -133,8 +151,11 @@ where
     name: OperatorName,
     exchange_id: ExchangeId,
 
-    /// The number of communicating peers.
-    npeers: usize,
+    /// The destination workers.
+    ///
+    /// Usually this is all workers, but output operators shard to the workers
+    /// on one particular host.
+    workers: Range<usize>,
 
     factories: B::Factories,
 
@@ -144,6 +165,7 @@ where
     /// The RPC clients to contact remote hosts.
     clients: Arc<ExchangeClients>,
 
+    /// One [Rxq] for each of `local_workers`.
     rxq: Vec<Mutex<Rxq<B>>>,
 
     enable_count: EnableCount,
@@ -156,6 +178,7 @@ where
     fn with_runtime(
         runtime: &Runtime,
         worker_index: usize,
+        workers: Range<usize>,
         exchange_id: ExchangeId,
         factories: &B::Factories,
     ) -> Arc<Self> {
@@ -172,6 +195,7 @@ where
                 ShardedAccumulator::new(
                     runtime,
                     worker_index,
+                    workers,
                     clients,
                     exchange_id,
                     &directory,
@@ -182,10 +206,12 @@ where
             .clone()
     }
 
-    /// Create a new streaming exchange operator for `npeers` communicating threads.
+    /// Create a new streaming exchange operator to shard and accumulate to the
+    /// given `workers` (which is often all the workers in the runtime).
     fn new(
         runtime: &Runtime,
         worker_index: usize,
+        workers: Range<usize>,
         clients: Arc<ExchangeClients>,
         exchange_id: ExchangeId,
         directory: &ExchangeDirectory,
@@ -197,7 +223,7 @@ where
         let name = OperatorName::new("ShardedAccumulatorReceiver");
         let exchange = Arc::new(Self {
             exchange_id,
-            npeers,
+            workers,
             local_workers: layout.local_workers(),
             factories: factories.clone(),
             clients,
@@ -258,7 +284,7 @@ where
         let mut batches = Vec::with_capacity(layout.n_workers());
         shard_batch(
             batch,
-            &(0..self.npeers),
+            &self.workers,
             &mut builders,
             &mut batches,
             &self.factories,
@@ -266,7 +292,6 @@ where
         let worker_locations = WorkerLocations::for_layout(layout);
         let mut data = batches.into_iter();
         let mut remote_waiters = Vec::new();
-        let mut local_waiters = Vec::new();
         let mut serialized_bytes = 0;
         for receivers in layout.all_hosts() {
             match worker_locations[receivers.start] {
@@ -277,66 +302,49 @@ where
                             .expect("data should include one item per peer")
                             .into_plain()
                             .expect("local data should not be serialized");
-                        if self.deliver(&self.factories, sender, receiver, item, flush)
-                            && !flush
-                            && let Some(waiter) = self
-                                .rxq(receiver)
-                                .spines
-                                .back()
-                                .unwrap()
-                                .spine
-                                .backpressure_waiter()
-                        {
-                            local_waiters.push((receiver, waiter));
-                        }
+                        self.deliver(&self.factories, sender, receiver, item, flush);
                     }
                 }
                 WorkerLocation::Remote => {
-                    let items = receivers
-                        .clone()
-                        .map(|_| {
-                            let mut fbuf = data
-                                .next()
-                                .expect("data should include one item per peer")
-                                .into_tx()
-                                .expect("remote mailboxes should always be serialized");
-                            fbuf.push(flush as u8);
-                            fbuf
-                        })
-                        .inspect(|serialized| {
-                            serialized_bytes += serialized.len();
-                        })
-                        .collect_vec();
-                    let this = self.clone();
-                    if let Some(waiter) = this.clients.connect(receivers.start).await.send(
-                        name.clone(),
-                        this.exchange_id,
-                        sender,
-                        items,
-                    ) {
-                        remote_waiters.push(waiter);
+                    let mut empty = true;
+                    let mut items = Vec::with_capacity(receivers.len());
+                    for _ in receivers.clone() {
+                        let fbuf = data
+                            .next()
+                            .expect("data should include one item per peer")
+                            .into_tx()
+                            .expect("remote mailboxes should always be serialized");
+                        if !fbuf.is_empty() {
+                            serialized_bytes += fbuf.len();
+                            empty = false;
+                        }
+                        items.push(fbuf);
+                    }
+
+                    // Skip sending to the remote host if there's no data to
+                    // send (unless we're flushing).
+                    //
+                    // The common case for no data to send is when we're
+                    // sharding to workers on only one host for an output
+                    // connector.
+                    if !empty || flush {
+                        for item in &mut items {
+                            item.push(flush as u8);
+                        }
+                        let this = self.clone();
+                        if let Some(waiter) = this
+                            .clients
+                            .connect(receivers.start, MessageType::Streaming)
+                            .await
+                            .send(name.clone(), this.exchange_id, sender, items)
+                        {
+                            remote_waiters.push(waiter);
+                        }
                     }
                 }
             }
         }
 
-        if !local_waiters.is_empty() {
-            let _span = Span::new("local send wait")
-                .with_category("Exchange")
-                .with_tooltip(|| {
-                    format!(
-                        "{name} wait for batches to merge in {} receive queues (for workers {})",
-                        local_waiters.len(),
-                        local_waiters
-                            .iter()
-                            .map(|(receiver, _waiter)| receiver)
-                            .format(", ")
-                    )
-                });
-            for (_receiver, waiter) in local_waiters {
-                waiter.await;
-            }
-        }
         if !remote_waiters.is_empty() {
             let _span = Span::new("remote send wait")
                 .with_category("Exchange")
@@ -366,6 +374,43 @@ where
     }
 }
 
+impl<B> ShardedAccumulator<B>
+where
+    B: Batch,
+{
+    async fn wait(&self, name: Arc<String>) {
+        let start = Instant::now();
+        let mut local_waiters = Vec::new();
+        for (rxq, worker) in self.rxq.iter().zip(self.local_workers.clone()) {
+            // This is intentionally two separate statements to avoid holding
+            // the lock while waiting.
+            let waiter = rxq
+                .lock()
+                .unwrap()
+                .spines
+                .front()
+                .and_then(|entry| entry.spine.backpressure_waiter());
+            if let Some(waiter) = waiter {
+                local_waiters.push(worker);
+                waiter.await;
+            }
+        }
+        if !local_waiters.is_empty() {
+            Span::new("local send wait")
+                .with_start(start)
+                .with_category("Exchange")
+                .with_tooltip(|| {
+                    format!(
+                        "{name} wait for batches to merge in {} receive queues (for workers {})",
+                        local_waiters.len(),
+                        local_waiters.iter().format(", ")
+                    )
+                })
+                .record();
+        }
+    }
+}
+
 impl<B> ExchangeDelivery for ShardedAccumulator<B>
 where
     B: Batch<Time = ()>,
@@ -400,7 +445,11 @@ where
     /// Our worker index within the runtime.
     worker_index: usize,
 
-    /// Total number of worker threads in this circuit.
+    /// Total number of worker threads (senders) in this circuit.
+    ///
+    /// This is important because each sender must send, in addition to any
+    /// data, a flush notification to indicate that all data for a step has been
+    /// sent.
     npeers: usize,
 
     /// A deque of spines under construction for delivery to the circuit.  The
@@ -654,6 +703,84 @@ where
     }
 }
 
+struct ShardedAccumulatorRemoteWaiter {
+    clients: Arc<ExchangeClients>,
+}
+
+impl Operator for ShardedAccumulatorRemoteWaiter {
+    fn name(&self) -> std::borrow::Cow<'static, str> {
+        Cow::Borrowed("ShardedAccumulatorRemoteWaiter")
+    }
+
+    fn fixedpoint(&self, _scope: crate::circuit::Scope) -> bool {
+        true
+    }
+}
+
+impl SourceOperator<()> for ShardedAccumulatorRemoteWaiter {
+    async fn eval(&mut self) {
+        self.clients.wait().await;
+    }
+}
+
+impl ShardedAccumulatorRemoteWaiter {
+    fn new(clients: Arc<ExchangeClients>) -> Self {
+        Self { clients }
+    }
+}
+
+struct ShardedAccumulatorLocalWaiter<B>
+where
+    B: Batch,
+{
+    exchange: Arc<ShardedAccumulator<B>>,
+    location: OperatorLocation,
+    name: OperatorName,
+}
+
+impl<B> ShardedAccumulatorLocalWaiter<B>
+where
+    B: Batch,
+{
+    fn new(location: OperatorLocation, exchange: Arc<ShardedAccumulator<B>>) -> Self {
+        Self {
+            exchange,
+            location,
+            name: OperatorName::new("ShardedAccumulatorLocalWaiter"),
+        }
+    }
+}
+
+impl<B> Operator for ShardedAccumulatorLocalWaiter<B>
+where
+    B: Batch,
+{
+    fn name(&self) -> std::borrow::Cow<'static, str> {
+        Cow::Borrowed("ShardedAccumulatorLocalWaiter")
+    }
+
+    fn location(&self) -> OperatorLocation {
+        self.location
+    }
+
+    fn init(&mut self, global_id: &GlobalNodeId) {
+        self.name.init(global_id);
+    }
+
+    fn fixedpoint(&self, _scope: crate::circuit::Scope) -> bool {
+        true
+    }
+}
+
+impl<B> SourceOperator<()> for ShardedAccumulatorLocalWaiter<B>
+where
+    B: Batch,
+{
+    async fn eval(&mut self) {
+        self.exchange.wait(self.name.get()).await;
+    }
+}
+
 struct ShardedAccumulatorReceiver<B>
 where
     B: Batch,
@@ -720,6 +847,11 @@ where
         //   then this could cause livelock, spinning uselessly with 100% CPU,
         //   if there's nothing for the circuit to do while data transmits.
         //
+        // `ShardedAccumulatorReceiver` operators in workers that are outside
+        // the set of workers being sharded to seem like a further special case,
+        // since we know in advance that they won't receive any data, but I
+        // don't see a way to do better with them.
+        //
         // I don't know the right solution.
         true
     }
diff --git a/crates/dbsp/src/operator/dynamic/time_series/waterline.rs b/crates/dbsp/src/operator/dynamic/time_series/waterline.rs
index 10a2bd40769..1b919acb79f 100644
--- a/crates/dbsp/src/operator/dynamic/time_series/waterline.rs
+++ b/crates/dbsp/src/operator/dynamic/time_series/waterline.rs
@@ -5,7 +5,7 @@ use size_of::SizeOf;
 use crate::circuit::checkpointer::Checkpoint;
 use crate::circuit::runtime::{WorkerLocation, WorkerLocations};
 use crate::dynamic::{DynData, DynUnit};
-use crate::operator::communication::Mailbox;
+use crate::operator::communication::{ExchangeActivity, Mailbox};
 use crate::operator::dynamic::{MonoIndexedZSet, MonoZSet};
 use crate::{
     Circuit, NumEntries, RootCircuit, Stream,
@@ -111,6 +111,7 @@ where
                         *result = waterline;
                     }
                 },
+                ExchangeActivity::AllSteps,
             );
 
             match exchange {
@@ -191,6 +192,7 @@ where
                     let old_result = clone_box(result);
                     least_upper_bound(&old_result, &waterline, result.as_mut());
                 },
+                ExchangeActivity::AllSteps,
             );
 
             match exchange {
diff --git a/crates/dbsp/src/trace.rs b/crates/dbsp/src/trace.rs
index 1a9e1818644..b97546eff6b 100644
--- a/crates/dbsp/src/trace.rs
+++ b/crates/dbsp/src/trace.rs
@@ -1544,14 +1544,25 @@ impl IndexedWSetSerializer {
         });
     }
 
+    fn is_empty(&self) -> bool {
+        self.n_keys == 0 && self.n_values == 0
+    }
+
+    /// Returns the serialized form as an [FBuf].
+    ///
+    /// If no data was pushed into the serializer, then the [FBuf] will be
+    /// empty.
     pub fn done(mut self, serializer_inner: &mut SerializerInner) -> FBuf {
         #[cfg(debug_assertions)]
         debug_assert_eq!(self.state, State::Key);
-        self.offsets[0] = self.n_keys;
-        self.offsets[1] = self.n_values;
-        serializer_inner.with(FBufSerializer::new(&mut self.fbuf), |s| {
-            s.serialize_value(&self.offsets).unwrap()
-        });
+
+        if !self.is_empty() {
+            self.offsets[0] = self.n_keys;
+            self.offsets[1] = self.n_values;
+            serializer_inner.with(FBufSerializer::new(&mut self.fbuf), |s| {
+                s.serialize_value(&self.offsets).unwrap()
+            });
+        }
         self.fbuf
     }
 }
@@ -1585,6 +1596,11 @@ where
     V: DataTrait + ?Sized,
     R: WeightTrait + ?Sized,
 {
+    if data.is_empty() {
+        // An empty batch is serialized as an empty FBuf.
+        return B::dyn_empty(factories);
+    }
+
     let offsets = unsafe { archived_root::<Vec<usize>>(data) };
     let n_keys = offsets[0] as usize;
     let n_values = offsets[1] as usize;
diff --git a/crates/feldera-types/src/program_schema.rs b/crates/feldera-types/src/program_schema.rs
index e3b0a676134..8789ee1bbae 100644
--- a/crates/feldera-types/src/program_schema.rs
+++ b/crates/feldera-types/src/program_schema.rs
@@ -258,6 +258,13 @@ impl Relation {
         self.properties.get(name).map(|p| p.value.as_str())
     }
 
+    /// `true` if the table declaration sets the `skip_unused_columns`
+    /// property, which asks connectors not to read declared-but-unused
+    /// columns.
+    pub fn skip_unused_columns(&self) -> bool {
+        self.get_property("skip_unused_columns") == Some("true")
+    }
+
     pub fn with_primary_key<'a>(
         mut self,
         primary_key: impl IntoIterator<Item = &'a SqlIdentifier>,
@@ -1218,6 +1225,45 @@ mod tests {
         }
     }
 
+    /// Only the exact property value "true" enables `skip_unused_columns`;
+    /// connectors have always compared the value verbatim.
+    #[test]
+    fn relation_skip_unused_columns_property() {
+        use super::{PropertyValue, Relation, SourcePosition};
+        use std::collections::BTreeMap;
+
+        let zero = SourcePosition {
+            start_line_number: 0,
+            start_column: 0,
+            end_line_number: 0,
+            end_column: 0,
+        };
+        let relation = |value: Option<&str>| {
+            let mut properties = BTreeMap::new();
+            if let Some(value) = value {
+                properties.insert(
+                    "skip_unused_columns".to_string(),
+                    PropertyValue {
+                        value: value.to_string(),
+                        key_position: zero,
+                        value_position: zero,
+                    },
+                );
+            }
+            Relation::new(
+                SqlIdentifier::new("t", false),
+                Vec::new(),
+                false,
+                properties,
+            )
+        };
+
+        assert!(relation(Some("true")).skip_unused_columns());
+        assert!(!relation(Some("false")).skip_unused_columns());
+        assert!(!relation(Some("TRUE")).skip_unused_columns());
+        assert!(!relation(None).skip_unused_columns());
+    }
+
     #[test]
     fn serde_sql_type() {
         for (sql_str_base, expected_value) in [
diff --git a/crates/iceberg/src/input.rs b/crates/iceberg/src/input.rs
index fbfab988835..b2bfe46f292 100644
--- a/crates/iceberg/src/input.rs
+++ b/crates/iceberg/src/input.rs
@@ -1,6 +1,8 @@
 use crate::iceberg_input_serde_config;
 use anyhow::{anyhow, bail, Error as AnyError, Result as AnyResult};
 use chrono::{DateTime, Utc};
+use datafusion::arrow::datatypes::Schema as ArrowSchema;
+use datafusion::catalog::TableProvider;
 use datafusion::prelude::{DataFrame, SQLOptions, SessionContext};
 use dbsp::circuit::tokio::TOKIO;
 use feldera_adapterlib::{
@@ -12,14 +14,16 @@ use feldera_adapterlib::{
         IntegratedInputEndpoint, NonFtInputReaderCommand,
     },
     utils::datafusion::{
-        array_to_string, create_session_context, execute_query_collect, execute_singleton_query,
+        array_to_string, columns_referenced_by_expression, create_session_context,
+        execute_query_collect, execute_singleton_query, quote_sql_identifier,
         timestamp_to_sql_expression, validate_sql_expression, validate_timestamp_column,
+        ColumnNameSet,
     },
     PipelineState,
 };
 use feldera_types::{
     config::{FtModel, PipelineConfig},
-    program_schema::Relation,
+    program_schema::{Field, Relation},
     transport::iceberg::{IcebergCatalogType, IcebergReaderConfig},
 };
 use futures_util::StreamExt;
@@ -44,7 +48,7 @@ use iceberg_catalog_s3tables::{
 use iceberg_datafusion::IcebergStaticTableProvider;
 use iceberg_storage_opendal::OpenDalResolvingStorageFactory;
 use log::{debug, info, trace};
-use std::{sync::Arc, thread};
+use std::{collections::BTreeSet, sync::Arc, thread};
 use tokio::{
     select,
     sync::{
@@ -70,6 +74,89 @@ const S3TABLES_PROP_SESSION_TOKEN: &str = "aws_session_token";
 const S3TABLES_PROP_PROFILE_NAME: &str = "profile_name";
 const S3TABLES_PROP_REGION_NAME: &str = "region_name";
 
+/// SQL columns named by the connector's own `snapshot_filter` expression,
+/// case-folded for matching. These are kept even when marked unused, so the
+/// expression is guaranteed to resolve them (mirrors the Delta connector; for
+/// the snapshot queries issued here a `where` clause could also reference
+/// unprojected columns).
+///
+/// The filter is validated before columns are computed, so it parses here; a
+/// parse error is therefore unreachable and contributes no columns rather
+/// than failing the connector a second time.
+fn config_referenced_columns(config: &IcebergReaderConfig) -> ColumnNameSet {
+    let mut columns = BTreeSet::new();
+    if let Some(filter) = &config.snapshot_filter {
+        columns.extend(columns_referenced_by_expression(filter).unwrap_or_default());
+    }
+    ColumnNameSet::from_names(columns)
+}
+
+/// True if a column's *shape* allows omitting it: no user-visible result
+/// depends on it (`unused`), and omitting it lets us substitute NULL or its
+/// default value (it is nullable or has a default).
+///
+/// This is the shape-only rule; [`can_skip_column`] adds the
+/// filter-reference check before a column is actually skipped.
+fn is_unused_and_omittable(field: &Field) -> bool {
+    field.unused && (field.columntype.nullable || field.default.is_some())
+}
+
+/// True if a column may actually be skipped: its shape permits omitting it
+/// ([`is_unused_and_omittable`]) *and* the `snapshot_filter` expression does
+/// not reference it.
+fn can_skip_column(field: &Field, config_referenced: &ColumnNameSet) -> bool {
+    is_unused_and_omittable(field) && !config_referenced.contains(&field.name.name())
+}
+
+/// SQL columns the connector reads, matched case-insensitively against
+/// Iceberg column names. When the SQL table declaration sets the
+/// `skip_unused_columns` property, skippable unused columns are removed.
+fn used_sql_columns(schema: &Relation, config: &IcebergReaderConfig) -> ColumnNameSet {
+    let skip = schema.skip_unused_columns();
+    let config_referenced = config_referenced_columns(config);
+    ColumnNameSet::from_names(
+        schema
+            .fields
+            .iter()
+            .filter(|f| !skip || !can_skip_column(f, &config_referenced))
+            .map(|f| f.name.name()),
+    )
+}
+
+/// Compute the subset of columns in the Iceberg table snapshot schema that
+/// occur in the SQL table declaration (minus columns removed by
+/// [`used_sql_columns`]), preserving the table schema's column order.
+///
+/// Snapshot queries select this subset instead of `*`, so the connector never
+/// reads table columns the pipeline does not ingest. Besides being wasteful,
+/// reading such columns can fail when their Arrow type is not supported by
+/// the Feldera deserializer.
+///
+/// Iceberg schemas carry no case-sensitivity information, so column names are
+/// matched in lowercased form (see [`ColumnNameSet`]).
+fn used_columns(
+    table_schema: &ArrowSchema,
+    schema: &Relation,
+    config: &IcebergReaderConfig,
+) -> Vec<String> {
+    let used = used_sql_columns(schema, config);
+    table_schema
+        .fields()
+        .iter()
+        .filter(|f| used.contains(f.name()))
+        .map(|f| f.name().to_string())
+        .collect()
+}
+
+/// Quoted, comma-separated column list for `select {} from snapshot` queries.
+fn used_column_list(columns: &[String]) -> String {
+    columns
+        .iter()
+        .map(quote_sql_identifier)
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
 enum SnapshotDescr {
     /// Open the latest snapshot (default)
     Latest,
@@ -304,20 +391,27 @@ impl IcebergInputEndpointInner {
         }
     }
 
-    /// Load the entire table snapshot as a single "select * where <filter>" query.
+    /// Load the entire table snapshot as a single
+    /// "select <used_columns> where <filter>" query.
     async fn read_unordered_snapshot(
         &self,
+        used_columns: &[String],
         input_stream: &mut dyn ArrowStream,
         receiver: &mut Receiver<PipelineState>,
     ) {
-        // Execute the snapshot query; push snapshot data to the circuit.
-        info!("iceberg {}: reading initial snapshot", &self.endpoint_name,);
+        let column_names = used_column_list(used_columns);
 
-        let mut snapshot_query = "select * from snapshot".to_string();
+        let mut snapshot_query = format!("select {column_names} from snapshot");
         if let Some(filter) = &self.config.snapshot_filter {
             snapshot_query = format!("{snapshot_query} where {filter}");
         }
 
+        // Execute the snapshot query; push snapshot data to the circuit.
+        info!(
+            "iceberg {}: reading initial snapshot: {snapshot_query}",
+            &self.endpoint_name,
+        );
+
         self.execute_snapshot_query(&snapshot_query, "initial snapshot", input_stream, receiver)
             .await;
 
@@ -330,17 +424,19 @@ impl IcebergInputEndpointInner {
 
     async fn read_ordered_snapshot(
         &self,
+        used_columns: &[String],
         input_stream: &mut dyn ArrowStream,
         schema: &Relation,
         receiver: &mut Receiver<PipelineState>,
     ) {
-        self.read_ordered_snapshot_inner(input_stream, schema, receiver)
+        self.read_ordered_snapshot_inner(used_columns, input_stream, schema, receiver)
             .await
             .unwrap_or_else(|e| self.consumer.error(true, e, None));
     }
 
     async fn read_ordered_snapshot_inner(
         &self,
+        used_columns: &[String],
         input_stream: &mut dyn ArrowStream,
         schema: &Relation,
         receiver: &mut Receiver<PipelineState>,
@@ -409,6 +505,8 @@ impl IcebergInputEndpointInner {
         let min = timestamp_to_sql_expression(&timestamp_field.columntype, &min);
         let max = timestamp_to_sql_expression(&timestamp_field.columntype, &max);
 
+        let column_names = used_column_list(used_columns);
+
         let mut start = min.clone();
         let mut done = "false".to_string();
 
@@ -423,7 +521,7 @@ impl IcebergInputEndpointInner {
 
             // Query the table for the range.
             let mut range_query =
-                format!("select * from snapshot where {timestamp_column} >= {start} and {timestamp_column} < {end}");
+                format!("select {column_names} from snapshot where {timestamp_column} >= {start} and {timestamp_column} < {end}");
             if let Some(filter) = &self.config.snapshot_filter {
                 range_query = format!("{range_query} and {filter}");
             }
@@ -460,9 +558,12 @@ impl IcebergInputEndpointInner {
 
         let table = Arc::new(table);
 
-        if let Err(e) = self.prepare_snapshot_query(&table, &schema).await {
-            let _ = init_status_sender.send(Err(e)).await;
-            return;
+        let used_columns = match self.prepare_snapshot_query(&table, &schema).await {
+            Err(e) => {
+                let _ = init_status_sender.send(Err(e)).await;
+                return;
+            }
+            Ok(used_columns) => used_columns,
         };
 
         // Code before this point is part of endpoint initialization.
@@ -472,12 +573,17 @@ impl IcebergInputEndpointInner {
 
         if self.config.snapshot() && self.config.timestamp_column.is_none() {
             // Read snapshot chunk-by-chunk.
-            self.read_unordered_snapshot(input_stream.as_mut(), &mut receiver)
+            self.read_unordered_snapshot(&used_columns, input_stream.as_mut(), &mut receiver)
                 .await;
         } else if self.config.snapshot() {
             // Read the entire snapshot in one query.
-            self.read_ordered_snapshot(input_stream.as_mut(), &schema, &mut receiver)
-                .await;
+            self.read_ordered_snapshot(
+                &used_columns,
+                input_stream.as_mut(),
+                &schema,
+                &mut receiver,
+            )
+            .await;
         };
 
         self.consumer.eoi();
@@ -819,15 +925,23 @@ impl IcebergInputEndpointInner {
     ///
     /// * register snapshot as a datafusion table
     /// * validate snapshot config: filter condition and timestamp column
+    ///
+    /// Returns the columns snapshot queries must select (see [`used_columns`]);
+    /// empty when the configuration requires no snapshot.
     async fn prepare_snapshot_query(
         &self,
         table: &IcebergTable,
         schema: &Relation,
-    ) -> Result<(), ControllerError> {
+    ) -> Result<Vec<String>, ControllerError> {
         if !self.config.snapshot() {
-            return Ok(());
+            return Ok(Vec::new());
         }
 
+        // Validate the filter before `config_referenced_columns` extracts
+        // column names from it, so an invalid filter fails with a parse error
+        // rather than being silently ignored during column selection.
+        self.validate_snapshot_filter()?;
+
         trace!(
             "iceberg {}: registering table with Datafusion",
             &self.endpoint_name,
@@ -870,6 +984,14 @@ impl IcebergInputEndpointInner {
             )
         })?;
 
+        let used_columns = used_columns(provider.schema().as_ref(), schema, &self.config);
+        if used_columns.is_empty() {
+            return Err(ControllerError::invalid_transport_configuration(
+                &self.endpoint_name,
+                "the connector would read no columns: none of the columns declared in the SQL table exist in the Iceberg table (columns skipped via the 'skip_unused_columns' table property don't count); check that the connector points to the correct table",
+            ));
+        }
+
         self.datafusion
             .register_table("snapshot", Arc::new(provider))
             .map_err(|e| {
@@ -880,8 +1002,6 @@ impl IcebergInputEndpointInner {
                 )
             })?;
 
-        self.validate_snapshot_filter()?;
-
         if let Some(timestamp_column) = &self.config.timestamp_column {
             validate_timestamp_column(
                 &self.endpoint_name,
@@ -893,7 +1013,7 @@ impl IcebergInputEndpointInner {
             .await?;
         };
 
-        Ok(())
+        Ok(used_columns)
     }
 
     /// Execute a SQL query to load a complete or partial snapshot of the table.
@@ -1013,10 +1133,159 @@ async fn wait_running(receiver: &mut Receiver<PipelineState>) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use datafusion::arrow::datatypes::{DataType, Field as ArrowField};
+    use feldera_types::program_schema::{ColumnType, PropertyValue, SourcePosition, SqlIdentifier};
+    use serde_json::json;
+    use std::collections::BTreeMap;
 
     #[test]
     fn storage_factory_constructs() {
         // Smoke test; scheme dispatch is covered upstream in iceberg-rust.
         let _factory = storage_factory();
     }
+
+    fn config(value: serde_json::Value) -> IcebergReaderConfig {
+        serde_json::from_value(value).unwrap()
+    }
+
+    fn snapshot_config() -> IcebergReaderConfig {
+        config(json!({"mode": "snapshot", "metadata_location": "/tmp/metadata.json"}))
+    }
+
+    /// SQL field named `name`; `nullable`, `unused`, and `default` control
+    /// whether `skip_unused_columns` may skip it.
+    fn field(name: &str, nullable: bool, unused: bool, default: Option<&str>) -> Field {
+        let mut field = Field::new(SqlIdentifier::new(name, false), ColumnType::int(nullable))
+            .with_unused(unused);
+        field.default = default.map(String::from);
+        field
+    }
+
+    fn relation(fields: Vec<Field>, skip_unused_columns: bool) -> Relation {
+        let zero = SourcePosition {
+            start_line_number: 0,
+            start_column: 0,
+            end_line_number: 0,
+            end_column: 0,
+        };
+        let mut properties = BTreeMap::new();
+        if skip_unused_columns {
+            properties.insert(
+                "skip_unused_columns".to_string(),
+                PropertyValue {
+                    value: "true".to_string(),
+                    key_position: zero,
+                    value_position: zero,
+                },
+            );
+        }
+        Relation::new(
+            SqlIdentifier::new("test_table", false),
+            fields,
+            false,
+            properties,
+        )
+    }
+
+    fn arrow_schema(names: &[&str]) -> ArrowSchema {
+        ArrowSchema::new(
+            names
+                .iter()
+                .map(|name| ArrowField::new(*name, DataType::Int32, true))
+                .collect::<Vec<_>>(),
+        )
+    }
+
+    /// The projection is the intersection of the Iceberg schema and the SQL
+    /// declaration: table-only columns (`b`, `uuid`) are never read, and
+    /// SQL-only columns (`missing`) are never selected. Output follows table
+    /// schema order, not declaration order.
+    #[test]
+    fn used_columns_selects_sql_declared_table_columns_in_table_order() {
+        let schema = relation(
+            vec![
+                field("c", true, false, None),
+                field("a", true, false, None),
+                field("missing", true, false, None),
+            ],
+            false,
+        );
+        let table_schema = arrow_schema(&["a", "b", "c", "uuid"]);
+
+        assert_eq!(
+            used_columns(&table_schema, &schema, &snapshot_config()),
+            vec!["a", "c"]
+        );
+    }
+
+    /// Names match case-insensitively, and the query uses the table's own
+    /// spelling (quoted identifiers resolve case-sensitively in datafusion).
+    #[test]
+    fn used_columns_matches_case_insensitively() {
+        let schema = relation(vec![field("tstz", true, false, None)], false);
+        let table_schema = arrow_schema(&["TsTz"]);
+
+        assert_eq!(
+            used_columns(&table_schema, &schema, &snapshot_config()),
+            vec!["TsTz"]
+        );
+    }
+
+    #[test]
+    fn used_columns_empty_when_nothing_matches() {
+        let schema = relation(vec![field("x", true, false, None)], false);
+        let table_schema = arrow_schema(&["a", "b"]);
+
+        assert!(used_columns(&table_schema, &schema, &snapshot_config()).is_empty());
+    }
+
+    /// With the `skip_unused_columns` table property, a column is dropped only
+    /// when it is unused *and* omittable (nullable or defaulted) *and* not
+    /// referenced by `snapshot_filter`. Without the property, everything the
+    /// SQL table declares is read.
+    #[test]
+    fn skip_unused_columns_drops_only_omittable_unreferenced_columns() {
+        let fields = vec![
+            field("used", false, false, None), // read by a view -> kept
+            field("unused_nullable", true, true, None), // skippable -> dropped
+            field("unused_nonnull", false, true, None), // not omittable -> kept
+            field("unused_default", false, true, Some("0")), // defaulted -> dropped
+            field("unused_filtered", true, true, None), // filter needs it -> kept
+        ];
+        let table_schema = arrow_schema(&[
+            "used",
+            "unused_nullable",
+            "unused_nonnull",
+            "unused_default",
+            "unused_filtered",
+        ]);
+        let config = config(json!({
+            "mode": "snapshot",
+            "metadata_location": "/tmp/metadata.json",
+            "snapshot_filter": "unused_filtered > 10",
+        }));
+
+        assert_eq!(
+            used_columns(&table_schema, &relation(fields.clone(), false), &config).len(),
+            5
+        );
+        assert_eq!(
+            used_columns(&table_schema, &relation(fields, true), &config),
+            vec!["used", "unused_nonnull", "unused_filtered"]
+        );
+    }
+
+    #[test]
+    fn used_column_list_quotes_identifiers() {
+        let columns = vec![
+            "simple".to_string(),
+            "with\"quote".to_string(),
+            "With Space".to_string(),
+        ];
+
+        assert_eq!(
+            used_column_list(&columns),
+            r#""simple", "with""quote", "With Space""#
+        );
+    }
 }
diff --git a/crates/iceberg/src/test/create_test_table_s3.py b/crates/iceberg/src/test/create_test_table_s3.py
index fabb75d53ec..d1f9da78946 100644
--- a/crates/iceberg/src/test/create_test_table_s3.py
+++ b/crates/iceberg/src/test/create_test_table_s3.py
@@ -14,12 +14,14 @@
     NestedField,
     TimeType,
     TimestampType,
+    TimestamptzType,
     IntegerType,
     FloatType,
     DoubleType,
     DecimalType,
     BinaryType,
     FixedType,
+    UUIDType,
 )
 from pyiceberg.partitioning import PartitionSpec, PartitionField
 from pyiceberg.transforms import DayTransform
@@ -28,6 +30,7 @@
 import datetime
 import os
 import sys
+import uuid
 import pyarrow as pa
 import pandas as pd
 import numpy as np
@@ -55,6 +58,12 @@
     help="Number of rows to generate (default: 1000000)",
 )
 parser.add_argument("--json-file", help="JSON file to load data from")
+parser.add_argument(
+    "--extra-columns",
+    action="store_true",
+    help="Add columns that the Feldera SQL test schemas do not declare "
+    "(a 'uuid' and a string column), which the connector must not read",
+)
 
 
 args = parser.parse_args()
@@ -86,13 +95,13 @@
             "s3.region": "us-east-1",
         },
     )
-    location = "s3://feldera-iceberg-test/test_table"
+    location = "s3://feldera-iceberg-test/test_table_v2"
 elif args.catalog == "rest":
     print("REST catalog not yet supported")
     exit(1)
 else:
     warehouse_path = args.warehouse_path
-    location = f"{warehouse_path}/test_table"
+    location = f"{warehouse_path}/test_table_v2"
 
     print(f"Creating SQL catalog at {warehouse_path}")
 
@@ -110,7 +119,7 @@
         pass
 
 # Iceberg schema (matches `IcebergTestStruct`)
-schema = Schema(
+schema_fields = [
     NestedField(1, "b", BooleanType(), required=True),
     NestedField(2, "i", IntegerType(), required=True),
     NestedField(3, "l", LongType(), required=True),
@@ -121,29 +130,43 @@
     NestedField(8, "tm", TimeType(), required=True),
     NestedField(9, "ts", TimestampType(), required=True),
     NestedField(10, "s", StringType(), required=True),
-    # NestedField(11, "uuid", UUIDType(), required=True),
     NestedField(11, "fixed", FixedType(5), required=True),
     NestedField(12, "varbin", BinaryType(), required=True),
-)
+    NestedField(13, "tstz", TimestamptzType(), required=True),
+]
 
 # Equivalent arrow schema
-arrow_schema = pa.schema(
-    [
-        pa.field("b", pa.bool_(), nullable=False),
-        pa.field("i", pa.int32(), nullable=False),
-        pa.field("l", pa.int64(), nullable=False),
-        pa.field("r", pa.float32(), nullable=False),
-        pa.field("d", pa.float64(), nullable=False),
-        pa.field("dec", pa.decimal128(10, 3), nullable=False),
-        pa.field("dt", pa.date32(), nullable=False),
-        pa.field("tm", pa.time64("us"), nullable=False),
-        pa.field("ts", pa.timestamp("us"), nullable=False),
-        pa.field("s", pa.string(), nullable=False),
-        # pa.field("uuid", pa.binary(16), nullable=False),
-        pa.field("fixed", pa.binary(5), nullable=False),
-        pa.field("varbin", pa.binary(), nullable=False),
+arrow_fields = [
+    pa.field("b", pa.bool_(), nullable=False),
+    pa.field("i", pa.int32(), nullable=False),
+    pa.field("l", pa.int64(), nullable=False),
+    pa.field("r", pa.float32(), nullable=False),
+    pa.field("d", pa.float64(), nullable=False),
+    pa.field("dec", pa.decimal128(10, 3), nullable=False),
+    pa.field("dt", pa.date32(), nullable=False),
+    pa.field("tm", pa.time64("us"), nullable=False),
+    pa.field("ts", pa.timestamp("us"), nullable=False),
+    pa.field("s", pa.string(), nullable=False),
+    pa.field("fixed", pa.binary(5), nullable=False),
+    pa.field("varbin", pa.binary(), nullable=False),
+    pa.field("tstz", pa.timestamp("us", tz="UTC"), nullable=False),
+]
+
+
+# Columns that the Feldera SQL test schemas do not declare; the connector
+# must never select them. `uuid` exercises an extension-typed column.
+if args.extra_columns:
+    schema_fields += [
+        NestedField(14, "uuid", UUIDType(), required=False),
+        NestedField(15, "extra_s", StringType(), required=False),
+    ]
+    arrow_fields += [
+        pa.field("uuid", pa.uuid(), nullable=True),
+        pa.field("extra_s", pa.string(), nullable=True),
     ]
-)
+
+schema = Schema(*schema_fields)
+arrow_schema = pa.schema(arrow_fields)
 
 partition_spec = PartitionSpec(
     PartitionField(source_id=9, field_id=1000, transform=DayTransform(), name="date")
@@ -151,14 +174,17 @@
 
 try:
     print("Deleting existing table, if any")
-    catalog.drop_table("iceberg_test.test_table")
+    catalog.drop_table("iceberg_test.test_table_v2")
 except:
     pass
 
 print("Creating Iceberg table")
 
 table = catalog.create_table(
-    "iceberg_test.test_table", schema, location=location, partition_spec=partition_spec
+    "iceberg_test.test_table_v2",
+    schema,
+    location=location,
+    partition_spec=partition_spec,
 )
 
 # Number of records
@@ -177,6 +203,7 @@
     pandas_df = pd.read_json(args.json_file, lines=True)
     pandas_df["tm"] = pd.to_datetime(pandas_df["tm"]).dt.time
     pandas_df["ts"] = pd.to_datetime(pandas_df["ts"])
+    pandas_df["tstz"] = pd.to_datetime(pandas_df["tstz"], utc=True)
     pandas_df["dt"] = pd.to_datetime(pandas_df["dt"]).dt.date
     pandas_df["dec"] = pandas_df["dec"].apply(lambda x: Decimal(f"{x:.3f}"))
     # pandas_df['uuid'] = pandas_df['uuid'].apply(lambda x: bytes(x))
@@ -221,6 +248,11 @@
             datetime.datetime(2023, 1, 1) + datetime.timedelta(seconds=i)
             for i in range(num_records)
         ],
+        "tstz": [
+            datetime.datetime(2023, 1, 1, tzinfo=datetime.timezone.utc)
+            + datetime.timedelta(seconds=i)
+            for i in range(num_records)
+        ],
         "s": [f"string_{i}" for i in range(num_records)],  # string
         # "uuid": [uuid.uuid4().bytes for _ in range(num_records)],  # binary(16) - UUID
         "fixed": [np.random.bytes(5) for _ in range(num_records)],  # fixed binary(5)
@@ -234,10 +266,16 @@
 
     # print(pandas_df.head())
 
+if args.extra_columns:
+    print("Adding extra columns not declared in the Feldera SQL test schemas")
+    pandas_df["uuid"] = [uuid.uuid4().bytes for _ in range(len(pandas_df))]
+    pandas_df["extra_s"] = [f"extra_{i}" for i in range(len(pandas_df))]
+
 print("Generating Pandas dataframe")
 
 # pyiceberg does not support nanosecond timestamps
 pandas_df["ts"] = pandas_df["ts"].astype("datetime64[us]")
+pandas_df["tstz"] = pandas_df["tstz"].astype("datetime64[us, UTC]")
 
 print("Converting Pandas dataframe to Arrow")
 
diff --git a/crates/sqllib/src/string_interner.rs b/crates/sqllib/src/string_interner.rs
index b4c2f79b4d9..60747c0fefe 100644
--- a/crates/sqllib/src/string_interner.rs
+++ b/crates/sqllib/src/string_interner.rs
@@ -10,7 +10,7 @@ use dbsp::{
     Circuit, DynZWeight, OrdZSet, RootCircuit, Runtime, Stream, ZWeight,
     circuit::{LocalStoreMarker, WorkerLocation, WorkerLocations},
     dynamic::{DowncastTrait, DynData},
-    operator::communication::{Mailbox, new_exchange_operators},
+    operator::communication::{ExchangeActivity, Mailbox, new_exchange_operators},
     storage::file::to_bytes,
     trace::{
         BatchReader, BatchReaderFactories, Cursor, OrdIndexedWSet as DynOrdIndexedWSet,
@@ -315,6 +315,7 @@ pub fn build_string_interner(
                 snapshot.extend(remote_snapshot);
             }
         },
+        ExchangeActivity::AllSteps,
     );
     let by_id = match exchange {
         Some((sender, receiver)) => interned_strings
diff --git a/docs.feldera.com/docs/connectors/sources/iceberg.md b/docs.feldera.com/docs/connectors/sources/iceberg.md
index b101c154db8..7f48f9280d2 100644
--- a/docs.feldera.com/docs/connectors/sources/iceberg.md
+++ b/docs.feldera.com/docs/connectors/sources/iceberg.md
@@ -156,6 +156,13 @@ The following table lists supported Iceberg data types and corresponding Feldera
 Types that are currently not supported include Iceberg's nested data types (`struct`s,
 `list`s and `map`s), `uuid`, and timestamps with time zone.
 
+## Column selection
+
+The connector reads only the columns that appear in the Feldera SQL table
+declaration. Other columns of the Iceberg table are never read. In addition,
+when the table declaration sets the [`skip_unused_columns` property](/sql/grammar#ignoring-unused-columns), the connector skips declared columns that no view uses, provided they are
+nullable or have default values.
+
 <!--  Uncomment when https://github.com/apache/iceberg-rust/issues/811 is resolved>
 <!-- ## Ingesting time series data from Iceberg
 
diff --git a/docs.feldera.com/docs/sql/ad-hoc.md b/docs.feldera.com/docs/sql/ad-hoc.md
index d4346a8b05c..725e8eb8a33 100644
--- a/docs.feldera.com/docs/sql/ad-hoc.md
+++ b/docs.feldera.com/docs/sql/ad-hoc.md
@@ -38,6 +38,10 @@ ad-hoc queries that need to be taken into account:
   (`SELECT 1729595568::TIMESTAMP;` will yield `2024-10-22T11:12:48` in ad-hoc queries and
   `1970-01-21 00:26:35` in Feldera SQL).
 - Ad-hoc SQL cannot perform as-of joins.
+- Feldera SQL reads fields of `VARIANT` values with subscripts (`doc['scores'][1]`, array indexes
+  are 1-based); ad-hoc queries use
+  [JSON functions](#querying-variant-columns-with-json-functions) instead
+  (`json_get(doc, 'scores', 0)`, array indexes are 0-based).
 
 We will continue to improve the consistency between the two engines in future releases.
 
@@ -155,6 +159,54 @@ An ad-hoc query to insert data into the `complex_types` table would look like th
 insert into complex_types values ([1,2,3], struct(2, 'b'), '{"field": 3}', MAP(['answer'], [42]), struct(2, 3));
 ```
 
+### Querying VARIANT Columns with JSON Functions
+
+Datafusion currently has no equivalent of the Feldera SQL [`VARIANT`](/sql/json) type. An ad-hoc query
+receives a `VARIANT` column as a string that holds the JSON-encoded value, so the Feldera SQL
+subscript syntax (`doc['name']`) does not work in ad-hoc queries. Instead, ad-hoc queries
+take JSON strings apart with the
+[datafusion-functions-json](https://github.com/datafusion-contrib/datafusion-functions-json)
+function family. These functions can be used on any string column that can be decoded as
+legal JSON.
+
+| Function                          | Return type     | Description                                                            |
+|-----------------------------------|-----------------|------------------------------------------------------------------------|
+| `json_get(json, path...)`         | union           | Value at `path`; cast the result to select a concrete type (see below) |
+| `json_get_str(json, path...)`     | `VARCHAR`       | String value at `path`                                                 |
+| `json_get_int(json, path...)`     | `BIGINT`        | Integer value at `path`                                                |
+| `json_get_float(json, path...)`   | `DOUBLE`        | Float value at `path`                                                  |
+| `json_get_bool(json, path...)`    | `BOOLEAN`       | Boolean value at `path`                                                |
+| `json_get_json(json, path...)`    | `VARCHAR`       | Raw JSON text of the value at `path`                                   |
+| `json_get_array(json, path...)`   | array           | Array at `path`, each element as raw JSON text                         |
+| `json_as_text(json, path...)`     | `VARCHAR`       | Value at `path` as text; also available as the `->>` operator          |
+| `json_contains(json, path...)`    | `BOOLEAN`       | Whether a value exists at `path`                                       |
+| `json_length(json, path...)`      | `BIGINT`        | Length of the object or array at `path`                                |
+| `json_object_keys(json, path...)` | `VARCHAR` array | Keys of the object at `path`                                           |
+
+A path is a sequence of object keys and 0-based array indexes:
+`json_get_int(doc, 'scores', 0)` reads element 0 of the array under the `scores` key.
+A missing key, a mismatched type, or a `NULL` document yields `NULL`.
+
+Given
+
+```sql
+CREATE TABLE json_docs (id INT, doc VARIANT) WITH ('materialized' = 'true');
+```
+
+where `doc` holds documents such as `{"name": "Bob", "scores": [8, 10], "active": true}`,
+the following ad-hoc query returns the names of active users whose first score exceeds 5:
+
+```sql
+SELECT id, json_get_str(doc, 'name') AS name
+FROM json_docs
+WHERE json_get_bool(doc, 'active') = TRUE
+  AND json_get_int(doc, 'scores', 0) > 5;
+```
+
+`json_get` returns a value of a special union type. Prefer the typed getters
+(`json_get_int`, ...) or cast the result to a concrete type, e.g.
+`json_get(doc, 'scores', 0)::BIGINT`.
+
 ### Parameterized Queries with PREPARE / EXECUTE
 
 Ad-hoc requests accept a `PREPARE` statement followed by a single
diff --git a/docs.feldera.com/docs/sql/aggregates.md b/docs.feldera.com/docs/sql/aggregates.md
index f57d73fbdcb..9570b1e8a5c 100644
--- a/docs.feldera.com/docs/sql/aggregates.md
+++ b/docs.feldera.com/docs/sql/aggregates.md
@@ -221,33 +221,6 @@ The following window aggregate functions are supported:
   </tr>
 </table>
 
-:::warning Potential inefficiency
-
-The window aggregate functions `RANK`, `DENSE_RANK`, and `ROW_NUMBER`
-may be very expensive to evaluate incrementally, because it's possible
-for a very small input change to produce a very large output change:
-inserting or deleting a single row can change the numbering of all
-subsequent rows in the same group.  These functions can have a
-reasonable cost in three circumstances:
-
-- each modified group (created by `PARTITION BY`) is relatively small in size
-
-- new insertions and deletions feature rows that appear towards the
-  end of the order produced by the `ORDER BY` clause
-
-- they are used in a TopK pattern with a small limit.
-  The topK is expressed in SQL with the following structure:
-
-```sql
-SELECT * FROM (
-   SELECT empno,
-          row_number() OVER (ORDER BY empno) rn
-   FROM empsalary) emp
-WHERE rn < 3
-```
-
-:::
-
 ## Pivots
 
 The SQL `PIVOT` operation can be used to turn rows into columns.  It
@@ -375,6 +348,33 @@ Window aggregation functions need to store the entire collection that
 is being aggregated -- the space overhead is thus O(N).  The work
 performed is expected to be O(D log N).
 
+The window aggregate functions `RANK`, `DENSE_RANK`, and `ROW_NUMBER`
+may be very expensive to evaluate incrementally, because it's possible
+for a very small input change to produce a very large output change:
+inserting or deleting a single row can change the numbering of all
+subsequent rows in the same group.  These functions can have a
+reasonable cost in three circumstances:
+
+- each modified group (created by `PARTITION BY`) is relatively small in size
+
+- new insertions and deletions feature rows that appear towards the
+  end of the order produced by the `ORDER BY` clause
+
+- they are used in a TopK pattern with a small limit.
+  The topK is expressed in SQL with the following structure:
+
+```sql
+SELECT * FROM (
+   SELECT empno,
+          row_number() OVER (ORDER BY empno) rn
+   FROM empsalary) emp
+WHERE rn < 3
+```
+
+Window aggregation functions involving `ROWS BETWEEN` are implemented
+behind the scenes by computing `ROW_NUMBER` for each `PARTITION BY`
+group, so they inherit the cost of `ROW_NUMBER` as described above.
+
 ### `DISTINCT`
 
 The `DISTINCT` operation can be used with an aggregation or in a
diff --git a/docs.feldera.com/docs/sql/grammar.md b/docs.feldera.com/docs/sql/grammar.md
index 14c57d086c7..7b291da794e 100644
--- a/docs.feldera.com/docs/sql/grammar.md
+++ b/docs.feldera.com/docs/sql/grammar.md
@@ -234,8 +234,8 @@ reading columns from the input that are not used in any view
 definitions. To be skipped, the columns must be either nullable or
 have default values. This can improve ingestion performance,
 especially for wide tables.  Not all connectors support this feature;
-currently only the Delta table connectors can take advantage of this
-feature.
+currently only the Delta table and Iceberg connectors can take
+advantage of this feature.
 
 Note: The simplest way to exclude unused columns is to omit them from
 the Feldera SQL table declaration. The connector never reads columns
diff --git a/docs.feldera.com/docs/sql/unsupported-operations.md b/docs.feldera.com/docs/sql/unsupported-operations.md
index 182669bac97..f68f8f15e82 100644
--- a/docs.feldera.com/docs/sql/unsupported-operations.md
+++ b/docs.feldera.com/docs/sql/unsupported-operations.md
@@ -6,17 +6,27 @@ Feldera.  These limitations are tracked in our [GitHub issue
 tracker](https://github.com/feldera/feldera/issues) and may be
 resolved in future releases.
 
+## Aggregate functions
+
+The following aggregate functions are not supported:
+`PERCENTILE_DISC`, `PERCENTILE_CONT`, `MODE`, `CORR`, `COVAR_POP`,
+`COVAR_SAMP`, `REGR_SLOPE`, `REGR_INTERCEPT`, `REGR_R2`, `JSON_AGG`,
+`JSON_OBJECT_AGG`, `VAR_POP`, `VAR_SAMP`, `LISTAGG`.
+
 ## Window functions (`OVER` clause)
 
-### `NTILE` and `NTH_VALUE` are not supported
+### Statistics window functions
 
-The `NTILE()` and `NTH_VALUE()` window functions are not yet implemented.
+`NTILE`, `NTH_VALUE`, `PERCENT_RANK`, `CUME_DIST`, `VAR_POP`,
+`VAR_SAMP` window functions are not yet implemented.
 
 ### `FIRST_VALUE` and `LAST_VALUE` limited to unbounded range
 
-`FIRST_VALUE()` and `LAST_VALUE()` are only supported for windows with
-an unbounded range (e.g., `RANGE BETWEEN UNBOUNDED PRECEDING AND
-CURRENT ROW`).  Custom `RANGE` bounds or `ROWS` frames are not yet
+`FIRST_VALUE()` and `LAST_VALUE()` are only supported for frames whose
+bounds are `UNBOUNDED PRECEDING`, `CURRENT ROW`, or `UNBOUNDED
+FOLLOWING` (with `RANGE` or `ROWS`): `FIRST_VALUE` requires the frame
+to start at `UNBOUNDED PRECEDING`, and `LAST_VALUE` requires the frame
+to end at `UNBOUNDED FOLLOWING`.  Numeric bounds are not yet
 supported.
 See [#3918](https://github.com/feldera/feldera/issues/3918).
 
@@ -26,12 +36,6 @@ Window functions using `ORDER BY` on `VARCHAR`/`STRING`,
 `DOUBLE`/`FLOAT` or `VARBINARY` columns are not yet supported.
 See [#457](https://github.com/feldera/feldera/issues/457).
 
-### `ROWS` frame type not supported
-
-The `ROWS` frame specification in window functions is not yet
-supported.  Only `RANGE` frames are currently accepted.  See
-[#457](https://github.com/feldera/feldera/issues/457).  This
-limitation affects TPC-DS query q51.
 
 ### `EXCLUDE` clause not supported
 
@@ -97,7 +101,6 @@ Several `MAP` functions are not yet implemented:
 
 A list of supported MAP operations is available [here](./map.md).
 See [#1907](https://github.com/feldera/feldera/issues/1907).
-
 ## `MATCH_RECOGNIZE`
 
 The `MATCH_RECOGNIZE` clause for pattern matching over rows is not yet
@@ -117,12 +120,9 @@ The `MULTISET` data type is not currently supported.
 Session windows (grouping events into sessions based on a gap in
 activity) are not yet supported.
 
-## Timezone support
+## `TIME` with timezone
 
-`TIME`, and `TIMESTAMP` types have no time zone.  There is no
-`TIMESTAMP WITH TIME ZONE` type, and timezone conversion functions are
-not available.  See the [datetime documentation](datetime.md#timezones)
-for details.
+The type `TIME WITH TIME ZONE` is not supported.
 
 ## Performance caveats
 
diff --git a/js-packages/web-console/src/lib/components/layout/Drawer.svelte b/js-packages/web-console/src/lib/components/layout/Drawer.svelte
index 54f41532dae..ca53ec42a1c 100644
--- a/js-packages/web-console/src/lib/components/layout/Drawer.svelte
+++ b/js-packages/web-console/src/lib/components/layout/Drawer.svelte
@@ -3,6 +3,7 @@
 
   import OverlayDrawer from '$lib/components/layout/OverlayDrawer.svelte'
   import { useIsTablet } from '$lib/compositions/layout/useIsMobile.svelte'
+  import type { Percent } from '$lib/functions/common/percent'
   import type { Snippet } from '$lib/types/svelte'
 
   const isTablet = useIsTablet()
@@ -10,16 +11,34 @@
   let {
     open = $bindable(),
     side,
+    main,
     children,
-    width,
+    width = 'w-[700px]',
     onClose,
-    inlineClass = ''
+    inlineClass = '',
+    defaultSize = '30%',
+    minSize = '20%',
+    maxSize = '80%',
+    localStorageKey
   }: {
     open: boolean
     side: 'right' | 'left'
+    /**
+     * Always-visible content. On wide screens the drawer resizes against it
+     * via a draggable divider; on tablet/mobile the drawer overlays it.
+     */
+    main: Snippet
+    /** Drawer content. */
     children: Snippet
-    width: string
+    /** Overlay-mode drawer width on tablet/mobile, e.g. `w-[700px]`. */
+    width?: string
     inlineClass?: string
+    /** Inline drawer pane size on open, as a percentage of the container. */
+    defaultSize?: Percent
+    minSize?: Percent
+    maxSize?: Percent
+    /** localStorage key to persist the resized inline layout. */
+    localStorageKey?: string
     /**
      * Called when the drawer requests dismissal (currently fired by the
      * modal-backdrop click in the tablet/mobile overlay variant).
@@ -28,8 +47,8 @@
   } = $props()
 </script>
 
-<!-- {#if isTablet.matches} -->
 {#if isTablet.current}
+  {@render main()}
   <OverlayDrawer
     {width}
     bind:open
@@ -40,5 +59,15 @@
     class="bg-white-dark p-4"
   ></OverlayDrawer>
 {:else}
-  <InlineDrawer {width} {open} {side} {children} class="bg-white-dark {inlineClass}"></InlineDrawer>
+  <InlineDrawer
+    {open}
+    {side}
+    {main}
+    {children}
+    {defaultSize}
+    {minSize}
+    {maxSize}
+    {localStorageKey}
+    class="bg-white-dark {inlineClass}"
+  ></InlineDrawer>
 {/if}
diff --git a/js-packages/web-console/src/lib/components/layout/InlineDrawer.svelte b/js-packages/web-console/src/lib/components/layout/InlineDrawer.svelte
index 5a2ccf07b0f..923872b9348 100644
--- a/js-packages/web-console/src/lib/components/layout/InlineDrawer.svelte
+++ b/js-packages/web-console/src/lib/components/layout/InlineDrawer.svelte
@@ -1,38 +1,75 @@
 <script lang="ts">
+  import { Pane, PaneGroup, PaneResizer } from 'paneforge'
+  import { type Percent, percentValue } from '$lib/functions/common/percent'
   import type { Snippet } from '$lib/types/svelte'
 
   const {
     side,
     open,
+    main,
     children,
-    width,
+    defaultSize = '33%',
+    minSize = '20%',
+    maxSize = '80%',
+    localStorageKey,
     class: _class = ''
   }: {
+    /** Drawer open state */
     open: boolean
+    /** Whether the drawer opens on the left or right of the container */
     side: 'right' | 'left'
+    /** Always-visible content the drawer resizes against. */
+    main: Snippet
+    /** Drawer content, shown next to `main` when `open` is true. */
     children: Snippet
-    width: string
+    /** Drawer pane size on open, as a percentage of the container width. */
+    defaultSize?: Percent
+    /** Smallest the drawer pane can be dragged, as a percentage of the container width. */
+    minSize?: Percent
+    /** Largest the drawer pane can be dragged, as a percentage of the container width. */
+    maxSize?: Percent
+    /** localStorage key to persist the resized layout across sessions. */
+    localStorageKey?: string
+    /** Classes of the drawer body wrapper */
     class?: string
   } = $props()
 
-  const positionClass = {
-    right: 'left-0',
-    left: 'right-0 '
-  }
-
-  const shadowClass = {
-    right: 'shadow-[-1px_0px_4px_0px_rgba(0,0,0,0.1)] [clip-path:inset(0_0_0_-5px)] pl-4 ml-4',
-    left: 'shadow-[1px_0px_-4px_0px_rgba(0,0,0,0.1)] [clip-path:inset(0_5px_0_0)] pr-4 mr-4'
-  }
+  const mainOrder = $derived(side === 'right' ? 1 : 2)
+  const drawerOrder = $derived(side === 'right' ? 2 : 1)
+  const mainMinSize = $derived(100 - percentValue(maxSize))
 </script>
 
-<div class="{open ? shadowClass[side] : ''} overflow-clip">
-  <div
-    class={' relative h-full transition-[width] duration-300 ease-in-out ' +
-      (open ? width : 'w-0 ')}
+{#snippet mainPane()}
+  <Pane order={mainOrder} minSize={mainMinSize} class="!overflow-visible">
+    {@render main()}
+  </Pane>
+{/snippet}
+{#snippet drawerPane()}
+  <Pane
+    order={drawerOrder}
+    defaultSize={percentValue(defaultSize)}
+    minSize={percentValue(minSize)}
+    maxSize={percentValue(maxSize)}
+    class="!overflow-visible"
   >
-    <div class=" absolute h-full {width} {positionClass[side]} {_class}">
+    <div class="h-full {_class}">
       {@render children()}
     </div>
-  </div>
-</div>
+  </Pane>
+{/snippet}
+
+<PaneGroup
+  direction="horizontal"
+  class="h-full min-w-0 flex-1 !overflow-visible"
+  autoSaveId={localStorageKey}
+>
+  {#if open && side === 'left'}
+    {@render drawerPane()}
+    <PaneResizer class="pane-divider-vertical mx-2" />
+  {/if}
+  {@render mainPane()}
+  {#if open && side === 'right'}
+    <PaneResizer class="pane-divider-vertical mx-2" />
+    {@render drawerPane()}
+  {/if}
+</PaneGroup>
diff --git a/js-packages/web-console/src/lib/components/layout/InlineDrawer.svelte.spec.ts b/js-packages/web-console/src/lib/components/layout/InlineDrawer.svelte.spec.ts
new file mode 100644
index 00000000000..14a4d753738
--- /dev/null
+++ b/js-packages/web-console/src/lib/components/layout/InlineDrawer.svelte.spec.ts
@@ -0,0 +1,54 @@
+/**
+ * Component tests for the resizable inline drawer. The drawer lays its
+ * always-visible `main` content next to a resizable `children` pane using
+ * PaneForge; a draggable separator (`[data-pane-resizer]`) appears only while
+ * the drawer is open. These tests run irrespective of viewport, since
+ * `InlineDrawer` is the wide-screen variant selected by `Drawer`.
+ */
+
+import { createRawSnippet } from 'svelte'
+import { describe, expect, it } from 'vitest'
+import { page } from 'vitest/browser'
+import { render } from 'vitest-browser-svelte'
+import InlineDrawer from './InlineDrawer.svelte'
+
+const textSnippet = (text: string) =>
+  createRawSnippet(() => ({ render: () => `<div>${text}</div>` }))
+
+const renderDrawer = (props: { open: boolean; side: 'right' | 'left' }) =>
+  render(InlineDrawer, {
+    ...props,
+    main: textSnippet('MAIN CONTENT'),
+    children: textSnippet('DRAWER CONTENT')
+  })
+
+describe('InlineDrawer', () => {
+  it('shows only the main content and no resize handle when closed', async () => {
+    const { container } = renderDrawer({ open: false, side: 'right' })
+
+    await expect.element(page.getByText('MAIN CONTENT')).toBeInTheDocument()
+    // Closed: the main pane fills the container, so there is nothing to drag.
+    expect(container.querySelector('[data-pane-resizer]')).toBeNull()
+    expect(container.textContent).not.toContain('DRAWER CONTENT')
+  })
+
+  it('renders the drawer content and a draggable resize handle when open', async () => {
+    const { container } = renderDrawer({ open: true, side: 'right' })
+
+    await expect.element(page.getByText('DRAWER CONTENT')).toBeInTheDocument()
+    await expect.element(page.getByText('MAIN CONTENT')).toBeInTheDocument()
+    // The separator is what makes the drawer resizable — the crux of the feature.
+    // Remove the `{#if open}` guard around the resizer to see this assertion fail.
+    expect(container.querySelector('[data-pane-resizer]')).not.toBeNull()
+  })
+
+  it('places the drawer before the main content when anchored to the left', async () => {
+    const { container } = renderDrawer({ open: true, side: 'left' })
+
+    await expect.element(page.getByText('DRAWER CONTENT')).toBeInTheDocument()
+    // Declared `order` keeps the drawer pane first regardless of render order.
+    const panes = [...container.querySelectorAll('[data-pane]')]
+    expect(panes[0]?.textContent).toContain('DRAWER CONTENT')
+    expect(panes[1]?.textContent).toContain('MAIN CONTENT')
+  })
+})
diff --git a/js-packages/web-console/src/lib/components/layout/OverlayDrawer.svelte b/js-packages/web-console/src/lib/components/layout/OverlayDrawer.svelte
index 06b6ade767c..7c0c8b76983 100644
--- a/js-packages/web-console/src/lib/components/layout/OverlayDrawer.svelte
+++ b/js-packages/web-console/src/lib/components/layout/OverlayDrawer.svelte
@@ -63,7 +63,10 @@
       <div
         role="dialog"
         aria-modal="true"
-        class={'flex h-full flex-col' + (open ? ' shadow-xl ' : ' ') + `${width} ` + _class}
+        class={'flex h-full max-w-full flex-col' +
+          (open ? ' shadow-xl ' : ' ') +
+          `${width} ` +
+          _class}
       >
         {@render children?.()}
       </div>
diff --git a/js-packages/web-console/src/lib/components/layout/OverlayDrawer.svelte.spec.ts b/js-packages/web-console/src/lib/components/layout/OverlayDrawer.svelte.spec.ts
new file mode 100644
index 00000000000..b3fa7f285cd
--- /dev/null
+++ b/js-packages/web-console/src/lib/components/layout/OverlayDrawer.svelte.spec.ts
@@ -0,0 +1,40 @@
+/**
+ * Component tests for the overlay drawer used on tablet/mobile. The drawer has
+ * a nominal width (e.g. `w-[700px]`) but must never grow wider than the screen,
+ * otherwise its contents scroll the page horizontally. These tests run at the
+ * browser's default narrow viewport, where the nominal width exceeds the screen.
+ */
+
+import { createRawSnippet } from 'svelte'
+import { describe, expect, it } from 'vitest'
+import { render } from 'vitest-browser-svelte'
+import OverlayDrawer from './OverlayDrawer.svelte'
+
+const textSnippet = (text: string) =>
+  createRawSnippet(() => ({ render: () => `<div>${text}</div>` }))
+
+const renderOverlay = () =>
+  render(OverlayDrawer, {
+    open: true,
+    side: 'right',
+    modal: true,
+    width: 'w-[700px]',
+    class: 'p-4',
+    children: textSnippet('DRAWER CONTENT')
+  })
+
+describe('OverlayDrawer', () => {
+  it('caps the drawer at the viewport width on narrow screens', async () => {
+    // Precondition: the nominal width is wider than the screen, so an
+    // uncapped drawer would overflow. Guard against a wide test viewport.
+    expect(window.innerWidth).toBeLessThan(700)
+
+    const { container } = renderOverlay()
+    const dialog = container.querySelector('[role="dialog"]') as HTMLElement
+    expect(dialog).not.toBeNull()
+
+    // The dialog shrinks to fit instead of forcing 700px.
+    // (Drop `max-w-full` from the dialog class to see this fail.)
+    expect(dialog.getBoundingClientRect().width).toBeLessThanOrEqual(window.innerWidth)
+  })
+})
diff --git a/js-packages/web-console/src/lib/components/layout/pipelines/PipelineEditLayout.svelte b/js-packages/web-console/src/lib/components/layout/pipelines/PipelineEditLayout.svelte
index c05940dd707..cd89e429947 100644
--- a/js-packages/web-console/src/lib/components/layout/pipelines/PipelineEditLayout.svelte
+++ b/js-packages/web-console/src/lib/components/layout/pipelines/PipelineEditLayout.svelte
@@ -345,7 +345,11 @@
     {/if}
 
     <Pane class="!overflow-visible">
-      <PaneGroup direction="vertical" class="!overflow-visible">
+      <PaneGroup
+        direction="vertical"
+        class="!overflow-visible"
+        autoSaveId="layout/pipelines/monitoringPanel/size"
+      >
         {#if pipelineBannerMessage}
           <div class="pb-2 md:pb-4">
             <PipelineBanner {...pipelineBannerMessage}></PipelineBanner>
@@ -353,7 +357,11 @@
         {/if}
 
         <Pane defaultSize={60} minSize={15} class="!overflow-visible">
-          <PaneGroup direction="horizontal" class="!overflow-visible">
+          <PaneGroup
+            direction="horizontal"
+            class="!overflow-visible"
+            autoSaveId="layout/pipelines/interactionPanel/size"
+          >
             <Pane minSize={30} class="!overflow-visible">
               {#if pipeline.current}
                 <PipelineCodePanel
diff --git a/js-packages/web-console/src/lib/components/pipelines/editor/TabHealth.svelte b/js-packages/web-console/src/lib/components/pipelines/editor/TabHealth.svelte
index 3d8c845029f..c46fea0cb82 100644
--- a/js-packages/web-console/src/lib/components/pipelines/editor/TabHealth.svelte
+++ b/js-packages/web-console/src/lib/components/pipelines/editor/TabHealth.svelte
@@ -253,59 +253,60 @@
 </script>
 
 <div data-testid="box-pipeline-health" class="flex h-full flex-nowrap overflow-hidden">
-  <div class="bg-white-dark flex h-full flex-1 flex-col gap-4 overflow-hidden rounded p-2">
-    <StatusTimeline
-      bind:this={timelineRef}
-      label="Pipeline status"
-      events={timelineEvents}
-      startAt={firstTimestamp(events)}
-      endAt={lastTimestamp(events)}
-      unitDurationMs={60 * 60 * 1000}
-      class="flex flex-col gap-2"
-      onBarClick={handleBarClick}
-      legend={['idle', 'transitioning', 'healthy', 'unhealthy', 'major_issue']}
-      updatedAt={lastUpdated}
-      getSeverity={(type) => pipelineStatus(type).severity}
-      getBarColor={(type, h) => pipelineStatus(type).barColor(h)}
-      getStatusStyle={(type) => pipelineStatus(type).statusStyle}
-      selectedBars={selectedEventTimestamp
-        ? { from: selectedEventTimestamp.from, to: selectedEventTimestamp.to }
-        : null}
-    ></StatusTimeline>
-
-    {#if !events && !deleted}
-      <Progress class="h-1" value={null} max={100}>
-        <Progress.Track>
-          <Progress.Range class="bg-primary-500" />
-        </Progress.Track>
-      </Progress>
-    {/if}
-
-    <div class="flex-1 overflow-hidden">
-      <EventLogList
-        bind:this={eventLogListRef}
-        previousEvents={splitEvents.previous}
-        unresolvedEvents={splitEvents.unresolved}
-        onEventSelected={handleEventSelected}
-        selectedEvents={selectedEventTimestamp}
-        getIconClass={(type) => pipelineStatus(type).iconClass}
-      >
-        {#snippet noIssues()}
-          {#if events}
-            <span>The pipeline experienced no issues in the observed period.</span>
-          {/if}
-        {/snippet}
-      </EventLogList>
-    </div>
-  </div>
-
   <Drawer
     open={!!selectedEvent}
     side="right"
-    width="w-[500px]"
     inlineClass="rounded pt-4 pl-4"
     onClose={closeDrawer}
+    localStorageKey="layout/drawer/pipelineHealth"
   >
+    {#snippet main()}
+      <div class="bg-white-dark flex h-full flex-1 flex-col gap-4 overflow-hidden rounded p-2">
+        <StatusTimeline
+          bind:this={timelineRef}
+          label="Pipeline status"
+          events={timelineEvents}
+          startAt={firstTimestamp(events)}
+          endAt={lastTimestamp(events)}
+          unitDurationMs={60 * 60 * 1000}
+          class="flex flex-col gap-2"
+          onBarClick={handleBarClick}
+          legend={['idle', 'transitioning', 'healthy', 'unhealthy', 'major_issue']}
+          updatedAt={lastUpdated}
+          getSeverity={(type) => pipelineStatus(type).severity}
+          getBarColor={(type, h) => pipelineStatus(type).barColor(h)}
+          getStatusStyle={(type) => pipelineStatus(type).statusStyle}
+          selectedBars={selectedEventTimestamp
+            ? { from: selectedEventTimestamp.from, to: selectedEventTimestamp.to }
+            : null}
+        ></StatusTimeline>
+
+        {#if !events && !deleted}
+          <Progress class="h-1" value={null} max={100}>
+            <Progress.Track>
+              <Progress.Range class="bg-primary-500" />
+            </Progress.Track>
+          </Progress>
+        {/if}
+
+        <div class="flex-1 overflow-hidden">
+          <EventLogList
+            bind:this={eventLogListRef}
+            previousEvents={splitEvents.previous}
+            unresolvedEvents={splitEvents.unresolved}
+            onEventSelected={handleEventSelected}
+            selectedEvents={selectedEventTimestamp}
+            getIconClass={(type) => pipelineStatus(type).iconClass}
+          >
+            {#snippet noIssues()}
+              {#if events}
+                <span>The pipeline experienced no issues in the observed period.</span>
+              {/if}
+            {/snippet}
+          </EventLogList>
+        </div>
+      </div>
+    {/snippet}
     {#if selectedEvent}
       <HealthEventList
         eventParts={selectedEvent}
diff --git a/js-packages/web-console/src/lib/components/pipelines/editor/TabPerformance.svelte b/js-packages/web-console/src/lib/components/pipelines/editor/TabPerformance.svelte
index 43a78e592cf..2dd2a0694b6 100644
--- a/js-packages/web-console/src/lib/components/pipelines/editor/TabPerformance.svelte
+++ b/js-packages/web-console/src/lib/components/pipelines/editor/TabPerformance.svelte
@@ -216,129 +216,136 @@
     <div>Pipeline is running, but has not reported usage telemetry yet</div>
   </div>
 {:else}<div class="flex h-full">
-    <div
-      class="-mr-2 scrollbar flex min-w-0 flex-1 flex-col gap-4 overflow-x-clip overflow-y-auto pr-2"
+    <Drawer
+      open={!!openDrawer}
+      side="right"
+      onClose={() => (openDrawer = null)}
+      localStorageKey="layout/drawer/pipelinePerformance"
     >
-      <div class="flex w-full flex-col gap-4">
-        <div class="flex flex-wrap gap-4">
-          <div class="mt-1 flex flex-wrap items-center gap-4">
-            <div class="flex flex-col">
-              <div class="text-start text-sm text-nowrap">Records Ingested</div>
-              <div class="pt-2">
-                {formatQty(global.total_input_records)}
-              </div>
-            </div>
-            <div class="flex flex-col">
-              <div class="text-start text-sm text-nowrap">Records Processed</div>
-              <div class="pt-2">
-                {formatQty(global.total_processed_records)}
-              </div>
-            </div>
-            <div class="flex flex-col">
-              <div class="text-start text-sm text-nowrap">Records Buffered</div>
-              <div class="pt-2">
-                {formatQty(global.buffered_input_records)}
-              </div>
-            </div>
-            {#snippet age()}
-              <div class="w-52 pt-2">
-                {#if global.start_time > 0}
-                  On {formatDateTime({ ms: global.start_time * 1000 })}
+      {#snippet main()}
+        <div
+          class="-mr-2 scrollbar flex min-w-0 flex-1 flex-col gap-4 overflow-x-clip overflow-y-auto pr-2"
+        >
+          <div class="flex w-full flex-col gap-4">
+            <div class="flex flex-wrap gap-4">
+              <div class="mt-1 flex flex-wrap items-center gap-4">
+                <div class="flex flex-col">
+                  <div class="text-start text-sm text-nowrap">Records Ingested</div>
+                  <div class="pt-2">
+                    {formatQty(global.total_input_records)}
+                  </div>
+                </div>
+                <div class="flex flex-col">
+                  <div class="text-start text-sm text-nowrap">Records Processed</div>
+                  <div class="pt-2">
+                    {formatQty(global.total_processed_records)}
+                  </div>
+                </div>
+                <div class="flex flex-col">
+                  <div class="text-start text-sm text-nowrap">Records Buffered</div>
+                  <div class="pt-2">
+                    {formatQty(global.buffered_input_records)}
+                  </div>
+                </div>
+                {#snippet age()}
+                  <div class="w-52 pt-2">
+                    {#if global.start_time > 0}
+                      On {formatDateTime({ ms: global.start_time * 1000 })}
+                    {:else}
+                      Not deployed
+                    {/if}
+                  </div>
+                {/snippet}
+                {#snippet updated()}
+                  <div class="w-64 pt-2 text-nowrap">
+                    {getDeploymentStatusLabel(pipeline.current.status)} since {Dayjs(
+                      pipeline.current.deploymentStatusSince
+                    ).format('MMM D, YYYY h:mm A')}
+                  </div>
+                {/snippet}
+                {#if isXl.current}
+                  <div class="flex flex-col">
+                    <div class="text-start text-sm">
+                      Deployment age -
+
+                      {#if global.start_time > 0}
+                        {formatElapsedTime(new Date(global.start_time * 1000))}
+                      {:else}
+                        N/A
+                      {/if}
+                    </div>
+                    {@render age()}
+                  </div>
+                  <div class="flex flex-col">
+                    <div class="text-start text-sm">
+                      Last status update - {formatElapsedTime(
+                        new Date(pipeline.current.deploymentStatusSince)
+                      )}
+                    </div>
+                    {@render updated()}
+                  </div>
                 {:else}
-                  Not deployed
+                  <div>
+                    <SegmentedControl
+                      value={statusTab}
+                      onValueChange={(v) => (statusTab = v)}
+                      items={[
+                        { value: 'age', label: 'Age' },
+                        { value: 'updated', label: 'Last status update' }
+                      ]}
+                      class="-mt-3"
+                    />
+                    {#if statusTab === 'age'}
+                      {@render age()}
+                    {:else if statusTab === 'updated'}
+                      {@render updated()}{/if}
+                  </div>
                 {/if}
               </div>
-            {/snippet}
-            {#snippet updated()}
-              <div class="w-64 pt-2 text-nowrap">
-                {getDeploymentStatusLabel(pipeline.current.status)} since {Dayjs(
-                  pipeline.current.deploymentStatusSince
-                ).format('MMM D, YYYY h:mm A')}
+            </div>
+            <div class="flex w-full flex-col gap-4 xl:flex-row">
+              <div class="bg-white-dark relative h-52 w-full max-w-[700px] rounded">
+                <PipelineThroughputGraph
+                  {pipeline}
+                  metrics={timeSeries}
+                  refetchMs={1000}
+                  keepMs={60 * 1000}
+                ></PipelineThroughputGraph>
               </div>
-            {/snippet}
-            {#if isXl.current}
-              <div class="flex flex-col">
-                <div class="text-start text-sm">
-                  Deployment age -
-
-                  {#if global.start_time > 0}
-                    {formatElapsedTime(new Date(global.start_time * 1000))}
-                  {:else}
-                    N/A
-                  {/if}
-                </div>
-                {@render age()}
+              <div class="bg-white-dark relative h-52 w-full max-w-[700px] rounded">
+                <PipelineMemoryGraph
+                  {pipeline}
+                  metrics={timeSeries}
+                  refetchMs={1000}
+                  keepMs={60 * 1000}
+                  memoryPressure={global.memory_pressure}
+                ></PipelineMemoryGraph>
               </div>
-              <div class="flex flex-col">
-                <div class="text-start text-sm">
-                  Last status update - {formatElapsedTime(
-                    new Date(pipeline.current.deploymentStatusSince)
-                  )}
-                </div>
-                {@render updated()}
+              <div class="bg-white-dark relative h-52 w-full max-w-[700px] rounded">
+                <PipelineStorageGraph
+                  {pipeline}
+                  metrics={timeSeries}
+                  refetchMs={1000}
+                  keepMs={60 * 1000}
+                ></PipelineStorageGraph>
               </div>
-            {:else}
-              <div>
-                <SegmentedControl
-                  value={statusTab}
-                  onValueChange={(v) => (statusTab = v)}
-                  items={[
-                    { value: 'age', label: 'Age' },
-                    { value: 'updated', label: 'Last status update' }
-                  ]}
-                  class="-mt-3"
-                />
-                {#if statusTab === 'age'}
-                  {@render age()}
-                {:else if statusTab === 'updated'}
-                  {@render updated()}{/if}
-              </div>
-            {/if}
-          </div>
-        </div>
-        <div class="flex w-full flex-col gap-4 xl:flex-row">
-          <div class="bg-white-dark relative h-52 w-full max-w-[700px] rounded">
-            <PipelineThroughputGraph
-              {pipeline}
-              metrics={timeSeries}
-              refetchMs={1000}
-              keepMs={60 * 1000}
-            ></PipelineThroughputGraph>
-          </div>
-          <div class="bg-white-dark relative h-52 w-full max-w-[700px] rounded">
-            <PipelineMemoryGraph
-              {pipeline}
-              metrics={timeSeries}
-              refetchMs={1000}
-              keepMs={60 * 1000}
-              memoryPressure={global.memory_pressure}
-            ></PipelineMemoryGraph>
-          </div>
-          <div class="bg-white-dark relative h-52 w-full max-w-[700px] rounded">
-            <PipelineStorageGraph
-              {pipeline}
-              metrics={timeSeries}
-              refetchMs={1000}
-              keepMs={60 * 1000}
-            ></PipelineStorageGraph>
+            </div>
+            <CheckpointsIndicator
+              {pipelineName}
+              {checkpoints}
+              {metrics}
+              {checkpointStatus}
+              onShowCheckpoints={() => (openDrawer = { kind: 'checkpoints' })}
+            />
+            <TransactionStatus {metrics} class="w-full"></TransactionStatus>
           </div>
+          {#if metrics.current.views.size || metrics.current.tables.size}
+            <div class="flex flex-wrap gap-4">
+              <MetricsTables {metrics} onConnectorSelect={handleConnectorSelect} />
+            </div>
+          {/if}
         </div>
-        <CheckpointsIndicator
-          {pipelineName}
-          {checkpoints}
-          {metrics}
-          {checkpointStatus}
-          onShowCheckpoints={() => (openDrawer = { kind: 'checkpoints' })}
-        />
-        <TransactionStatus {metrics} class="w-full"></TransactionStatus>
-      </div>
-      {#if metrics.current.views.size || metrics.current.tables.size}
-        <div class="flex flex-wrap gap-4">
-          <MetricsTables {metrics} onConnectorSelect={handleConnectorSelect} />
-        </div>
-      {/if}
-    </div>
-    <Drawer open={!!openDrawer} side="right" width="w-[500px]" onClose={() => (openDrawer = null)}>
+      {/snippet}
       {#if openDrawer?.kind === 'connector'}
         <ConnectorErrors
           {pipelineName}
diff --git a/js-packages/web-console/src/lib/functions/common/percent.ts b/js-packages/web-console/src/lib/functions/common/percent.ts
new file mode 100644
index 00000000000..25b79156ca0
--- /dev/null
+++ b/js-packages/web-console/src/lib/functions/common/percent.ts
@@ -0,0 +1,15 @@
+/** A percentage string such as `30%`. */
+export type Percent = `${number}%`
+
+/**
+ * Build a {@link Percent} from a number.
+ * @example percent(30) // '30%'
+ * @param value Percentage magnitude, e.g. `30` for `30%`.
+ */
+export const percent = (value: number): Percent => `${value}%`
+
+/**
+ * Read the numeric magnitude of a {@link Percent}.
+ * @example percentValue('30%') // 30
+ */
+export const percentValue = (value: Percent): number => parseFloat(value)
diff --git a/js-packages/web-console/src/routes/(system)/(authenticated)/health/+page.svelte b/js-packages/web-console/src/routes/(system)/(authenticated)/health/+page.svelte
index ae6fc263c48..d96a8a92d21 100644
--- a/js-packages/web-console/src/routes/(system)/(authenticated)/health/+page.svelte
+++ b/js-packages/web-console/src/routes/(system)/(authenticated)/health/+page.svelte
@@ -264,53 +264,61 @@
 </AppHeader>
 
 <div class="flex h-full flex-nowrap px-2 pb-5 md:px-8">
-  <div class="flex h-full flex-1 flex-col gap-8 rounded-container">
-    <!-- Status Timelines for each Feldera service -->
-    <div class="flex flex-col gap-2">
-      {#each Object.entries(componentLabels) as [tag, label], i}
-        <StatusTimeline
-          bind:this={timelineRefs[tag as EventTag]}
-          {label}
-          events={rawClusterEvents.filter((e) => e.tag === tag)}
-          startAt={firstTimestamp(events)}
-          endAt={lastTimestamp(events)}
-          unitDurationMs={60 * 60 * 1000}
-          class="flex flex-col gap-2"
-          onBarClick={(group) => handleBarClick(tag as EventTag, group)}
-          legend={i === 2 ? (['healthy', 'unhealthy', 'major_issue'] as ClusterEventType[]) : []}
-          selectedBars={selectedEventTimestamp?.tag === tag
-            ? { from: selectedEventTimestamp.from, to: selectedEventTimestamp.to }
-            : null}
-          getSeverity={(type) => clusterStatus(type).severity}
-          getBarColor={(type, h) => clusterStatus(type).barColor(h)}
-          getStatusStyle={(type) => clusterStatus(type).statusStyle}
-        ></StatusTimeline>
-      {/each}
-    </div>
-    {#if !events}
-      <Progress class="h-1" value={null} max={100}>
-        <Progress.Track>
-          <Progress.Range class="bg-primary-500" />
-        </Progress.Track>
-      </Progress>
-    {/if}
-    <EventLogList
-      bind:this={eventLogListRef}
-      previousEvents={splitClusterEvents.previous}
-      unresolvedEvents={splitClusterEvents.unresolved}
-      onEventSelected={handleEventSelected}
-      selectedEvents={selectedEventTimestamp}
-      getIconClass={(type) => clusterStatus(type).iconClass}
-    >
-      {#snippet noIssues()}
-        {#if events}
-          <span>The cluster experienced no issues in the observed period.</span>
+  <Drawer
+    open={!!selectedEvent}
+    side="right"
+    onClose={onCloseDrawer}
+    localStorageKey="layout/drawer/clusterHealth"
+  >
+    {#snippet main()}
+      <div class="flex h-full flex-1 flex-col gap-8 rounded-container">
+        <!-- Status Timelines for each Feldera service -->
+        <div class="flex flex-col gap-2">
+          {#each Object.entries(componentLabels) as [tag, label], i}
+            <StatusTimeline
+              bind:this={timelineRefs[tag as EventTag]}
+              {label}
+              events={rawClusterEvents.filter((e) => e.tag === tag)}
+              startAt={firstTimestamp(events)}
+              endAt={lastTimestamp(events)}
+              unitDurationMs={60 * 60 * 1000}
+              class="flex flex-col gap-2"
+              onBarClick={(group) => handleBarClick(tag as EventTag, group)}
+              legend={i === 2
+                ? (['healthy', 'unhealthy', 'major_issue'] as ClusterEventType[])
+                : []}
+              selectedBars={selectedEventTimestamp?.tag === tag
+                ? { from: selectedEventTimestamp.from, to: selectedEventTimestamp.to }
+                : null}
+              getSeverity={(type) => clusterStatus(type).severity}
+              getBarColor={(type, h) => clusterStatus(type).barColor(h)}
+              getStatusStyle={(type) => clusterStatus(type).statusStyle}
+            ></StatusTimeline>
+          {/each}
+        </div>
+        {#if !events}
+          <Progress class="h-1" value={null} max={100}>
+            <Progress.Track>
+              <Progress.Range class="bg-primary-500" />
+            </Progress.Track>
+          </Progress>
         {/if}
-      {/snippet}
-    </EventLogList>
-  </div>
-  <!-- TODO: Create a responsive inline drawer - that takes up full width on smaller screens -->
-  <Drawer open={!!selectedEvent} side="right" width="w-[500px]" onClose={onCloseDrawer}>
+        <EventLogList
+          bind:this={eventLogListRef}
+          previousEvents={splitClusterEvents.previous}
+          unresolvedEvents={splitClusterEvents.unresolved}
+          onEventSelected={handleEventSelected}
+          selectedEvents={selectedEventTimestamp}
+          getIconClass={(type) => clusterStatus(type).iconClass}
+        >
+          {#snippet noIssues()}
+            {#if events}
+              <span>The cluster experienced no issues in the observed period.</span>
+            {/if}
+          {/snippet}
+        </EventLogList>
+      </div>
+    {/snippet}
     {#if selectedEvent}
       <HealthEventList
         eventParts={selectedEvent}
diff --git a/openapi.json b/openapi.json
index ae463787026..cb4264f90c0 100644
--- a/openapi.json
+++ b/openapi.json
@@ -10,7 +10,7 @@
     "license": {
       "name": "MIT OR Apache-2.0"
     },
-    "version": "0.322.0"
+    "version": "0.323.0"
   },
   "paths": {
     "/config/authentication": {
diff --git a/python/dbt-feldera/pyproject.toml b/python/dbt-feldera/pyproject.toml
index efb418810d6..b348c2d926c 100644
--- a/python/dbt-feldera/pyproject.toml
+++ b/python/dbt-feldera/pyproject.toml
@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "dbt-feldera"
 readme = "README.md"
 description = "The dbt adapter for Feldera — DBSP-native incremental view maintenance"
-version = "0.322.0"
+version = "0.323.0"
 license = "MIT"
 requires-python = ">=3.10"
 authors = [
diff --git a/python/felderize/pyproject.toml b/python/felderize/pyproject.toml
index e643bc850e2..eb43304cdce 100644
--- a/python/felderize/pyproject.toml
+++ b/python/felderize/pyproject.toml
@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "felderize"
 readme = "README.md"
 description = "SQL dialect to Feldera SQL translator agent"
-version = "0.322.0"
+version = "0.323.0"
 license = "MIT"
 requires-python = ">=3.10"
 authors = [
diff --git a/python/pyproject.toml b/python/pyproject.toml
index 18dcac354e2..19601bf8260 100644
--- a/python/pyproject.toml
+++ b/python/pyproject.toml
@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "feldera"
 readme = "README.md"
 description = "The feldera python client"
-version = "0.322.0"
+version = "0.323.0"
 license = "MIT"
 requires-python = ">=3.10,<3.14"
 authors = [
diff --git a/python/tests/platform/test_shared_pipeline.py b/python/tests/platform/test_shared_pipeline.py
index 9ebf255cdc6..d51663aef60 100644
--- a/python/tests/platform/test_shared_pipeline.py
+++ b/python/tests/platform/test_shared_pipeline.py
@@ -208,6 +208,81 @@ def test_adhoc_query_arrow(self):
         table_pipeline = pa.Table.from_batches(batches_pipeline)
         assert table_pipeline.column("id").to_pylist() == expected_ids
 
+    def test_adhoc_json_functions(self):
+        """
+        CREATE TABLE json_docs (id INT NOT NULL, doc VARIANT) WITH ('materialized' = 'true');
+        """
+        self.pipeline.start()
+        self.pipeline.input_json(
+            "json_docs",
+            [
+                {"id": 1, "doc": {"name": "Bob", "scores": [8, 10], "active": True}},
+                {
+                    "id": 2,
+                    "doc": {
+                        "name": "Ann",
+                        "scores": [3],
+                        "address": {"city": "Berlin"},
+                    },
+                },
+                {"id": 3, "doc": None},
+            ],
+        )
+
+        # A bare VARIANT column comes back as a JSON-encoded string.
+        got = list(self.pipeline.query("SELECT doc FROM json_docs WHERE id = 1"))
+        assert json.loads(got[0]["doc"]) == {
+            "name": "Bob",
+            "scores": [8, 10],
+            "active": True,
+        }
+
+        got = list(
+            self.pipeline.query(
+                "SELECT id, json_get_str(doc, 'name') AS name,"
+                " json_get_int(doc, 'scores', 1) AS second_score"
+                " FROM json_docs ORDER BY id"
+            )
+        )
+        assert got == [
+            {"id": 1, "name": "Bob", "second_score": 10},
+            {"id": 2, "name": "Ann", "second_score": None},
+            {"id": 3, "name": None, "second_score": None},
+        ]
+
+        # Nested paths mix object keys and array indexes.
+        got = list(
+            self.pipeline.query(
+                "SELECT json_get_str(doc, 'address', 'city') AS city"
+                " FROM json_docs WHERE id = 2"
+            )
+        )
+        assert got == [{"city": "Berlin"}]
+
+        # JSON predicates filter on document contents.
+        got = list(
+            self.pipeline.query(
+                "SELECT id FROM json_docs WHERE json_contains(doc, 'address')"
+            )
+        )
+        assert got == [{"id": 2}]
+        got = list(
+            self.pipeline.query(
+                "SELECT id FROM json_docs WHERE json_get_bool(doc, 'active') = TRUE"
+            )
+        )
+        assert got == [{"id": 1}]
+
+        got = list(
+            self.pipeline.query(
+                "SELECT doc->>'name' AS name,"
+                " CAST(json_get(doc, 'scores', 0) AS BIGINT) AS first_score"
+                " FROM json_docs WHERE id = 1"
+            )
+        )
+        assert got == [{"name": "Bob", "first_score": 8}]
+        self.pipeline.stop(force=True)
+
     def test_local(self):
         """
         CREATE TABLE students (
diff --git a/python/tests/runtime_aggtest/lateness_tests/test_lateness_check.py b/python/tests/runtime_aggtest/lateness_tests/test_lateness_check.py
index a99ce511abb..9bab6636554 100644
--- a/python/tests/runtime_aggtest/lateness_tests/test_lateness_check.py
+++ b/python/tests/runtime_aggtest/lateness_tests/test_lateness_check.py
@@ -65,7 +65,6 @@ def __init__(self):
                         ts,
                         SUM(value) OVER (ORDER BY ts ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) AS rolling_sum
                     FROM purchase"""
-        self.expected_error = "Not yet implemented"
 
 
 class lateness_interval_add(TstView):
diff --git a/python/uv.lock b/python/uv.lock
index 984aaa814a3..bd7f1ec83fb 100644
--- a/python/uv.lock
+++ b/python/uv.lock
@@ -9,7 +9,7 @@ resolution-markers = [
 ]
 
 [options]
-exclude-newer = "2026-07-07T15:40:42.875333412Z"
+exclude-newer = "2026-07-09T03:18:37.849091555Z"
 exclude-newer-span = "P1W"
 
 [[package]]
@@ -273,7 +273,7 @@ wheels = [
 
 [[package]]
 name = "feldera"
-version = "0.322.0"
+version = "0.323.0"
 source = { editable = "." }
 dependencies = [
     { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
diff --git a/sql-to-dbsp-compiler/SQL-compiler/pom.xml b/sql-to-dbsp-compiler/SQL-compiler/pom.xml
index c9da7249b42..0461abeda08 100644
--- a/sql-to-dbsp-compiler/SQL-compiler/pom.xml
+++ b/sql-to-dbsp-compiler/SQL-compiler/pom.xml
@@ -19,7 +19,7 @@
         <calcite.version>1.43.0</calcite.version>
         <jackson.version>2.22.0</jackson.version>
         <janino.version>3.1.12</janino.version>
-        <project.version>0.322.0</project.version>
+        <project.version>0.323.0</project.version>
         <avatica.version>1.28.0</avatica.version>
     </properties>
 
diff --git a/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/compiler/frontend/calciteCompiler/SqlToRelCompiler.java b/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/compiler/frontend/calciteCompiler/SqlToRelCompiler.java
index 57782723dfb..305f1e183f8 100644
--- a/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/compiler/frontend/calciteCompiler/SqlToRelCompiler.java
+++ b/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/compiler/frontend/calciteCompiler/SqlToRelCompiler.java
@@ -692,6 +692,11 @@ public boolean isGroupByAlias() {
         public boolean isHavingAlias() {
             return true;
         }
+
+        @Override
+        public boolean allowLambdaClosure() {
+            return false;
+        }
     }
 
     /** Add a new set of operators to the operator table.  Creates a new validator, converter */
diff --git a/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/compiler/frontend/calciteCompiler/optimizer/CalciteOptimizer.java b/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/compiler/frontend/calciteCompiler/optimizer/CalciteOptimizer.java
index 29042df2295..021d61b322e 100644
--- a/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/compiler/frontend/calciteCompiler/optimizer/CalciteOptimizer.java
+++ b/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/compiler/frontend/calciteCompiler/optimizer/CalciteOptimizer.java
@@ -364,6 +364,8 @@ public String toString() {
                 // See discussion in https://issues.apache.org/jira/browse/CALCITE-6020
                 CoreRules.PROJECT_TO_LOGICAL_PROJECT_AND_WINDOW
         ));
+        this.addStep(new SimpleOptimizerStep("Window ROWS to RANGE", 0,
+                new RowsToRangeRule()));
         this.addStep(new SimpleOptimizerStep("Isolate DISTINCT aggregates", 0,
                 CoreRules.AGGREGATE_EXPAND_DISTINCT_AGGREGATES_TO_JOIN,
                 CoreRules.AGGREGATE_EXPAND_DISTINCT_AGGREGATES
diff --git a/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/compiler/frontend/calciteCompiler/optimizer/RowsToRangeRule.java b/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/compiler/frontend/calciteCompiler/optimizer/RowsToRangeRule.java
new file mode 100644
index 00000000000..7b1637bcdf4
--- /dev/null
+++ b/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/compiler/frontend/calciteCompiler/optimizer/RowsToRangeRule.java
@@ -0,0 +1,356 @@
+package org.dbsp.sqlCompiler.compiler.frontend.calciteCompiler.optimizer;
+
+import com.google.common.collect.ImmutableList;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.plan.RelRule;
+import org.apache.calcite.rel.RelCollation;
+import org.apache.calcite.rel.RelCollations;
+import org.apache.calcite.rel.RelFieldCollation;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Window;
+import org.apache.calcite.rel.logical.LogicalWindow;
+import org.apache.calcite.rel.rules.TransformationRule;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexInputRef;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexShuttle;
+import org.apache.calcite.rex.RexWindowBound;
+import org.apache.calcite.rex.RexWindowBounds;
+import org.apache.calcite.rex.RexWindowExclusion;
+import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.validate.SqlValidatorUtil;
+import org.apache.calcite.util.ImmutableBitSet;
+import org.dbsp.util.Utilities;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Rule that rewrites window aggregates using ROWS frames into aggregates
+ * using RANGE frames over an intermediate ROW_NUMBER() value.
+ *
+ * <p>Within a partition, ROW_NUMBER() assigns consecutive integers following
+ * the ORDER BY of the frame.  A physical frame such as
+ * {@code ROWS BETWEEN 2 PRECEDING AND CURRENT ROW} therefore selects exactly
+ * the rows whose row number lies within {@code [rn - 2, rn]}, which is the
+ * logical frame {@code RANGE BETWEEN 2 PRECEDING AND CURRENT ROW} evaluated
+ * over the row number.  (Row numbers have no duplicates, so the peer rows
+ * that make RANGE differ from ROWS cannot occur.)
+ *
+ * <p>Rewrite of a window over an input with fields $0..$n-1.  SUM is
+ * frame-sensitive and is rewritten; ROW_NUMBER and RANK ignore the frame
+ * and keep the original partitioning and ordering.  The quoted names are
+ * the variables in {@link #onMatch} that hold each plan node:
+ * <pre>
+ * LogicalWindow(window#0=[window(partition {p} order by [o]    -- "window"
+ *                          rows between 2 PRECEDING and 3 FOLLOWING
+ *                          aggs [SUM($1), ROW_NUMBER(), RANK()])])
+ *                                                 -- fields $n, $n+1, $n+2
+ *   Input(fields $0..$n-1)                                     -- "input"
+ * </pre>
+ * becomes
+ * <pre>
+ * LogicalProject($0, ..., $n-1, $n+2, $n, $n+1)                -- "result"
+ *   LogicalWindow(                                             -- "outer"
+ *       window#0=[window(partition {p} order by [o]
+ *                  rows between 2 PRECEDING and 3 FOLLOWING
+ *                  aggs [RANK()])],                            -- field $n+1
+ *       window#1=[window(partition {p} order by [$n]
+ *                  range between 2 PRECEDING and 3 FOLLOWING
+ *                  aggs [SUM($1)])])                           -- field $n+2
+ *     LogicalWindow(window#0=[window(partition {p} order by [o]  -- "outerInput"
+ *                              aggs [ROW_NUMBER()])])          -- field $n
+ *       Input(fields $0..$n-1)                                 -- "input"
+ * </pre>
+ * The projection restores the original aggregate order.
+ * The bottom window synthesizes the row number that orders SUM's RANGE
+ * frame; it carries the default frame, which ROW_NUMBER ignores.  The
+ * user's ROW_NUMBER has the same partitioning and ordering, so it computes
+ * the same value as field $n, and the projection reuses that field instead
+ * of keeping the call.  RANK is tie-sensitive, so it keeps the original
+ * ORDER BY in its own group; that group remains a ROWS group, which is
+ * harmless because RANK ignores the frame.
+ *
+ * <p>Window functions that ignore the frame (their result depends only on
+ * the partition and the ORDER BY) keep the original group: the ROWS flag
+ * has no effect on their result, and ordering by the row number instead of
+ * the original columns would corrupt the tie-sensitive ones (RANK and
+ * friends).  If such calls share a group with rewritten calls, the group
+ * is split in two and a final projection restores the original column
+ * order.
+ */
+public class RowsToRangeRule
+        extends RelRule<DefaultOptRuleConfig<RowsToRangeRule>>
+        implements TransformationRule {
+    protected RowsToRangeRule() {
+        super(CONFIG);
+    }
+
+    /** List of window functions whose result depends only on the partition and the
+     * ORDER BY, never on the frame.  SQL semantics alone determines this
+     * set.  Groups holding only such calls need no rewrite, because the
+     * ROWS flag has no effect on their result.  Moreover, RANK, DENSE_RANK,
+     * PERCENT_RANK, and CUME_DIST are tie-sensitive: ordering by the row
+     * number would break ties and corrupt their result. */
+    private static final EnumSet<SqlKind> FRAME_INSENSITIVE = EnumSet.of(
+            SqlKind.RANK, SqlKind.DENSE_RANK, SqlKind.PERCENT_RANK, SqlKind.CUME_DIST,
+            SqlKind.ROW_NUMBER, SqlKind.NTILE,
+            SqlKind.LAG, SqlKind.LEAD);
+
+    /** What the rule does to one window group. */
+    private enum Action {
+        /** Leave the group unchanged. */
+        NONE,
+        /** The frame covers the whole partition: RANGE selects the same rows
+         * as ROWS, so implement always using RANGE. */
+        USE_RANGE,
+        /** Order by an intermediate ROW_NUMBER() and use a RANGE frame. */
+        REWRITE
+    }
+
+    /** Partitioning and ordering of a ROW_NUMBER() computed by the inner window. */
+    private record OrderSpec(ImmutableBitSet keys, RelCollation orderKeys) {
+        static OrderSpec of(Window.Group group) {
+            return new OrderSpec(group.keys, group.orderKeys);
+        }
+    }
+
+    /** True when the call's result does not depend on the window frame. */
+    static boolean ignoresFrame(Window.RexWinAggCall aggCall) {
+        return FRAME_INSENSITIVE.contains(aggCall.getOperator().getKind());
+    }
+
+    /** Decide what the rule does to one window group.
+     *
+     * <p>A group is left unchanged when it does not use a ROWS frame, or
+     * when every call in it ignores the frame (the ROWS flag then has no
+     * effect on any result), or when a peer-dependent exclusion (EXCLUDE
+     * GROUP, EXCLUDE TIES) makes the rewrite unsound: peers are defined by
+     * the ORDER BY columns, and the row number ordering that the rewrite
+     * introduces has no peers.
+     *
+     * <p>A ROWS frame that spans the whole partition selects the same rows
+     * as the corresponding RANGE frame, so such a group only needs its ROWS
+     * flag cleared; its ORDER BY, and therefore any EXCLUDE clause, keeps
+     * its meaning.
+     *
+     * <p>Every other group is rewritten to a RANGE frame ordered by an
+     * intermediate ROW_NUMBER().  EXCLUDE CURRENT ROW is peer-independent,
+     * so it survives this rewrite.
+     *
+     * @param group A group of aggregate calls sharing one window frame.
+     * @return      The action to apply to the group.
+     */
+    static Action classify(Window.Group group) {
+        if (!group.isRows)
+            return Action.NONE;
+        if (group.aggCalls.stream().allMatch(RowsToRangeRule::ignoresFrame))
+            // The ROWS flag has no effect on any result.
+            return Action.NONE;
+        if (group.lowerBound.isUnboundedPreceding()
+                && group.upperBound.isUnboundedFollowing())
+            // The frame is the whole partition whether it is interpreted
+            // physically or logically.  The ORDER BY is unchanged, so any
+            // EXCLUDE clause keeps its meaning.
+            return Action.USE_RANGE;
+        if (group.exclude == RexWindowExclusion.EXCLUDE_GROUP
+                || group.exclude == RexWindowExclusion.EXCLUDE_TIES)
+            // These exclusions remove peers of the current row; the row
+            // number ordering has no peers, which would change the excluded
+            // set; a rewrite would be unsound.
+            // (EXCLUDE CURRENT ROW is peer-independent and survives the rewrite.)
+            return Action.NONE;
+        return Action.REWRITE;
+    }
+
+    @Override
+    public void onMatch(RelOptRuleCall call) {
+        final LogicalWindow window = call.rel(0);
+        // How to rewrite each group
+        final List<Action> actions = new ArrayList<>(window.groups.size());
+        final List<OrderSpec> rowNumberSpecs = new ArrayList<>();
+        for (Window.Group group : window.groups) {
+            Action action = classify(group);
+            actions.add(action);
+            if (action == Action.REWRITE && !rowNumberSpecs.contains(OrderSpec.of(group)))
+                rowNumberSpecs.add(OrderSpec.of(group));
+        }
+        if (actions.stream().allMatch(a -> a == Action.NONE))
+            return;
+
+        final RelNode input = window.getInput();
+        final int inputFieldCount = input.getRowType().getFieldCount();
+        final RelDataTypeFactory typeFactory = window.getCluster().getTypeFactory();
+        final RexBuilder rexBuilder = window.getCluster().getRexBuilder();
+        final int rowNumberQueriesInserted = rowNumberSpecs.size();
+
+        // Inner window: one ROW_NUMBER() per distinct (partition, order),
+        // appended after the input fields.
+        final RelNode outerInput;
+        if (rowNumberQueriesInserted == 0) {
+            outerInput = input;
+        } else {
+            // The type ROW_NUMBER has under this type system.
+            RelDataType rowNumberType =
+                    typeFactory.getTypeSystem().deriveRankType(typeFactory);
+            List<Window.Group> rowNumberGroups = new ArrayList<>(rowNumberQueriesInserted);
+            RelDataTypeFactory.Builder innerType = typeFactory.builder();
+            innerType.addAll(input.getRowType().getFieldList());
+            Set<String> usedNames = new HashSet<>(input.getRowType().getFieldNames());
+            usedNames.addAll(window.getRowType().getFieldNames());
+            for (int i = 0; i < rowNumberQueriesInserted; i++) {
+                Window.RexWinAggCall rowNumber = new Window.RexWinAggCall(
+                        SqlParserPos.ZERO, SqlStdOperatorTable.ROW_NUMBER, rowNumberType,
+                        ImmutableList.of(), i, false, false);
+                rowNumberGroups.add(new Window.Group(
+                        rowNumberSpecs.get(i).keys(), false,
+                        // ROW_NUMBER ignores the window frame, so use the default RANGE frame
+                        RexWindowBounds.UNBOUNDED_PRECEDING, RexWindowBounds.CURRENT_ROW,
+                        RexWindowExclusion.EXCLUDE_NO_OTHER, rowNumberSpecs.get(i).orderKeys(),
+                        ImmutableList.of(rowNumber)));
+                String name = SqlValidatorUtil.uniquify(
+                        "$row_number" + i, usedNames, SqlValidatorUtil.ATTEMPT_SUGGESTER);
+                innerType.add(name, rowNumberType);
+            }
+            outerInput = LogicalWindow.create(window.getTraitSet(), ImmutableList.of(),
+                    input, ImmutableList.of(), innerType.build(), rowNumberGroups);
+        }
+
+        // In a Window, a RexInputRef with index >= inputFieldCount denotes a
+        // constant; the row number columns push the constants up by rowNumberQueriesInserted.
+        final RexShuttle shiftConstants = new RexShuttle() {
+            @Override public RexNode visitInputRef(RexInputRef ref) {
+                if (ref.getIndex() >= inputFieldCount)
+                    return new RexInputRef(ref.getIndex() + rowNumberQueriesInserted, ref.getType());
+                return ref;
+            }
+        };
+
+        // Rebuild the groups
+        final List<Window.Group> newGroups = new ArrayList<>();
+        // Maps the position of each aggregate in the new window to its position in the original one.
+        final List<Integer> origPositions = new ArrayList<>();
+        final Map<Integer, Integer> reusedRowNumbers = new HashMap<>();
+        int origPosition = 0;
+        for (int g = 0; g < window.groups.size(); g++) {
+            Window.Group group = window.groups.get(g);
+            List<Window.RexWinAggCall> keep = new ArrayList<>();
+            List<Window.RexWinAggCall> move = new ArrayList<>();
+            List<Integer> keepPositions = new ArrayList<>();
+            List<Integer> movePositions = new ArrayList<>();
+            Action action = actions.get(g);
+            int specIndex = rowNumberSpecs.indexOf(OrderSpec.of(group));
+            for (Window.RexWinAggCall aggCall : group.aggCalls) {
+                if (specIndex >= 0
+                        && aggCall.getOperator().getKind() == SqlKind.ROW_NUMBER
+                        && !aggCall.distinct) {
+                    // A ROW_NUMBER over the same (partition, order) as a synthesized row
+                    // number computes the same value, so it is dropped here and the
+                    // final projection reads the inner window's column instead.
+                    reusedRowNumbers.put(origPosition, specIndex);
+                } else {
+                    boolean moves = action == Action.REWRITE && !ignoresFrame(aggCall);
+                    (moves ? move : keep).add(aggCall);
+                    (moves ? movePositions : keepPositions).add(origPosition);
+                }
+                origPosition++;
+            }
+            RexWindowBound lowerBound = group.lowerBound.accept(shiftConstants);
+            RexWindowBound upperBound = group.upperBound.accept(shiftConstants);
+            if (!keep.isEmpty()) {
+                boolean isRows = action != Action.USE_RANGE && group.isRows;
+                newGroups.add(new Window.Group(group.keys, isRows,
+                        lowerBound, upperBound,
+                        group.exclude, group.orderKeys,
+                        rebuildCalls(keep, keepPositions, shiftConstants, origPositions)));
+            }
+            if (!move.isEmpty()) {
+                RelCollation rowNumberOrder = RelCollations.of(
+                        new RelFieldCollation(inputFieldCount + specIndex));
+                newGroups.add(new Window.Group(group.keys, false,
+                        lowerBound, upperBound,
+                        group.exclude, rowNumberOrder,
+                        rebuildCalls(move, movePositions, shiftConstants, origPositions)));
+            }
+        }
+
+        final RelDataTypeFactory.Builder outerType = typeFactory.builder();
+        outerType.addAll(outerInput.getRowType().getFieldList());
+        for (int position : origPositions) {
+            RelDataTypeField field =
+                    window.getRowType().getFieldList().get(inputFieldCount + position);
+            outerType.add(field.getName(), field.getType());
+        }
+        final LogicalWindow outer = LogicalWindow.create(window.getTraitSet(),
+                window.getHints(), outerInput, window.constants, outerType.build(), newGroups);
+        if (rowNumberQueriesInserted == 0) {
+            // No columns were added and no group was split; the aggregates
+            // kept their positions.
+            call.transformTo(outer);
+            return;
+        }
+
+        // Final projection: restore the original aggregate order.  Reused
+        // ROW_NUMBERs read the inner window's row number column; the other
+        // row number columns are dropped.
+        final int aggregateCount = window.getRowType().getFieldCount() - inputFieldCount;
+        Utilities.enforce(origPositions.size() + reusedRowNumbers.size() == aggregateCount);
+        final int[] newPositions = new int[aggregateCount];
+        for (int newPosition = 0; newPosition < origPositions.size(); newPosition++)
+            newPositions[origPositions.get(newPosition)] = newPosition;
+        final List<RexNode> projects = new ArrayList<>();
+        for (int i = 0; i < inputFieldCount; i++)
+            projects.add(rexBuilder.makeInputRef(outer, i));
+        for (int position = 0; position < aggregateCount; position++) {
+            Integer specIndex = reusedRowNumbers.get(position);
+            projects.add(rexBuilder.makeInputRef(outer,
+                    specIndex != null
+                            ? inputFieldCount + specIndex
+                            : inputFieldCount + rowNumberQueriesInserted + newPositions[position]));
+        }
+
+        RelNode result = call.builder()
+                .push(outer)
+                .project(projects, window.getRowType().getFieldNames())
+                .build();
+        call.transformTo(result);
+    }
+
+    /** Copy the calls with constant references shifted and with ordinals that
+     * match their position in the rebuilt window; extends origPositions with
+     * the calls' original positions. */
+    private static List<Window.RexWinAggCall> rebuildCalls(
+            List<Window.RexWinAggCall> calls, List<Integer> positions,
+            RexShuttle shiftConstants, List<Integer> origPositions) {
+        List<Window.RexWinAggCall> result = new ArrayList<>(calls.size());
+        for (int i = 0; i < calls.size(); i++) {
+            Window.RexWinAggCall aggCall = calls.get(i);
+            result.add(new Window.RexWinAggCall(
+                    aggCall.getParserPosition(),
+                    (SqlAggFunction) aggCall.getOperator(),
+                    aggCall.getType(),
+                    shiftConstants.visitList(aggCall.getOperands()),
+                    origPositions.size(),
+                    aggCall.distinct,
+                    aggCall.ignoreNulls));
+            origPositions.add(positions.get(i));
+        }
+        return result;
+    }
+
+    public static final DefaultOptRuleConfig<RowsToRangeRule> CONFIG =
+            DefaultOptRuleConfig.<RowsToRangeRule>create()
+                    .withOperandSupplier(
+                            b -> b.operand(LogicalWindow.class).anyInputs());
+}
diff --git a/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/ir/expression/DBSPZSetExpression.java b/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/ir/expression/DBSPZSetExpression.java
index 4b6bd947aaa..3159d2227d5 100644
--- a/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/ir/expression/DBSPZSetExpression.java
+++ b/sql-to-dbsp-compiler/SQL-compiler/src/main/java/org/dbsp/sqlCompiler/ir/expression/DBSPZSetExpression.java
@@ -177,12 +177,16 @@ public DBSPExpression castRecursive(DBSPExpression expression, DBSPType type) {
             return expression.cast(expression.getNode(), type, DBSPCastExpression.CastType.SqlUnsafe);
         } else if (type.is(DBSPTypeArray.class)) {
             DBSPTypeArray array = type.to(DBSPTypeArray.class);
-            DBSPArrayExpression vecLit = expression.to(DBSPArrayExpression.class);
-            if (vecLit.data == null) {
-                return new DBSPArrayExpression(array, type.mayBeNull);
+            if (expression.is(DBSPArrayExpression.class)) {
+                DBSPArrayExpression vecLit = expression.to(DBSPArrayExpression.class);
+                if (vecLit.data == null) {
+                    return new DBSPArrayExpression(array, type.mayBeNull);
+                }
+                List<DBSPExpression> fields = Linq.map(vecLit.data, e -> castRecursive(e, array.getElementType()));
+                return new DBSPArrayExpression(expression.getNode(), type, fields);
+            } else {
+                return expression.cast(CalciteObject.EMPTY, type, DBSPCastExpression.CastType.SqlUnsafe);
             }
-            List<DBSPExpression> fields = Linq.map(vecLit.data, e -> castRecursive(e, array.getElementType()));
-            return new DBSPArrayExpression(expression.getNode(), type, fields);
         } else if (type.is(DBSPTypeTupleBase.class)) {
             DBSPTypeTupleBase tuple = type.to(DBSPTypeTupleBase.class);
             DBSPExpression[] fields = new DBSPExpression[tuple.size()];
diff --git a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/WindowTests.java b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/WindowTests.java
index 5e32b59472d..cd6d2019e3a 100644
--- a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/WindowTests.java
+++ b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/WindowTests.java
@@ -658,4 +658,141 @@ CREATE VIEW V AS WITH ranked AS (
                  e| 70  | 50  | 1  | 1
                  f| 60  | 60  | 1  | 1""");
         }
+
+    @Test
+    public void rowsFrameTests() {
+        // Validated on Postgres.
+        this.qst("""
+                SELECT empno, SUM(sal) OVER (
+                    PARTITION BY deptno ORDER BY empno
+                    ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) AS s
+                FROM emp;
+                 empno | s
+                ------------------
+                 7369 | 800.00
+                 7499 | 1600.00
+                 7521 | 2850.00
+                 7566 | 3775.00
+                 7654 | 4100.00
+                 7698 | 5350.00
+                 7782 | 2450.00
+                 7788 | 6775.00
+                 7839 | 7450.00
+                 7844 | 5600.00
+                 7876 | 7075.00
+                 7900 | 5300.00
+                 7902 | 7100.00
+                 7934 | 8750.00
+                (14 rows)
+
+                SELECT empno, MIN(sal) OVER (
+                    PARTITION BY deptno ORDER BY sal DESC, empno
+                    ROWS BETWEEN 1 FOLLOWING AND 2 FOLLOWING) AS m
+                FROM emp;
+                 empno | m
+                ------------------
+                 7369 |
+                 7499 | 1250.00
+                 7521 | 950.00
+                 7566 | 800.00
+                 7654 | 950.00
+                 7698 | 1500.00
+                 7782 | 1300.00
+                 7788 | 2975.00
+                 7839 | 1300.00
+                 7844 | 1250.00
+                 7876 | 800.00
+                 7900 |
+                 7902 | 1100.00
+                 7934 |
+                (14 rows)
+
+                SELECT empno, COUNT(*) OVER (
+                    PARTITION BY deptno ORDER BY empno
+                    ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS c
+                FROM emp;
+                 empno | c
+                ------------------
+                 7369 | 5
+                 7499 | 6
+                 7521 | 6
+                 7566 | 5
+                 7654 | 6
+                 7698 | 6
+                 7782 | 3
+                 7788 | 5
+                 7839 | 3
+                 7844 | 6
+                 7876 | 5
+                 7900 | 6
+                 7902 | 5
+                 7934 | 3
+                (14 rows)
+
+                SELECT empno,
+                    SUM(sal) OVER (PARTITION BY deptno ORDER BY empno ROWS UNBOUNDED PRECEDING) AS s,
+                    FIRST_VALUE(sal) OVER (PARTITION BY deptno ORDER BY empno ROWS UNBOUNDED PRECEDING) AS f
+                FROM emp;
+                 empno | s       | f
+                --------------------------
+                 7369 | 800.00   | 800.00
+                 7499 | 1600.00  | 1600.00
+                 7521 | 2850.00  | 1600.00
+                 7566 | 3775.00  | 800.00
+                 7654 | 4100.00  | 1600.00
+                 7698 | 6950.00  | 1600.00
+                 7782 | 2450.00  | 2450.00
+                 7788 | 6775.00  | 800.00
+                 7839 | 7450.00  | 2450.00
+                 7844 | 8450.00  | 1600.00
+                 7876 | 7875.00  | 800.00
+                 7900 | 9400.00  | 1600.00
+                 7902 | 10875.00 | 800.00
+                 7934 | 8750.00  | 2450.00
+                (14 rows)
+
+                SELECT empno,
+                    ROW_NUMBER() OVER (PARTITION BY deptno ORDER BY empno) AS r,
+                    SUM(sal) OVER (PARTITION BY deptno ORDER BY empno ROWS UNBOUNDED PRECEDING) AS s
+                FROM emp;
+                 empno | r | s
+                ------------------
+                 7369 | 1 | 800.00
+                 7499 | 1 | 1600.00
+                 7521 | 2 | 2850.00
+                 7566 | 2 | 3775.00
+                 7654 | 3 | 4100.00
+                 7698 | 4 | 6950.00
+                 7782 | 1 | 2450.00
+                 7788 | 3 | 6775.00
+                 7839 | 2 | 7450.00
+                 7844 | 5 | 8450.00
+                 7876 | 4 | 7875.00
+                 7900 | 6 | 9400.00
+                 7902 | 5 | 10875.00
+                 7934 | 3 | 8750.00
+                (14 rows)
+
+                SELECT COUNT(*) OVER (
+                    PARTITION BY deptno
+                    ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) AS c
+                FROM emp;
+                 c
+                ----
+                 1
+                 1
+                 1
+                 2
+                 2
+                 2
+                 3
+                 3
+                 3
+                 3
+                 3
+                 3
+                 3
+                 3
+                (14 rows)""");
+    }
     }
diff --git a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/quidem/FoodmartTests.java b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/quidem/FoodmartTests.java
index cf82c454802..523f9f6e858 100644
--- a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/quidem/FoodmartTests.java
+++ b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/quidem/FoodmartTests.java
@@ -4,14 +4,43 @@
 import org.junit.Test;
 
 public class FoodmartTests extends FoodmartBaseTests {
-    @Test@Ignore("Calcite desugars qualify into WINDOW aggregate with ROWS; not yet implemented")
+    @Test
     public void testQualify() {
-        this.q("""
-                SELECT empno, ename, deptno, job, mgr
+        this.qst("""
+                SELECT empno, ename, deptno
+                FROM emp
+                QUALIFY ROW_NUMBER() over (partition by ename order by deptno) = 1;
+                 EMPNO | ENAME  | DEPTNO
+                -------------------------
+                 7369  | SMITH  | 20
+                 7499  | ALLEN  | 30
+                 7521  | WARD   | 30
+                 7566  | JONES  | 20
+                 7654  | MARTIN | 30
+                 7698  | BLAKE  | 30
+                 7782  | CLARK  | 10
+                 7788  | SCOTT  | 20
+                 7839  | KING   | 10
+                 7844  | TURNER | 30
+                 7876  | ADAMS  | 20
+                 7900  | JAMES  | 30
+                 7902  | FORD   | 20
+                 7934  | MILLER | 10
+                (14 rows)
+
+                SELECT empno, ename, deptno
                 FROM emp
+                WHERE deptno > 20
                 QUALIFY ROW_NUMBER() over (partition by ename order by deptno) = 1;
-                 empno | ename | deptno | job | mgr
-                ------------------------------------""");
+                 EMPNO | ENAME  | DEPTNO
+                -------------------------
+                 7499  | ALLEN  | 30
+                 7521  | WARD   | 30
+                 7654  | MARTIN | 30
+                 7698  | BLAKE  | 30
+                 7844  | TURNER | 30
+                 7900  | JAMES  | 30
+                (6 rows)""");
     }
 
     @Test
diff --git a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/quidem/WinAggPostTests.java b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/quidem/WinAggPostTests.java
index 946255675ea..8d2d2899d9c 100644
--- a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/quidem/WinAggPostTests.java
+++ b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/quidem/WinAggPostTests.java
@@ -179,8 +179,8 @@ public void test0() {
                 | M      | 20     | 1      |
                 | M      | 50     | 1      |
                 +--------+--------+--------+
-                (9 rows)""");
-        this.qst("""
+                (9 rows)
+                
                 -- [CALCITE-1540] Support multiple columns in PARTITION BY clause of window function
                 select gender,deptno,
                   count(*) over (partition by gender,deptno) as count1
@@ -240,8 +240,8 @@ public void test2() {
                  Eve   |     50 | F      |          50
                  Grace |     60 | F      |          50
                  Wilma |        | F      |          50
-                (9 rows)""");
-        this.qst("""
+                (9 rows)
+        
                 select *, first_value(ename) over () from emp;
                  ename | deptno | gender | first_value
                 -------+--------+--------+-------------
diff --git a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/quidem/WinAggTests.java b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/quidem/WinAggTests.java
index d6dd7bd0dbd..64169460e34 100644
--- a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/quidem/WinAggTests.java
+++ b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/quidem/WinAggTests.java
@@ -35,9 +35,182 @@ public void testWindows0() {
                 (14 rows)""");
     }
 
-    @Test @Ignore("ROWS not yet implemented in WINDOW https://github.com/feldera/feldera/issues/457")
-    public void testWindows() {
+    @Test @Ignore("We don't support windows without ORDER BY spec")
+    public void testWindowIllegal() {
         this.qst("""
+                -- [CALCITE-6538] OVER (ROWS CURRENT ROW) should return a window with one row, not all rows
+                -- (RANGE CURRENT ROW returns all rows, and is already correct.)
+                select ename,
+                  sal,
+                  sum(sal) over (rows current row) as row_sum_sal,
+                  sum(sal) over (range current row) as range_sum_sal
+                from emp
+                where job = 'MANAGER';
+                +-------+---------+-------------+---------------+
+                | ENAME | SAL     | ROW_SUM_SAL | RANGE_SUM_SAL |
+                +-------+---------+-------------+---------------+
+                | BLAKE | 2850.00 |     2850.00 |       8275.00 |
+                | CLARK | 2450.00 |     2450.00 |       8275.00 |
+                | JONES | 2975.00 |     2975.00 |       8275.00 |
+                +-------+---------+-------------+---------------+
+                (3 rows)
+                
+                select count(*) over (rows between 3 preceding and 2 preceding) as c3p2p,
+                  sum(two) over (rows between 3 preceding and 2 preceding) as s3p2p,
+                  sum(two) over (rows 1 preceding) as s1p,
+                  sum(two) over (rows between 1 preceding and 1 following) as s1p1f,
+                  sum(two) over (rows between current row and 2 following) as s2f
+                from (select *, 2 as two from emp)
+                order by 1;
+                +-------+-------+-----+-------+-----+
+                | C3P2P | S3P2P | S1P | S1P1F | S2F |
+                +-------+-------+-----+-------+-----+
+                |     0 |       |   2 |     4 |   6 |
+                |     0 |       |   4 |     6 |   6 |
+                |     1 |     2 |   4 |     6 |   6 |
+                |     2 |     4 |   4 |     6 |   6 |
+                |     2 |     4 |   4 |     6 |   6 |
+                |     2 |     4 |   4 |     6 |   6 |
+                |     2 |     4 |   4 |     6 |   6 |
+                |     2 |     4 |   4 |     6 |   6 |
+                |     2 |     4 |   4 |     6 |   6 |
+                |     2 |     4 |   4 |     6 |   6 |
+                |     2 |     4 |   4 |     6 |   6 |
+                |     2 |     4 |   4 |     6 |   6 |
+                |     2 |     4 |   4 |     6 |   4 |
+                |     2 |     4 |   4 |     4 |   2 |
+                +-------+-------+-----+-------+-----+
+                (14 rows)
+                
+                -- Various combinations of ROWS, RANGE, UNBOUNDED PRECEDING,
+                -- UNBOUNDED FOLLOWING, and CURRENT ROW.
+                --
+                -- 'OVER (ROWS CURRENT ROW)' includes one row;
+                --
+                -- 'OVER (ROWS UNBOUNDED PRECEDING)' includes the previous rows;
+                --
+                -- 'OVER ()' includes all rows and is equivalent to
+                -- 'OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)' and
+                -- 'OVER (RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)' and
+                -- 'OVER (RANGE UNBOUNDED PRECEDING)'.
+                -- Checked on Postgres.
+                select count(*) over (rows current row) as "rows",
+                  count(*) over (rows unbounded preceding) as "rowsUp",
+                  count(*) over (range unbounded preceding) as "rangeUp",
+                  count(*) over () as "empty",
+                  count(*) over (rows between unbounded preceding and unbounded following) as "rowsUpUf",
+                  count(*) over (range between unbounded preceding and unbounded following) as "rangeUpUf",
+                  count(*) over (range unbounded preceding) as "rangeUp"
+                from emp
+                order by 3;
+                +------+--------+---------+-------+----------+-----------+---------+
+                | rows | rowsUp | rangeUp | empty | rowsUpUf | rangeUpUf | rangeUp |
+                +------+--------+---------+-------+----------+-----------+---------+
+                |    1 |      1 |      14 |    14 |       14 |        14 |      14 |
+                |    1 |      2 |      14 |    14 |       14 |        14 |      14 |
+                |    1 |      3 |      14 |    14 |       14 |        14 |      14 |
+                |    1 |      4 |      14 |    14 |       14 |        14 |      14 |
+                |    1 |      5 |      14 |    14 |       14 |        14 |      14 |
+                |    1 |      6 |      14 |    14 |       14 |        14 |      14 |
+                |    1 |      7 |      14 |    14 |       14 |        14 |      14 |
+                |    1 |      8 |      14 |    14 |       14 |        14 |      14 |
+                |    1 |      9 |      14 |    14 |       14 |        14 |      14 |
+                |    1 |     10 |      14 |    14 |       14 |        14 |      14 |
+                |    1 |     11 |      14 |    14 |       14 |        14 |      14 |
+                |    1 |     12 |      14 |    14 |       14 |        14 |      14 |
+                |    1 |     13 |      14 |    14 |       14 |        14 |      14 |
+                |    1 |     14 |      14 |    14 |       14 |        14 |      14 |
+                +------+--------+---------+-------+----------+-----------+---------+
+                (14 rows)
+                
+                -- Various combinations of ROWS, RANGE, UNBOUNDED PRECEDING,
+                -- UNBOUNDED FOLLOWING, and CURRENT ROW, with PARTITION BY.
+                -- The equivalence sets are the same the previous query (without PARTITION BY).
+                -- Checked on Postgres.
+                select deptno,
+                  count(*) over (partition by deptno rows current row) as "rows",
+                  count(*) over (partition by deptno rows unbounded preceding) as "rowsUp",
+                  count(*) over (partition by deptno range unbounded preceding) as "rangeUp",
+                  count(*) over (partition by deptno) as "empty",
+                  count(*) over (partition by deptno rows between unbounded preceding and unbounded following) as "rowsUpUf",
+                  count(*) over (partition by deptno range between unbounded preceding and unbounded following) as "rangeUpUf",
+                  count(*) over (partition by deptno range unbounded preceding) as "rangeUp"
+                from emp
+                order by 1, 4;
+                +--------+------+--------+---------+-------+----------+-----------+---------+
+                | DEPTNO | rows | rowsUp | rangeUp | empty | rowsUpUf | rangeUpUf | rangeUp |
+                +--------+------+--------+---------+-------+----------+-----------+---------+
+                |     10 |    1 |      1 |       3 |     3 |        3 |         3 |       3 |
+                |     10 |    1 |      2 |       3 |     3 |        3 |         3 |       3 |
+                |     10 |    1 |      3 |       3 |     3 |        3 |         3 |       3 |
+                |     20 |    1 |      1 |       5 |     5 |        5 |         5 |       5 |
+                |     20 |    1 |      2 |       5 |     5 |        5 |         5 |       5 |
+                |     20 |    1 |      3 |       5 |     5 |        5 |         5 |       5 |
+                |     20 |    1 |      4 |       5 |     5 |        5 |         5 |       5 |
+                |     20 |    1 |      5 |       5 |     5 |        5 |         5 |       5 |
+                |     30 |    1 |      1 |       6 |     6 |        6 |         6 |       6 |
+                |     30 |    1 |      2 |       6 |     6 |        6 |         6 |       6 |
+                |     30 |    1 |      3 |       6 |     6 |        6 |         6 |       6 |
+                |     30 |    1 |      4 |       6 |     6 |        6 |         6 |       6 |
+                |     30 |    1 |      5 |       6 |     6 |        6 |         6 |       6 |
+                |     30 |    1 |      6 |       6 |     6 |        6 |         6 |       6 |
+                +--------+------+--------+---------+-------+----------+-----------+---------+
+                (14 rows)""");
+    }
+
+    @Test
+    public void testWindowRows() {
+        this.qst("""
+                -- As previous, with PARTITION BY and ORDER BY.
+                --
+                -- 'OVER (... ROWS CURRENT ROW)' (rows) includes one row;
+                --
+                -- 'OVER (...)' (empty),
+                -- 'OVER (... RANGE UNBOUNDED PRECEDING)' (rangeUp) and
+                -- 'OVER (... RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)' (rangeUpC)
+                -- are equivalent to each other,
+                --
+                -- 'OVER (... ROWS UNBOUNDED PRECEDING)' (rowsUp) and
+                -- 'OVER (... ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)' (rowsUpC)
+                -- are equivalent to each other and include N rows,
+                -- and are similar to empty/rangeUp/rangeUpC except when there are ties (WARD, SCOTT);
+                --
+                -- 'OVER (... ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)' (rowsUpUf) and
+                -- 'OVER (... RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)' (rangeUpUf)
+                -- are equivalent and return all rows.
+                --
+                -- Checked on Postgres.
+                select deptno, sal, ename,
+                  count(*) over (partition by deptno order by sal rows current row) as "rows",
+                  count(*) over (partition by deptno order by sal) as "empty",
+                  count(*) over (partition by deptno order by sal range unbounded preceding) as "rangeUp",
+                  count(*) over (partition by deptno order by sal range between unbounded preceding and current row) as "rangeUpC",
+                  count(*) over (partition by deptno order by sal rows unbounded preceding) as "rowsUp",
+                  count(*) over (partition by deptno order by sal rows between unbounded preceding and current row) as "rowsUpC",
+                  count(*) over (partition by deptno order by sal range between unbounded preceding and unbounded following) as "rangeUpUf",
+                  count(*) over (partition by deptno order by sal rows between unbounded preceding and unbounded following) as "rowsUpUf"
+                from emp
+                order by 1, 2;
+                +--------+---------+--------+------+-------+---------+----------+--------+---------+-----------+----------+
+                | DEPTNO | SAL     | ENAME  | rows | empty | rangeUp | rangeUpC | rowsUp | rowsUpC | rangeUpUf | rowsUpUf |
+                +--------+---------+--------+------+-------+---------+----------+--------+---------+-----------+----------+
+                |     10 | 1300.00 | MILLER |    1 |     1 |       1 |        1 |      1 |       1 |         3 |        3 |
+                |     10 | 2450.00 | CLARK  |    1 |     2 |       2 |        2 |      2 |       2 |         3 |        3 |
+                |     10 | 5000.00 | KING   |    1 |     3 |       3 |        3 |      3 |       3 |         3 |        3 |
+                |     20 |  800.00 | SMITH  |    1 |     1 |       1 |        1 |      1 |       1 |         5 |        5 |
+                |     20 | 1100.00 | ADAMS  |    1 |     2 |       2 |        2 |      2 |       2 |         5 |        5 |
+                |     20 | 2975.00 | JONES  |    1 |     3 |       3 |        3 |      3 |       3 |         5 |        5 |
+                |     20 | 3000.00 | SCOTT  |    1 |     5 |       5 |        5 |      4 |       4 |         5 |        5 |
+                |     20 | 3000.00 | FORD   |    1 |     5 |       5 |        5 |      5 |       5 |         5 |        5 |
+                |     30 |  950.00 | JAMES  |    1 |     1 |       1 |        1 |      1 |       1 |         6 |        6 |
+                |     30 | 1250.00 | WARD   |    1 |     3 |       3 |        3 |      2 |       2 |         6 |        6 |
+                |     30 | 1250.00 | MARTIN |    1 |     3 |       3 |        3 |      3 |       3 |         6 |        6 |
+                |     30 | 1500.00 | TURNER |    1 |     4 |       4 |        4 |      4 |       4 |         6 |        6 |
+                |     30 | 1600.00 | ALLEN  |    1 |     5 |       5 |        5 |      5 |       5 |         6 |        6 |
+                |     30 | 2850.00 | BLAKE  |    1 |     6 |       6 |        6 |      6 |       6 |         6 |        6 |
+                +--------+---------+--------+------+-------+---------+----------+--------+---------+-----------+----------+
+                (14 rows)
+                
                 -- Check default brackets. Note that:
                 -- c2 and c3 are equivalent to c1;
                 -- c5 is equivalent to c4;
@@ -99,8 +272,8 @@ public void testWindows() {
                 +-------+--------+
                 |  7499 |        |
                 |  7521 | 141.42 |
-                |  7654 | 585.95 |
-                |  7698 | 585.95 |
+                |  7654 | 585.94 |
+                |  7698 | 585.94 |
                 |  7844 | 602.77 |
                 |  7900 | 602.77 |
                 +-------+--------+
diff --git a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/simple/Regression2Tests.java b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/simple/Regression2Tests.java
index 1b143e31cfb..39d45c06f32 100644
--- a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/simple/Regression2Tests.java
+++ b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/simple/Regression2Tests.java
@@ -777,7 +777,7 @@ amount DECIMAL(12, 2),
 
     @Test
     public void rowsTest() {
-        this.statementsFailingInCompilation("""
+        this.getCCS("""
                 CREATE TABLE purchase (
                     ts TIMESTAMP NOT NULL,
                     amount BIGINT,
@@ -787,7 +787,7 @@ CREATE TABLE purchase (
                 CREATE MATERIALIZED VIEW rolling_sum AS
                 SELECT ts,
                     SUM(value) OVER (ORDER BY ts ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) AS rolling_sum
-                    FROM purchase;""", "Not yet implemented: Window aggregates with ROWS");
+                    FROM purchase;""");
     }
 
     @Test
diff --git a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/simple/Regression3Tests.java b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/simple/Regression3Tests.java
index 53c5bd5554c..617821c2f01 100644
--- a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/simple/Regression3Tests.java
+++ b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/simple/Regression3Tests.java
@@ -728,4 +728,65 @@ public void testEnforcePositiveInputs() {
         this.runtimeFail(compiler, "REMOVE FROM T VALUES (1);",
                 "Table t: negative weight found");
     }
+
+    @Test
+    public void issue6453() {
+        var ccs = this.getCCS("""
+                CREATE TABLE t (id INT, arr ROW(name VARCHAR, score INT) ARRAY);
+                CREATE MATERIALIZED VIEW v AS
+                SELECT id, TRANSFORM(arr, x -> x.name) AS names FROM t;""");
+        String insert = """
+                INSERT INTO t VALUES
+                  -- Simple single-element array
+                  (1, ARRAY[
+                        ROW('alice', 10)
+                      ]),
+                
+                  -- Multi-element array
+                  (2, ARRAY[
+                        ROW('bob', 5),
+                        ROW('carol', 7),
+                        ROW('dave', 3)
+                      ]),
+                
+                  -- Empty array; direct casts of ARRAY[] do not work
+                  (3, ARRAY_REMOVE(ARRAY[NULL], NULL)),
+                
+                  -- Array with NULL element
+                  (4, ARRAY[
+                        NULL,
+                        ROW('eve', 42)
+                      ]),
+                
+                  -- Repeated names, varied scores
+                  (5, ARRAY[
+                        ROW('zoe', 1),
+                        ROW('zoe', 99),
+                        ROW('max', 50)
+                      ]),
+                
+                  -- Stress test: longer array
+                  (6, ARRAY[
+                        ROW('p1', 10),
+                        ROW('p2', 20),
+                        ROW('p3', 30),
+                        ROW('p4', 40)
+                      ]);""";
+        String expected = """
+                 id | names
+                -------------
+                  1 | { alice}
+                  2 | { bob, carol, dave}
+                  3 | {}
+                  4 | {NULL, eve}
+                  5 | { zoe, zoe, max}
+                  6 | { p1, p2, p3, p4}""";
+        ccs.stepWeightOne(insert, expected);
+
+        ccs = this.getCCS("""
+                CREATE TABLE t (id INT, arr ROW(name VARCHAR, score INT) ARRAY);
+                CREATE MATERIALIZED VIEW v AS
+                SELECT id, TRANSFORM(arr, x -> (x).name) AS names FROM t;""");
+        ccs.stepWeightOne(insert, expected);
+    }
 }
diff --git a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/suites/TpcDsTest.java b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/suites/TpcDsTest.java
index 81cd4c957c2..c87384a45ae 100644
--- a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/suites/TpcDsTest.java
+++ b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/suites/TpcDsTest.java
@@ -21,7 +21,6 @@ public CompilerOptions testOptions() {
         return options;
     }
 
-    // View q51 is disabled in tpcds.sql due to OVER with ROWS aggregate
     @Test
     public void compileIndividually() throws IOException {
         String tpcds = TestUtil.readStringFromResourceFile("tpcds.sql");
diff --git a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/suites/nexmark/NexmarkTest.java b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/suites/nexmark/NexmarkTest.java
index 30e8c3cc505..0d11b49d588 100644
--- a/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/suites/nexmark/NexmarkTest.java
+++ b/sql-to-dbsp-compiler/SQL-compiler/src/test/java/org/dbsp/sqlCompiler/compiler/sql/suites/nexmark/NexmarkTest.java
@@ -742,7 +742,7 @@ public void q5Test() {
                 ---------------""");
     }
 
-    @Test @Ignore("OVER with ROWS")
+    @Test
     public void q6test() {
         this.createTest(6,
                 """
diff --git a/sql-to-dbsp-compiler/SQL-compiler/src/test/resources/tpcds.sql b/sql-to-dbsp-compiler/SQL-compiler/src/test/resources/tpcds.sql
index c78ade34381..dffcd4da760 100644
--- a/sql-to-dbsp-compiler/SQL-compiler/src/test/resources/tpcds.sql
+++ b/sql-to-dbsp-compiler/SQL-compiler/src/test/resources/tpcds.sql
@@ -2966,7 +2966,7 @@ order by s_store_name
  limit 100
 ;
 
-/* sql_51.sql
+/* sql_51.sql */
 CREATE VIEW sql_51 AS
 WITH web_v1 as (
 select
@@ -3011,7 +3011,6 @@ order by item_sk
         ,d_date
 limit 100
 ;
-*/
 
 /* sql_52.sql */
 CREATE VIEW sql_52 AS
diff --git a/sql-to-dbsp-compiler/calcite_version.env b/sql-to-dbsp-compiler/calcite_version.env
index 062f571c5a4..6a5138dd66a 100644
--- a/sql-to-dbsp-compiler/calcite_version.env
+++ b/sql-to-dbsp-compiler/calcite_version.env
@@ -3,5 +3,5 @@ CALCITE_REPO="https://github.com/apache/calcite.git"
 #CALCITE_REPO="https://github.com/mihaibudiu/calcite"
 CALCITE_BRANCH="main"
 CALCITE_CURRENT="1.42.0"
-CALCITE_NEXT_COMMIT="7311760481af747175d0119ebdb83d58c14fc684"
+CALCITE_NEXT_COMMIT="0c28ff962775c2d03273b7094fc92589bfb3ae6a"
 CALCITE_NEXT="1.43.0"
diff --git a/sql-to-dbsp-compiler/slt/skip.txt b/sql-to-dbsp-compiler/slt/skip.txt
index 5ea8a3c96fe..f670804cf01 100644
--- a/sql-to-dbsp-compiler/slt/skip.txt
+++ b/sql-to-dbsp-compiler/slt/skip.txt
@@ -33,4 +33,9 @@ SELECT ALL + NULLIF ( - COUNT ( * ), + 47 * - 93 * MAX ( 45 ) * - 63 * - 56 / -
 SELECT ALL - col0 AS col2, - 22 / + - 41 * + col0 AS col2 FROM tab2 AS cor0 GROUP BY col0 HAVING + SUM ( ALL - - col2 ) IS NOT NULL
 // test/random/groupby/slt_good_12.test: ambiguous query; Postgres rejects this query as well
 SELECT + COUNT ( * ) AS col1, - 0 * + - 69 * + ( + 53 ) AS col1 FROM tab0 WHERE NOT NULL IS NOT NULL GROUP BY col2 HAVING ( COUNT ( col1 ) ) IS NULL
-
+// test/index/random/1000/slt_good_6.test: test 8506-8510 (identical!): arithmetic overflow; reproduced on Postgres
+SELECT ALL + - CAST ( NULL AS INTEGER ) + + col3 FROM tab0 AS cor0 WHERE col3 * + col0 * + - CAST ( col1 AS INTEGER ) * col4 + - + col4 IS NULL
+SELECT ALL + - CAST ( NULL AS INTEGER ) + + col3 FROM tab1 AS cor0 WHERE col3 * + col0 * + - CAST ( col1 AS INTEGER ) * col4 + - + col4 IS NULL
+SELECT ALL + - CAST ( NULL AS INTEGER ) + + col3 FROM tab2 AS cor0 WHERE col3 * + col0 * + - CAST ( col1 AS INTEGER ) * col4 + - + col4 IS NULL
+SELECT ALL + - CAST ( NULL AS INTEGER ) + + col3 FROM tab3 AS cor0 WHERE col3 * + col0 * + - CAST ( col1 AS INTEGER ) * col4 + - + col4 IS NULL
+SELECT ALL + - CAST ( NULL AS INTEGER ) + + col3 FROM tab4 AS cor0 WHERE col3 * + col0 * + - CAST ( col1 AS INTEGER ) * col4 + - + col4 IS NULL