You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cloudberry.apache.org by li...@apache.org on 2026/09/01 07:42:05 UTC

(cloudberry) branch main updated: Add contrib/datalake_fdw: Apache Iceberg lake tables as an extension (#1842)

This is an automated email from the ASF dual-hosted git repository.

MisterRaindrop pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/cloudberry.git


The following commit(s) were added to refs/heads/main by this push:
     new 217874dcc08 Add contrib/datalake_fdw: Apache Iceberg lake tables as an extension (#1842)
217874dcc08 is described below

commit 217874dcc08c9db165e2a827a96726039ee925d4
Author: liuxiaoyu <45...@users.noreply.github.com>
AuthorDate: Tue Sep 1 15:41:58 2026 +0800

    Add contrib/datalake_fdw: Apache Iceberg lake tables as an extension (#1842)
    
    Makes an Iceberg table usable as an ordinary Cloudberry table, with no
    kernel changes:
    
        CREATE SERVER cat FOREIGN DATA WRAPPER iceberg_catalog_fdw
          OPTIONS (type 'rest', uri '...', warehouse 's3://bkt/wh');
        CREATE USER MAPPING FOR CURRENT_USER SERVER cat OPTIONS (...);
        CREATE SERVER vol FOREIGN DATA WRAPPER iceberg_volume_fdw
          OPTIONS (base_path 's3://bkt/prefix');
    
        CREATE TABLE t (a int, b text) USING iceberg
          WITH (catalog = 'cat', volume = 'vol');
    
    The module registers a table access method and the two wrappers above,
    and recognises lake tables through ProcessUtility_hook and
    object_access_hook. The table -> server mapping is kept in pg_depend on
    the coordinator and every segment, so DROP SERVER is refused while a
    lake table references it. Credentials live only in USER MAPPING.
    
    An earlier revision added kernel syntax instead -- CREATE ICEBERG TABLE
    and two new catalogs, with a catversion bump. Review preferred reaching
    the same place through mechanisms PostgreSQL already has, so that work
    was reverted and this replaces it; nothing in src/backend changes.
    
    This is a skeleton: CREATE TABLE and DROP TABLE work end to end against
    a stub metadata engine, and everything that would touch data reports
    "iceberg: <operation> is not supported yet". DROP TABLE leaves the lake
    data alone unless the table was created with purge_on_drop = true.
    
    Off by default behind --enable-datalake-fdw. It is not compiled into the
    RPM: CI installs the shipped server and builds the extension against it
    with PGXS, the way anyone outside the project would. The module must be
    in shared_preload_libraries; _PG_init refuses to load any other way.
    
    Known limits: a full pg_dump of a database containing a lake table fails
    (dumping contents means scanning; a schema-level dump round-trips),
    ALTER SERVER ... RENAME on a referenced server is refused because the
    mapping stores names, and every ALTER TABLE form except OWNER TO is
    refused while the access method is unfinished.
---
 .github/workflows/build-cloudberry.yml             |  53 ++
 configure                                          |  38 +
 configure.ac                                       |  13 +
 contrib/Makefile                                   |   6 +
 contrib/datalake_fdw/.gitignore                    |   8 +
 contrib/datalake_fdw/Makefile                      | 109 +++
 contrib/datalake_fdw/datalake_fdw--1.0.sql         |  40 +
 contrib/datalake_fdw/datalake_fdw.conf             |  25 +
 contrib/datalake_fdw/datalake_fdw.control          |  23 +
 contrib/datalake_fdw/exports.txt                   |  32 +
 .../src/am_iceberg/pg_iceberg_am_handler.c         | 509 +++++++++++
 .../datalake_fdw/src/am_iceberg/pg_iceberg_ddl.c   | 302 +++++++
 .../datalake_fdw/src/am_iceberg/pg_iceberg_ddl.h   |  42 +
 .../src/am_iceberg/pg_iceberg_extensible.c         | 964 +++++++++++++++++++++
 .../datalake_fdw/src/am_iceberg/pg_iceberg_guc.c   |  67 ++
 .../datalake_fdw/src/am_iceberg/pg_iceberg_guc.h   |  37 +
 .../src/am_iceberg/pg_iceberg_options.c            | 616 +++++++++++++
 .../src/am_iceberg/pg_iceberg_options.h            | 155 ++++
 .../src/am_iceberg/pg_iceberg_reject.c             |  44 +
 .../src/am_iceberg/pg_iceberg_reject.h             |  36 +
 .../datalake_fdw/src/common/backend_registry.cpp   | 122 +++
 contrib/datalake_fdw/src/common/backend_registry.h | 100 +++
 .../datalake_fdw/src/common/datalake_location.h    |  50 ++
 contrib/datalake_fdw/src/common/dl_err.c           | 218 +++++
 contrib/datalake_fdw/src/common/dl_err.h           | 120 +++
 contrib/datalake_fdw/src/common/dl_kv.h            |  44 +
 contrib/datalake_fdw/src/common/dl_option_util.c   |  65 ++
 contrib/datalake_fdw/src/common/dl_option_util.h   |  63 ++
 contrib/datalake_fdw/src/common/dl_pg_api.h        |  45 +
 contrib/datalake_fdw/src/common/dl_wrappers.h      | 193 +++++
 .../src/common/file_system_wrapper.cpp             | 232 +++++
 .../datalake_fdw/src/common/file_system_wrapper.h  | 113 +++
 contrib/datalake_fdw/src/common/parser_option.c    |  94 ++
 contrib/datalake_fdw/src/common/parser_option.h    |  54 ++
 contrib/datalake_fdw/src/common/s3_file_system.cpp | 261 ++++++
 contrib/datalake_fdw/src/format/format.h           | 117 +++
 contrib/datalake_fdw/src/format/format_registry.c  |  48 +
 .../src/iceberg_catalog_fdw/iceberg_catalog_fdw.c  | 226 +++++
 .../iceberg_catalog_fdw/iceberg_catalog_option.c   | 185 ++++
 .../iceberg_catalog_fdw/iceberg_catalog_option.h   | 171 ++++
 .../src/iceberg_volume_fdw/iceberg_volume_fdw.c    | 155 ++++
 .../src/iceberg_volume_fdw/iceberg_volume_option.c |  94 ++
 .../src/iceberg_volume_fdw/iceberg_volume_option.h | 146 ++++
 .../src/meta/engine_stub/stub_engine.c             | 102 +++
 .../src/meta/engine_stub/stub_engine.h             |  36 +
 .../datalake_fdw/src/meta/iceberg_meta_engine.h    | 149 ++++
 contrib/datalake_fdw/src/meta/meta_engine_init.c   |  49 ++
 contrib/datalake_fdw/src/meta/meta_engine_init.h   |  34 +
 .../datalake_fdw/src/meta/meta_engine_registry.c   | 245 ++++++
 contrib/datalake_fdw/test/automation/Makefile      |  52 ++
 contrib/datalake_fdw/test/automation/README.md     |  80 ++
 .../test/automation/config/test_config.env         |  39 +
 .../automation/scripts/setup/check_services.sh     |  60 ++
 .../automation/scripts/test/run_smoke_tests.sh     | 120 +++
 .../automation/scripts/utils/common_functions.sh   | 100 +++
 .../smoke/iceberg_am/expected/iceberg_am_acl.out   |  75 ++
 .../smoke/iceberg_am/expected/iceberg_am_ddl.out   | 227 +++++
 .../iceberg_am/expected/iceberg_am_reject.out      | 457 ++++++++++
 .../smoke/iceberg_am/sql/iceberg_am_acl.sql        |  78 ++
 .../smoke/iceberg_am/sql/iceberg_am_ddl.sql        | 162 ++++
 .../smoke/iceberg_am/sql/iceberg_am_reject.sql     | 379 ++++++++
 src/Makefile.global.in                             |   1 +
 62 files changed, 8480 insertions(+)

diff --git a/.github/workflows/build-cloudberry.yml b/.github/workflows/build-cloudberry.yml
index 7abb658632d..b790d3411ec 100644
--- a/.github/workflows/build-cloudberry.yml
+++ b/.github/workflows/build-cloudberry.yml
@@ -326,6 +326,11 @@ jobs:
                                "contrib/pg_buffercache:installcheck",
                                "contrib/sslinfo:installcheck"]
               },
+              {"test":"ic-datalake-fdw",
+               "make_configs":["contrib/datalake_fdw:installcheck"],
+               "pgxs_extension":"contrib/datalake_fdw",
+               "shared_preload_libraries":"datalake_fdw"
+              },
               {"test":"ic-gpcontrib",
                "make_configs":["gpcontrib/orafce:installcheck",
                                "gpcontrib/zstd:installcheck",
@@ -1430,6 +1435,54 @@ jobs:
           echo "Exact KB:"
           df -k /
 
+      # Modules that ship as extensions are not built into the RPM.  Build them
+      # here the way a user would: against the server that was just installed,
+      # through PGXS, with no configured source tree involved.  This has to run
+      # before the demo cluster is created, because a module named in
+      # shared_preload_libraries has to exist for the cluster to start.
+      #
+      # The regression below still runs through the ordinary make_configs
+      # entry.  Note that those entries cannot carry make variables: the runner
+      # joins the list and re-splits it on spaces, so "dir:target VAR=1" would
+      # be read as two configurations and the second one would fail.
+      - name: Build extension against the installed server
+        if: success() && needs.check-skip.outputs.should_skip != 'true'
+        env:
+          SRC_DIR: ${{ github.workspace }}
+          BUILD_DESTINATION: /usr/local/cloudberry-db
+          PGXS_EXTENSION: ${{ matrix.pgxs_extension }}
+        run: |
+          set -eo pipefail
+
+          # Matched inside the step rather than in "if:", the way
+          # shared_preload_libraries is handled below: most matrix entries do
+          # not set this key at all, and an unset key is easier to reason about
+          # in bash than in an expression.
+          if [[ -z "${PGXS_EXTENSION}" ]]; then
+            echo "No PGXS extension requested for this test; nothing to build."
+            exit 0
+          fi
+
+          # The RPM installs as root; the build runs as gpadmin, as everywhere
+          # else in this job.  -H follows the command-line symlink.
+          chown -RH gpadmin:gpadmin "${BUILD_DESTINATION}/"
+
+          {
+            echo "=== Building ${PGXS_EXTENSION} with PGXS ==="
+            if ! time su - gpadmin -c "source ${BUILD_DESTINATION}/cloudberry-env.sh && \
+                 cd ${SRC_DIR}/${PGXS_EXTENSION} && \
+                 make USE_PGXS=1 && \
+                 make USE_PGXS=1 install"; then
+              echo "::error::Building ${PGXS_EXTENSION} with PGXS failed"
+              exit 1
+            fi
+
+            echo "=== Installed files ==="
+            su - gpadmin -c "source ${BUILD_DESTINATION}/cloudberry-env.sh && \
+              ls -l \"\$(pg_config --pkglibdir)\" | grep '$(basename "${PGXS_EXTENSION}")' && \
+              ls -l \"\$(pg_config --sharedir)/extension\" | grep '$(basename "${PGXS_EXTENSION}")'"
+          } 2>&1 | tee -a build-logs/details/build-pgxs-extension.log
+
       - name: Create Apache Cloudberry demo cluster
         if: success() && needs.check-skip.outputs.should_skip != 'true'
         env:
diff --git a/configure b/configure
index 64d9c34b972..4af0eae3686 100755
--- a/configure
+++ b/configure
@@ -752,6 +752,7 @@ ICU_CFLAGS
 with_icu
 enable_thread_safety
 INCLUDES
+enable_datalake_fdw
 enable_pax
 CMAKE
 ZSTD_LIBS
@@ -917,6 +918,7 @@ enable_ic_udp2
 enable_ic_proxy
 enable_preload_ic_module
 enable_pax
+enable_datalake_fdw
 enable_thread_safety
 with_icu
 with_tcl
@@ -1642,6 +1644,7 @@ Optional Features:
   --disable-preload-ic-module
                           disable preload interconnect module
   --enable-pax            enable PAX support
+  --enable-datalake-fdw   build with Apache Iceberg lake table support
   --disable-thread-safety disable thread-safety in client libraries
   --enable-openssl-redirect
                           enable redirect openssl interface to internal
@@ -10003,6 +10006,41 @@ $as_echo "checking whether to build with PAX support ... no" >&6; }
 fi
 
 
+#
+# datalake_fdw support
+#
+# Off by default like the other storage integrations.  The module builds with
+# no external dependency today, but the read and write paths bring an
+# object-store SDK and Arrow with them, so it is opt-in from the start rather
+# than becoming opt-in later.
+#
+
+
+# Check whether --enable-datalake-fdw was given.
+if test "${enable_datalake_fdw+set}" = set; then :
+  enableval=$enable_datalake_fdw;
+  case $enableval in
+    yes)
+      :
+      ;;
+    no)
+      :
+      ;;
+    *)
+      as_fn_error $? "no argument expected for --enable-datalake-fdw option" "$LINENO" 5
+      ;;
+  esac
+
+else
+  enable_datalake_fdw=no
+
+fi
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: checking whether to build with datalake_fdw support ... $enable_datalake_fdw" >&5
+$as_echo "checking whether to build with datalake_fdw support ... $enable_datalake_fdw" >&6; }
+
+
 #
 # Include directories
 #
diff --git a/configure.ac b/configure.ac
index 04d849c39f3..20ac3aa0f6d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1072,6 +1072,19 @@ else
 fi
 AC_SUBST(enable_pax)
 
+#
+# datalake_fdw support
+#
+# Off by default like the other storage integrations.  The module builds with
+# no external dependency today, but the read and write paths bring an
+# object-store SDK and Arrow with them, so it is opt-in from the start rather
+# than becoming opt-in later.
+#
+PGAC_ARG_BOOL(enable, datalake-fdw, no,
+              [build with Apache Iceberg lake table support])
+AC_MSG_RESULT([checking whether to build with datalake_fdw support ... $enable_datalake_fdw])
+AC_SUBST(enable_datalake_fdw)
+
 #
 # Include directories
 #
diff --git a/contrib/Makefile b/contrib/Makefile
index 001f7ecf770..d41d20614f2 100644
--- a/contrib/Makefile
+++ b/contrib/Makefile
@@ -111,6 +111,12 @@ else
 ALWAYS_SUBDIRS += pax_storage
 endif
 
+ifeq ($(enable_datalake_fdw),yes)
+SUBDIRS += datalake_fdw
+else
+ALWAYS_SUBDIRS += datalake_fdw
+endif
+
 ifeq ($(enable_ic_udp2),yes)
 SUBDIRS += udp2
 else
diff --git a/contrib/datalake_fdw/.gitignore b/contrib/datalake_fdw/.gitignore
new file mode 100644
index 00000000000..e769026571a
--- /dev/null
+++ b/contrib/datalake_fdw/.gitignore
@@ -0,0 +1,8 @@
+# Generated subdirectories
+/log/
+/results/
+/tmp_check/
+
+# Generated from exports.txt at build time
+/exports.map
+/exports_darwin.list
diff --git a/contrib/datalake_fdw/Makefile b/contrib/datalake_fdw/Makefile
new file mode 100644
index 00000000000..bd1d0179513
--- /dev/null
+++ b/contrib/datalake_fdw/Makefile
@@ -0,0 +1,109 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# contrib/datalake_fdw/Makefile
+
+MODULE_big = datalake_fdw
+EXTENSION = datalake_fdw
+DATA = datalake_fdw--1.0.sql
+
+OBJS = \
+	src/am_iceberg/pg_iceberg_am_handler.o \
+	src/am_iceberg/pg_iceberg_extensible.o \
+	src/am_iceberg/pg_iceberg_ddl.o \
+	src/am_iceberg/pg_iceberg_options.o \
+	src/am_iceberg/pg_iceberg_guc.o \
+	src/am_iceberg/pg_iceberg_reject.o \
+	src/iceberg_catalog_fdw/iceberg_catalog_fdw.o \
+	src/iceberg_catalog_fdw/iceberg_catalog_option.o \
+	src/iceberg_volume_fdw/iceberg_volume_fdw.o \
+	src/iceberg_volume_fdw/iceberg_volume_option.o \
+	src/meta/meta_engine_registry.o \
+	src/meta/meta_engine_init.o \
+	src/meta/engine_stub/stub_engine.o \
+	src/format/format_registry.o \
+	src/common/dl_err.o \
+	src/common/dl_option_util.o \
+	src/common/parser_option.o \
+	src/common/file_system_wrapper.o \
+	src/common/s3_file_system.o \
+	src/common/backend_registry.o
+
+# Use the documented PGXS knobs: pgxs.mk appends these AFTER the flags configure
+# chose, so optimization/warning settings survive.  A pre-include
+# "override CFLAGS +=" would give CFLAGS override origin and silently discard
+# Makefile.global's own "CFLAGS = @CFLAGS@" assignment.
+PG_CFLAGS = -fvisibility=hidden
+PG_CXXFLAGS = -fvisibility=hidden -fvisibility-inlines-hidden -std=c++17
+PG_CPPFLAGS = -I$(srcdir)/src
+
+# The regression cases live with the rest of the test material rather than in a
+# second place of their own; pg_regress is pointed at them.  REGRESS_OPTS is
+# expanded after the --inputdir that Makefile.global supplies, so this wins.
+#
+# _PG_init refuses to run outside shared_preload_libraries, so any server used
+# to test this module has to be started with it.  For an in-tree "make check"
+# that is what the temp-config supplies.  For "make installcheck" -- which is
+# what CI runs, against a cluster created with the library already preloaded --
+# pg_regress ignores it.  Note that "make check" exists in-tree only; under PGXS
+# pgxs.mk refuses the target outright.
+REGRESS = iceberg_am_ddl iceberg_am_reject iceberg_am_acl
+REGRESS_OPTS = --temp-config=$(srcdir)/datalake_fdw.conf \
+	--inputdir=$(srcdir)/test/automation/sqlrepo/smoke/iceberg_am
+
+EXTRA_CLEAN = exports_darwin.list exports.map
+
+# Keep the aggregate target as make's default goal.
+all:
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = contrib/datalake_fdw
+top_builddir = ../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
+
+# Everything below needs variables that Makefile.global defines (PORTNAME), and
+# SHLIB_LINK additions still apply because the link recipe expands it when it
+# runs.
+
+# Shared libraries are linked with $(CC) (see src/Makefile.shlib COMPILER), so a
+# module containing C++ translation units must pull in the C++ runtime itself.
+SHLIB_LINK += -lstdc++
+
+# Arrow and other C++ dependencies land in this module later; the export list is
+# the single place that decides what stays visible, so the mechanism ships now.
+ifeq ($(PORTNAME), darwin)
+EXPORT_LIST = exports_darwin.list
+SHLIB_LINK += -Wl,-exported_symbols_list,exports_darwin.list
+
+exports_darwin.list: exports.txt
+	sed -e '/^[[:space:]]*#/d' -e '/^[[:space:]]*$$/d' -e 's/^/_/' $< > $@
+else
+EXPORT_LIST = exports.map
+SHLIB_LINK += -Wl,--version-script=exports.map -Wl,--exclude-libs,ALL
+
+exports.map: exports.txt
+	{ echo '{ global:'; sed -e '/^[[:space:]]*#/d' -e '/^[[:space:]]*$$/d' -e 's/$$/;/' $<; echo 'local: *; };'; } > $@
+endif
+
+all: $(EXPORT_LIST)
+$(shlib): $(EXPORT_LIST)
diff --git a/contrib/datalake_fdw/datalake_fdw--1.0.sql b/contrib/datalake_fdw/datalake_fdw--1.0.sql
new file mode 100644
index 00000000000..f8e87df5477
--- /dev/null
+++ b/contrib/datalake_fdw/datalake_fdw--1.0.sql
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * contrib/datalake_fdw/datalake_fdw--1.0.sql
+ */
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION datalake_fdw" to load this file. \quit
+
+CREATE FUNCTION iceberg_am_handler(internal)
+RETURNS table_am_handler AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE ACCESS METHOD iceberg TYPE TABLE HANDLER iceberg_am_handler;
+
+CREATE FUNCTION iceberg_catalog_fdw_validator(text[], oid)
+RETURNS void AS 'MODULE_PATHNAME' LANGUAGE C STRICT;
+
+CREATE FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  VALIDATOR iceberg_catalog_fdw_validator;
+
+CREATE FUNCTION iceberg_volume_fdw_validator(text[], oid)
+RETURNS void AS 'MODULE_PATHNAME' LANGUAGE C STRICT;
+
+CREATE FOREIGN DATA WRAPPER iceberg_volume_fdw
+  VALIDATOR iceberg_volume_fdw_validator;
diff --git a/contrib/datalake_fdw/datalake_fdw.conf b/contrib/datalake_fdw/datalake_fdw.conf
new file mode 100644
index 00000000000..7e1c7c5a785
--- /dev/null
+++ b/contrib/datalake_fdw/datalake_fdw.conf
@@ -0,0 +1,25 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# contrib/datalake_fdw/datalake_fdw.conf
+#
+# Configuration for the temporary server that "make check" starts.  The module
+# installs process-wide hooks, so _PG_init refuses to run outside
+# shared_preload_libraries; without this the first statement that reaches the
+# access method would fail to load the library instead of testing it.
+
+shared_preload_libraries = 'datalake_fdw'
diff --git a/contrib/datalake_fdw/datalake_fdw.control b/contrib/datalake_fdw/datalake_fdw.control
new file mode 100644
index 00000000000..263990ba8b1
--- /dev/null
+++ b/contrib/datalake_fdw/datalake_fdw.control
@@ -0,0 +1,23 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# contrib/datalake_fdw/datalake_fdw.control
+
+comment = 'Apache Iceberg lake tables for Cloudberry (demo skeleton)'
+default_version = '1.0'
+module_pathname = '$libdir/datalake_fdw'
+relocatable = false
diff --git a/contrib/datalake_fdw/exports.txt b/contrib/datalake_fdw/exports.txt
new file mode 100644
index 00000000000..0db251366df
--- /dev/null
+++ b/contrib/datalake_fdw/exports.txt
@@ -0,0 +1,32 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# contrib/datalake_fdw/exports.txt
+#
+# Single source of truth for exported symbols; the linker script for each
+# platform is generated from it at build time.  Adding a line here is an API
+# decision, so it is one a reviewer has to see.  Comment lines are stripped
+# when the script is generated.
+
+_PG_init
+Pg_magic_func
+pg_finfo_iceberg_am_handler
+iceberg_am_handler
+pg_finfo_iceberg_catalog_fdw_validator
+iceberg_catalog_fdw_validator
+pg_finfo_iceberg_volume_fdw_validator
+iceberg_volume_fdw_validator
diff --git a/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_am_handler.c b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_am_handler.c
new file mode 100644
index 00000000000..4a610fc3238
--- /dev/null
+++ b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_am_handler.c
@@ -0,0 +1,509 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * pg_iceberg_am_handler.c
+ *	  Table access method callbacks for Iceberg tables.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/am_iceberg/pg_iceberg_am_handler.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/multixact.h"
+#include "access/tableam.h"
+#include "am_iceberg/pg_iceberg_options.h"
+#include "am_iceberg/pg_iceberg_reject.h"
+#include "fmgr.h"
+
+PG_FUNCTION_INFO_V1(iceberg_am_handler);
+
+static const TupleTableSlotOps *
+pg_iceberg_slot_callbacks(Relation rel pg_attribute_unused())
+{
+	return &TTSOpsVirtual;
+}
+
+static TableScanDesc
+pg_iceberg_scan_begin(Relation rel pg_attribute_unused(),
+					  Snapshot snapshot pg_attribute_unused(),
+					  int nkeys pg_attribute_unused(),
+					  struct ScanKeyData *key pg_attribute_unused(),
+					  ParallelTableScanDesc pscan pg_attribute_unused(),
+					  uint32 flags pg_attribute_unused())
+{
+	pg_iceberg_not_supported("SELECT");
+}
+
+static void
+pg_iceberg_scan_end(TableScanDesc scan pg_attribute_unused())
+{
+	pg_iceberg_not_supported("SELECT");
+}
+
+static void
+pg_iceberg_scan_rescan(TableScanDesc scan pg_attribute_unused(),
+					   struct ScanKeyData *key pg_attribute_unused(),
+					   bool set_params pg_attribute_unused(),
+					   bool allow_strat pg_attribute_unused(),
+					   bool allow_sync pg_attribute_unused(),
+					   bool allow_pagemode pg_attribute_unused())
+{
+	pg_iceberg_not_supported("SELECT");
+}
+
+static bool
+pg_iceberg_scan_getnextslot(TableScanDesc scan pg_attribute_unused(),
+							ScanDirection direction pg_attribute_unused(),
+							TupleTableSlot *slot pg_attribute_unused())
+{
+	pg_iceberg_not_supported("SELECT");
+}
+
+static Size
+pg_iceberg_parallelscan_estimate(Relation rel pg_attribute_unused())
+{
+	pg_iceberg_not_supported("parallel scan");
+}
+
+static Size
+pg_iceberg_parallelscan_initialize(Relation rel pg_attribute_unused(),
+								   ParallelTableScanDesc pscan pg_attribute_unused())
+{
+	pg_iceberg_not_supported("parallel scan");
+}
+
+static void
+pg_iceberg_parallelscan_reinitialize(Relation rel pg_attribute_unused(),
+									 ParallelTableScanDesc pscan pg_attribute_unused())
+{
+	pg_iceberg_not_supported("parallel scan");
+}
+
+static struct IndexFetchTableData *
+pg_iceberg_index_fetch_begin(Relation rel pg_attribute_unused())
+{
+	pg_iceberg_not_supported("index access");
+}
+
+static void
+pg_iceberg_index_fetch_reset(struct IndexFetchTableData *data pg_attribute_unused())
+{
+	pg_iceberg_not_supported("index access");
+}
+
+static void
+pg_iceberg_index_fetch_end(struct IndexFetchTableData *data pg_attribute_unused())
+{
+	pg_iceberg_not_supported("index access");
+}
+
+static bool
+pg_iceberg_index_fetch_tuple(struct IndexFetchTableData *scan pg_attribute_unused(),
+							 ItemPointer tid pg_attribute_unused(),
+							 Snapshot snapshot pg_attribute_unused(),
+							 TupleTableSlot *slot pg_attribute_unused(),
+							 bool *call_again pg_attribute_unused(),
+							 bool *all_dead pg_attribute_unused())
+{
+	pg_iceberg_not_supported("index access");
+}
+
+static bool
+pg_iceberg_tuple_fetch_row_version(Relation rel pg_attribute_unused(),
+								   ItemPointer tid pg_attribute_unused(),
+								   Snapshot snapshot pg_attribute_unused(),
+								   TupleTableSlot *slot pg_attribute_unused())
+{
+	pg_iceberg_not_supported("tuple fetch by TID");
+}
+
+static bool
+pg_iceberg_tuple_tid_valid(TableScanDesc scan pg_attribute_unused(),
+						   ItemPointer tid pg_attribute_unused())
+{
+	pg_iceberg_not_supported("tuple fetch by TID");
+}
+
+static void
+pg_iceberg_tuple_get_latest_tid(TableScanDesc scan pg_attribute_unused(),
+								ItemPointer tid pg_attribute_unused())
+{
+	pg_iceberg_not_supported("tuple fetch by TID");
+}
+
+static bool
+pg_iceberg_tuple_satisfies_snapshot(Relation rel pg_attribute_unused(),
+									TupleTableSlot *slot pg_attribute_unused(),
+									Snapshot snapshot pg_attribute_unused())
+{
+	pg_iceberg_not_supported("tuple fetch by TID");
+}
+
+static TransactionId
+pg_iceberg_index_delete_tuples(Relation rel pg_attribute_unused(),
+							   TM_IndexDeleteOp *delstate pg_attribute_unused())
+{
+	pg_iceberg_not_supported("index maintenance");
+}
+
+static void
+pg_iceberg_tuple_insert(Relation rel pg_attribute_unused(),
+						TupleTableSlot *slot pg_attribute_unused(),
+						CommandId cid pg_attribute_unused(),
+						int options pg_attribute_unused(),
+						struct BulkInsertStateData *bistate pg_attribute_unused())
+{
+	pg_iceberg_not_supported("INSERT");
+}
+
+static void
+pg_iceberg_tuple_insert_speculative(Relation rel pg_attribute_unused(),
+									TupleTableSlot *slot pg_attribute_unused(),
+									CommandId cid pg_attribute_unused(),
+									int options pg_attribute_unused(),
+									struct BulkInsertStateData *bistate pg_attribute_unused(),
+									uint32 specToken pg_attribute_unused())
+{
+	pg_iceberg_not_supported("INSERT ... ON CONFLICT");
+}
+
+static void
+pg_iceberg_tuple_complete_speculative(Relation rel pg_attribute_unused(),
+									  TupleTableSlot *slot pg_attribute_unused(),
+									  uint32 specToken pg_attribute_unused(),
+									  bool succeeded pg_attribute_unused())
+{
+	pg_iceberg_not_supported("INSERT ... ON CONFLICT");
+}
+
+static void
+pg_iceberg_multi_insert(Relation rel pg_attribute_unused(),
+						TupleTableSlot **slots pg_attribute_unused(),
+						int nslots pg_attribute_unused(),
+						CommandId cid pg_attribute_unused(),
+						int options pg_attribute_unused(),
+						struct BulkInsertStateData *bistate pg_attribute_unused())
+{
+	pg_iceberg_not_supported("INSERT");
+}
+
+static TM_Result
+pg_iceberg_tuple_delete(Relation rel pg_attribute_unused(),
+						ItemPointer tid pg_attribute_unused(),
+						CommandId cid pg_attribute_unused(),
+						Snapshot snapshot pg_attribute_unused(),
+						Snapshot crosscheck pg_attribute_unused(),
+						bool wait pg_attribute_unused(),
+						TM_FailureData *tmfd pg_attribute_unused(),
+						bool changingPart pg_attribute_unused())
+{
+	pg_iceberg_not_supported("DELETE");
+}
+
+static TM_Result
+pg_iceberg_tuple_update(Relation rel pg_attribute_unused(),
+						ItemPointer otid pg_attribute_unused(),
+						TupleTableSlot *slot pg_attribute_unused(),
+						CommandId cid pg_attribute_unused(),
+						Snapshot snapshot pg_attribute_unused(),
+						Snapshot crosscheck pg_attribute_unused(),
+						bool wait pg_attribute_unused(),
+						TM_FailureData *tmfd pg_attribute_unused(),
+						LockTupleMode *lockmode pg_attribute_unused(),
+						TU_UpdateIndexes *update_indexes pg_attribute_unused())
+{
+	pg_iceberg_not_supported("UPDATE");
+}
+
+static TM_Result
+pg_iceberg_tuple_lock(Relation rel pg_attribute_unused(),
+					  ItemPointer tid pg_attribute_unused(),
+					  Snapshot snapshot pg_attribute_unused(),
+					  TupleTableSlot *slot pg_attribute_unused(),
+					  CommandId cid pg_attribute_unused(),
+					  LockTupleMode mode pg_attribute_unused(),
+					  LockWaitPolicy wait_policy pg_attribute_unused(),
+					  uint8 flags pg_attribute_unused(),
+					  TM_FailureData *tmfd pg_attribute_unused())
+{
+	pg_iceberg_not_supported("row locking (SELECT ... FOR UPDATE)");
+}
+
+static void
+pg_iceberg_relation_set_new_filelocator(Relation rel pg_attribute_unused(),
+										const RelFileLocator *newrlocator pg_attribute_unused(),
+										char persistence pg_attribute_unused(),
+										TransactionId *freezeXid,
+										MultiXactId *minmulti)
+{
+	/*
+	 * Iceberg data lives in external object storage, so creating local smgr
+	 * storage here would be both unnecessary and misleading.
+	 */
+	*freezeXid = InvalidTransactionId;
+	*minmulti = InvalidMultiXactId;
+	return;
+}
+
+static void
+pg_iceberg_relation_nontransactional_truncate(Relation rel pg_attribute_unused())
+{
+	pg_iceberg_not_supported("TRUNCATE");
+}
+
+static void
+pg_iceberg_relation_copy_data(Relation rel pg_attribute_unused(),
+							  const RelFileLocator *newrlocator pg_attribute_unused())
+{
+	pg_iceberg_not_supported("ALTER TABLE ... SET TABLESPACE");
+}
+
+static void
+pg_iceberg_relation_copy_for_cluster(Relation OldTable pg_attribute_unused(),
+									 Relation NewTable pg_attribute_unused(),
+									 Relation OldIndex pg_attribute_unused(),
+									 bool use_sort pg_attribute_unused(),
+									 TransactionId OldestXmin pg_attribute_unused(),
+									 TransactionId *xid_cutoff pg_attribute_unused(),
+									 MultiXactId *multi_cutoff pg_attribute_unused(),
+									 double *num_tuples pg_attribute_unused(),
+									 double *tups_vacuumed pg_attribute_unused(),
+									 double *tups_recently_dead pg_attribute_unused())
+{
+	pg_iceberg_not_supported("CLUSTER / VACUUM FULL");
+}
+
+static void
+pg_iceberg_relation_vacuum(Relation rel pg_attribute_unused(),
+						   struct VacuumParams *params pg_attribute_unused(),
+						   BufferAccessStrategy bstrategy pg_attribute_unused())
+{
+	/*
+	 * A database-wide VACUUM or autovacuum must not fail merely because it
+	 * encounters an Iceberg table. There is no local storage to vacuum.
+	 */
+	return;
+}
+
+static bool
+pg_iceberg_scan_analyze_next_block(TableScanDesc scan pg_attribute_unused(),
+								   BlockNumber blockno pg_attribute_unused(),
+								   BufferAccessStrategy bstrategy pg_attribute_unused())
+{
+	/* Defensive fallback; relation_acquire_sample_rows bypasses this path. */
+	return false;
+}
+
+static bool
+pg_iceberg_scan_analyze_next_tuple(TableScanDesc scan pg_attribute_unused(),
+								   TransactionId OldestXmin pg_attribute_unused(),
+								   double *liverows pg_attribute_unused(),
+								   double *deadrows pg_attribute_unused(),
+								   TupleTableSlot *slot pg_attribute_unused())
+{
+	/* Defensive fallback; relation_acquire_sample_rows bypasses this path. */
+	return false;
+}
+
+static int
+pg_iceberg_relation_acquire_sample_rows(Relation onerel pg_attribute_unused(),
+										int elevel pg_attribute_unused(),
+										HeapTuple *rows pg_attribute_unused(),
+										int targrows pg_attribute_unused(),
+										double *totalrows,
+										double *totaldeadrows)
+{
+	/*
+	 * analyze.c uses this callback directly when present and therefore never
+	 * starts a table_beginscan_analyze() scan. This lets ANALYZE succeed as a
+	 * zero-sample no-op while ordinary scans remain unsupported.
+	 */
+	*totalrows = 0;
+	*totaldeadrows = 0;
+	return 0;
+}
+
+static double
+pg_iceberg_index_build_range_scan(Relation table_rel pg_attribute_unused(),
+								  Relation index_rel pg_attribute_unused(),
+								  struct IndexInfo *index_info pg_attribute_unused(),
+								  bool allow_sync pg_attribute_unused(),
+								  bool anyvisible pg_attribute_unused(),
+								  bool progress pg_attribute_unused(),
+								  BlockNumber start_blockno pg_attribute_unused(),
+								  BlockNumber numblocks pg_attribute_unused(),
+								  IndexBuildCallback callback pg_attribute_unused(),
+								  void *callback_state pg_attribute_unused(),
+								  TableScanDesc scan pg_attribute_unused())
+{
+	pg_iceberg_not_supported("CREATE INDEX");
+}
+
+static void
+pg_iceberg_index_validate_scan(Relation table_rel pg_attribute_unused(),
+							   Relation index_rel pg_attribute_unused(),
+							   struct IndexInfo *index_info pg_attribute_unused(),
+							   Snapshot snapshot pg_attribute_unused(),
+							   struct ValidateIndexState *state pg_attribute_unused())
+{
+	pg_iceberg_not_supported("CREATE INDEX");
+}
+
+static uint64
+pg_iceberg_relation_size(Relation rel pg_attribute_unused(),
+						 ForkNumber forkNumber pg_attribute_unused())
+{
+	return 0;
+}
+
+static BlockSequence *
+pg_iceberg_relation_get_block_sequences(Relation rel pg_attribute_unused(),
+										int *numSequences)
+{
+	*numSequences = 0;
+	return palloc0(sizeof(BlockSequence));
+}
+
+static void
+pg_iceberg_relation_get_block_sequence(Relation rel pg_attribute_unused(),
+									   BlockNumber blkNum pg_attribute_unused(),
+									   BlockSequence *sequence pg_attribute_unused())
+{
+	pg_iceberg_not_supported("block sequence access");
+}
+
+static bool
+pg_iceberg_relation_needs_toast_table(Relation rel pg_attribute_unused())
+{
+	return false;
+}
+
+static void
+pg_iceberg_relation_estimate_size(Relation rel pg_attribute_unused(),
+								  int32 *attr_widths pg_attribute_unused(),
+								  BlockNumber *pages,
+								  double *tuples,
+								  double *allvisfrac)
+{
+	*pages = 0;
+	*tuples = 0;
+	*allvisfrac = 0;
+}
+
+static bool
+pg_iceberg_scan_sample_next_block(TableScanDesc scan pg_attribute_unused(),
+								  struct SampleScanState *scanstate pg_attribute_unused())
+{
+	pg_iceberg_not_supported("TABLESAMPLE");
+}
+
+static bool
+pg_iceberg_scan_sample_next_tuple(TableScanDesc scan pg_attribute_unused(),
+								  struct SampleScanState *scanstate pg_attribute_unused(),
+								  TupleTableSlot *slot pg_attribute_unused())
+{
+	pg_iceberg_not_supported("TABLESAMPLE");
+}
+
+/*
+ * Optional callbacks below remain NULL. Iceberg currently has no local tuple
+ * scanning, index, bulk-insert, TOAST, bitmap-scan, DML-state, file-swap, or
+ * column-encoding implementation.
+ */
+static const TableAmRoutine pg_iceberg_methods = {
+	.type = T_TableAmRoutine,
+
+	.slot_callbacks = pg_iceberg_slot_callbacks,
+
+	.scan_begin = pg_iceberg_scan_begin,
+	.scan_begin_extractcolumns = NULL,
+	.scan_begin_extractcolumns_bm = NULL,
+	.scan_end = pg_iceberg_scan_end,
+	.scan_rescan = pg_iceberg_scan_rescan,
+	.scan_getnextslot = pg_iceberg_scan_getnextslot,
+	.scan_set_tidrange = NULL,
+	.scan_getnextslot_tidrange = NULL,
+	.scan_flags = NULL,
+
+	.parallelscan_estimate = pg_iceberg_parallelscan_estimate,
+	.parallelscan_initialize = pg_iceberg_parallelscan_initialize,
+	.parallelscan_reinitialize = pg_iceberg_parallelscan_reinitialize,
+
+	.index_fetch_begin = pg_iceberg_index_fetch_begin,
+	.index_fetch_reset = pg_iceberg_index_fetch_reset,
+	.index_fetch_end = pg_iceberg_index_fetch_end,
+	.index_fetch_tuple = pg_iceberg_index_fetch_tuple,
+	.index_unique_check = NULL,
+
+	.tuple_fetch_row_version = pg_iceberg_tuple_fetch_row_version,
+	.tuple_tid_valid = pg_iceberg_tuple_tid_valid,
+	.tuple_get_latest_tid = pg_iceberg_tuple_get_latest_tid,
+	.tuple_satisfies_snapshot = pg_iceberg_tuple_satisfies_snapshot,
+	.index_delete_tuples = pg_iceberg_index_delete_tuples,
+
+	.tuple_insert = pg_iceberg_tuple_insert,
+	.tuple_insert_speculative = pg_iceberg_tuple_insert_speculative,
+	.tuple_complete_speculative = pg_iceberg_tuple_complete_speculative,
+	.multi_insert = pg_iceberg_multi_insert,
+	.tuple_delete = pg_iceberg_tuple_delete,
+	.tuple_update = pg_iceberg_tuple_update,
+	.tuple_lock = pg_iceberg_tuple_lock,
+	.finish_bulk_insert = NULL,
+
+	.relation_set_new_filelocator = pg_iceberg_relation_set_new_filelocator,
+	.relation_nontransactional_truncate = pg_iceberg_relation_nontransactional_truncate,
+	.relation_copy_data = pg_iceberg_relation_copy_data,
+	.relation_copy_for_cluster = pg_iceberg_relation_copy_for_cluster,
+	.relation_vacuum = pg_iceberg_relation_vacuum,
+	.scan_analyze_next_block = pg_iceberg_scan_analyze_next_block,
+	.scan_analyze_next_tuple = pg_iceberg_scan_analyze_next_tuple,
+	.relation_acquire_sample_rows = pg_iceberg_relation_acquire_sample_rows,
+	.index_build_range_scan = pg_iceberg_index_build_range_scan,
+	.index_validate_scan = pg_iceberg_index_validate_scan,
+
+	.relation_size = pg_iceberg_relation_size,
+	.relation_get_block_sequences = pg_iceberg_relation_get_block_sequences,
+	.relation_get_block_sequence = pg_iceberg_relation_get_block_sequence,
+	.relation_needs_toast_table = pg_iceberg_relation_needs_toast_table,
+	.relation_toast_am = NULL,
+	.relation_fetch_toast_slice = NULL,
+
+	.relation_estimate_size = pg_iceberg_relation_estimate_size,
+
+	.scan_bitmap_next_block = NULL,
+	.scan_bitmap_next_tuple = NULL,
+	.scan_sample_next_block = pg_iceberg_scan_sample_next_block,
+	.scan_sample_next_tuple = pg_iceberg_scan_sample_next_tuple,
+
+	.dml_init = NULL,
+	.dml_fini = NULL,
+	.amoptions = pg_iceberg_amoptions,
+	.swap_relation_files = NULL,
+	.validate_column_encoding_clauses = NULL,
+	.transform_column_encoding_clauses = NULL,
+};
+
+Datum
+iceberg_am_handler(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_POINTER(&pg_iceberg_methods);
+}
diff --git a/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_ddl.c b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_ddl.c
new file mode 100644
index 00000000000..ee70aa7fa83
--- /dev/null
+++ b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_ddl.c
@@ -0,0 +1,302 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * pg_iceberg_ddl.c
+ *	  Object-access integration for the Iceberg table lifecycle.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/am_iceberg/pg_iceberg_ddl.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/htup_details.h"
+#include "access/relation.h"
+#include "am_iceberg/pg_iceberg_ddl.h"
+#include "am_iceberg/pg_iceberg_options.h"
+#include "am_iceberg/pg_iceberg_reject.h"
+#include "catalog/pg_class.h"
+#include "cdb/cdbvars.h"
+#include "commands/defrem.h"
+#include "meta/iceberg_meta_engine.h"
+#include "utils/lsyscache.h"
+#include "utils/memutils.h"
+#include "utils/rel.h"
+#include "utils/syscache.h"
+
+object_access_hook_type pg_iceberg_prev_object_access_hook;
+
+static Oid get_rel_relam(Oid relid);
+static MetaCtx table_info_meta_ctx(const IcebergTableInfo *info);
+static void iceberg_post_create(Oid objectId);
+static void iceberg_drop(Oid objectId);
+
+/*
+ * This tree has no lsyscache get_rel_relam() helper, so provide the same
+ * missing-ok syscache lookup locally.
+ */
+static Oid
+get_rel_relam(Oid relid)
+{
+	HeapTuple	tuple;
+	Oid			relam = InvalidOid;
+
+	tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
+	if (HeapTupleIsValid(tuple))
+	{
+		relam = ((Form_pg_class) GETSTRUCT(tuple))->relam;
+		ReleaseSysCache(tuple);
+	}
+
+	return relam;
+}
+
+static MetaCtx
+table_info_meta_ctx(const IcebergTableInfo *info)
+{
+	MetaCtx	ctx = {
+		.catalog_name = info->catalog_name,
+		.namespace_name = info->opts->namespace,
+		.table_name = info->opts->table,
+		.catalog_props = info->catalog_props,
+		.n_catalog_props = info->n_catalog_props,
+		.credential_props = NULL,
+		.n_credential_props = 0
+	};
+
+	return ctx;
+}
+
+static void
+iceberg_post_create(Oid objectId)
+{
+	Relation	rel;
+	Oid			amoid;
+	IcebergTableInfo *info;
+
+	amoid = pg_iceberg_am_oid();
+	if (!OidIsValid(amoid))
+		return;
+
+	rel = relation_open(objectId, AccessShareLock);
+	if (rel->rd_rel->relam != amoid)
+	{
+		relation_close(rel, AccessShareLock);
+		return;
+	}
+
+	info = pg_iceberg_get_table_info_rel(rel);
+	InsertLakeTableEntry(objectId, info);
+
+	if (Gp_role == GP_ROLE_DISPATCH)
+	{
+		const IcebergMetaEngine *engine = get_meta_engine();
+		MetaCtx		ctx = table_info_meta_ctx(info);
+		MetaTableDef def = {.schema_json = ""};
+		MetaTable  *table_metadata = NULL;
+		DlErrCode	rc;
+
+		/* Always cross the metadata-engine boundary through its wrapper. */
+		rc = meta_engine_create_table(engine, &ctx, &def, &table_metadata);
+		relation_close(rel, AccessShareLock);
+
+		/* ctx borrows from info, so release only once the call has returned. */
+		pg_iceberg_free_table_info(info);
+
+		if (rc != DL_OK)
+			dl_error_report(ERROR, rc, "create_table");
+		return;
+	}
+
+	relation_close(rel, AccessShareLock);
+	pg_iceberg_free_table_info(info);
+}
+
+static void
+iceberg_drop(Oid objectId)
+{
+	Relation	rel;
+	Oid			amoid;
+	IcebergTableInfo *info;
+	const IcebergMetaEngine *engine;
+	MetaCtx		ctx;
+	DlErrCode	rc;
+
+	amoid = pg_iceberg_am_oid();
+	if (!OidIsValid(amoid) || get_rel_relam(objectId) != amoid)
+		return;
+
+	/*
+	 * The dispatcher makes the single remote call; everyone else only drops
+	 * local catalog rows and the dependencies recorded at creation.
+	 *
+	 * A utility-mode backend deliberately falls in the second group.  It talks
+	 * to one node, so letting it delete the remote table would remove metadata
+	 * the other nodes still reference.  The utility guard refuses the
+	 * statements that reach a lake table directly; an indirect cascade that
+	 * slips past it drops the local rows only, which is recoverable, unlike a
+	 * remote catalog entry deleted on one node's say-so.
+	 */
+	if (Gp_role != GP_ROLE_DISPATCH)
+		return;
+
+	/*
+	 * Defensive: no path the regression suite covers -- DROP TABLE, DROP SERVER
+	 * CASCADE, DROP SCHEMA CASCADE -- reaches this hook with the relation no
+	 * longer openable, so the open below has always succeeded.  It stays a try
+	 * rather than an open because a hook that raised here would make the object
+	 * undroppable, and there is nothing to reconstruct the mapping from anyway.
+	 */
+	rel = try_relation_open(objectId, AccessShareLock, false);
+	if (rel == NULL)
+		return;
+
+	/*
+	 * Resolving the mapping can fail -- a server option that no longer parses,
+	 * a wrapper renamed out from under the table -- and DROP is exactly the
+	 * statement that must still work in that state.  Report what could not be
+	 * cleaned up remotely and let the local drop proceed, rather than leaving
+	 * the user with a table that cannot be dropped at all.
+	 */
+	info = NULL;
+	PG_TRY();
+	{
+		info = pg_iceberg_get_table_info_rel(rel);
+	}
+	PG_CATCH();
+	{
+		MemoryContext ctxt = MemoryContextSwitchTo(TopTransactionContext);
+		ErrorData  *edata = CopyErrorData();
+
+		MemoryContextSwitchTo(ctxt);
+
+		/*
+		 * Only a mapping that no longer describes anything usable may be
+		 * downgraded here.  A cancelled query or an out-of-memory failure has
+		 * nothing to do with the mapping, and turning one of those into a
+		 * warning would drop the table while pretending the statement
+		 * succeeded.
+		 */
+		if (edata->sqlerrcode != ERRCODE_INVALID_TABLE_DEFINITION &&
+			edata->sqlerrcode != ERRCODE_INVALID_PARAMETER_VALUE &&
+			edata->sqlerrcode != ERRCODE_UNDEFINED_OBJECT)
+		{
+			FreeErrorData(edata);
+			relation_close(rel, AccessShareLock);
+			PG_RE_THROW();
+		}
+
+		FlushErrorState();
+		relation_close(rel, AccessShareLock);
+		ereport(WARNING,
+				(errmsg("iceberg: dropping \"%s\" without notifying the metadata engine",
+						get_rel_name(objectId)),
+				 errdetail("%s", edata->message)));
+		FreeErrorData(edata);
+		return;
+	}
+	PG_END_TRY();
+
+	engine = get_meta_engine();
+	ctx = table_info_meta_ctx(info);
+
+	/*
+	 * Dropping the table drops this database's reference to it.  Whether the
+	 * lake data goes too is the table's own decision, recorded in its options
+	 * when it was created; the default is to leave it, so that dropping a
+	 * reference cannot destroy data another reader still expects to find.
+	 *
+	 * A table's identity is its (catalog, namespace, name) triple, so there is
+	 * nothing to fence this call against: a remote table under that name is by
+	 * definition the table being dropped.
+	 */
+	rc = meta_engine_drop_table(engine, &ctx, info->opts->purge_on_drop);
+	relation_close(rel, AccessShareLock);
+
+	/* ctx borrows from info, so release only once the call has returned. */
+	pg_iceberg_free_table_info(info);
+
+	/*
+	 * Do not strand the local table when the remote drop fails.  The catalog
+	 * DROP continues and the failure stays visible; reconciling what the
+	 * remote catalog still holds is the metadata agent's job, not something
+	 * this skeleton can record durably.
+	 */
+	if (rc != DL_OK)
+		dl_error_report(WARNING, rc, "drop_table");
+}
+
+void
+pg_iceberg_object_access(ObjectAccessType access,
+						 Oid classId,
+						 Oid objectId,
+						 int subId,
+						 void *arg)
+{
+	if (pg_iceberg_prev_object_access_hook)
+		(*pg_iceberg_prev_object_access_hook) (access, classId, objectId,
+											  subId, arg);
+
+	if (classId != RelationRelationId || subId != 0)
+		return;
+
+	switch (access)
+	{
+		case OAT_POST_CREATE:
+			{
+				ObjectAccessPostCreate *created = (ObjectAccessPostCreate *) arg;
+
+				/*
+				 * Relations the system builds for itself -- the transient heap
+				 * of a rewrite above all -- must never reach the metadata
+				 * engine.  They carry a generated name, they live only until
+				 * the rewrite swaps them in, and creating them remotely leaves
+				 * an orphan the moment the local work rolls back.  The utility
+				 * hook refuses the statements that rewrite a lake table; this
+				 * is the backstop for whatever it does not see.
+				 */
+				if (created != NULL && created->is_internal)
+					return;
+
+				iceberg_post_create(objectId);
+			}
+			break;
+		case OAT_DROP:
+			iceberg_drop(objectId);
+			break;
+		case OAT_TRUNCATE:
+
+			/*
+			 * TRUNCATE of a table created in an earlier transaction never
+			 * reaches the access method's nontransactional path: it goes
+			 * through relation_set_new_filelocator, which succeeds because a
+			 * lake table has no local storage to reset.  Without this event
+			 * the statement would report success while every Iceberg data file
+			 * stayed exactly where it was.
+			 */
+			if (OidIsValid(pg_iceberg_am_oid()) &&
+				get_rel_relam(objectId) == pg_iceberg_am_oid())
+				pg_iceberg_not_supported("TRUNCATE");
+			break;
+		default:
+			break;
+	}
+}
diff --git a/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_ddl.h b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_ddl.h
new file mode 100644
index 00000000000..c6cd354a732
--- /dev/null
+++ b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_ddl.h
@@ -0,0 +1,42 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * pg_iceberg_ddl.h
+ *	  Object-access integration for the Iceberg table lifecycle.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/am_iceberg/pg_iceberg_ddl.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef PG_ICEBERG_DDL_H
+#define PG_ICEBERG_DDL_H
+
+#include "catalog/objectaccess.h"
+
+extern object_access_hook_type pg_iceberg_prev_object_access_hook;
+
+extern void pg_iceberg_object_access(ObjectAccessType access,
+									 Oid classId,
+									 Oid objectId,
+									 int subId,
+									 void *arg);
+
+#endif							/* PG_ICEBERG_DDL_H */
diff --git a/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_extensible.c b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_extensible.c
new file mode 100644
index 00000000000..f675a1ef24d
--- /dev/null
+++ b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_extensible.c
@@ -0,0 +1,964 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * pg_iceberg_extensible.c
+ *	  Extension initialization and the Iceberg utility guard.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/am_iceberg/pg_iceberg_extensible.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/genam.h"
+#include "access/htup_details.h"
+#include "access/table.h"
+#include "access/tableam.h"
+#include "am_iceberg/pg_iceberg_ddl.h"
+#include "am_iceberg/pg_iceberg_guc.h"
+#include "am_iceberg/pg_iceberg_options.h"
+#include "am_iceberg/pg_iceberg_reject.h"
+#include "catalog/namespace.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_depend.h"
+#include "catalog/pg_foreign_server.h"
+#include "catalog/pg_namespace.h"
+#include "cdb/cdbvars.h"
+#include "commands/defrem.h"
+#include "common/backend_registry.h"
+#include "fmgr.h"
+#include "foreign/foreign.h"
+#include "meta/iceberg_meta_engine.h"
+#include "meta/meta_engine_init.h"
+#include "miscadmin.h"
+#include "nodes/makefuncs.h"
+#include "nodes/parsenodes.h"
+#include "storage/lmgr.h"
+#include "tcop/utility.h"
+#include "utils/fmgroids.h"
+#include "utils/syscache.h"
+
+PG_MODULE_MAGIC;
+
+static ProcessUtility_hook_type prev_ProcessUtility_hook;
+
+static bool iceberg_is_effective_am(const char *accessMethod);
+static Oid get_rel_relam(Oid relid);
+static bool relid_is_iceberg(Oid relid);
+static bool server_referenced_by_iceberg(Oid srvid);
+static bool rangevar_is_iceberg(RangeVar *relation);
+static const char *string_object_name(Node *object);
+static Oid lock_object_by_name(Oid classid,
+							   Oid (*lookup) (const char *name, bool missing_ok),
+							   const char *name, LOCKMODE lockmode);
+static bool locked_server_referenced_by_iceberg(const char *servername);
+static bool utility_drop_targets_iceberg(DropStmt *stmt);
+static bool alter_table_targets_iceberg_am(AlterTableStmt *stmt);
+static bool alter_table_is_owner_only(AlterTableStmt *stmt);
+static bool database_has_iceberg_table(void);
+static bool schema_has_iceberg_table(const char *schemaname);
+static bool server_belongs_to_module(const char *servername);
+static bool is_module_fdw_name(const char *fdwname);
+static const char *find_reloption(List *options, const char *name);
+static void lock_create_servers(Oid catalog_srvid, Oid volume_srvid,
+								LOCKMODE lockmode);
+static void unlock_create_servers(Oid catalog_srvid, Oid volume_srvid,
+								  LOCKMODE lockmode);
+static void validate_create_binding(const char *catalog_name,
+									const char *volume_name);
+static void prepare_iceberg_create(CreateStmt *stmt);
+static void reject_utility_mode_ddl(const char *subject) pg_attribute_noreturn();
+static void reject_targeted_operation(const char *operation);
+static void pg_iceberg_ProcessUtility(PlannedStmt *pstmt,
+									 const char *queryString,
+									 bool readOnlyTree,
+									 ProcessUtilityContext context,
+									 ParamListInfo params,
+									 QueryEnvironment *queryEnv,
+									 DestReceiver *dest,
+									 QueryCompletion *qc);
+
+/*
+ * Resolve an omitted access method exactly as core CREATE TABLE does.  Keep
+ * this as the single source of truth for every relation-creating node handled
+ * by the hook.
+ */
+static bool
+iceberg_is_effective_am(const char *accessMethod)
+{
+	if (accessMethod != NULL)
+		return strcmp(accessMethod, "iceberg") == 0;
+	return default_table_access_method != NULL &&
+		strcmp(default_table_access_method, "iceberg") == 0;
+}
+
+/*
+ * This tree has no lsyscache get_rel_relam() helper, so provide the same
+ * missing-ok syscache lookup locally.
+ */
+static Oid
+get_rel_relam(Oid relid)
+{
+	HeapTuple	tuple;
+	Oid			relam = InvalidOid;
+
+	tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(relid));
+	if (HeapTupleIsValid(tuple))
+	{
+		relam = ((Form_pg_class) GETSTRUCT(tuple))->relam;
+		ReleaseSysCache(tuple);
+	}
+
+	return relam;
+}
+
+static bool
+relid_is_iceberg(Oid relid)
+{
+	Oid			iceberg_am_oid;
+
+	/*
+	 * Look the OID up every time instead of caching it: DROP EXTENSION
+	 * followed by CREATE EXTENSION hands out a new OID, and a cached one would
+	 * make these guards silently stop matching.  The lookup is syscache-backed,
+	 * and it must be missing-ok because the predicate is consulted for
+	 * arbitrary relations before the extension exists.
+	 */
+	iceberg_am_oid = get_table_am_oid("iceberg", true);
+
+	return OidIsValid(iceberg_am_oid) && OidIsValid(relid) &&
+		get_rel_relam(relid) == iceberg_am_oid;
+}
+
+static bool
+server_referenced_by_iceberg(Oid srvid)
+{
+	Relation	depend_rel;
+	ScanKeyData keys[2];
+	SysScanDesc scan;
+	HeapTuple	tuple;
+	bool		referenced = false;
+
+	if (!OidIsValid(srvid))
+		return false;
+
+	depend_rel = table_open(DependRelationId, AccessShareLock);
+
+	ScanKeyInit(&keys[0],
+				Anum_pg_depend_refclassid,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(ForeignServerRelationId));
+	ScanKeyInit(&keys[1],
+				Anum_pg_depend_refobjid,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(srvid));
+
+	scan = systable_beginscan(depend_rel, DependReferenceIndexId, true,
+							  NULL, lengthof(keys), keys);
+	while (HeapTupleIsValid(tuple = systable_getnext(scan)))
+	{
+		Form_pg_depend dependency = (Form_pg_depend) GETSTRUCT(tuple);
+
+		if (dependency->classid == RelationRelationId &&
+			relid_is_iceberg(dependency->objid))
+		{
+			referenced = true;
+			break;
+		}
+	}
+
+	systable_endscan(scan);
+	table_close(depend_rel, AccessShareLock);
+
+	return referenced;
+}
+
+static bool
+rangevar_is_iceberg(RangeVar *relation)
+{
+	Oid			relid;
+
+	if (relation == NULL)
+		return false;
+
+	relid = RangeVarGetRelid(relation, AccessShareLock, true);
+	return OidIsValid(relid) && relid_is_iceberg(relid);
+}
+
+static const char *
+string_object_name(Node *object)
+{
+	if (object != NULL && IsA(object, String))
+		return strVal(object);
+	return NULL;
+}
+
+/*
+ * Resolve a name to an object OID and lock that object exclusively, so that a
+ * guard can decide about it without racing the statement it is guarding.
+ *
+ * The re-resolution is what makes this correct rather than merely locked.
+ * Acquiring the lock can mean waiting, and the transactions waited for are free
+ * to rename this object away and give its name to a different one.  A guard
+ * that skipped the recheck would then hold a lock on an object the statement no
+ * longer names, and would scan it instead of the object about to be changed.
+ * This is the lookup-lock-recheck loop PostgreSQL applies to relations for the
+ * same reason.
+ *
+ * Returns InvalidOid when the name resolves to nothing, holding no lock.
+ */
+static Oid
+lock_object_by_name(Oid classid,
+					Oid (*lookup) (const char *name, bool missing_ok),
+					const char *name, LOCKMODE lockmode)
+{
+	for (;;)
+	{
+		Oid			objectid = lookup(name, true);
+
+		if (!OidIsValid(objectid))
+			return InvalidOid;
+
+		LockDatabaseObject(classid, objectid, 0, lockmode);
+
+		if (lookup(name, true) == objectid)
+			return objectid;
+
+		UnlockDatabaseObject(classid, objectid, 0, lockmode);
+	}
+}
+
+/*
+ * The exclusive counterpart of the share lock CREATE takes on the servers it
+ * binds to.  ALTER statements name one server, so ascending-OID order is
+ * trivial; preserve that ordering if a future statement form locks more than
+ * one.  Lock before scanning so the dependency decision cannot race CREATE.
+ */
+static bool
+locked_server_referenced_by_iceberg(const char *servername)
+{
+	Oid			srvid;
+
+	if (servername == NULL)
+		return false;
+
+	srvid = lock_object_by_name(ForeignServerRelationId,
+								get_foreign_server_oid, servername,
+								AccessExclusiveLock);
+	if (!OidIsValid(srvid))
+		return false;
+
+	return server_referenced_by_iceberg(srvid);
+}
+
+static bool
+utility_drop_targets_iceberg(DropStmt *stmt)
+{
+	ListCell   *lc;
+
+	if (stmt->removeType == OBJECT_TABLE)
+	{
+		foreach(lc, stmt->objects)
+		{
+			RangeVar   *relation =
+				makeRangeVarFromNameList((List *) lfirst(lc));
+
+			if (rangevar_is_iceberg(relation))
+				return true;
+		}
+	}
+	else if (stmt->removeType == OBJECT_FOREIGN_SERVER)
+	{
+		foreach(lc, stmt->objects)
+		{
+			Node	   *object = (Node *) lfirst(lc);
+
+			if (locked_server_referenced_by_iceberg(
+					string_object_name(object)))
+				return true;
+		}
+	}
+
+	return false;
+}
+
+/*
+ * Does this statement convert its target into a lake table?
+ */
+static bool
+alter_table_targets_iceberg_am(AlterTableStmt *stmt)
+{
+	ListCell   *lc;
+
+	foreach(lc, stmt->cmds)
+	{
+		AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lc);
+
+		if (cmd->subtype == AT_SetAccessMethod &&
+			iceberg_is_effective_am(cmd->name))
+			return true;
+	}
+
+	return false;
+}
+
+/*
+ * Does any lake table exist in this database?
+ *
+ * Used by the statements that name no relation at all, where there is nothing
+ * to match against and the only safe answer is to refuse if such a table could
+ * be reached.
+ */
+static bool
+database_has_iceberg_table(void)
+{
+	Relation	class_rel;
+	ScanKeyData key;
+	SysScanDesc scan;
+	HeapTuple	tuple;
+	Oid			iceberg_am_oid;
+	bool		found = false;
+
+	iceberg_am_oid = get_table_am_oid("iceberg", true);
+	if (!OidIsValid(iceberg_am_oid))
+		return false;
+
+	class_rel = table_open(RelationRelationId, AccessShareLock);
+	ScanKeyInit(&key,
+				Anum_pg_class_relam,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(iceberg_am_oid));
+	scan = systable_beginscan(class_rel, InvalidOid, false, NULL, 1, &key);
+	if (HeapTupleIsValid(tuple = systable_getnext(scan)))
+		found = true;
+	systable_endscan(scan);
+	table_close(class_rel, AccessShareLock);
+
+	return found;
+}
+
+/*
+ * Does the named schema contain a lake table?
+ *
+ * A lake table's namespace is not just where it lives locally: it is the
+ * namespace this module reports to the metadata engine.  Renaming the schema
+ * would therefore silently repoint the table at a different external namespace,
+ * leaving whatever it named before behind.  The check is scoped to schemas that
+ * actually contain one, so renaming any other schema stays unaffected.
+ */
+static bool
+schema_has_iceberg_table(const char *schemaname)
+{
+	Relation	class_rel;
+	ScanKeyData key[2];
+	SysScanDesc scan;
+	HeapTuple	tuple;
+	Oid			iceberg_am_oid;
+	Oid			namespace_oid;
+	bool		found = false;
+
+	if (schemaname == NULL)
+		return false;
+
+	iceberg_am_oid = get_table_am_oid("iceberg", true);
+	if (!OidIsValid(iceberg_am_oid))
+		return false;
+
+	/*
+	 * The exclusive counterpart of the share lock CREATE takes on its target
+	 * namespace, same as the server guard: without it a concurrent CREATE could
+	 * add a lake table to this schema after the scan below and before the
+	 * rename runs, and that table would then live in the renamed schema while
+	 * the metadata engine had already been told the old name.
+	 */
+	namespace_oid = lock_object_by_name(NamespaceRelationId,
+										get_namespace_oid, schemaname,
+										AccessExclusiveLock);
+	if (!OidIsValid(namespace_oid))
+		return false;
+
+	class_rel = table_open(RelationRelationId, AccessShareLock);
+	ScanKeyInit(&key[0],
+				Anum_pg_class_relam,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(iceberg_am_oid));
+	ScanKeyInit(&key[1],
+				Anum_pg_class_relnamespace,
+				BTEqualStrategyNumber, F_OIDEQ,
+				ObjectIdGetDatum(namespace_oid));
+	scan = systable_beginscan(class_rel, InvalidOid, false, NULL, 2, key);
+	if (HeapTupleIsValid(tuple = systable_getnext(scan)))
+		found = true;
+	systable_endscan(scan);
+	table_close(class_rel, AccessShareLock);
+
+	return found;
+}
+
+/*
+ * Does this ALTER TABLE do nothing but change the owner?
+ *
+ * Every other form is refused while the access method is unfinished, but this
+ * one has to go through: pg_dump writes ALTER TABLE ... OWNER TO for every
+ * table it dumps, so refusing it means refusing to restore a dump this module
+ * produced.  Ownership is local catalog state -- it cannot reach the external
+ * table or change what the mapping resolves to -- so letting it through costs
+ * nothing that the refusal was protecting.
+ */
+static bool
+alter_table_is_owner_only(AlterTableStmt *stmt)
+{
+	ListCell   *lc;
+
+	if (stmt->cmds == NIL)
+		return false;
+
+	foreach(lc, stmt->cmds)
+	{
+		AlterTableCmd *cmd = (AlterTableCmd *) lfirst(lc);
+
+		if (cmd->subtype != AT_ChangeOwner)
+			return false;
+	}
+
+	return true;
+}
+
+/*
+ * Is this a server belonging to one of this module's wrappers?
+ *
+ * Distinct from "referenced by a lake table": a server can be mutated before
+ * any table names it, and that is exactly the window in which the coordinator
+ * and a segment can be left holding different options for the same server name.
+ */
+static bool
+server_belongs_to_module(const char *servername)
+{
+	ForeignServer *server;
+	Oid			catalog_fdw;
+	Oid			volume_fdw;
+
+	if (servername == NULL)
+		return false;
+
+	server = GetForeignServerByName(servername, true);
+	if (server == NULL)
+		return false;
+
+	catalog_fdw = pg_iceberg_catalog_fdw_oid(true);
+	volume_fdw = pg_iceberg_volume_fdw_oid(true);
+
+	return (OidIsValid(catalog_fdw) && server->fdwid == catalog_fdw) ||
+		(OidIsValid(volume_fdw) && server->fdwid == volume_fdw);
+}
+
+/*
+ * Is this one of the two wrappers this extension registers?
+ *
+ * Mappings name their servers, and a server is resolved back to its wrapper by
+ * the wrapper's name.  Renaming one therefore breaks every mapping lookup at
+ * once -- including on the DROP path, which then cannot tell the metadata engine
+ * anything.  Refused whether or not a table exists yet, because the breakage is
+ * in the lookup rather than in any particular table.
+ */
+static bool
+is_module_fdw_name(const char *fdwname)
+{
+	return fdwname != NULL &&
+		(strcmp(fdwname, "iceberg_catalog_fdw") == 0 ||
+		 strcmp(fdwname, "iceberg_volume_fdw") == 0);
+}
+
+static const char *
+find_reloption(List *options, const char *name)
+{
+	ListCell   *lc;
+
+	foreach(lc, options)
+	{
+		DefElem    *def = (DefElem *) lfirst(lc);
+
+		if (strcmp(def->defname, name) == 0)
+			return defGetString(def);
+	}
+
+	return NULL;
+}
+
+static void
+lock_create_servers(Oid catalog_srvid, Oid volume_srvid, LOCKMODE lockmode)
+{
+	/*
+	 * Ascending OID order, so that two CREATEs naming the same pair in opposite
+	 * order cannot deadlock.  ALTER-side server guards take the
+	 * AccessExclusiveLock counterpart before scanning pg_depend.
+	 */
+	if (catalog_srvid < volume_srvid)
+	{
+		LockDatabaseObject(ForeignServerRelationId, catalog_srvid, 0, lockmode);
+		LockDatabaseObject(ForeignServerRelationId, volume_srvid, 0, lockmode);
+	}
+	else if (volume_srvid < catalog_srvid)
+	{
+		LockDatabaseObject(ForeignServerRelationId, volume_srvid, 0, lockmode);
+		LockDatabaseObject(ForeignServerRelationId, catalog_srvid, 0, lockmode);
+	}
+	else
+		LockDatabaseObject(ForeignServerRelationId, catalog_srvid, 0, lockmode);
+}
+
+static void
+unlock_create_servers(Oid catalog_srvid, Oid volume_srvid, LOCKMODE lockmode)
+{
+	UnlockDatabaseObject(ForeignServerRelationId, catalog_srvid, 0, lockmode);
+	if (volume_srvid != catalog_srvid)
+		UnlockDatabaseObject(ForeignServerRelationId, volume_srvid, 0, lockmode);
+}
+
+static void
+validate_create_binding(const char *catalog_name, const char *volume_name)
+{
+	ForeignServer *catalog_server;
+	ForeignServer *volume_server;
+
+	/*
+	 * Resolve, lock, and only then read what was locked -- the same
+	 * lookup-lock-recheck the guards use, for the same reason.  Two things go
+	 * wrong without it: the name can come to denote a different server while
+	 * this backend waits for the lock, so the checks below would describe a
+	 * server the statement no longer names; and a concurrent ALTER SERVER that
+	 * commits during that wait leaves any copy fetched beforehand stale, so the
+	 * definitive read has to happen afterwards.
+	 */
+	for (;;)
+	{
+		Oid			catalog_srvid = get_foreign_server_oid(catalog_name, false);
+		Oid			volume_srvid = get_foreign_server_oid(volume_name, false);
+
+		lock_create_servers(catalog_srvid, volume_srvid, AccessShareLock);
+
+		if (get_foreign_server_oid(catalog_name, true) == catalog_srvid &&
+			get_foreign_server_oid(volume_name, true) == volume_srvid)
+		{
+			catalog_server = GetForeignServer(catalog_srvid);
+			volume_server = GetForeignServer(volume_srvid);
+			break;
+		}
+
+		unlock_create_servers(catalog_srvid, volume_srvid, AccessShareLock);
+	}
+
+	if (catalog_server->fdwid != pg_iceberg_catalog_fdw_oid(false))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+				 errmsg("server \"%s\" is not an iceberg catalog server",
+						catalog_name)));
+	if (volume_server->fdwid != pg_iceberg_volume_fdw_oid(false))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+				 errmsg("server \"%s\" is not an iceberg volume server",
+						volume_name)));
+
+	pg_iceberg_check_server_usage(catalog_server->serverid);
+	pg_iceberg_check_server_usage(volume_server->serverid);
+}
+
+static void
+prepare_iceberg_create(CreateStmt *stmt)
+{
+	DistributedBy *distributed_by;
+	const char *catalog_name;
+	const char *volume_name;
+
+	if (stmt->accessMethod == NULL)
+		stmt->accessMethod = pstrdup("iceberg");
+
+	/*
+	 * A lake table is distributed randomly: rows live outside PostgreSQL, so no
+	 * local key can describe where they are.  That policy is injected below.
+	 *
+	 * A QE receives the policy the QD injected and transformed, including the
+	 * resolved segment count, so it accepts exactly that shape.
+	 *
+	 * On the dispatcher, an explicit clause is accepted only when it asks for
+	 * what would have been injected anyway.  Refusing every clause looks
+	 * stricter but is wrong in one case that matters: pg_dump writes
+	 * DISTRIBUTED RANDOMLY into the CREATE TABLE it emits, so refusing it means
+	 * refusing to restore a dump this module produced.  A clause naming columns
+	 * still cannot be honoured and is refused with the syntax the user wrote.
+	 */
+	if (stmt->distributedBy != NULL)
+	{
+		if (stmt->distributedBy->ptype != POLICYTYPE_PARTITIONED)
+			pg_iceberg_not_supported(
+				stmt->distributedBy->ptype == POLICYTYPE_REPLICATED ?
+				"DISTRIBUTED REPLICATED" : "this distribution policy");
+		if (stmt->distributedBy->keyCols != NIL)
+			pg_iceberg_not_supported("DISTRIBUTED BY");
+	}
+	else if (Gp_role == GP_ROLE_EXECUTE)
+		pg_iceberg_not_supported("DISTRIBUTED BY");
+	if (stmt->partspec != NULL || stmt->partbound != NULL)
+		pg_iceberg_not_supported("partitioned tables");
+	if (stmt->inhRelations != NIL)
+		pg_iceberg_not_supported("INHERITS");
+	if (stmt->ofTypename != NULL)
+		pg_iceberg_not_supported("typed tables (OF type)");
+	if (stmt->relation->relpersistence == RELPERSISTENCE_TEMP)
+		pg_iceberg_not_supported("TEMP tables");
+	if (stmt->relation->relpersistence == RELPERSISTENCE_UNLOGGED)
+		pg_iceberg_not_supported("UNLOGGED tables");
+	if (stmt->oncommit != ONCOMMIT_NOOP)
+		pg_iceberg_not_supported("ON COMMIT");
+	if (stmt->tablespacename != NULL)
+		pg_iceberg_not_supported("TABLESPACE");
+
+	if (Gp_role != GP_ROLE_EXECUTE)
+	{
+		distributed_by = makeNode(DistributedBy);
+		distributed_by->ptype = POLICYTYPE_PARTITIONED;
+		distributed_by->numsegments = -1;
+		distributed_by->keyCols = NIL;
+		stmt->distributedBy = distributed_by;
+	}
+
+	catalog_name = find_reloption(stmt->options, "catalog");
+	if (catalog_name == NULL)
+	{
+		if (iceberg_default_catalog == NULL ||
+			iceberg_default_catalog[0] == '\0')
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+					 errmsg("no catalog specified"),
+					 errhint("Specify WITH (catalog = '...') or SET iceberg.default_catalog.")));
+
+		stmt->options = lappend(stmt->options,
+								makeDefElem("catalog",
+											(Node *) makeString(
+												pstrdup(iceberg_default_catalog)),
+											-1));
+		catalog_name = iceberg_default_catalog;
+	}
+
+	volume_name = find_reloption(stmt->options, "volume");
+	if (volume_name == NULL)
+	{
+		if (iceberg_default_volume == NULL ||
+			iceberg_default_volume[0] == '\0')
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+					 errmsg("no volume specified"),
+					 errhint("Specify WITH (volume = '...') or SET iceberg.default_volume.")));
+
+		stmt->options = lappend(stmt->options,
+								makeDefElem("volume",
+											(Node *) makeString(
+												pstrdup(iceberg_default_volume)),
+											-1));
+		volume_name = iceberg_default_volume;
+	}
+
+	/*
+	 * This makes the QD fail before dispatch; QEs repeat the checks against
+	 * their local catalog copies.
+	 */
+	validate_create_binding(catalog_name, volume_name);
+}
+
+static void
+reject_utility_mode_ddl(const char *subject)
+{
+	/*
+	 * A utility-mode backend would create, alter, or drop only local catalog
+	 * state, without dispatch.  That would break the invariant that every node
+	 * agrees about a lake table's mapping and about the servers it names.
+	 */
+	pg_iceberg_not_supported(psprintf("utility-mode DDL on %s", subject));
+}
+
+static void
+reject_targeted_operation(const char *operation)
+{
+	if (Gp_role == GP_ROLE_UTILITY)
+		reject_utility_mode_ddl("iceberg tables");
+	pg_iceberg_not_supported(operation);
+}
+
+static void
+pg_iceberg_ProcessUtility(PlannedStmt *pstmt,
+						  const char *queryString,
+						  bool readOnlyTree,
+						  ProcessUtilityContext context,
+						  ParamListInfo params,
+						  QueryEnvironment *queryEnv,
+						  DestReceiver *dest,
+						  QueryCompletion *qc)
+{
+	Node	   *parsetree = pstmt->utilityStmt;
+
+	switch (nodeTag(parsetree))
+	{
+		case T_CreateStmt:
+			{
+				CreateStmt *stmt = (CreateStmt *) parsetree;
+
+				if (iceberg_is_effective_am(stmt->accessMethod))
+				{
+					if (Gp_role == GP_ROLE_UTILITY)
+						reject_utility_mode_ddl("iceberg tables");
+
+					/*
+					 * Every successful Iceberg CREATE is mutated.  Preserve a
+					 * protected parse tree by replacing the PlannedStmt and
+					 * mutating only its copy.
+					 */
+					if (readOnlyTree)
+					{
+						pstmt = copyObject(pstmt);
+						readOnlyTree = false;
+						parsetree = pstmt->utilityStmt;
+						stmt = (CreateStmt *) parsetree;
+					}
+					prepare_iceberg_create(stmt);
+				}
+			}
+			break;
+
+		case T_CreateTableAsStmt:
+			{
+				CreateTableAsStmt *stmt = (CreateTableAsStmt *) parsetree;
+
+				if (stmt->into != NULL &&
+					iceberg_is_effective_am(stmt->into->accessMethod))
+					reject_targeted_operation(
+						"CREATE TABLE AS / CREATE MATERIALIZED VIEW");
+			}
+			break;
+
+		case T_AlterTableStmt:
+			{
+				AlterTableStmt *stmt = (AlterTableStmt *) parsetree;
+
+				if (rangevar_is_iceberg(stmt->relation))
+				{
+					/*
+					 * Utility mode is refused for every form, including the one
+					 * accepted below: core does not dispatch a utility-mode
+					 * ALTER TABLE, so an owner change made there would land on
+					 * the connected node alone and leave the catalogs
+					 * disagreeing about who owns the table.
+					 */
+					if (Gp_role == GP_ROLE_UTILITY)
+						reject_utility_mode_ddl("iceberg tables");
+
+					if (!alter_table_is_owner_only(stmt))
+						reject_targeted_operation(
+							"ALTER TABLE on iceberg tables");
+				}
+
+				/*
+				 * Converting some other table INTO a lake table has to be
+				 * refused here as well, and the guard above does not see it:
+				 * the relation is still a heap when the statement arrives.
+				 * Left alone, the rewrite would reach the metadata engine
+				 * through the transient relation it builds -- under a
+				 * generated name, with none of the checks CREATE TABLE makes,
+				 * including whether the user may use the servers at all.
+				 */
+				if (alter_table_targets_iceberg_am(stmt))
+					reject_targeted_operation(
+						"ALTER TABLE ... SET ACCESS METHOD iceberg");
+			}
+			break;
+
+		case T_RenameStmt:
+			{
+				RenameStmt *stmt = (RenameStmt *) parsetree;
+
+				if ((stmt->renameType == OBJECT_TABLE ||
+					 stmt->renameType == OBJECT_COLUMN) &&
+					rangevar_is_iceberg(stmt->relation))
+					reject_targeted_operation("RENAME on iceberg tables");
+				if (stmt->renameType == OBJECT_FOREIGN_SERVER &&
+					locked_server_referenced_by_iceberg(
+						string_object_name(stmt->object)))
+					reject_targeted_operation(
+						"RENAME on servers referenced by iceberg tables");
+				if (stmt->renameType == OBJECT_SCHEMA &&
+					schema_has_iceberg_table(stmt->subname))
+					reject_targeted_operation(
+						"RENAME on schemas containing iceberg tables");
+				if (stmt->renameType == OBJECT_FDW &&
+					is_module_fdw_name(string_object_name(stmt->object)))
+					reject_targeted_operation(
+						"RENAME on the iceberg foreign-data wrappers");
+			}
+			break;
+
+		case T_AlterObjectSchemaStmt:
+			{
+				AlterObjectSchemaStmt *stmt =
+					(AlterObjectSchemaStmt *) parsetree;
+
+				if (stmt->objectType == OBJECT_TABLE &&
+					rangevar_is_iceberg(stmt->relation))
+					reject_targeted_operation(
+						"SET SCHEMA on iceberg tables");
+			}
+			break;
+
+		case T_AlterOwnerStmt:
+			{
+				AlterOwnerStmt *stmt = (AlterOwnerStmt *) parsetree;
+
+				if (stmt->objectType == OBJECT_TABLE &&
+					rangevar_is_iceberg(stmt->relation))
+					reject_targeted_operation(
+						"ALTER OWNER on iceberg tables");
+				if (stmt->objectType == OBJECT_FOREIGN_SERVER &&
+					locked_server_referenced_by_iceberg(
+						string_object_name(stmt->object)))
+					reject_targeted_operation(
+						"ALTER OWNER on servers referenced by iceberg tables");
+			}
+			break;
+
+		case T_AlterForeignServerStmt:
+			{
+				AlterForeignServerStmt *stmt =
+					(AlterForeignServerStmt *) parsetree;
+
+				/*
+				 * Utility mode first, and for any server of ours rather than
+				 * only for one a table already names.  Core does not dispatch a
+				 * utility-mode ALTER SERVER, so the options would change on the
+				 * connected node alone; a table created afterwards would then
+				 * resolve the same server name to different options depending on
+				 * which node resolved it, and nothing downstream would notice.
+				 * The window is before any dependency exists, which is precisely
+				 * what the reference check below cannot see.
+				 */
+				if (Gp_role == GP_ROLE_UTILITY &&
+					server_belongs_to_module(stmt->servername))
+					reject_utility_mode_ddl("iceberg servers");
+
+				/* Both VERSION and OPTIONS forms use this parse node. */
+				if (locked_server_referenced_by_iceberg(stmt->servername))
+					reject_targeted_operation(
+						"ALTER SERVER on servers referenced by iceberg tables");
+			}
+			break;
+
+		case T_VacuumStmt:
+			/*
+			 * Plain VACUUM and ANALYZE are no-ops for iceberg tables and stay
+			 * allowed, but VACUUM FULL must be refused here rather than in the
+			 * table AM: rewriting a relation first creates a transient one,
+			 * which reaches OAT_POST_CREATE and makes the metadata engine
+			 * create a table in the remote catalog.  The subsequent
+			 * relation_copy_for_cluster error rolls back the local catalog,
+			 * yet the remote side would keep an orphan behind.
+			 */
+			{
+				VacuumStmt *stmt = (VacuumStmt *) parsetree;
+				ListCell   *lc;
+				bool		is_full = false;
+
+				foreach(lc, stmt->options)
+				{
+					DefElem    *def = (DefElem *) lfirst(lc);
+
+					if (strcmp(def->defname, "full") == 0)
+						is_full = defGetBoolean(def);
+				}
+
+				if (is_full)
+				{
+					/*
+					 * A database-wide VACUUM FULL names no relation, so there
+					 * is nothing to match: refuse it outright while any lake
+					 * table exists, rather than let it reach one and rewrite
+					 * it.
+					 */
+					if (stmt->rels == NIL)
+					{
+						if (database_has_iceberg_table())
+							reject_targeted_operation(
+								"VACUUM FULL while iceberg tables exist");
+					}
+					else
+					{
+						foreach(lc, stmt->rels)
+						{
+							VacuumRelation *vrel = (VacuumRelation *) lfirst(lc);
+
+							if (rangevar_is_iceberg(vrel->relation))
+								reject_targeted_operation(
+									"VACUUM FULL on iceberg tables");
+						}
+					}
+				}
+			}
+			break;
+
+		case T_DropStmt:
+			/*
+			 * Plain DROP TABLE is supported outside utility mode; OAT_DROP
+			 * performs the engine call.  DROP SERVER protection otherwise
+			 * comes from the dependencies recorded on every node.
+			 */
+			if (Gp_role == GP_ROLE_UTILITY &&
+				utility_drop_targets_iceberg((DropStmt *) parsetree))
+				reject_utility_mode_ddl("iceberg tables");
+			break;
+
+		default:
+			break;
+	}
+
+	if (prev_ProcessUtility_hook)
+		(*prev_ProcessUtility_hook) (pstmt, queryString, readOnlyTree,
+									context, params, queryEnv, dest, qc);
+	else
+		standard_ProcessUtility(pstmt, queryString, readOnlyTree,
+								context, params, queryEnv, dest, qc);
+}
+
+void
+_PG_init(void)
+{
+	if (!process_shared_preload_libraries_in_progress)
+		ereport(ERROR,
+				(errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+				 errmsg("datalake_fdw must be loaded via shared_preload_libraries"),
+				 errhint("Add \"datalake_fdw\" to shared_preload_libraries and restart the server.")));
+
+	pg_iceberg_define_gucs();
+	pg_iceberg_register_reloptions();
+	DatalakeRegisterMetaEngines();
+	datalake_register_storage_backends();
+
+	prev_ProcessUtility_hook = ProcessUtility_hook;
+	ProcessUtility_hook = pg_iceberg_ProcessUtility;
+
+	pg_iceberg_prev_object_access_hook = object_access_hook;
+	object_access_hook = pg_iceberg_object_access;
+}
diff --git a/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_guc.c b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_guc.c
new file mode 100644
index 00000000000..71dc5c53ef1
--- /dev/null
+++ b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_guc.c
@@ -0,0 +1,67 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * pg_iceberg_guc.c
+ *	  Configuration variables for Iceberg table creation.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/am_iceberg/pg_iceberg_guc.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "am_iceberg/pg_iceberg_guc.h"
+#include "utils/guc.h"
+
+char	   *iceberg_default_catalog;
+char	   *iceberg_default_volume;
+
+void
+pg_iceberg_define_gucs(void)
+{
+	/*
+	 * Do not install check hooks for these names.  The servers they name are
+	 * not necessarily present at assignment time, and assignment happens at
+	 * different moments on the coordinator and on the segments.  CREATE TABLE
+	 * validates the values against the catalog the executing backend sees.
+	 */
+	DefineCustomStringVariable("iceberg.default_catalog",
+							   "Default catalog server for new Iceberg tables.",
+							   NULL,
+							   &iceberg_default_catalog,
+							   "",
+							   PGC_USERSET,
+							   0,
+							   NULL,
+							   NULL,
+							   NULL);
+
+	DefineCustomStringVariable("iceberg.default_volume",
+							   "Default volume server for new Iceberg tables.",
+							   NULL,
+							   &iceberg_default_volume,
+							   "",
+							   PGC_USERSET,
+							   0,
+							   NULL,
+							   NULL,
+							   NULL);
+}
diff --git a/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_guc.h b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_guc.h
new file mode 100644
index 00000000000..8cd8d0a4400
--- /dev/null
+++ b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_guc.h
@@ -0,0 +1,37 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * pg_iceberg_guc.h
+ *	  Configuration variables for Iceberg table creation.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/am_iceberg/pg_iceberg_guc.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef PG_ICEBERG_GUC_H
+#define PG_ICEBERG_GUC_H
+
+extern char *iceberg_default_catalog;
+extern char *iceberg_default_volume;
+
+extern void pg_iceberg_define_gucs(void);
+
+#endif							/* PG_ICEBERG_GUC_H */
diff --git a/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_options.c b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_options.c
new file mode 100644
index 00000000000..6475546223c
--- /dev/null
+++ b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_options.c
@@ -0,0 +1,616 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * pg_iceberg_options.c
+ *	  How a lake table names its catalog and volume, and how that is read back.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/am_iceberg/pg_iceberg_options.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/relation.h"
+#include "access/reloptions.h"
+#include "am_iceberg/pg_iceberg_options.h"
+#include "catalog/dependency.h"
+#include "catalog/objectaddress.h"
+#include "catalog/pg_class.h"
+#include "catalog/pg_foreign_server.h"
+#include "catalog/pg_user_mapping.h"
+#include "commands/defrem.h"
+#include "foreign/foreign.h"
+#include "iceberg_catalog_fdw/iceberg_catalog_option.h"
+#include "iceberg_volume_fdw/iceberg_volume_option.h"
+#include "miscadmin.h"
+#include "utils/acl.h"
+#include "utils/builtins.h"
+#include "utils/lsyscache.h"
+#include "utils/rel.h"
+#include "utils/syscache.h"
+
+typedef struct IcebergRelOptions
+{
+	int32		vl_len_;
+	int			catalog_off;
+	int			volume_off;
+	int			fileformat_off;
+	bool		purge_on_drop;
+} IcebergRelOptions;
+
+static relopt_kind iceberg_relopt_kind;
+
+static char *iceberg_relopt_string(IcebergRelOptions *opts, int off);
+static MetaKv *defelems_to_kvs(List *options, int *n_props);
+static DlErrCode invalid_location(char **errdetail, char *detail);
+static bool s3_bucket_alnum(char ch);
+static bool s3_bucket_char(char ch);
+
+/*
+ * Register a private reloption kind for iceberg table access-method options.
+ */
+void
+pg_iceberg_register_reloptions(void)
+{
+	if (iceberg_relopt_kind != 0)
+		return;
+
+	iceberg_relopt_kind = add_reloption_kind();
+
+	add_string_reloption(iceberg_relopt_kind, "catalog",
+						 "iceberg catalog foreign server name", "", NULL,
+						 AccessExclusiveLock);
+	add_string_reloption(iceberg_relopt_kind, "volume",
+						 "iceberg volume foreign server name", "", NULL,
+						 AccessExclusiveLock);
+	add_string_reloption(iceberg_relopt_kind, "fileformat",
+						 "iceberg data file format", "parquet", NULL,
+						 AccessExclusiveLock);
+
+	/*
+	 * Dropping the table means dropping this database's reference to it; the
+	 * data belongs to the lake and stays there.  Deleting it as well has to be
+	 * asked for, and the answer belongs to the table rather than to a session:
+	 * a setting could make the same DROP destroy data or not depending on who
+	 * typed it, and a reloption travels with the table into a dump.
+	 */
+	add_bool_reloption(iceberg_relopt_kind, "purge_on_drop",
+					   "delete the lake data when the table is dropped",
+					   false, AccessExclusiveLock);
+}
+
+bytea *
+pg_iceberg_amoptions(Datum reloptions, char relkind, bool validate)
+{
+	static const relopt_parse_elt tab[] = {
+		{"catalog", RELOPT_TYPE_STRING,
+		 offsetof(IcebergRelOptions, catalog_off)},
+		{"volume", RELOPT_TYPE_STRING,
+		 offsetof(IcebergRelOptions, volume_off)},
+		{"fileformat", RELOPT_TYPE_STRING,
+		 offsetof(IcebergRelOptions, fileformat_off)},
+		{"purge_on_drop", RELOPT_TYPE_BOOL,
+		 offsetof(IcebergRelOptions, purge_on_drop)}
+	};
+
+	Assert(iceberg_relopt_kind != 0);
+
+	/*
+	 * The option set does not depend on relkind; the same mapping applies to
+	 * every relation kind that can carry this access method.
+	 */
+
+	/*
+	 * Whether the named servers exist is deliberately not checked here:
+	 * amoptions runs in relcache and utility contexts where such lookups are
+	 * unsafe or premature.  The use points check instead.
+	 */
+	return (bytea *) build_reloptions(reloptions, validate,
+									 iceberg_relopt_kind,
+									 sizeof(IcebergRelOptions),
+									 tab, lengthof(tab));
+}
+
+/*
+ * rd_options belongs to the relcache.  Every returned string is copied into
+ * the caller's current memory context; callers must never retain a pointer
+ * into rd_options itself.
+ */
+static char *
+iceberg_relopt_string(IcebergRelOptions *opts, int off)
+{
+	if (opts == NULL || off == 0)
+		return NULL;
+
+	return pstrdup(((char *) opts) + off);
+}
+
+static MetaKv *
+defelems_to_kvs(List *options, int *n_props)
+{
+	MetaKv	   *props;
+	ListCell   *lc;
+	int			i = 0;
+	int			count = list_length(options);
+
+	*n_props = count;
+	if (count == 0)
+		return NULL;
+
+	props = palloc0(sizeof(MetaKv) * count);
+	foreach(lc, options)
+	{
+		DefElem    *def = (DefElem *) lfirst(lc);
+
+		props[i].key = pstrdup(def->defname);
+		props[i].value = pstrdup(defGetString(def));
+		i++;
+	}
+
+	return props;
+}
+
+Oid
+pg_iceberg_catalog_fdw_oid(bool missing_ok)
+{
+	ForeignDataWrapper *fdw;
+
+	fdw = GetForeignDataWrapperByName("iceberg_catalog_fdw", missing_ok);
+	return fdw == NULL ? InvalidOid : fdw->fdwid;
+}
+
+Oid
+pg_iceberg_volume_fdw_oid(bool missing_ok)
+{
+	ForeignDataWrapper *fdw;
+
+	fdw = GetForeignDataWrapperByName("iceberg_volume_fdw", missing_ok);
+	return fdw == NULL ? InvalidOid : fdw->fdwid;
+}
+
+/*
+ * OID of this extension's access method, or InvalidOid while it does not
+ * exist.
+ *
+ * Missing-ok because the AM is absent while CREATE EXTENSION is still
+ * installing it.  The result is deliberately not cached: DROP EXTENSION
+ * followed by CREATE EXTENSION produces a new OID, and a stale cached one
+ * would make callers silently treat lake tables as ordinary relations.  The
+ * lookup is syscache-backed.
+ */
+Oid
+pg_iceberg_am_oid(void)
+{
+	return get_table_am_oid("iceberg", true);
+}
+
+IcebergTableInfo *
+pg_iceberg_get_table_info_rel(Relation rel)
+{
+	IcebergRelOptions *opts;
+	IcebergTableInfo *info;
+	IcebergCatalogOptions *catalog_options;
+	IcebergVolumeOptions *volume_options;
+	ForeignServer *catalog_server;
+	ForeignServer *volume_server;
+	char	   *catalog_server_name;
+	char	   *volume_server_name;
+	char	   *parse_detail = NULL;
+	DlErrCode	parse_result;
+	Oid			amoid;
+
+	/*
+	 * rd_options is only an IcebergRelOptions when this access method put it
+	 * there.  Every other access method has its own layout -- a heap's
+	 * StdRdOptions would present fillfactor and toast_tuple_target where the
+	 * string offsets are read below, and pstrdup() would then run off the
+	 * allocation.  The callers in this module check the access method before
+	 * getting here, but this function is reachable from anywhere, so it cannot
+	 * rely on that.
+	 */
+	amoid = pg_iceberg_am_oid();
+	if (!OidIsValid(amoid) || rel->rd_rel->relam != amoid)
+		ereport(ERROR,
+				(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				 errmsg("\"%s\" is not an iceberg table",
+						RelationGetRelationName(rel))));
+
+	opts = (IcebergRelOptions *) rel->rd_options;
+
+	catalog_server_name = iceberg_relopt_string(opts,
+											   opts == NULL ? 0 : opts->catalog_off);
+	volume_server_name = iceberg_relopt_string(opts,
+											   opts == NULL ? 0 : opts->volume_off);
+
+	/*
+	 * fileformat is a valid option and is persisted, but nothing consumes it
+	 * until the format layer exists, so the result does not carry it.
+	 */
+
+	if (catalog_server_name == NULL || catalog_server_name[0] == '\0')
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+				 errmsg("iceberg table \"%s\" has no catalog binding",
+						RelationGetRelationName(rel)),
+				 errhint("Specify WITH (catalog = '...', volume = '...'), or set "
+						 "iceberg.default_catalog and iceberg.default_volume "
+						 "before CREATE TABLE.")));
+
+	if (volume_server_name == NULL || volume_server_name[0] == '\0')
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+				 errmsg("iceberg table \"%s\" has no volume binding",
+						RelationGetRelationName(rel)),
+				 errhint("Specify WITH (catalog = '...', volume = '...'), or set "
+						 "iceberg.default_catalog and iceberg.default_volume "
+						 "before CREATE TABLE.")));
+
+	catalog_server = GetForeignServerByName(catalog_server_name, false);
+	if (catalog_server->fdwid != pg_iceberg_catalog_fdw_oid(false))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+				 errmsg("server \"%s\" is not an iceberg catalog server",
+						catalog_server_name)));
+
+	volume_server = GetForeignServerByName(volume_server_name, false);
+	if (volume_server->fdwid != pg_iceberg_volume_fdw_oid(false))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
+				 errmsg("server \"%s\" is not an iceberg volume server",
+						volume_server_name)));
+
+	catalog_options = get_iceberg_catalog_options(catalog_server);
+	volume_options = get_iceberg_volume_options(volume_server);
+
+	info = palloc0(sizeof(IcebergTableInfo));
+	info->catalog_name = pstrdup(catalog_options->foreign_catalog.catalog_name);
+	info->catalog_server_name = catalog_server_name;
+	info->volume_name = pstrdup(volume_server->servername);
+	info->volume_server_name = volume_server_name;
+
+	info->opts = palloc0(sizeof(IcebergTableOptions));
+
+	/*
+	 * Copied rather than aliased to info->catalog_name: the two fields are
+	 * released independently.
+	 */
+	info->opts->catalog = pstrdup(info->catalog_name);
+	info->opts->namespace = get_namespace_name(RelationGetNamespace(rel));
+	info->opts->table = pstrdup(RelationGetRelationName(rel));
+	info->opts->location = NULL;
+	info->opts->purge_on_drop = opts != NULL && opts->purge_on_drop;
+
+	info->catalog_srvid = catalog_server->serverid;
+	info->volume_srvid = volume_server->serverid;
+	info->catalog_props = defelems_to_kvs(catalog_server->options,
+										 &info->n_catalog_props);
+
+	parse_result = pg_iceberg_parse_location(volume_options->foreign_volume.base_path,
+											 volume_options->volume_server.endpoint,
+											 volume_options->volume_server.region,
+											 &info->volume_location,
+											 &parse_detail);
+	if (parse_result != DL_OK)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("iceberg volume server \"%s\" has an invalid %s",
+						volume_server_name,
+						DATALAKE_ICEBERG_VOLUME_BASE_PATH),
+				 errdetail("%s", parse_detail)));
+
+	/*
+	 * Credential resolution intentionally does not happen here.  Stub and
+	 * DDL-only paths must be able to describe a table with zero credentials.
+	 */
+	return info;
+}
+
+/*
+ * Same result from a relation OID.
+ *
+ * Not for use from an object access hook: while a relation is being dropped its
+ * relcache entry may already be gone, and a hook has to decide what to do about
+ * that rather than error out.  Those callers open the relation themselves and
+ * use pg_iceberg_get_table_info_rel().
+ */
+IcebergTableInfo *
+pg_iceberg_get_table_info(Oid relid)
+{
+	Relation	rel;
+	IcebergTableInfo *info;
+
+	rel = try_relation_open(relid, AccessShareLock, false);
+	if (rel == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_UNDEFINED_OBJECT),
+				 errmsg("lake table entry not found for relation %u", relid)));
+
+	info = pg_iceberg_get_table_info_rel(rel);
+	relation_close(rel, AccessShareLock);
+
+	return info;
+}
+
+void
+pg_iceberg_free_table_info(IcebergTableInfo *info)
+{
+	int			i;
+
+	if (info == NULL)
+		return;
+
+	if (info->catalog_name)
+		pfree(info->catalog_name);
+	if (info->catalog_server_name)
+		pfree(info->catalog_server_name);
+	if (info->volume_name)
+		pfree(info->volume_name);
+	if (info->volume_server_name)
+		pfree(info->volume_server_name);
+
+	if (info->opts)
+	{
+		if (info->opts->catalog)
+			pfree(info->opts->catalog);
+		if (info->opts->namespace)
+			pfree(info->opts->namespace);
+		if (info->opts->table)
+			pfree(info->opts->table);
+		if (info->opts->location)
+			pfree(info->opts->location);
+		pfree(info->opts);
+	}
+
+	/*
+	 * The parsed location and the property array are allocated by this module
+	 * too; a destructor that released only the names would let a statement
+	 * resolving many tables accumulate the rest until its context is reset.
+	 */
+	if (info->volume_location.scheme)
+		pfree(info->volume_location.scheme);
+	if (info->volume_location.authority)
+		pfree(info->volume_location.authority);
+	if (info->volume_location.path_prefix)
+		pfree(info->volume_location.path_prefix);
+	if (info->volume_location.endpoint)
+		pfree(info->volume_location.endpoint);
+	if (info->volume_location.region)
+		pfree(info->volume_location.region);
+
+	for (i = 0; i < info->n_catalog_props; i++)
+	{
+		if (info->catalog_props[i].key)
+			pfree(info->catalog_props[i].key);
+		if (info->catalog_props[i].value)
+			pfree(info->catalog_props[i].value);
+	}
+	if (info->catalog_props)
+		pfree(info->catalog_props);
+
+	pfree(info);
+}
+
+/*
+ * Make the mapping enforceable by recording what the table depends on.
+ *
+ * The mapping itself needs no insertion: it is part of the relation, written by
+ * the CREATE TABLE that produced it.  What has to be added is the pair of
+ * dependency rows that stop either server from being dropped out from under the
+ * table, and that carry it along when one is dropped with CASCADE.  Recorded on
+ * the dispatcher and on every segment, so that DROP SERVER is refused locally on
+ * whichever node first evaluates it.
+ *
+ * There is deliberately no RemoveLakeTableEntry() counterpart: both the
+ * reloptions and these rows belong to the relation, so they are removed by the
+ * same delete that removes it.
+ */
+void
+InsertLakeTableEntry(Oid relid, const IcebergTableInfo *info)
+{
+	ObjectAddress table;
+	ObjectAddress server;
+
+	ObjectAddressSet(table, RelationRelationId, relid);
+
+	ObjectAddressSet(server, ForeignServerRelationId, info->catalog_srvid);
+	recordDependencyOn(&table, &server, DEPENDENCY_NORMAL);
+
+	ObjectAddressSet(server, ForeignServerRelationId, info->volume_srvid);
+	recordDependencyOn(&table, &server, DEPENDENCY_NORMAL);
+}
+
+MetaKv *
+pg_iceberg_resolve_credentials(Oid serverid, Oid auth_userid, int *n_props)
+{
+	HeapTuple	tuple;
+	Datum		options_datum;
+	bool		isnull;
+	List	   *options;
+	MetaKv	   *props;
+
+	Assert(n_props != NULL);
+	*n_props = 0;
+
+	/*
+	 * GetUserMapping() cannot be used here because it ereports when neither a
+	 * user-specific nor PUBLIC mapping exists.  User mappings are optional in
+	 * v1, so perform the same two syscache probes with missing-ok semantics.
+	 */
+	tuple = SearchSysCache2(USERMAPPINGUSERSERVER,
+							ObjectIdGetDatum(auth_userid),
+							ObjectIdGetDatum(serverid));
+	if (!HeapTupleIsValid(tuple) && OidIsValid(auth_userid))
+		tuple = SearchSysCache2(USERMAPPINGUSERSERVER,
+								ObjectIdGetDatum(InvalidOid),
+								ObjectIdGetDatum(serverid));
+
+	if (!HeapTupleIsValid(tuple))
+		return NULL;
+
+	options_datum = SysCacheGetAttr(USERMAPPINGUSERSERVER, tuple,
+									Anum_pg_user_mapping_umoptions,
+									&isnull);
+	if (isnull)
+	{
+		ReleaseSysCache(tuple);
+		return NULL;
+	}
+
+	options = untransformRelOptions(options_datum);
+	props = defelems_to_kvs(options, n_props);
+	ReleaseSysCache(tuple);
+
+	return props;
+}
+
+void
+pg_iceberg_check_server_usage(Oid serverid)
+{
+	AclResult	aclresult;
+
+	aclresult = object_aclcheck(ForeignServerRelationId, serverid,
+								GetUserId(), ACL_USAGE);
+	if (aclresult == ACLCHECK_NO_PRIV)
+		aclcheck_error(aclresult, OBJECT_FOREIGN_SERVER,
+					   GetForeignServer(serverid)->servername);
+}
+
+static DlErrCode
+invalid_location(char **errdetail, char *detail)
+{
+	if (errdetail != NULL)
+		*errdetail = detail;
+	else
+		pfree(detail);
+
+	return DL_ERR_INVALID_OPTION;
+}
+
+static bool
+s3_bucket_alnum(char ch)
+{
+	return (ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9');
+}
+
+static bool
+s3_bucket_char(char ch)
+{
+	return s3_bucket_alnum(ch) || ch == '.' || ch == '-';
+}
+
+DlErrCode
+pg_iceberg_parse_location(const char *uri, const char *endpoint,
+						  const char *region, DatalakeLocation *out,
+						  char **errdetail)
+{
+	const char *scheme_end;
+	const char *authority_start;
+	const char *path_start;
+	Size		scheme_len;
+	Size		authority_len;
+	Size		path_len;
+	bool		is_s3;
+	Size		i;
+
+	Assert(out != NULL);
+	memset(out, 0, sizeof(*out));
+	if (errdetail != NULL)
+		*errdetail = NULL;
+
+	if (uri == NULL)
+		return invalid_location(errdetail,
+								pstrdup("location URI is null"));
+
+	scheme_end = strstr(uri, "://");
+	if (scheme_end == NULL)
+		return invalid_location(errdetail,
+								psprintf("location URI \"%s\" is missing \"://\"",
+										 uri));
+
+	scheme_len = scheme_end - uri;
+	is_s3 = scheme_len == strlen(DATALAKE_ICEBERG_VOLUME_SERVER_TYPE_S3) &&
+		strncmp(uri, DATALAKE_ICEBERG_VOLUME_SERVER_TYPE_S3, scheme_len) == 0;
+	if (!is_s3 &&
+		!(scheme_len == strlen(DATALAKE_ICEBERG_VOLUME_SERVER_TYPE_HDFS) &&
+		  strncmp(uri, DATALAKE_ICEBERG_VOLUME_SERVER_TYPE_HDFS, scheme_len) == 0))
+		return invalid_location(errdetail,
+								psprintf("location URI \"%s\" has unsupported scheme; expected %s or %s",
+										 uri,
+										 DATALAKE_ICEBERG_VOLUME_SERVER_TYPE_S3,
+										 DATALAKE_ICEBERG_VOLUME_SERVER_TYPE_HDFS));
+
+	if (strchr(uri, '?') != NULL)
+		return invalid_location(errdetail,
+								psprintf("location URI \"%s\" must not contain a query",
+										 uri));
+	if (strchr(uri, '#') != NULL)
+		return invalid_location(errdetail,
+								psprintf("location URI \"%s\" must not contain a fragment",
+										 uri));
+
+	authority_start = scheme_end + 3;
+	path_start = strchr(authority_start, '/');
+	authority_len = path_start == NULL ?
+		strlen(authority_start) : (Size) (path_start - authority_start);
+
+	if (authority_len == 0)
+		return invalid_location(errdetail,
+								psprintf("location URI \"%s\" has an empty authority",
+										 uri));
+	if (memchr(authority_start, '@', authority_len) != NULL)
+		return invalid_location(errdetail,
+								psprintf("location URI \"%s\" must not contain userinfo",
+										 uri));
+
+	if (is_s3)
+	{
+		if (authority_len < 3 || authority_len > 63)
+			return invalid_location(errdetail,
+									psprintf("s3 bucket in location URI \"%s\" must be 3 to 63 characters",
+											 uri));
+		if (!s3_bucket_alnum(authority_start[0]) ||
+			!s3_bucket_alnum(authority_start[authority_len - 1]))
+			return invalid_location(errdetail,
+									psprintf("s3 bucket in location URI \"%s\" must start and end with a lowercase letter or digit",
+											 uri));
+		for (i = 0; i < authority_len; i++)
+		{
+			if (!s3_bucket_char(authority_start[i]))
+				return invalid_location(errdetail,
+										psprintf("s3 bucket in location URI \"%s\" contains an invalid character",
+												 uri));
+		}
+	}
+
+	path_len = path_start == NULL ? 0 : strlen(path_start);
+	while (path_len > 0 && path_start[path_len - 1] == '/')
+		path_len--;
+
+	out->schema_version = DATALAKE_LOCATION_SCHEMA_VERSION;
+	out->scheme = pnstrdup(uri, scheme_len);
+	out->authority = pnstrdup(authority_start, authority_len);
+	out->path_prefix = path_len == 0 ?
+		pstrdup("") : pnstrdup(path_start, path_len);
+	out->endpoint = endpoint == NULL ? NULL : pstrdup(endpoint);
+	out->region = region == NULL ? NULL : pstrdup(region);
+
+	return DL_OK;
+}
diff --git a/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_options.h b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_options.h
new file mode 100644
index 00000000000..d081ffacdb0
--- /dev/null
+++ b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_options.h
@@ -0,0 +1,155 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * pg_iceberg_options.h
+ *	  How a lake table names its catalog and volume, and how that is read back.
+ *
+ * A relation using this access method holds no data locally: its metadata lives
+ * in an external Iceberg catalog and its files live on external storage.  The
+ * mapping from the relation to the two foreign servers that describe those
+ * places is therefore part of the table definition, and every operation on the
+ * table starts by reading it.
+ *
+ * pg_iceberg_get_table_info() is that read.  It is the only place that knows
+ * where the mapping is stored -- here, the relation's own reloptions -- so the
+ * storage can be reconsidered later without touching a single caller.
+ *
+ * Its signature and result types are those of the reference implementation: the
+ * existing implementation of this feature that this work derives from and is
+ * meant to replace, which keeps the same mapping in a system catalog of its own
+ * that an extension cannot add.  The difference stops inside this function, and
+ * code written against either one compiles against the other.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/am_iceberg/pg_iceberg_options.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef PG_ICEBERG_OPTIONS_H
+#define PG_ICEBERG_OPTIONS_H
+
+#ifdef __cplusplus
+/*
+ * IcebergTableOptions.namespace carries the reference implementation's field
+ * name, which is a keyword in C++.  Keeping the name is what lets that code
+ * move here unchanged; the cost is that this header is C-only.  A C++ layer
+ * that needs the mapping should be given an accessor rather than this struct.
+ */
+#error "pg_iceberg_options.h is C-only; see the comment above this #error"
+#endif
+
+#include "postgres.h"
+
+#include "common/datalake_location.h"
+#include "common/dl_err.h"
+#include "meta/iceberg_meta_engine.h"
+#include "utils/relcache.h"
+
+/*
+ * Reference implementation: IcebergTableOptions.
+ *
+ * Deferred, names kept for the port: autovacuum_enabled, compression,
+ * compression_level -- all of them write-path options.
+ */
+typedef struct IcebergTableOptions
+{
+	char	   *catalog;		/* catalog name within the external catalog */
+	char	   *namespace;		/* namespace within the external catalog */
+	char	   *table;			/* table name within the external catalog */
+	char	   *location;		/* optional location override, NULL when the
+								 * volume's own base path applies */
+
+	/*
+	 * Whether DROP TABLE should delete the lake data as well.  No counterpart
+	 * in the reference implementation, which deletes it unconditionally; here
+	 * the default is not to, so that dropping a reference cannot destroy data
+	 * another reader still expects to find.
+	 */
+	bool		purge_on_drop;
+} IcebergTableOptions;
+
+/*
+ * Reference implementation: IcebergTableInfo.
+ *
+ * The reference implementation distinguishes a catalog object from the server
+ * hosting it, and likewise for volumes.  An extension cannot add catalog or
+ * volume objects to the system catalogs, so here a server names exactly one of
+ * each and catalog_name/volume_name fall back to the server name.  Keeping all
+ * four fields means a caller that reads either one still gets a usable answer.
+ *
+ * Fields below the marker have no counterpart in the reference implementation.
+ * They stay at the end so that the shared prefix keeps its layout.
+ */
+typedef struct IcebergTableInfo
+{
+	char	   *catalog_name;
+	char	   *catalog_server_name;
+	char	   *volume_name;
+	char	   *volume_server_name;
+	IcebergTableOptions *opts;
+
+	/* --- extension-only, keep last --- */
+	Oid			catalog_srvid;	/* for USAGE checks and dependency records */
+	Oid			volume_srvid;
+	DatalakeLocation volume_location;	/* parsed once from the volume server */
+	MetaKv	   *catalog_props;	/* catalog server options, non-secret only */
+	int			n_catalog_props;
+} IcebergTableInfo;
+
+extern void pg_iceberg_register_reloptions(void);
+extern bytea *pg_iceberg_amoptions(Datum reloptions, char relkind,
+								   bool validate);
+
+/*
+ * Reference implementation: pg_iceberg_get_table_info().  Errors out when relid
+ * is not a lake table with a resolvable mapping.
+ *
+ * The _rel variant is what this tree calls: reading reloptions needs the
+ * relation anyway, so a caller holding one should not pay for a second open.
+ * Callers reached from object access hooks must use it -- see the note in
+ * pg_iceberg_options.c.
+ */
+extern IcebergTableInfo *pg_iceberg_get_table_info(Oid relid);
+extern IcebergTableInfo *pg_iceberg_get_table_info_rel(Relation rel);
+extern void pg_iceberg_free_table_info(IcebergTableInfo *info);
+
+/*
+ * Record the dependency rows that make the mapping durable.  Named after the
+ * reference implementation's catalog-side equivalent so that the two lifecycles
+ * read alike.  There is no removal counterpart: both the reloptions and these
+ * rows belong to the relation, so the delete that removes it removes them too.
+ */
+extern void InsertLakeTableEntry(Oid relid, const IcebergTableInfo *info);
+
+/* OID of this extension's access method, InvalidOid when it does not exist. */
+extern Oid pg_iceberg_am_oid(void);
+
+extern MetaKv *pg_iceberg_resolve_credentials(Oid serverid, Oid auth_userid,
+											  int *n_props);
+extern void pg_iceberg_check_server_usage(Oid serverid);
+extern DlErrCode pg_iceberg_parse_location(const char *uri,
+										   const char *endpoint,
+										   const char *region,
+										   DatalakeLocation *out,
+										   char **errdetail);
+extern Oid pg_iceberg_catalog_fdw_oid(bool missing_ok);
+extern Oid pg_iceberg_volume_fdw_oid(bool missing_ok);
+
+#endif							/* PG_ICEBERG_OPTIONS_H */
diff --git a/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_reject.c b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_reject.c
new file mode 100644
index 00000000000..a90be0114d6
--- /dev/null
+++ b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_reject.c
@@ -0,0 +1,44 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * pg_iceberg_reject.c
+ *	  Common rejection path for unsupported Iceberg operations.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/am_iceberg/pg_iceberg_reject.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "am_iceberg/pg_iceberg_reject.h"
+
+void
+pg_iceberg_not_supported(const char *operation)
+{
+	ereport(ERROR,
+			(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+			 errmsg("iceberg: %s is not supported yet", operation)));
+}
+
+/* ------------------------------------------------------------------------
+ * Utility-statement reject matrix (placeholder for the hooks task).
+ * ------------------------------------------------------------------------
+ */
diff --git a/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_reject.h b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_reject.h
new file mode 100644
index 00000000000..2db11592e87
--- /dev/null
+++ b/contrib/datalake_fdw/src/am_iceberg/pg_iceberg_reject.h
@@ -0,0 +1,36 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * pg_iceberg_reject.h
+ *	  Common rejection path for unsupported Iceberg operations.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/am_iceberg/pg_iceberg_reject.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef PG_ICEBERG_REJECT_H
+#define PG_ICEBERG_REJECT_H
+
+#include "c.h"
+
+extern void pg_iceberg_not_supported(const char *operation) pg_attribute_noreturn();
+
+#endif							/* PG_ICEBERG_REJECT_H */
diff --git a/contrib/datalake_fdw/src/common/backend_registry.cpp b/contrib/datalake_fdw/src/common/backend_registry.cpp
new file mode 100644
index 00000000000..78fb04a5e33
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/backend_registry.cpp
@@ -0,0 +1,122 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * backend_registry.cpp
+ *	  Registry of the storage backends, one per protocol.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/backend_registry.cpp
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "common/dl_pg_api.h"
+
+#include <string.h>
+
+#include "common/backend_registry.h"
+#include "common/dl_wrappers.h"
+
+typedef struct DatalakeStorageBackend
+{
+	const char *scheme;
+	const struct DatalakeStorageOps *ops;
+} DatalakeStorageBackend;
+
+/* Room for s3 and hdfs, plus space to grow without revisiting this. */
+static DatalakeStorageBackend storage_backends[4];
+static int	nstorage_backends;
+
+extern DlErrCode datalake_register_s3_backend(void);
+
+static bool
+storage_ops_are_complete(const struct DatalakeStorageOps *ops)
+{
+	/*
+	 * A partially filled table would turn into a null call at the first
+	 * operation the backend forgot, so refuse it at registration instead.
+	 */
+	return ops != NULL &&
+		ops->fs_open != NULL &&
+		ops->fs_close != NULL &&
+		ops->fs_list != NULL &&
+		ops->file_open != NULL &&
+		ops->file_read != NULL &&
+		ops->file_write != NULL &&
+		ops->file_close != NULL &&
+		ops->file_abort != NULL;
+}
+
+DlErrCode
+datalake_register_storage_backend(const char *scheme,
+								  const struct DatalakeStorageOps *ops)
+{
+	int			i;
+
+	if (scheme == NULL || scheme[0] == '\0' || !storage_ops_are_complete(ops))
+		return DL_ERR_INVALID_OPTION;
+
+	for (i = 0; i < nstorage_backends; i++)
+	{
+		if (strcmp(storage_backends[i].scheme, scheme) == 0)
+			return DL_ERR_ALREADY_EXISTS;
+	}
+
+	if (nstorage_backends >= (int) lengthof(storage_backends))
+		return DL_ERR_INTERNAL;
+
+	storage_backends[nstorage_backends].scheme = scheme;
+	storage_backends[nstorage_backends].ops = ops;
+	nstorage_backends++;
+
+	return DL_OK;
+}
+
+const struct DatalakeStorageOps *
+datalake_lookup_storage_backend(const char *scheme)
+{
+	int			i;
+
+	if (scheme == NULL)
+		return NULL;
+
+	for (i = 0; i < nstorage_backends; i++)
+	{
+		if (strcmp(storage_backends[i].scheme, scheme) == 0)
+			return storage_backends[i].ops;
+	}
+
+	return NULL;
+}
+
+extern "C" void
+datalake_register_storage_backends(void)
+{
+	DL_TRY
+	{
+		DlErrCode	rc = datalake_register_s3_backend();
+
+		/* Registering twice is harmless; anything else is a coding error. */
+		if (rc != DL_OK && rc != DL_ERR_ALREADY_EXISTS)
+			ereport(ERROR,
+					(errmsg("datalake_fdw: could not register the s3 storage backend: %s",
+							dl_err_message(rc))));
+	}
+	DL_CATCH_END();
+}
diff --git a/contrib/datalake_fdw/src/common/backend_registry.h b/contrib/datalake_fdw/src/common/backend_registry.h
new file mode 100644
index 00000000000..5432502ed42
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/backend_registry.h
@@ -0,0 +1,100 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * backend_registry.h
+ *	  Registry of the storage backends, one per protocol.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/backend_registry.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef BACKEND_REGISTRY_H
+#define BACKEND_REGISTRY_H
+
+#include <stdint.h>
+
+#include "common/file_system_wrapper.h"
+
+#ifdef __cplusplus
+
+/*
+ * One storage protocol's implementation of the facade in
+ * common/file_system_wrapper.h.  The operations mirror it one for one, so a
+ * backend is written against the same contract its callers see.
+ */
+struct DatalakeStorageOps
+{
+	DlErrCode	(*fs_open) (const DatalakeLocation *location,
+							const DlKeyValue *credentials, int ncredentials,
+							DatalakeFileSystem *fs_out);
+	void		(*fs_close) (DatalakeFileSystem fs);	/* releases fs */
+	DlErrCode	(*fs_list) (DatalakeFileSystem fs, const char *prefix,
+							char ***names_out, int *nnames_out);
+	DlErrCode	(*file_open) (DatalakeFileSystem fs, const char *path,
+							  DatalakeFileMode mode, DatalakeFile *file_out);
+	DlErrCode	(*file_read) (DatalakeFile file, void *buffer, int64_t length,
+							  int64_t *nread);
+	DlErrCode	(*file_write) (DatalakeFile file, const void *buffer,
+							   int64_t length);
+	DlErrCode	(*file_close) (DatalakeFile file);	/* releases file */
+	void		(*file_abort) (DatalakeFile file);	/* releases file */
+};
+
+/*
+ * Every handle a backend hands out starts with this field, which is how the
+ * facade finds its way back to the right operations.  A handle lives until a
+ * cleanup entry point consumes it; there is no closed-but-alive state, because
+ * keeping one would mean either leaking every handle or letting a backend free
+ * memory the facade still reads.
+ */
+struct DatalakeFileSystemData
+{
+	const struct DatalakeStorageOps *ops;
+};
+
+struct DatalakeFileData
+{
+	const struct DatalakeStorageOps *ops;
+};
+
+extern DlErrCode datalake_register_storage_backend(const char *scheme,
+												   const struct DatalakeStorageOps *ops);
+extern const struct DatalakeStorageOps *datalake_lookup_storage_backend(const char *scheme);
+
+#endif							/* __cplusplus */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*
+ * Registration is an explicit call rather than a static initializer: the order
+ * static initializers run in a shared module is not something to depend on,
+ * and _PG_init is where this is meant to happen.
+ */
+extern void datalake_register_storage_backends(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif							/* BACKEND_REGISTRY_H */
diff --git a/contrib/datalake_fdw/src/common/datalake_location.h b/contrib/datalake_fdw/src/common/datalake_location.h
new file mode 100644
index 00000000000..28bede6f71f
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/datalake_location.h
@@ -0,0 +1,50 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * datalake_location.h
+ *	  The canonical form of a lake table storage location.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/datalake_location.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef DATALAKE_LOCATION_H
+#define DATALAKE_LOCATION_H
+
+#include <stdint.h>
+
+/* Canonical, versioned location form. URIs are parsed ONCE (options layer);
+ * every backend receives only this struct and must never re-parse URIs. */
+typedef struct DatalakeLocation {
+    uint32_t schema_version;  /* = 1 */
+    char    *scheme;          /* v1 whitelist: "s3" | "hdfs" */
+    char    *authority;       /* s3: bucket (validated); hdfs: namenode[:port] */
+    char    *path_prefix;     /* normalized: always starts with '/', never ends with '/'
+                               * (a bare "/" normalizes to "") */
+    char    *endpoint;        /* optional, may be NULL */
+    char    *region;          /* optional, may be NULL */
+} DatalakeLocation;
+#define DATALAKE_LOCATION_SCHEMA_VERSION 1
+
+/* Join paths as full = path_prefix + "/" + relative; relative never starts
+ * with '/'. */
+
+#endif						/* DATALAKE_LOCATION_H */
diff --git a/contrib/datalake_fdw/src/common/dl_err.c b/contrib/datalake_fdw/src/common/dl_err.c
new file mode 100644
index 00000000000..4780d9d44a0
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/dl_err.c
@@ -0,0 +1,218 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * dl_err.c
+ *	  Error codes shared by the layers below the access method, and the
+ *	  channel that carries what the code alone cannot say.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/dl_err.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "common/dl_err.h"
+#include "utils/guc.h"
+
+/*
+ * One record per backend.  A backend runs one statement at a time, and nothing
+ * here outlives the report it feeds, so there is no reason to key this by
+ * anything finer.
+ */
+static DlErrorDetail dl_error_detail;
+
+static void dl_error_copy_field(char *dest, Size dest_size, const char *src);
+static int	dl_error_sqlstate(DlErrCode code);
+
+/*
+ * SQLSTATE for a failure below the access method.
+ *
+ * Only a defect in this module is an internal error.  A remote catalog that
+ * refuses a name, or storage that will not answer, is a condition a client can
+ * act on and deserves a code that says so -- and reporting everything as
+ * ERRCODE_INTERNAL_ERROR has a second cost here: this server appends the
+ * raising source location to internal errors, which puts a file and line number
+ * into user-visible output and into every expected-output file.
+ */
+static int
+dl_error_sqlstate(DlErrCode code)
+{
+	switch (code)
+	{
+		case DL_OK:
+		case DL_ERR_INTERNAL:
+			return ERRCODE_INTERNAL_ERROR;
+		case DL_ERR_NOT_SUPPORTED:
+			return ERRCODE_FEATURE_NOT_SUPPORTED;
+		case DL_ERR_INVALID_OPTION:
+			return ERRCODE_INVALID_PARAMETER_VALUE;
+		case DL_ERR_NOT_FOUND:
+			return ERRCODE_UNDEFINED_OBJECT;
+		case DL_ERR_ALREADY_EXISTS:
+			return ERRCODE_DUPLICATE_TABLE;
+		case DL_ERR_IO:
+			return ERRCODE_IO_ERROR;
+	}
+
+	return ERRCODE_INTERNAL_ERROR;
+}
+
+static void
+dl_error_copy_field(char *dest, Size dest_size, const char *src)
+{
+	if (src == NULL)
+	{
+		dest[0] = '\0';
+		return;
+	}
+
+	/* Truncates rather than failing; see the header for why. */
+	strlcpy(dest, src, dest_size);
+}
+
+void
+dl_error_reset(void)
+{
+	dl_error_detail.code = DL_OK;
+	dl_error_detail.remote_code = 0;
+	dl_error_detail.operation[0] = '\0';
+	dl_error_detail.type[0] = '\0';
+	dl_error_detail.message[0] = '\0';
+	dl_error_detail.stack[0] = '\0';
+}
+
+void
+dl_error_set(DlErrCode code, const char *operation, const char *type,
+			 const char *message)
+{
+	dl_error_detail.code = code;
+	dl_error_detail.remote_code = 0;
+	dl_error_copy_field(dl_error_detail.operation,
+						sizeof(dl_error_detail.operation), operation);
+	dl_error_copy_field(dl_error_detail.type,
+						sizeof(dl_error_detail.type), type);
+	dl_error_copy_field(dl_error_detail.message,
+						sizeof(dl_error_detail.message), message);
+	dl_error_detail.stack[0] = '\0';
+}
+
+void
+dl_error_set_remote_code(int remote_code)
+{
+	dl_error_detail.remote_code = remote_code;
+}
+
+void
+dl_error_set_stack(const char *stack)
+{
+	dl_error_copy_field(dl_error_detail.stack,
+						sizeof(dl_error_detail.stack), stack);
+}
+
+const DlErrorDetail *
+dl_error_get(void)
+{
+	return &dl_error_detail;
+}
+
+const char *
+dl_err_message(DlErrCode code)
+{
+	switch (code)
+	{
+		case DL_OK:
+			return "success";
+		case DL_ERR_NOT_SUPPORTED:
+			return "operation not supported";
+		case DL_ERR_INVALID_OPTION:
+			return "invalid option";
+		case DL_ERR_NOT_FOUND:
+			return "not found";
+		case DL_ERR_ALREADY_EXISTS:
+			return "already exists";
+		case DL_ERR_IO:
+			return "I/O error";
+		case DL_ERR_INTERNAL:
+			return "internal error";
+	}
+
+	return "unknown error";
+}
+
+void
+dl_error_report(int elevel, DlErrCode code, const char *prefix)
+{
+	const DlErrorDetail *detail = dl_error_get();
+	StringInfoData detail_buf;
+	bool		has_detail;
+
+	/*
+	 * Detail recorded against a different code belongs to some other failure --
+	 * an implementation that reported this one without recording anything, for
+	 * instance.  Reporting it here would attribute the wrong cause.
+	 */
+	has_detail = (detail->code == code &&
+				  (detail->message[0] != '\0' ||
+				   detail->type[0] != '\0' ||
+				   detail->remote_code != 0));
+
+	if (!has_detail)
+	{
+		ereport(elevel,
+				(errcode(dl_error_sqlstate(code)),
+				 errmsg("iceberg: %s failed: %s", prefix,
+						dl_err_message(code))));
+		return;
+	}
+
+	initStringInfo(&detail_buf);
+
+	if (detail->operation[0] != '\0')
+		appendStringInfo(&detail_buf, "%s: ", detail->operation);
+
+	if (detail->message[0] != '\0')
+		appendStringInfoString(&detail_buf, detail->message);
+	else
+		appendStringInfoString(&detail_buf, dl_err_message(code));
+
+	if (detail->type[0] != '\0')
+		appendStringInfo(&detail_buf, " (%s", detail->type);
+	if (detail->remote_code != 0)
+		appendStringInfo(&detail_buf, "%s%d",
+						 detail->type[0] != '\0' ? ", code " : " (code ",
+						 detail->remote_code);
+	if (detail->type[0] != '\0' || detail->remote_code != 0)
+		appendStringInfoChar(&detail_buf, ')');
+
+	/*
+	 * A stack describes the implementation, not the statement, so it is offered
+	 * only to a session that asked to see log-level detail.
+	 */
+	if (detail->stack[0] != '\0' && client_min_messages <= LOG)
+		appendStringInfo(&detail_buf, "\nStack:\n%s", detail->stack);
+
+	ereport(elevel,
+			(errcode(dl_error_sqlstate(code)),
+			 errmsg("iceberg: %s failed", prefix),
+			 errdetail("%s", detail_buf.data)));
+
+	pfree(detail_buf.data);
+}
diff --git a/contrib/datalake_fdw/src/common/dl_err.h b/contrib/datalake_fdw/src/common/dl_err.h
new file mode 100644
index 00000000000..67949644c95
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/dl_err.h
@@ -0,0 +1,120 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * dl_err.h
+ *	  Error codes shared by the layers below the access method, and the
+ *	  channel that carries what the code alone cannot say.
+ *
+ * A code says which kind of failure occurred.  It cannot say which table the
+ * remote catalog rejected, what the storage service answered, or where a remote
+ * implementation threw -- and those are the only things that make such a failure
+ * diagnosable.  Every layer below the access method therefore reports a code and
+ * additionally records the detail here; the entry points that face PostgreSQL
+ * turn both into one ereport.
+ *
+ * The detail is recorded into fixed-size storage on purpose.  Recording happens
+ * on paths that must not allocate and must not raise -- a cleanup callback
+ * crossing back from C++ is one of them -- so a setter that could palloc, and
+ * therefore could fail, is not usable there.  Long values are truncated, which
+ * is the right trade against losing the report entirely.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/dl_err.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef DL_ERR_H
+#define DL_ERR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum DlErrCode {
+	DL_OK = 0,
+	DL_ERR_NOT_SUPPORTED,
+	DL_ERR_INVALID_OPTION,
+	DL_ERR_NOT_FOUND,
+	DL_ERR_ALREADY_EXISTS,
+	DL_ERR_IO,
+	DL_ERR_INTERNAL,
+} DlErrCode;
+
+#define DL_ERR_FIELD_LEN	128
+#define DL_ERR_MSG_LEN		1024
+#define DL_ERR_STACK_LEN	4096
+
+/*
+ * What an implementation below the access method has to say about its last
+ * failure.  The field set follows what a remote metadata engine reports, so
+ * that connecting one is a matter of filling this in rather than changing it.
+ */
+typedef struct DlErrorDetail
+{
+	DlErrCode	code;
+	int			remote_code;			/* implementation's own numeric code, 0
+										 * when it has none */
+	char		operation[DL_ERR_FIELD_LEN];	/* which call failed */
+	char		type[DL_ERR_FIELD_LEN]; /* implementation's error class */
+	char		message[DL_ERR_MSG_LEN];
+	char		stack[DL_ERR_STACK_LEN];
+} DlErrorDetail;
+
+/*
+ * Discard any recorded detail.  Called by the dispatch wrappers before entering
+ * an implementation, so that a report can never describe an earlier failure.
+ */
+extern void dl_error_reset(void);
+
+/*
+ * Record the detail for a failure that is being reported as `code`.  Allocates
+ * nothing and raises nothing, so it is callable from a cleanup path.  NULL is
+ * accepted for any string and leaves that field empty.
+ */
+extern void dl_error_set(DlErrCode code, const char *operation,
+						 const char *type, const char *message);
+
+/* Record the implementation's own numeric code, when it reports one. */
+extern void dl_error_set_remote_code(int remote_code);
+
+/* Record a stack from the failing implementation. */
+extern void dl_error_set_stack(const char *stack);
+
+/* The recorded detail, never NULL; code is DL_OK when nothing was recorded. */
+extern const DlErrorDetail *dl_error_get(void);
+
+/* Short, code-only wording, for when there is nothing recorded to add. */
+extern const char *dl_err_message(DlErrCode code);
+
+/*
+ * Report a failure to PostgreSQL: `prefix` names what was being attempted, the
+ * recorded message becomes the detail, and a recorded stack is included only
+ * when the session asked for log-level detail -- a stack is for whoever is
+ * debugging the implementation, not for whoever ran the statement.
+ *
+ * Detail recorded against a different code is ignored rather than misattributed.
+ */
+extern void dl_error_report(int elevel, DlErrCode code, const char *prefix);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif						/* DL_ERR_H */
diff --git a/contrib/datalake_fdw/src/common/dl_kv.h b/contrib/datalake_fdw/src/common/dl_kv.h
new file mode 100644
index 00000000000..f5db0db31d8
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/dl_kv.h
@@ -0,0 +1,44 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * dl_kv.h
+ *	  A configuration pair as options and mappings deliver it.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/dl_kv.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef DL_KV_H
+#define DL_KV_H
+
+/*
+ * A configuration pair as it arrives from a foreign server, a user mapping or
+ * a table option.  It lives in common/ because both the storage layer and the
+ * metadata layer consume such pairs, and neither should have to include the
+ * other's headers to name the type.
+ */
+typedef struct DlKeyValue
+{
+	char	   *key;
+	char	   *value;
+} DlKeyValue;
+
+#endif							/* DL_KV_H */
diff --git a/contrib/datalake_fdw/src/common/dl_option_util.c b/contrib/datalake_fdw/src/common/dl_option_util.c
new file mode 100644
index 00000000000..c2cfbdaef54
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/dl_option_util.c
@@ -0,0 +1,65 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * dl_option_util.c
+ *	  Option policy shared by the catalog and volume option validators.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/dl_option_util.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "common/dl_option_util.h"
+
+bool
+dl_is_credential_option(const char *name)
+{
+	static const char *const credential_options[] = {
+		DL_OPTION_KEY_USERNAME,
+		DL_OPTION_KEY_KRB_CLIENT_KEYTAB,
+		DL_OPTION_KEY_CLIENT_ID,
+		DL_OPTION_KEY_CLIENT_SECRET,
+		DL_OPTION_KEY_ACCESS_KEY_ID,
+		DL_OPTION_KEY_SECRET_ACCESS_KEY,
+		DL_OPTION_KEY_SESSION_TOKEN,
+
+		/*
+		 * Not options this module accepts anywhere, but names users reach for
+		 * out of habit.  Listing them turns "unrecognized option" into the hint
+		 * that says where credentials actually go.
+		 */
+		"user",
+		"password",
+		"token",
+		"access_key",
+		"secret_key"
+	};
+	int			i;
+
+	for (i = 0; i < lengthof(credential_options); i++)
+	{
+		if (strcmp(name, credential_options[i]) == 0)
+			return true;
+	}
+
+	return false;
+}
diff --git a/contrib/datalake_fdw/src/common/dl_option_util.h b/contrib/datalake_fdw/src/common/dl_option_util.h
new file mode 100644
index 00000000000..2ac33fadf77
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/dl_option_util.h
@@ -0,0 +1,63 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * dl_option_util.h
+ *	  Option policy shared by the catalog and volume option validators.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/dl_option_util.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef DL_OPTION_UTIL_H
+#define DL_OPTION_UTIL_H
+
+#include "postgres.h"
+
+/*
+ * The option keys that identify or authenticate a principal.
+ *
+ * They are defined here, below the option modules that name them, because
+ * dl_is_credential_option() and those modules have to agree: a key the modules
+ * accept but this list does not know is a credential the server would store in
+ * the clear.  One definition each is what makes disagreement impossible; the
+ * per-module macros below are spelled the way the reference implementation
+ * spells them and resolve to these.
+ */
+#define DL_OPTION_KEY_USERNAME "username"
+#define DL_OPTION_KEY_KRB_CLIENT_KEYTAB "krb_client_keytab"
+#define DL_OPTION_KEY_CLIENT_ID "client_id"
+#define DL_OPTION_KEY_CLIENT_SECRET "client_secret"
+#define DL_OPTION_KEY_ACCESS_KEY_ID "access_key_id"
+#define DL_OPTION_KEY_SECRET_ACCESS_KEY "secret_access_key"
+#define DL_OPTION_KEY_SESSION_TOKEN "session_token"
+
+/*
+ * True for an option that identifies or authenticates a principal.  Such an
+ * option belongs to a user mapping, never to a server, so that one server can
+ * be shared by roles with different credentials and so that the value is not
+ * readable through pg_foreign_server by every role holding USAGE.
+ *
+ * Both option validators consult this, which is why it lives here rather than
+ * being spelled out twice.
+ */
+extern bool dl_is_credential_option(const char *name);
+
+#endif							/* DL_OPTION_UTIL_H */
diff --git a/contrib/datalake_fdw/src/common/dl_pg_api.h b/contrib/datalake_fdw/src/common/dl_pg_api.h
new file mode 100644
index 00000000000..6584db45fff
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/dl_pg_api.h
@@ -0,0 +1,45 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * dl_pg_api.h
+ *	  The PostgreSQL headers, safe to include from C++.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/dl_pg_api.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef DL_PG_API_H
+#define DL_PG_API_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "postgres.h"
+
+#include "access/xact.h"
+#include "utils/elog.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif							/* DL_PG_API_H */
diff --git a/contrib/datalake_fdw/src/common/dl_wrappers.h b/contrib/datalake_fdw/src/common/dl_wrappers.h
new file mode 100644
index 00000000000..737d97fae7d
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/dl_wrappers.h
@@ -0,0 +1,193 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * dl_wrappers.h
+ *	  The boundaries between C++ code and the PostgreSQL runtime.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/dl_wrappers.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef DL_WRAPPERS_H
+#define DL_WRAPPERS_H
+
+#include <setjmp.h>
+
+#include "common/dl_err.h"
+#include "common/dl_pg_api.h"
+
+/*
+ * Exception-boundary classes:
+ *
+ * 1. PG-called C entry (extern "C" handler/UDF/hook):
+ *    DL_TRY { } DL_CATCH_END(); converts C++ exceptions to ereport(ERROR,
+ *    ...) at the boundary; no C++ exception may escape into PG stack frames.
+ * 2. Status-returning DlErrCode ABI (vtable implementations): functions must
+ *    be noexcept; DL_ABI_GUARD_BEGIN / DL_ABI_GUARD_END(errvar) converts every
+ *    exception to DL_ERR_INTERNAL.
+ * 3. Void cleanup ABI (close, abort, iterator close): functions must be
+ *    noexcept and idempotent, and must never ereport.  The cleanup guard logs
+ *    a best-effort WARNING only outside error cleanup and otherwise swallows.
+ * 4. C++ calling PG APIs: DL_WRAP_START; ... DL_WRAP_END; converts a PG longjmp
+ *    to DlPgError so the C++ caller can handle it without crossing the ABI.
+ */
+
+#ifdef __cplusplus
+
+#include <exception>
+
+class DlPgError : public std::exception {
+public:
+	const char *what() const noexcept override
+	{
+		return "PostgreSQL error";
+	}
+};
+
+/* Save and restore PG's longjmp targets around a C++ call site. */
+class DlPgExceptionStack {
+public:
+	DlPgExceptionStack(void **exception_stack, void **error_context_stack)
+		: exception_stack_(exception_stack),
+		  error_context_stack_(error_context_stack),
+		  saved_exception_stack_(*exception_stack),
+		  saved_error_context_stack_(*error_context_stack)
+	{
+	}
+
+	~DlPgExceptionStack()
+	{
+		*exception_stack_ = saved_exception_stack_;
+		*error_context_stack_ = saved_error_context_stack_;
+	}
+
+	void SetLocalJmp(void *local_jump)
+	{
+		*exception_stack_ = local_jump;
+	}
+
+private:
+	void **exception_stack_;
+	void **error_context_stack_;
+	void *saved_exception_stack_;
+	void *saved_error_context_stack_;
+};
+
+static inline bool
+dl_can_log_cleanup_warning(void)
+{
+	return !in_error_recursion_trouble() && !IsAbortInProgress() &&
+		!IsAbortedTransactionBlockState();
+}
+
+/*
+ * Class 1: a C entry point called by PostgreSQL.
+ *
+ * ereport(ERROR) unwinds with longjmp(), and longjmp()ing out of a C++ catch
+ * handler leaves the in-flight exception alive, which is undefined behavior.
+ * So the handler only records what happened -- the message is copied into a
+ * local buffer because the exception object dies with the handler -- and the
+ * ereport() happens after the try/catch statement has been left, the same way
+ * PAX defers it to CBDB_END_TRY().
+ */
+#define DL_ERROR_MSG_MAX 512
+
+#define DL_TRY \
+	do { \
+		bool		dl_pending_error_ = false; \
+		char		dl_error_msg_[DL_ERROR_MSG_MAX]; \
+\
+		dl_error_msg_[0] = '\0'; \
+		try
+
+#define DL_CATCH_END() \
+		catch (const std::exception &e) \
+		{ \
+			dl_pending_error_ = true; \
+			strlcpy(dl_error_msg_, e.what(), sizeof(dl_error_msg_)); \
+		} \
+		catch (...) \
+		{ \
+			dl_pending_error_ = true; \
+			strlcpy(dl_error_msg_, "unknown C++ exception", \
+					sizeof(dl_error_msg_)); \
+		} \
+		if (dl_pending_error_) \
+			ereport(ERROR, \
+					(errcode(ERRCODE_INTERNAL_ERROR), \
+					 errmsg("datalake_fdw: %s", dl_error_msg_))); \
+	} while (0)
+
+#define DL_ABI_GUARD_BEGIN \
+	try \
+	{
+
+#define DL_ABI_GUARD_END(errvar) \
+	} \
+	catch (...) \
+	{ \
+		(errvar) = DL_ERR_INTERNAL; \
+	}
+
+#define DL_CLEANUP_GUARD_BEGIN \
+	do { \
+		bool		dl_cleanup_failed_ = false; \
+\
+		try \
+		{
+
+/*
+ * Class 3 cleanup guards must never ereport(), so the report is a WARNING at
+ * most -- and it is emitted after the handler has been left, because even
+ * elog() can escalate into an ERROR while the error subsystem is in trouble.
+ */
+#define DL_CLEANUP_GUARD_END \
+	} \
+	catch (...) \
+	{ \
+		dl_cleanup_failed_ = true; \
+	} \
+	if (dl_cleanup_failed_ && dl_can_log_cleanup_warning()) \
+		elog(WARNING, "datalake_fdw: C++ exception during cleanup"); \
+	} while (0)
+
+/* Modeled on the PAX CBDB_WRAP_START/END saved-exception-stack pattern. */
+#define DL_WRAP_START \
+	sigjmp_buf dl_local_sigjmp_buf; \
+	{ \
+		DlPgExceptionStack dl_exception_stack( \
+			reinterpret_cast<void **>(&PG_exception_stack), \
+			reinterpret_cast<void **>(&error_context_stack)); \
+		if (sigsetjmp(dl_local_sigjmp_buf, 0) == 0) \
+		{ \
+			dl_exception_stack.SetLocalJmp(&dl_local_sigjmp_buf)
+
+#define DL_WRAP_END \
+		} \
+		else \
+		{ \
+			throw DlPgError(); \
+		} \
+	}
+
+#endif						/* __cplusplus */
+
+#endif						/* DL_WRAPPERS_H */
diff --git a/contrib/datalake_fdw/src/common/file_system_wrapper.cpp b/contrib/datalake_fdw/src/common/file_system_wrapper.cpp
new file mode 100644
index 00000000000..2b576fe4344
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/file_system_wrapper.cpp
@@ -0,0 +1,232 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * file_system_wrapper.cpp
+ *	  Storage facade dispatching to the registered backend.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/file_system_wrapper.cpp
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "common/dl_pg_api.h"
+
+#include "common/backend_registry.h"
+#include "common/dl_wrappers.h"
+#include "common/file_system_wrapper.h"
+
+/*
+ * Dispatch only: each call finds the backend registered for the location's
+ * scheme and hands the work over.  Nothing here is reachable from SQL in this
+ * skeleton, so what the regression suite asserts is the behaviour of the
+ * layers above.
+ */
+
+extern "C" DlErrCode
+datalake_fs_open(const DatalakeLocation *location,
+				 const DlKeyValue *credentials, int ncredentials,
+				 DatalakeFileSystem *fs_out)
+{
+	DlErrCode	rc = DL_ERR_INTERNAL;
+
+	DL_ABI_GUARD_BEGIN
+	{
+		const struct DatalakeStorageOps *ops;
+
+		if (fs_out == NULL || location == NULL || location->scheme == NULL ||
+			ncredentials < 0)
+			rc = DL_ERR_INVALID_OPTION;
+		else
+		{
+			*fs_out = NULL;
+			ops = datalake_lookup_storage_backend(location->scheme);
+
+			if (ops == NULL)
+				rc = DL_ERR_NOT_SUPPORTED;
+			else
+			{
+				rc = ops->fs_open(location, credentials, ncredentials, fs_out);
+
+				if (rc == DL_OK && *fs_out == NULL)
+					rc = DL_ERR_INTERNAL;
+				else if (rc == DL_OK)
+					(*fs_out)->ops = ops;
+			}
+		}
+	}
+	DL_ABI_GUARD_END(rc);
+
+	return rc;
+}
+
+extern "C" void
+datalake_fs_close(DatalakeFileSystem *fs)
+{
+	DL_CLEANUP_GUARD_BEGIN
+	{
+		/*
+		 * Clear the caller's handle before releasing it, so that a repeated
+		 * close -- the normal shape of resource-owner cleanup after an error
+		 * that already closed things -- finds nothing to do instead of
+		 * reaching a backend that has freed itself.
+		 */
+		if (fs != NULL && *fs != NULL)
+		{
+			DatalakeFileSystem doomed = *fs;
+
+			*fs = NULL;
+			doomed->ops->fs_close(doomed);
+		}
+	}
+	DL_CLEANUP_GUARD_END;
+}
+
+extern "C" DlErrCode
+datalake_fs_list(DatalakeFileSystem fs, const char *prefix,
+				 char ***names_out, int *nnames_out)
+{
+	DlErrCode	rc = DL_ERR_INTERNAL;
+
+	DL_ABI_GUARD_BEGIN
+	{
+		if (fs == NULL || prefix == NULL || names_out == NULL ||
+			nnames_out == NULL)
+			rc = DL_ERR_INVALID_OPTION;
+		else
+		{
+			*names_out = NULL;
+			*nnames_out = 0;
+			rc = fs->ops->fs_list(fs, prefix, names_out, nnames_out);
+		}
+	}
+	DL_ABI_GUARD_END(rc);
+
+	return rc;
+}
+
+extern "C" DlErrCode
+datalake_file_open(DatalakeFileSystem fs, const char *path,
+				   DatalakeFileMode mode, DatalakeFile *file_out)
+{
+	DlErrCode	rc = DL_ERR_INTERNAL;
+
+	DL_ABI_GUARD_BEGIN
+	{
+		if (file_out == NULL || fs == NULL || path == NULL)
+			rc = DL_ERR_INVALID_OPTION;
+		else if (mode != DATALAKE_FILE_READ && mode != DATALAKE_FILE_WRITE)
+			rc = DL_ERR_INVALID_OPTION;
+		else
+		{
+			*file_out = NULL;
+			rc = fs->ops->file_open(fs, path, mode, file_out);
+
+			if (rc == DL_OK && *file_out == NULL)
+				rc = DL_ERR_INTERNAL;
+			else if (rc == DL_OK)
+				(*file_out)->ops = fs->ops;
+		}
+	}
+	DL_ABI_GUARD_END(rc);
+
+	return rc;
+}
+
+extern "C" DlErrCode
+datalake_file_read(DatalakeFile file, void *buffer, int64_t length,
+				   int64_t *nread)
+{
+	DlErrCode	rc = DL_ERR_INTERNAL;
+
+	DL_ABI_GUARD_BEGIN
+	{
+		if (file == NULL || nread == NULL || length < 0)
+			rc = DL_ERR_INVALID_OPTION;
+		else
+		{
+			*nread = 0;
+			rc = file->ops->file_read(file, buffer, length, nread);
+		}
+	}
+	DL_ABI_GUARD_END(rc);
+
+	return rc;
+}
+
+extern "C" DlErrCode
+datalake_file_write(DatalakeFile file, const void *buffer, int64_t length)
+{
+	DlErrCode	rc = DL_ERR_INTERNAL;
+
+	DL_ABI_GUARD_BEGIN
+	{
+		if (file == NULL || length < 0)
+			rc = DL_ERR_INVALID_OPTION;
+		else
+			rc = file->ops->file_write(file, buffer, length);
+	}
+	DL_ABI_GUARD_END(rc);
+
+	return rc;
+}
+
+extern "C" DlErrCode
+datalake_file_close(DatalakeFile *file)
+{
+	DlErrCode	rc = DL_ERR_INTERNAL;
+
+	DL_ABI_GUARD_BEGIN
+	{
+		if (file == NULL || *file == NULL)
+			rc = DL_ERR_INVALID_OPTION;
+		else
+		{
+			DatalakeFile doomed = *file;
+
+			/*
+			 * The handle is consumed even when the close reports an error:
+			 * the backend has released it either way, and there is nothing
+			 * left to retry the close against.
+			 */
+			*file = NULL;
+			rc = doomed->ops->file_close(doomed);
+		}
+	}
+	DL_ABI_GUARD_END(rc);
+
+	return rc;
+}
+
+extern "C" void
+datalake_file_abort(DatalakeFile *file)
+{
+	DL_CLEANUP_GUARD_BEGIN
+	{
+		/* Cleared first, so a repeated abort finds nothing to do. */
+		if (file != NULL && *file != NULL)
+		{
+			DatalakeFile doomed = *file;
+
+			*file = NULL;
+			doomed->ops->file_abort(doomed);
+		}
+	}
+	DL_CLEANUP_GUARD_END;
+}
diff --git a/contrib/datalake_fdw/src/common/file_system_wrapper.h b/contrib/datalake_fdw/src/common/file_system_wrapper.h
new file mode 100644
index 00000000000..37b6c037d2c
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/file_system_wrapper.h
@@ -0,0 +1,113 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * file_system_wrapper.h
+ *	  Storage facade over one protocol: open, read, write, list.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/file_system_wrapper.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef FILE_SYSTEM_WRAPPER_H
+#define FILE_SYSTEM_WRAPPER_H
+
+#include <stdint.h>
+
+#include "common/datalake_location.h"
+#include "common/dl_err.h"
+#include "common/dl_kv.h"
+
+/*
+ * A file system reached over one storage protocol, and an open file in it.
+ * Both are opaque: callers hold a handle and pass it back, exactly as they do
+ * for a File or a BufFile, so a backend can keep whatever state it needs
+ * without any of it becoming part of this interface.
+ *
+ * This is deliberately a facade over open/read/write/close/list and not a
+ * storage framework.  Its only consumer is the format layer, and keeping the
+ * surface this narrow is what lets the implementation be replaced -- by an
+ * Arrow filesystem, say -- without the layers above noticing.
+ */
+typedef struct DatalakeFileSystemData *DatalakeFileSystem;
+typedef struct DatalakeFileData *DatalakeFile;
+
+typedef enum DatalakeFileMode
+{
+	DATALAKE_FILE_READ,
+	DATALAKE_FILE_WRITE
+} DatalakeFileMode;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*
+ * The location names the protocol and the bucket or namenode; credentials are
+ * resolved separately and may be empty, in which case the backend falls back
+ * to whatever ambient credentials it finds.
+ */
+extern DlErrCode datalake_fs_open(const DatalakeLocation *location,
+								  const DlKeyValue *credentials,
+								  int ncredentials,
+								  DatalakeFileSystem *fs_out);
+
+/*
+ * Cleanup entry point: releases the file system and clears the caller's
+ * handle, so a repeated call has nothing left to act on.  It never raises,
+ * because it runs on the resource-owner path during transaction abort.
+ * Passing a handle by value could not clear it, and the second call would
+ * then reach a backend that had already freed itself.
+ */
+extern void datalake_fs_close(DatalakeFileSystem *fs);
+
+extern DlErrCode datalake_fs_list(DatalakeFileSystem fs, const char *prefix,
+								  char ***names_out, int *nnames_out);
+
+extern DlErrCode datalake_file_open(DatalakeFileSystem fs, const char *path,
+									DatalakeFileMode mode,
+									DatalakeFile *file_out);
+
+extern DlErrCode datalake_file_read(DatalakeFile file, void *buffer,
+									int64_t length, int64_t *nread);
+
+extern DlErrCode datalake_file_write(DatalakeFile file, const void *buffer,
+									 int64_t length);
+
+/*
+ * Finishes the file and clears the caller's handle.  Errors worth reporting
+ * surface here, and the handle is consumed whether or not one does: there is
+ * nothing left to retry against.
+ */
+extern DlErrCode datalake_file_close(DatalakeFile *file);
+
+/*
+ * Cleanup entry point for the failure path: discards the file and clears the
+ * caller's handle.  Never raises; anything worth reporting comes out of
+ * datalake_file_close() instead.
+ */
+extern void datalake_file_abort(DatalakeFile *file);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif							/* FILE_SYSTEM_WRAPPER_H */
diff --git a/contrib/datalake_fdw/src/common/parser_option.c b/contrib/datalake_fdw/src/common/parser_option.c
new file mode 100644
index 00000000000..9e4a4ab0469
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/parser_option.c
@@ -0,0 +1,94 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * parser_option.c
+ *	  Typed accessors over a DefElem option list.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/parser_option.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "commands/defrem.h"
+#include "common/parser_option.h"
+#include "utils/builtins.h"
+
+/*
+ * Return the value of the named option, or NULL when it is absent.
+ *
+ * The comparison is case-sensitive, matching how the server stores and
+ * de-duplicates option names.  Matching case-insensitively here would let
+ * "type" and a quoted "TYPE" both be stored -- the generic duplicate check
+ * would not see them as the same option -- and then silently return whichever
+ * came first, which for a credential is the wrong one to pick at random.
+ */
+char *
+get_string_option(List *options, const char *option_name)
+{
+	ListCell   *lc;
+
+	foreach(lc, options)
+	{
+		DefElem    *def = (DefElem *) lfirst(lc);
+
+		if (strcmp(def->defname, option_name) == 0)
+			return defGetString(def);
+	}
+
+	return NULL;
+}
+
+/*
+ * Boolean accessor that also reports whether the option was written at all.
+ *
+ * Callers that forward options to the metadata engine need that distinction:
+ * an unset boolean may fall back to site configuration, while an explicit
+ * false has to override it.
+ *
+ * Unlike the reference implementation, an unparsable value raises an error
+ * instead of silently yielding the default -- a typo in a boolean server
+ * option should not read as "you asked for the default".  Stored values are
+ * already validated by the option validators, so this only fires on input
+ * paths that have not been through them.
+ */
+bool
+get_bool_option_ex(List *options, const char *option_name,
+				   bool default_value, bool *isset)
+{
+	char	   *value = get_string_option(options, option_name);
+	bool		parsed_value;
+
+	Assert(isset != NULL);
+	*isset = false;
+
+	if (value == NULL)
+		return default_value;
+
+	if (!parse_bool(value, &parsed_value))
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("invalid boolean value \"%s\" for option \"%s\"",
+						value, option_name)));
+
+	*isset = true;
+	return parsed_value;
+}
diff --git a/contrib/datalake_fdw/src/common/parser_option.h b/contrib/datalake_fdw/src/common/parser_option.h
new file mode 100644
index 00000000000..10a8181e3e0
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/parser_option.h
@@ -0,0 +1,54 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * parser_option.h
+ *	  Typed accessors over a DefElem option list.
+ *
+ * Every layer that reads SERVER, USER MAPPING or table options goes through
+ * these accessors rather than walking the list itself, so that lookup and
+ * absent-versus-empty are decided in one place.
+ *
+ * The reference implementation -- the existing implementation of this feature
+ * that this work derives from and is meant to replace -- also carries integer
+ * and defaulting-boolean accessors (getIntOption, getBoolOption).  They are
+ * omitted here rather than shipped unused; add them under those names, as thin
+ * wrappers over the accessors below, together with the first option that needs
+ * them.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/parser_option.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef PARSER_OPTION_H
+#define PARSER_OPTION_H
+
+#include "postgres.h"
+
+#include "nodes/pg_list.h"
+
+/* Reference implementation: getStringOption() */
+extern char *get_string_option(List *options, const char *option_name);
+
+/* Reference implementation: getBoolOptionEx() */
+extern bool get_bool_option_ex(List *options, const char *option_name,
+							   bool default_value, bool *isset);
+
+#endif							/* PARSER_OPTION_H */
diff --git a/contrib/datalake_fdw/src/common/s3_file_system.cpp b/contrib/datalake_fdw/src/common/s3_file_system.cpp
new file mode 100644
index 00000000000..d255200528b
--- /dev/null
+++ b/contrib/datalake_fdw/src/common/s3_file_system.cpp
@@ -0,0 +1,261 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * s3_file_system.cpp
+ *	  The S3 storage backend.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/common/s3_file_system.cpp
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "common/dl_pg_api.h"
+
+#include "common/backend_registry.h"
+#include "common/dl_wrappers.h"
+
+#include <memory>
+
+/*
+ * The S3 backend, without an S3 client yet: the shape a backend takes is what
+ * this file establishes, so that the change adding a real client replaces
+ * method bodies rather than the structure around them.  Every entry point
+ * reports that the operation is not supported.
+ */
+class S3FileSystem
+{
+public:
+	DlErrCode
+	Initialize(const DatalakeLocation *location, const DlKeyValue *credentials,
+			   int ncredentials)
+	{
+		(void) location;
+		(void) credentials;
+		(void) ncredentials;
+
+		return DL_ERR_NOT_SUPPORTED;
+	}
+
+	DlErrCode
+	OpenFile(const char *path, DatalakeFileMode mode, DatalakeFile *file_out)
+	{
+		(void) path;
+		(void) mode;
+
+		if (file_out != NULL)
+			*file_out = NULL;
+
+		return DL_ERR_NOT_SUPPORTED;
+	}
+
+	DlErrCode
+	List(const char *prefix, char ***names_out, int *nnames_out)
+	{
+		(void) prefix;
+
+		if (names_out != NULL)
+			*names_out = NULL;
+		if (nnames_out != NULL)
+			*nnames_out = 0;
+
+		return DL_ERR_NOT_SUPPORTED;
+	}
+};
+
+/*
+ * A handle the facade can hold.
+ *
+ * Deriving from the C struct rather than embedding it as a first member is what
+ * makes recovering the handle defined behaviour: a derived-to-base pointer
+ * conversion and a static_cast back are guaranteed for any class, while the
+ * first-member trick is only guaranteed for standard-layout types -- which this
+ * is not, because of the unique_ptr.  The C side still sees a plain
+ * DatalakeFileSystemData, since that is what the base subobject is.
+ */
+struct S3FileSystemHandle : public DatalakeFileSystemData
+{
+	std::unique_ptr<S3FileSystem> impl;
+};
+
+static DlErrCode
+s3_fs_open(const DatalakeLocation *location, const DlKeyValue *credentials,
+		   int ncredentials, DatalakeFileSystem *fs_out)
+{
+	DlErrCode	rc = DL_ERR_INTERNAL;
+
+	DL_ABI_GUARD_BEGIN
+	{
+		if (fs_out == NULL)
+			rc = DL_ERR_INVALID_OPTION;
+		else
+		{
+			/*
+			 * Owned by unique_ptr until the handle is published, so that an
+			 * exception from the second allocation or from Initialize() --
+			 * which the guard below turns into an error code -- cannot leave
+			 * the first allocation behind.
+			 */
+			std::unique_ptr<S3FileSystemHandle> handle(new S3FileSystemHandle());
+
+			*fs_out = NULL;
+			handle->impl.reset(new S3FileSystem());
+			rc = handle->impl->Initialize(location, credentials, ncredentials);
+
+			if (rc == DL_OK)
+				*fs_out = handle.release();
+		}
+	}
+	DL_ABI_GUARD_END(rc);
+
+	return rc;
+}
+
+static void
+s3_fs_close(DatalakeFileSystem fs)
+{
+	DL_CLEANUP_GUARD_BEGIN
+	{
+		/* The facade has already cleared its caller's handle. */
+		delete static_cast<S3FileSystemHandle *>(fs);
+	}
+	DL_CLEANUP_GUARD_END;
+}
+
+static DlErrCode
+s3_fs_list(DatalakeFileSystem fs, const char *prefix, char ***names_out,
+		   int *nnames_out)
+{
+	DlErrCode	rc = DL_ERR_INTERNAL;
+
+	DL_ABI_GUARD_BEGIN
+	{
+		S3FileSystemHandle *handle = static_cast<S3FileSystemHandle *>(fs);
+
+		if (handle == NULL)
+			rc = DL_ERR_INVALID_OPTION;
+		else
+			rc = handle->impl->List(prefix, names_out, nnames_out);
+	}
+	DL_ABI_GUARD_END(rc);
+
+	return rc;
+}
+
+static DlErrCode
+s3_file_open(DatalakeFileSystem fs, const char *path, DatalakeFileMode mode,
+			 DatalakeFile *file_out)
+{
+	DlErrCode	rc = DL_ERR_INTERNAL;
+
+	DL_ABI_GUARD_BEGIN
+	{
+		S3FileSystemHandle *handle = static_cast<S3FileSystemHandle *>(fs);
+
+		if (handle == NULL)
+			rc = DL_ERR_INVALID_OPTION;
+		else
+			rc = handle->impl->OpenFile(path, mode, file_out);
+	}
+	DL_ABI_GUARD_END(rc);
+
+	return rc;
+}
+
+static DlErrCode
+s3_file_read(DatalakeFile file, void *buffer, int64_t length, int64_t *nread)
+{
+	DlErrCode	rc = DL_ERR_INTERNAL;
+
+	DL_ABI_GUARD_BEGIN
+	{
+		(void) file;
+		(void) buffer;
+		(void) length;
+
+		if (nread != NULL)
+			*nread = 0;
+
+		rc = DL_ERR_NOT_SUPPORTED;
+	}
+	DL_ABI_GUARD_END(rc);
+
+	return rc;
+}
+
+static DlErrCode
+s3_file_write(DatalakeFile file, const void *buffer, int64_t length)
+{
+	DlErrCode	rc = DL_ERR_INTERNAL;
+
+	DL_ABI_GUARD_BEGIN
+	{
+		(void) file;
+		(void) buffer;
+		(void) length;
+
+		rc = DL_ERR_NOT_SUPPORTED;
+	}
+	DL_ABI_GUARD_END(rc);
+
+	return rc;
+}
+
+static DlErrCode
+s3_file_close(DatalakeFile file)
+{
+	DlErrCode	rc = DL_ERR_INTERNAL;
+
+	DL_ABI_GUARD_BEGIN
+	{
+		(void) file;
+
+		rc = DL_ERR_NOT_SUPPORTED;
+	}
+	DL_ABI_GUARD_END(rc);
+
+	return rc;
+}
+
+static void
+s3_file_abort(DatalakeFile file)
+{
+	DL_CLEANUP_GUARD_BEGIN
+	{
+		(void) file;
+	}
+	DL_CLEANUP_GUARD_END;
+}
+
+static const struct DatalakeStorageOps s3_storage_ops = {
+	s3_fs_open,
+	s3_fs_close,
+	s3_fs_list,
+	s3_file_open,
+	s3_file_read,
+	s3_file_write,
+	s3_file_close,
+	s3_file_abort
+};
+
+DlErrCode
+datalake_register_s3_backend(void)
+{
+	return datalake_register_storage_backend("s3", &s3_storage_ops);
+}
diff --git a/contrib/datalake_fdw/src/format/format.h b/contrib/datalake_fdw/src/format/format.h
new file mode 100644
index 00000000000..003101ae550
--- /dev/null
+++ b/contrib/datalake_fdw/src/format/format.h
@@ -0,0 +1,117 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * format.h
+ *	  Reader and writer interfaces for lake table data files.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/format/format.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef DL_FORMAT_H
+#define DL_FORMAT_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "common/dl_err.h"
+
+/* Arrow C data interface: stable public ABI. */
+#ifndef ARROW_C_DATA_INTERFACE
+#define ARROW_C_DATA_INTERFACE
+
+struct ArrowSchema {
+	const char *format;
+	const char *name;
+	const char *metadata;
+	int64_t flags;
+	int64_t n_children;
+	struct ArrowSchema **children;
+	struct ArrowSchema *dictionary;
+	void (*release)(struct ArrowSchema *);
+	void *private_data;
+};
+
+struct ArrowArray {
+	int64_t length;
+	int64_t null_count;
+	int64_t offset;
+	int64_t n_buffers;
+	int64_t n_children;
+	const void **buffers;
+	struct ArrowArray **children;
+	struct ArrowArray *dictionary;
+	void (*release)(struct ArrowArray *);
+	void *private_data;
+};
+#endif						/* ARROW_C_DATA_INTERFACE */
+
+typedef struct Fragment Fragment;                 /* opaque in skeleton */
+typedef struct ProjectionSet ProjectionSet;
+typedef struct RowGroupFilterSet RowGroupFilterSet;
+typedef struct WriterOptions WriterOptions;
+typedef struct FileMeta FileMeta;
+typedef struct DeleteFileSet DeleteFileSet;
+
+/* Readers/writers are INSTANCES (ops + impl); configuration travels with the instance.
+ * No global slots or trampolines, ever. */
+typedef struct FormatReader FormatReader;
+typedef struct FormatReaderOps {
+	/* Each batch yields ArrowArray+ArrowSchema; last column is a hidden int64 file-row
+	 * ordinal (for MoR positional deletes). */
+	DlErrCode (*next_batch)(FormatReader *, struct ArrowArray *out,
+							struct ArrowSchema *schema, bool *eof);
+	void      (*close)(FormatReader *);   /* void cleanup ABI: noexcept, idempotent, never ereport */
+} FormatReaderOps;
+struct FormatReader { const FormatReaderOps *ops; void *impl; };
+
+typedef struct FormatWriter FormatWriter;
+typedef struct FormatWriterOps {
+	DlErrCode (*write_batch)(FormatWriter *, struct ArrowArray *batch); /* success == consumed */
+	/* Rolling support: actual bytes encoded into the sink so far. Valid to query after a
+	 * successful write_batch; on failure returns an error code and *out is invalid.
+	 * The write.c orchestration layer rolls files (finish -> new open_writer) when this
+	 * reaches the soft target; overshoot of at most one batch is allowed. */
+	DlErrCode (*bytes_written)(FormatWriter *, int64_t *out);
+	DlErrCode (*finish)(FormatWriter *, FileMeta **meta);  /* reportable close-time errors
+																		* surface ONLY here */
+	void      (*abort)(FormatWriter *);   /* void cleanup ABI: noexcept, idempotent, never ereport */
+} FormatWriterOps;
+struct FormatWriter { const FormatWriterOps *ops; void *impl; };
+
+typedef struct FormatRoutine {
+	uint32_t abi_version, struct_size;    /* same prefix-compat semantics as meta engine */
+	const char *name;                     /* "parquet" */
+	DlErrCode (*open_reader)(const Fragment *, const ProjectionSet *,
+							 const RowGroupFilterSet *, FormatReader **out);
+	DlErrCode (*open_writer)(const char *path, /* TupleDesc */ void *tupdesc,
+							 const WriterOptions *, FormatWriter **out);
+} FormatRoutine;
+
+extern const FormatRoutine *GetFormatRoutine(const char *format);
+
+/* MoR positional-delete decorator: consumes the inner instance, returns a new instance.
+ * close(outer) exactly-once: releases itself then close(inner); idempotent; on open
+ * failure the wrapper owns releasing inner. */
+extern DlErrCode WrapPositionDeleteFilter(FormatReader *inner, const DeleteFileSet *,
+										  FormatReader **out);
+
+#endif						/* DL_FORMAT_H */
diff --git a/contrib/datalake_fdw/src/format/format_registry.c b/contrib/datalake_fdw/src/format/format_registry.c
new file mode 100644
index 00000000000..83370a51f64
--- /dev/null
+++ b/contrib/datalake_fdw/src/format/format_registry.c
@@ -0,0 +1,48 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * format_registry.c
+ *	  Lookup of the reader and writer for a data file format.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/format/format_registry.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include <stddef.h>
+
+#include "format/format.h"
+
+/* No formats in the skeleton; parquet lands in PR-3/4.  Callers must treat
+ * NULL as not-supported. */
+const FormatRoutine *
+GetFormatRoutine(const char *format)
+{
+	return NULL;
+}
+
+DlErrCode
+WrapPositionDeleteFilter(FormatReader *inner, const DeleteFileSet *delete_files,
+						 FormatReader **out)
+{
+	if (out != NULL)
+		*out = NULL;
+	return DL_ERR_NOT_SUPPORTED;
+}
diff --git a/contrib/datalake_fdw/src/iceberg_catalog_fdw/iceberg_catalog_fdw.c b/contrib/datalake_fdw/src/iceberg_catalog_fdw/iceberg_catalog_fdw.c
new file mode 100644
index 00000000000..ba408c6ab0c
--- /dev/null
+++ b/contrib/datalake_fdw/src/iceberg_catalog_fdw/iceberg_catalog_fdw.c
@@ -0,0 +1,226 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * iceberg_catalog_fdw.c
+ *	  Option validator for Iceberg catalog foreign servers.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/iceberg_catalog_fdw/iceberg_catalog_fdw.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/reloptions.h"
+#include "am_iceberg/pg_iceberg_reject.h"
+#include "catalog/pg_foreign_data_wrapper.h"
+#include "catalog/pg_foreign_server.h"
+#include "catalog/pg_user_mapping.h"
+#include "commands/defrem.h"
+#include "common/dl_option_util.h"
+#include "common/parser_option.h"
+#include "fmgr.h"
+#include "iceberg_catalog_fdw/iceberg_catalog_option.h"
+
+PG_FUNCTION_INFO_V1(iceberg_catalog_fdw_validator);
+
+static bool is_catalog_server_option(const char *name);
+static bool is_catalog_user_mapping_option(const char *name);
+static void check_catalog_server_type(const char *server_type);
+
+/*
+ * The server options this wrapper accepts.  A storage protocol is never among
+ * them: where the data files live is decided by the volume server.
+ */
+static bool
+is_catalog_server_option(const char *name)
+{
+	return strcmp(name, DATALAKE_ICEBERG_CATALOG_SERVER_TYPE) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_CATALOG_URL) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_CATALOG_NAME) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_CATALOG_WAREHOUSE_LOCATION_PREFIX) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_CATALOG_POLARIS_SERVER_REALM) == 0;
+}
+
+/*
+ * The user mapping options this wrapper accepts: the union over catalog types,
+ * because a mapping is validated without reference to the server it belongs to.
+ * parse_iceberg_catalog_user_mapping_options() is what narrows them by type.
+ */
+static bool
+is_catalog_user_mapping_option(const char *name)
+{
+	return strcmp(name, DATALAKE_ICEBERG_CATALOG_USERNAME) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_CATALOG_AUTH_METHOD) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_CATALOG_KRB_SERVICE_PRINCIPAL) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_CATALOG_KRB_CLIENT_PRINCIPAL) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_CATALOG_KRB_CLIENT_KEYTAB) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_CATALOG_CLIENT_ID) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_CATALOG_CLIENT_SECRET) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_CATALOG_SCOPE) == 0;
+}
+
+static void
+check_catalog_server_type(const char *server_type)
+{
+	if (pg_strcasecmp(server_type,
+					  DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_HIVE) == 0 ||
+		pg_strcasecmp(server_type,
+					  DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_REST) == 0 ||
+		pg_strcasecmp(server_type,
+					  DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_POLARIS) == 0 ||
+		pg_strcasecmp(server_type,
+					  DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_BUILTIN) == 0)
+		return;
+
+	/*
+	 * Names the vocabulary defines but this module cannot serve yet.  Refusing
+	 * them is what keeps a server from being created against a catalog no
+	 * statement could subsequently use.
+	 */
+	if (pg_strcasecmp(server_type,
+					  DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_HADOOP) == 0 ||
+		pg_strcasecmp(server_type,
+					  DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_S3) == 0)
+		pg_iceberg_not_supported(psprintf("catalog type \"%s\"", server_type));
+
+	ereport(ERROR,
+			(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			 errmsg("invalid iceberg catalog type \"%s\"", server_type),
+			 errhint("Allowed types are \"%s\", \"%s\" and \"%s\"; \"%s\" is accepted as an alias of \"%s\".",
+					 DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_HIVE,
+					 DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_REST,
+					 DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_BUILTIN,
+					 DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_POLARIS,
+					 DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_REST)));
+}
+
+Datum
+iceberg_catalog_fdw_validator(PG_FUNCTION_ARGS)
+{
+	List	   *options = untransformRelOptions(PG_GETARG_DATUM(0));
+	Oid			catalog = PG_GETARG_OID(1);
+	ListCell   *lc;
+	const char *server_type;
+	const char *url;
+	const char *realm;
+
+	/*
+	 * CREATE FOREIGN DATA WRAPPER invokes its validator with an empty array.
+	 * Permit that bootstrap call, but this FDW has no wrapper-level options.
+	 */
+	if (catalog == ForeignDataWrapperRelationId && options == NIL)
+		PG_RETURN_VOID();
+
+	if (catalog != ForeignServerRelationId &&
+		catalog != UserMappingRelationId)
+		ereport(ERROR,
+				(errcode(ERRCODE_FDW_INVALID_OPTION_NAME),
+				 errmsg("iceberg_catalog_fdw has no options in this context")));
+
+	foreach(lc, options)
+	{
+		DefElem    *def = (DefElem *) lfirst(lc);
+		const char *name = def->defname;
+
+		if (catalog == ForeignServerRelationId)
+		{
+			if (dl_is_credential_option(name))
+				ereport(ERROR,
+						(errcode(ERRCODE_FDW_INVALID_OPTION_NAME),
+						 errmsg("credential option \"%s\" is not allowed on an iceberg catalog server",
+								name),
+						 errhint("credentials belong in CREATE USER MAPPING ... OPTIONS (...)")));
+
+			if (!is_catalog_server_option(name))
+				ereport(ERROR,
+						(errcode(ERRCODE_FDW_INVALID_OPTION_NAME),
+						 errmsg("invalid iceberg catalog server option \"%s\"",
+								name),
+						 errhint("Allowed options are \"%s\", \"%s\", \"%s\", \"%s\" and \"%s\".",
+								 DATALAKE_ICEBERG_CATALOG_SERVER_TYPE,
+								 DATALAKE_ICEBERG_CATALOG_URL,
+								 DATALAKE_ICEBERG_CATALOG_NAME,
+								 DATALAKE_ICEBERG_CATALOG_WAREHOUSE_LOCATION_PREFIX,
+								 DATALAKE_ICEBERG_CATALOG_POLARIS_SERVER_REALM)));
+
+			/* Reject an empty value here rather than at first use. */
+			if (defGetString(def)[0] == '\0')
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("iceberg catalog server option \"%s\" cannot be empty",
+								name)));
+		}
+		else if (!is_catalog_user_mapping_option(name))
+			ereport(ERROR,
+					(errcode(ERRCODE_FDW_INVALID_OPTION_NAME),
+					 errmsg("invalid iceberg catalog user mapping option \"%s\"",
+							name)));
+	}
+
+	if (catalog == UserMappingRelationId)
+		PG_RETURN_VOID();
+
+	/*
+	 * Cross-option rules run once the whole list has been seen, so that they do
+	 * not depend on the order the options were written in.
+	 */
+	server_type = get_string_option(options,
+									DATALAKE_ICEBERG_CATALOG_SERVER_TYPE);
+	url = get_string_option(options, DATALAKE_ICEBERG_CATALOG_URL);
+	realm = get_string_option(options,
+							  DATALAKE_ICEBERG_CATALOG_POLARIS_SERVER_REALM);
+
+	if (server_type == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("iceberg catalog server option \"%s\" is required",
+						DATALAKE_ICEBERG_CATALOG_SERVER_TYPE)));
+
+	check_catalog_server_type(server_type);
+
+	if (pg_strcasecmp(server_type,
+					  DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_BUILTIN) == 0)
+	{
+		if (url != NULL)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("iceberg catalog type \"%s\" forbids server option \"%s\"",
+							server_type, DATALAKE_ICEBERG_CATALOG_URL)));
+	}
+	else if (url == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("iceberg catalog type \"%s\" requires server option \"%s\"",
+						server_type, DATALAKE_ICEBERG_CATALOG_URL)));
+
+	if (realm != NULL &&
+		pg_strcasecmp(server_type,
+					  DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_REST) != 0 &&
+		pg_strcasecmp(server_type,
+					  DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_POLARIS) != 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("iceberg catalog server option \"%s\" applies only to catalog type \"%s\"",
+						DATALAKE_ICEBERG_CATALOG_POLARIS_SERVER_REALM,
+						DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_REST)));
+
+	PG_RETURN_VOID();
+}
diff --git a/contrib/datalake_fdw/src/iceberg_catalog_fdw/iceberg_catalog_option.c b/contrib/datalake_fdw/src/iceberg_catalog_fdw/iceberg_catalog_option.c
new file mode 100644
index 00000000000..9587132ecba
--- /dev/null
+++ b/contrib/datalake_fdw/src/iceberg_catalog_fdw/iceberg_catalog_option.c
@@ -0,0 +1,185 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * iceberg_catalog_option.c
+ *	  Option vocabulary and parsed forms for Iceberg catalog servers.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/iceberg_catalog_fdw/iceberg_catalog_option.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "common/parser_option.h"
+#include "iceberg_catalog_fdw/iceberg_catalog_option.h"
+#include "utils/builtins.h"
+
+static void parse_hive_catalog_server_options(IcebergCatalogServerOptions *options,
+											  List *server_options);
+static void parse_rest_catalog_server_options(IcebergCatalogServerOptions *options,
+											  List *server_options);
+static void parse_hive_user_mapping_options(HiveUserMappingOptions *options,
+											List *user_options);
+static void parse_polaris_user_mapping_options(PolarisUserMappingOptions *options,
+											   List *user_options);
+
+/*
+ * Reference implementation: parseHiveCatalogServerOptions().
+ *
+ * That version also accepts "hive_metastore_uri" as a second spelling of the
+ * same option, for servers created before the key was renamed.  This extension
+ * has never been released, so there is nothing to be compatible with and only
+ * one spelling is accepted.
+ */
+static void
+parse_hive_catalog_server_options(IcebergCatalogServerOptions *options,
+								  List *server_options)
+{
+	options->hive_metastore_uri =
+		get_string_option(server_options, DATALAKE_ICEBERG_CATALOG_URL);
+}
+
+/* Reference implementation: parsePolarisCatalogServerOptions() */
+static void
+parse_rest_catalog_server_options(IcebergCatalogServerOptions *options,
+								  List *server_options)
+{
+	options->polaris_server_url =
+		get_string_option(server_options, DATALAKE_ICEBERG_CATALOG_URL);
+
+	/*
+	 * Sent as the realm header on every request.  Optional: the metadata engine
+	 * applies its own default when unset.
+	 */
+	options->polaris_server_realm =
+		get_string_option(server_options,
+						  DATALAKE_ICEBERG_CATALOG_POLARIS_SERVER_REALM);
+}
+
+void
+parse_iceberg_catalog_server_options(IcebergCatalogServerOptions *options,
+									 List *server_options)
+{
+	options->server_type =
+		get_string_option(server_options, DATALAKE_ICEBERG_CATALOG_SERVER_TYPE);
+
+	if (options->server_type == NULL)
+		return;
+
+	if (pg_strcasecmp(options->server_type,
+					  DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_HIVE) == 0)
+		parse_hive_catalog_server_options(options, server_options);
+	else if (pg_strcasecmp(options->server_type,
+						   DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_REST) == 0 ||
+			 pg_strcasecmp(options->server_type,
+						   DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_POLARIS) == 0)
+		parse_rest_catalog_server_options(options, server_options);
+}
+
+/* Reference implementation: parseHiveUserMappingOptions() */
+static void
+parse_hive_user_mapping_options(HiveUserMappingOptions *options,
+								List *user_options)
+{
+	options->username =
+		get_string_option(user_options, DATALAKE_ICEBERG_CATALOG_USERNAME);
+	options->auth_method =
+		get_string_option(user_options, DATALAKE_ICEBERG_CATALOG_AUTH_METHOD);
+	options->krb_service_principal =
+		get_string_option(user_options,
+						  DATALAKE_ICEBERG_CATALOG_KRB_SERVICE_PRINCIPAL);
+	options->krb_client_principal =
+		get_string_option(user_options,
+						  DATALAKE_ICEBERG_CATALOG_KRB_CLIENT_PRINCIPAL);
+	options->krb_client_keytab =
+		get_string_option(user_options,
+						  DATALAKE_ICEBERG_CATALOG_KRB_CLIENT_KEYTAB);
+}
+
+/* Reference implementation: parsePolarisUserMappingOptions() */
+static void
+parse_polaris_user_mapping_options(PolarisUserMappingOptions *options,
+								   List *user_options)
+{
+	options->client_id =
+		get_string_option(user_options, DATALAKE_ICEBERG_CATALOG_CLIENT_ID);
+	options->client_secret =
+		get_string_option(user_options, DATALAKE_ICEBERG_CATALOG_CLIENT_SECRET);
+	options->scope =
+		get_string_option(user_options, DATALAKE_ICEBERG_CATALOG_SCOPE);
+}
+
+void
+parse_iceberg_catalog_user_mapping_options(IcebergCatalogUserMappingOptions *options,
+										   List *user_options,
+										   const char *server_type)
+{
+	if (server_type == NULL)
+		return;
+
+	if (pg_strcasecmp(server_type,
+					  DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_HIVE) == 0)
+		parse_hive_user_mapping_options(&options->hive, user_options);
+	else if (pg_strcasecmp(server_type,
+						   DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_REST) == 0 ||
+			 pg_strcasecmp(server_type,
+						   DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_POLARIS) == 0)
+		parse_polaris_user_mapping_options(&options->polaris, user_options);
+}
+
+/*
+ * Reference implementation: parseIcebergForeignCatalogOptions().
+ *
+ * server_name supplies the default catalog name, because a catalog server here
+ * names exactly one Iceberg catalog.
+ */
+void
+parse_iceberg_foreign_catalog_options(IcebergForeignCatalogOptions *options,
+									  List *catalog_options,
+									  const char *server_name)
+{
+	options->catalog_name =
+		get_string_option(catalog_options, DATALAKE_ICEBERG_CATALOG_NAME);
+	if (options->catalog_name == NULL)
+		options->catalog_name = pstrdup(server_name);
+
+	options->warehouse_location_prefix =
+		get_string_option(catalog_options,
+						  DATALAKE_ICEBERG_CATALOG_WAREHOUSE_LOCATION_PREFIX);
+}
+
+IcebergCatalogOptions *
+get_iceberg_catalog_options(ForeignServer *server)
+{
+	IcebergCatalogOptions *options;
+
+	Assert(server != NULL);
+
+	options = (IcebergCatalogOptions *) palloc0(sizeof(IcebergCatalogOptions));
+
+	parse_iceberg_catalog_server_options(&options->catalog_server,
+										 server->options);
+	parse_iceberg_foreign_catalog_options(&options->foreign_catalog,
+										  server->options,
+										  server->servername);
+
+	return options;
+}
diff --git a/contrib/datalake_fdw/src/iceberg_catalog_fdw/iceberg_catalog_option.h b/contrib/datalake_fdw/src/iceberg_catalog_fdw/iceberg_catalog_option.h
new file mode 100644
index 00000000000..df6e3b6b9a1
--- /dev/null
+++ b/contrib/datalake_fdw/src/iceberg_catalog_fdw/iceberg_catalog_option.h
@@ -0,0 +1,171 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * iceberg_catalog_option.h
+ *	  Option vocabulary and parsed forms for Iceberg catalog servers.
+ *
+ * "The reference implementation", here and in the other option modules, means
+ * the existing implementation of this feature that this work derives from and
+ * is meant to replace.  Its option key macros, struct names and field names are
+ * reproduced exactly, so that a parser for a further catalog type can move
+ * between the two as an addition rather than a rewrite.  Where the two models
+ * genuinely differ, the difference is called out on the field.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/iceberg_catalog_fdw/iceberg_catalog_option.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef ICEBERG_CATALOG_OPTION_H
+#define ICEBERG_CATALOG_OPTION_H
+
+#include "postgres.h"
+
+#include "common/dl_option_util.h"
+#include "foreign/foreign.h"
+#include "nodes/pg_list.h"
+
+/* Catalog server options */
+#define DATALAKE_ICEBERG_CATALOG_SERVER_TYPE "type"
+#define DATALAKE_ICEBERG_CATALOG_URL "uri"
+#define DATALAKE_ICEBERG_CATALOG_POLARIS_SERVER_REALM "polaris_server_realm"
+
+/*
+ * Recognized catalog server types.
+ *
+ * The names are Apache Iceberg's, not this module's: a catalog reached over the
+ * REST protocol is "rest", because the specification defines one protocol that
+ * several implementations answer.  "polaris" is accepted as an alias for it --
+ * Polaris is one such implementation, and it is the spelling the reference
+ * implementation uses, so servers written for that one keep working.
+ *
+ * A storage protocol is never a catalog type -- where the data files live is
+ * volume business -- but the reference implementation defines these two names,
+ * so they are kept here to stay one vocabulary; the validator refuses them
+ * until an implementation exists.
+ */
+#define DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_HIVE "hive"
+#define DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_REST "rest"
+#define DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_POLARIS "polaris"
+#define DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_BUILTIN "builtin"
+#define DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_HADOOP "hadoop"
+#define DATALAKE_ICEBERG_CATALOG_SERVER_TYPE_S3 "s3"
+
+/* Catalog user mapping options */
+#define DATALAKE_ICEBERG_CATALOG_USERNAME DL_OPTION_KEY_USERNAME
+#define DATALAKE_ICEBERG_CATALOG_AUTH_METHOD "auth_method"
+#define DATALAKE_ICEBERG_CATALOG_KRB_SERVICE_PRINCIPAL "krb_service_principal"
+#define DATALAKE_ICEBERG_CATALOG_KRB_CLIENT_PRINCIPAL "krb_client_principal"
+#define DATALAKE_ICEBERG_CATALOG_KRB_CLIENT_KEYTAB DL_OPTION_KEY_KRB_CLIENT_KEYTAB
+#define DATALAKE_ICEBERG_CATALOG_CLIENT_ID DL_OPTION_KEY_CLIENT_ID
+#define DATALAKE_ICEBERG_CATALOG_CLIENT_SECRET DL_OPTION_KEY_CLIENT_SECRET
+#define DATALAKE_ICEBERG_CATALOG_SCOPE "scope"
+
+/* Catalog identity options */
+#define DATALAKE_ICEBERG_CATALOG_NAME "catalog_name"
+#define DATALAKE_ICEBERG_CATALOG_WAREHOUSE_LOCATION_PREFIX "warehouse"
+
+typedef struct IcebergCatalogServerOptions
+{
+	char	   *server_type;		/* DATALAKE_ICEBERG_CATALOG_SERVER_TYPE */
+	char	   *hive_metastore_uri; /* DATALAKE_ICEBERG_CATALOG_URL, hive */
+	char	   *polaris_server_url; /* DATALAKE_ICEBERG_CATALOG_URL, rest */
+	char	   *polaris_server_realm;	/* DATALAKE_ICEBERG_CATALOG_POLARIS_SERVER_REALM */
+
+	/*
+	 * The reference implementation also carries server_name, naming a section
+	 * of a site configuration file.  There is no such file here: an option that
+	 * would be accepted and then ignored is worse than one that is refused, so
+	 * it is left out until site configuration exists.
+	 */
+} IcebergCatalogServerOptions;
+
+typedef struct HiveUserMappingOptions
+{
+	char	   *username;
+	char	   *auth_method;
+	char	   *krb_service_principal;
+	char	   *krb_client_principal;
+	char	   *krb_client_keytab;
+} HiveUserMappingOptions;
+
+typedef struct PolarisUserMappingOptions
+{
+	char	   *client_id;
+	char	   *client_secret;
+	char	   *scope;
+} PolarisUserMappingOptions;
+
+typedef struct IcebergCatalogUserMappingOptions
+{
+	HiveUserMappingOptions hive;
+	PolarisUserMappingOptions polaris;
+} IcebergCatalogUserMappingOptions;
+
+typedef struct IcebergForeignCatalogOptions
+{
+	/*
+	 * The reference implementation reads these from a foreign catalog object
+	 * that a server can hold several of.  This extension cannot add a catalog
+	 * of its own to the system catalogs, so a catalog server names exactly one
+	 * Iceberg catalog and both values come from that server's options;
+	 * catalog_name defaults to the server name when unset.
+	 */
+	char	   *catalog_name;		/* DATALAKE_ICEBERG_CATALOG_NAME */
+	char	   *warehouse_location_prefix;	/* DATALAKE_ICEBERG_CATALOG_WAREHOUSE_LOCATION_PREFIX */
+
+	/*
+	 * Deferred, with the reference implementation's names kept for the port:
+	 * enable_metadata_cache / metadata_cache_ttl / auto_refresh_metadata /
+	 * total_segment / split_size / filter_string.
+	 */
+} IcebergForeignCatalogOptions;
+
+typedef struct IcebergCatalogOptions
+{
+	IcebergCatalogServerOptions catalog_server;
+	IcebergCatalogUserMappingOptions catalog_user;
+	IcebergForeignCatalogOptions foreign_catalog;
+} IcebergCatalogOptions;
+
+/* Reference implementation: parseIcebergCatalogServerOptions() */
+extern void parse_iceberg_catalog_server_options(IcebergCatalogServerOptions *options,
+												 List *server_options);
+
+/* Reference implementation: parseIcebergCatalogUserMappingOptions() */
+extern void parse_iceberg_catalog_user_mapping_options(IcebergCatalogUserMappingOptions *options,
+													   List *user_options,
+													   const char *server_type);
+
+/* Reference implementation: parseIcebergForeignCatalogOptions() */
+extern void parse_iceberg_foreign_catalog_options(IcebergForeignCatalogOptions *options,
+												  List *catalog_options,
+												  const char *server_name);
+
+/*
+ * Reference implementation: getIcebergCatalogOptions(), which additionally
+ * fills catalog_user from the invoking role's user mapping.  Credentials are
+ * resolved separately and lazily here, because a DDL path must be able to
+ * describe a table without reading anyone's secrets; catalog_user is left
+ * zeroed by this function.
+ */
+extern IcebergCatalogOptions *get_iceberg_catalog_options(ForeignServer *server);
+
+#endif							/* ICEBERG_CATALOG_OPTION_H */
diff --git a/contrib/datalake_fdw/src/iceberg_volume_fdw/iceberg_volume_fdw.c b/contrib/datalake_fdw/src/iceberg_volume_fdw/iceberg_volume_fdw.c
new file mode 100644
index 00000000000..ab5f5c735d0
--- /dev/null
+++ b/contrib/datalake_fdw/src/iceberg_volume_fdw/iceberg_volume_fdw.c
@@ -0,0 +1,155 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * iceberg_volume_fdw.c
+ *	  Option validator for Iceberg volume foreign servers.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/iceberg_volume_fdw/iceberg_volume_fdw.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "access/reloptions.h"
+#include "am_iceberg/pg_iceberg_options.h"
+#include "catalog/pg_foreign_data_wrapper.h"
+#include "catalog/pg_foreign_server.h"
+#include "catalog/pg_user_mapping.h"
+#include "commands/defrem.h"
+#include "common/dl_option_util.h"
+#include "fmgr.h"
+#include "iceberg_volume_fdw/iceberg_volume_option.h"
+
+PG_FUNCTION_INFO_V1(iceberg_volume_fdw_validator);
+
+static bool is_volume_server_option(const char *name);
+static bool is_volume_user_mapping_option(const char *name);
+
+static bool
+is_volume_server_option(const char *name)
+{
+	return strcmp(name, DATALAKE_ICEBERG_VOLUME_BASE_PATH) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_VOLUME_ENDPOINT) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_VOLUME_REGION) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_VOLUME_PATH_STYLE_ACCESS) == 0;
+}
+
+/*
+ * Every credential here is optional, so that ambient storage credentials -- an
+ * instance profile, a ticket cache -- remain a valid deployment choice.
+ */
+static bool
+is_volume_user_mapping_option(const char *name)
+{
+	return strcmp(name, DATALAKE_ICEBERG_VOLUME_USERNAME) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_VOLUME_AWS_ACCESS_KEY_ID) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_VOLUME_AWS_SECRET_ACCESS_KEY) == 0 ||
+		strcmp(name, DATALAKE_ICEBERG_VOLUME_AWS_SESSION_TOKEN) == 0;
+}
+
+Datum
+iceberg_volume_fdw_validator(PG_FUNCTION_ARGS)
+{
+	List	   *options = untransformRelOptions(PG_GETARG_DATUM(0));
+	Oid			catalog = PG_GETARG_OID(1);
+	ListCell   *lc;
+	IcebergVolumeServerOptions server_options = {0};
+	IcebergForeignVolumeOptions volume_options = {0};
+	DatalakeLocation location;
+	char	   *parse_detail = NULL;
+	DlErrCode	parse_result;
+
+	/*
+	 * CREATE FOREIGN DATA WRAPPER invokes its validator with an empty array.
+	 * Permit that bootstrap call, but this FDW has no wrapper-level options.
+	 */
+	if (catalog == ForeignDataWrapperRelationId && options == NIL)
+		PG_RETURN_VOID();
+
+	if (catalog != ForeignServerRelationId &&
+		catalog != UserMappingRelationId)
+		ereport(ERROR,
+				(errcode(ERRCODE_FDW_INVALID_OPTION_NAME),
+				 errmsg("iceberg_volume_fdw has no options in this context")));
+
+	foreach(lc, options)
+	{
+		DefElem    *def = (DefElem *) lfirst(lc);
+		const char *name = def->defname;
+
+		if (catalog == ForeignServerRelationId)
+		{
+			if (dl_is_credential_option(name))
+				ereport(ERROR,
+						(errcode(ERRCODE_FDW_INVALID_OPTION_NAME),
+						 errmsg("credential option \"%s\" is not allowed on an iceberg volume server",
+								name),
+						 errhint("credentials belong in CREATE USER MAPPING ... OPTIONS (...)")));
+
+			if (!is_volume_server_option(name))
+				ereport(ERROR,
+						(errcode(ERRCODE_FDW_INVALID_OPTION_NAME),
+						 errmsg("invalid iceberg volume server option \"%s\"",
+								name),
+						 errhint("Allowed options are \"%s\", \"%s\", \"%s\" and \"%s\".",
+								 DATALAKE_ICEBERG_VOLUME_BASE_PATH,
+								 DATALAKE_ICEBERG_VOLUME_ENDPOINT,
+								 DATALAKE_ICEBERG_VOLUME_REGION,
+								 DATALAKE_ICEBERG_VOLUME_PATH_STYLE_ACCESS)));
+		}
+		else if (!is_volume_user_mapping_option(name))
+			ereport(ERROR,
+					(errcode(ERRCODE_FDW_INVALID_OPTION_NAME),
+					 errmsg("invalid iceberg volume user mapping option \"%s\"",
+							name)));
+	}
+
+	if (catalog == UserMappingRelationId)
+		PG_RETURN_VOID();
+
+	/*
+	 * Parse with the same functions the use points parse with, so a server this
+	 * validator accepted cannot fail to parse afterwards.  path_style_access is
+	 * checked as a side effect: the accessor refuses a non-boolean value.
+	 */
+	parse_iceberg_volume_server_options(&server_options, options);
+	parse_iceberg_foreign_volume_options(&volume_options, options);
+
+	if (volume_options.base_path == NULL)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("iceberg volume server option \"%s\" is required",
+						DATALAKE_ICEBERG_VOLUME_BASE_PATH)));
+
+	parse_result = pg_iceberg_parse_location(volume_options.base_path,
+											 server_options.endpoint,
+											 server_options.region,
+											 &location, &parse_detail);
+	if (parse_result != DL_OK)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("invalid iceberg volume %s \"%s\"",
+						DATALAKE_ICEBERG_VOLUME_BASE_PATH,
+						volume_options.base_path),
+				 errdetail("%s", parse_detail)));
+
+	PG_RETURN_VOID();
+}
diff --git a/contrib/datalake_fdw/src/iceberg_volume_fdw/iceberg_volume_option.c b/contrib/datalake_fdw/src/iceberg_volume_fdw/iceberg_volume_option.c
new file mode 100644
index 00000000000..b304f27620e
--- /dev/null
+++ b/contrib/datalake_fdw/src/iceberg_volume_fdw/iceberg_volume_option.c
@@ -0,0 +1,94 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * iceberg_volume_option.c
+ *	  Option vocabulary and parsed forms for Iceberg volume servers.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/iceberg_volume_fdw/iceberg_volume_option.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "common/parser_option.h"
+#include "iceberg_volume_fdw/iceberg_volume_option.h"
+
+void
+parse_iceberg_volume_server_options(IcebergVolumeServerOptions *options,
+									List *server_options)
+{
+	options->endpoint =
+		get_string_option(server_options, DATALAKE_ICEBERG_VOLUME_ENDPOINT);
+	options->region =
+		get_string_option(server_options, DATALAKE_ICEBERG_VOLUME_REGION);
+
+	/*
+	 * Absence has to stay distinguishable from an explicit false: the metadata
+	 * engine merges what a server states over its own defaults per key, so an
+	 * unset boolean must not arrive as one the user chose.
+	 */
+	options->path_style_access =
+		get_bool_option_ex(server_options,
+						   DATALAKE_ICEBERG_VOLUME_PATH_STYLE_ACCESS,
+						   false, &options->path_style_access_set);
+}
+
+void
+parse_iceberg_volume_user_mapping_options(IcebergVolumeUserMappingOptions *options,
+										  List *user_options)
+{
+	options->username =
+		get_string_option(user_options, DATALAKE_ICEBERG_VOLUME_USERNAME);
+	options->aws_access_key_id =
+		get_string_option(user_options,
+						  DATALAKE_ICEBERG_VOLUME_AWS_ACCESS_KEY_ID);
+	options->aws_secret_access_key =
+		get_string_option(user_options,
+						  DATALAKE_ICEBERG_VOLUME_AWS_SECRET_ACCESS_KEY);
+	options->aws_session_token =
+		get_string_option(user_options,
+						  DATALAKE_ICEBERG_VOLUME_AWS_SESSION_TOKEN);
+}
+
+void
+parse_iceberg_foreign_volume_options(IcebergForeignVolumeOptions *options,
+									 List *volume_options)
+{
+	options->base_path =
+		get_string_option(volume_options, DATALAKE_ICEBERG_VOLUME_BASE_PATH);
+}
+
+IcebergVolumeOptions *
+get_iceberg_volume_options(ForeignServer *server)
+{
+	IcebergVolumeOptions *options;
+
+	Assert(server != NULL);
+
+	options = (IcebergVolumeOptions *) palloc0(sizeof(IcebergVolumeOptions));
+
+	parse_iceberg_volume_server_options(&options->volume_server,
+										server->options);
+	parse_iceberg_foreign_volume_options(&options->foreign_volume,
+										 server->options);
+
+	return options;
+}
diff --git a/contrib/datalake_fdw/src/iceberg_volume_fdw/iceberg_volume_option.h b/contrib/datalake_fdw/src/iceberg_volume_fdw/iceberg_volume_option.h
new file mode 100644
index 00000000000..2b4ab16b46c
--- /dev/null
+++ b/contrib/datalake_fdw/src/iceberg_volume_fdw/iceberg_volume_option.h
@@ -0,0 +1,146 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * iceberg_volume_option.h
+ *	  Option vocabulary and parsed forms for Iceberg volume servers.
+ *
+ * As on the catalog side, the key macros, struct names and field names are
+ * reproduced from the reference implementation -- the existing implementation
+ * of this feature that this work derives from and is meant to replace -- so
+ * that support for a further storage protocol moves across as an addition.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/iceberg_volume_fdw/iceberg_volume_option.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef ICEBERG_VOLUME_OPTION_H
+#define ICEBERG_VOLUME_OPTION_H
+
+#include "postgres.h"
+
+#include "common/dl_option_util.h"
+#include "foreign/foreign.h"
+#include "nodes/pg_list.h"
+
+/* Volume server options */
+#define DATALAKE_ICEBERG_VOLUME_ENDPOINT "endpoint"
+#define DATALAKE_ICEBERG_VOLUME_REGION "region"
+#define DATALAKE_ICEBERG_VOLUME_PATH_STYLE_ACCESS "path_style_access"
+
+/* Volume user mapping options */
+#define DATALAKE_ICEBERG_VOLUME_USERNAME DL_OPTION_KEY_USERNAME
+#define DATALAKE_ICEBERG_VOLUME_AWS_ACCESS_KEY_ID DL_OPTION_KEY_ACCESS_KEY_ID
+#define DATALAKE_ICEBERG_VOLUME_AWS_SECRET_ACCESS_KEY DL_OPTION_KEY_SECRET_ACCESS_KEY
+#define DATALAKE_ICEBERG_VOLUME_AWS_SESSION_TOKEN DL_OPTION_KEY_SESSION_TOKEN
+
+/* Volume location option */
+#define DATALAKE_ICEBERG_VOLUME_BASE_PATH "base_path"
+
+/*
+ * Storage protocols.  Unlike the reference implementation, no server option
+ * names the protocol: base_path carries a URI, so its scheme already says which
+ * protocol this volume speaks, and a separate option could only disagree with
+ * it.  The names are kept because the parsed location is compared against them.
+ */
+#define DATALAKE_ICEBERG_VOLUME_SERVER_TYPE_S3 "s3"
+#define DATALAKE_ICEBERG_VOLUME_SERVER_TYPE_HDFS "hdfs"
+
+typedef struct IcebergVolumeServerOptions
+{
+	char	   *endpoint;			/* DATALAKE_ICEBERG_VOLUME_ENDPOINT */
+	char	   *region;				/* DATALAKE_ICEBERG_VOLUME_REGION */
+	bool		path_style_access;	/* DATALAKE_ICEBERG_VOLUME_PATH_STYLE_ACCESS */
+	bool		path_style_access_set;	/* user actually wrote path_style_access */
+
+	/*
+	 * Deferred, with the reference implementation's names kept for the port.
+	 * server_type and bucket_name are absent by design instead: both are
+	 * derived from base_path, and DatalakeLocation is the parsed form.
+	 *
+	 * AWS: role_arn / external_id / user_arn / current_kms_key /
+	 *      allowed_kms_keys / sts_endpoint / sts_unavailable / endpoint_internal
+	 * Azure: tenant_id / multi_tenant_app_name / consent_url / hierarchical
+	 * HDFS: hdfs_namenodes / hdfs_port / hdfs_auth_method / krb_principal /
+	 *      krb_principal_keytab / krb_service_principal /
+	 *      hadoop_rpc_protection / data_transfer_protocol / is_ha_supported /
+	 *      dfs_nameservices / dfs_ha_namenodes / dfs_namenode_rpc_address /
+	 *      dfs_client_failover_proxy_provider /
+	 *      dfs_client_use_datanode_hostname
+	 */
+} IcebergVolumeServerOptions;
+
+typedef struct IcebergVolumeUserMappingOptions
+{
+	char	   *username;			/* DATALAKE_ICEBERG_VOLUME_USERNAME */
+	char	   *aws_access_key_id;	/* DATALAKE_ICEBERG_VOLUME_AWS_ACCESS_KEY_ID */
+	char	   *aws_secret_access_key;	/* DATALAKE_ICEBERG_VOLUME_AWS_SECRET_ACCESS_KEY */
+
+	/*
+	 * Temporary credentials are three values, not two, and are what AWS
+	 * recommends over long-lived keys; without this field the mapping could
+	 * only express the long-lived form.
+	 */
+	char	   *aws_session_token;	/* DATALAKE_ICEBERG_VOLUME_AWS_SESSION_TOKEN */
+} IcebergVolumeUserMappingOptions;
+
+typedef struct IcebergForeignVolumeOptions
+{
+	/*
+	 * The reference implementation reads these from a foreign volume object; as
+	 * with the catalog side, a volume server here names exactly one volume and
+	 * the value comes from that server's options.
+	 *
+	 * Deferred, names kept: enable_caching / allow_writes / fileIOConfig /
+	 * table_identifier.
+	 */
+	char	   *base_path;			/* DATALAKE_ICEBERG_VOLUME_BASE_PATH */
+} IcebergForeignVolumeOptions;
+
+typedef struct IcebergVolumeOptions
+{
+	IcebergVolumeServerOptions volume_server;
+	IcebergVolumeUserMappingOptions volume_user;
+	IcebergForeignVolumeOptions foreign_volume;
+} IcebergVolumeOptions;
+
+/* Reference implementation: parseIcebergVolumeServerOptions() */
+extern void parse_iceberg_volume_server_options(IcebergVolumeServerOptions *options,
+												List *server_options);
+
+/* Reference implementation: parseIcebergVolumeUserMappingOptions() */
+extern void parse_iceberg_volume_user_mapping_options(IcebergVolumeUserMappingOptions *options,
+													  List *user_options);
+
+/* Reference implementation: parseIcebergForeignVolumeOptions() */
+extern void parse_iceberg_foreign_volume_options(IcebergForeignVolumeOptions *options,
+												 List *volume_options);
+
+/*
+ * Reference implementation: getIcebergVolumeOptions().  volume_user is left
+ * zeroed for the same reason as on the catalog side.
+ *
+ * The reference implementation's buildVolumeBasePath() has no counterpart:
+ * base_path is parsed once into a DatalakeLocation, and every layer below
+ * receives that instead of re-parsing a URI.
+ */
+extern IcebergVolumeOptions *get_iceberg_volume_options(ForeignServer *server);
+
+#endif							/* ICEBERG_VOLUME_OPTION_H */
diff --git a/contrib/datalake_fdw/src/meta/engine_stub/stub_engine.c b/contrib/datalake_fdw/src/meta/engine_stub/stub_engine.c
new file mode 100644
index 00000000000..dfd84c5e54e
--- /dev/null
+++ b/contrib/datalake_fdw/src/meta/engine_stub/stub_engine.c
@@ -0,0 +1,102 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * stub_engine.c
+ *	  A metadata engine that reports what it would have done.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/meta/engine_stub/stub_engine.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "meta/engine_stub/stub_engine.h"
+#include "meta/iceberg_meta_engine.h"
+
+static DlErrCode
+stub_create_table(const MetaCtx *ctx, const MetaTableDef *def, MetaTable **out)
+{
+
+	ereport(NOTICE,
+			(errmsg("stub engine: created iceberg table \"%s.%s\" in catalog \"%s\"",
+					ctx->namespace_name, ctx->table_name, ctx->catalog_name)));
+	*out = NULL;
+	return DL_OK;
+}
+
+static DlErrCode
+stub_drop_table(const MetaCtx *ctx, bool purge)
+{
+	/*
+	 * Report whether the data would have gone with it, so that a regression can
+	 * see which of the two things a DROP asked for.
+	 */
+	ereport(NOTICE,
+			(errmsg("stub engine: dropped iceberg table \"%s.%s\" from catalog \"%s\"%s",
+					ctx->namespace_name, ctx->table_name, ctx->catalog_name,
+					purge ? ", purging data" : ", keeping data")));
+	return DL_OK;
+}
+
+static DlErrCode
+stub_table_exists(const MetaCtx *ctx, bool *exists)
+{
+
+	/* The stub has no remote catalog. */
+	*exists = false;
+	return DL_OK;
+}
+
+/*
+ * Nothing to load in the skeleton; the method remains a member of the lifecycle
+ * family, so it exists and refuses.
+ *
+ * It refuses the way a real engine has to: the code says what kind of failure it
+ * is, and everything specific to this failure -- which table, which operation,
+ * what the implementation calls it -- is recorded for the reporting layer.  A
+ * remote engine records the message and stack it received here instead.
+ */
+static DlErrCode
+stub_load_table(const MetaCtx *ctx, MetaTable **out)
+{
+	dl_error_set(DL_ERR_NOT_SUPPORTED, "load_table", "StubEngine",
+				 psprintf("the stub engine holds no metadata for \"%s.%s\"",
+						  ctx->namespace_name, ctx->table_name));
+	return DL_ERR_NOT_SUPPORTED;
+}
+
+static const IcebergMetaEngine stub_engine =
+{
+	.abi_version = DL_META_ENGINE_ABI_VERSION,
+	.struct_size = sizeof(IcebergMetaEngine),
+	.capabilities = DL_CAP_TABLE_LIFECYCLE,
+	.name = "stub",
+	.load_table = stub_load_table,
+	.create_table = stub_create_table,
+	.drop_table = stub_drop_table,
+	.table_exists = stub_table_exists
+};
+
+DlErrCode
+RegisterStubMetaEngine(void)
+{
+	return RegisterMetaEngine(&stub_engine);
+}
diff --git a/contrib/datalake_fdw/src/meta/engine_stub/stub_engine.h b/contrib/datalake_fdw/src/meta/engine_stub/stub_engine.h
new file mode 100644
index 00000000000..df87bb58d2e
--- /dev/null
+++ b/contrib/datalake_fdw/src/meta/engine_stub/stub_engine.h
@@ -0,0 +1,36 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * stub_engine.h
+ *	  A metadata engine that reports what it would have done.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/meta/engine_stub/stub_engine.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef STUB_ENGINE_H
+#define STUB_ENGINE_H
+
+#include "common/dl_err.h"
+
+extern DlErrCode RegisterStubMetaEngine(void);
+
+#endif						/* STUB_ENGINE_H */
diff --git a/contrib/datalake_fdw/src/meta/iceberg_meta_engine.h b/contrib/datalake_fdw/src/meta/iceberg_meta_engine.h
new file mode 100644
index 00000000000..ef80835eb27
--- /dev/null
+++ b/contrib/datalake_fdw/src/meta/iceberg_meta_engine.h
@@ -0,0 +1,149 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * iceberg_meta_engine.h
+ *	  The metadata engine interface and its central dispatch.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/meta/iceberg_meta_engine.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef ICEBERG_META_ENGINE_H
+#define ICEBERG_META_ENGINE_H
+
+/*
+ * This is the header an engine implementation includes, and the next one is
+ * expected to be C++.  Everything below therefore has to keep C linkage: a C++
+ * translation unit that saw these as C++ declarations would emit mangled
+ * references and fail to link against the C registry.  The server headers come
+ * in through dl_pg_api.h for the same reason.
+ */
+#include "common/dl_pg_api.h"
+
+#include "common/dl_err.h"
+#include "common/dl_kv.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Server, mapping and table options all arrive as plain pairs. */
+typedef DlKeyValue MetaKv;
+
+typedef struct MetaCtx {           /* identity + mapping, no credentials in skeleton */
+	const char *catalog_name;      /* catalog name within the external catalog */
+	const char *namespace_name;    /* PG schema name */
+	const char *table_name;
+	const MetaKv *catalog_props;   int n_catalog_props;
+	const MetaKv *credential_props; int n_credential_props;  /* empty in stub paths */
+} MetaCtx;
+
+typedef struct MetaTableDef { const char *schema_json; } MetaTableDef;
+typedef struct MetaTable    { char *metadata_location; char *table_uuid; } MetaTable;
+/* Opaque in skeleton: */
+typedef struct MetaStatistics MetaStatistics;
+typedef struct MetaAppendRequest MetaAppendRequest;
+typedef struct MetaCommitAppendRequest MetaCommitAppendRequest;
+typedef struct MetaUpdateRequest MetaUpdateRequest;
+typedef struct MetaCommitUpdateRequest MetaCommitUpdateRequest;
+typedef struct MetaStageResult MetaStageResult;
+typedef struct MetaCommitResult MetaCommitResult;
+typedef struct MetaFilterExpr MetaFilterExpr;
+typedef struct MetaFragmentIter MetaFragmentIter;
+typedef struct MetaFragmentBatch MetaFragmentBatch;
+typedef struct MetaFileGroupIter MetaFileGroupIter;
+typedef struct MetaFileGroup MetaFileGroup;
+typedef struct MetaFileGroupList MetaFileGroupList;
+typedef struct MetaAlterTableRequest MetaAlterTableRequest;
+typedef struct MetaTruncateRequest MetaTruncateRequest;
+
+#define DL_META_ENGINE_ABI_VERSION 1
+
+typedef struct IcebergMetaEngine {
+	uint32_t abi_version;      /* must equal DL_META_ENGINE_ABI_VERSION */
+	uint32_t struct_size;      /* PREFIX-compat: registry only touches fields covered by
+								* struct_size; validation bound is the minimal v1 prefix,
+								* NOT sizeof(current struct). Tail may only grow. */
+	uint64_t capabilities;     /* DL_CAP_* method-family bitmap, see below */
+	const char *name;          /* "agent" / "builtin" / "stub" */
+
+	DlErrCode (*load_table)(const MetaCtx *, MetaTable **);
+	DlErrCode (*create_table)(const MetaCtx *, const MetaTableDef *, MetaTable **);
+	DlErrCode (*drop_table)(const MetaCtx *, bool purge);
+	DlErrCode (*table_exists)(const MetaCtx *, bool *);
+	DlErrCode (*get_statistics)(const MetaCtx *, int64_t snapshot, MetaStatistics **);
+
+	/* Iceberg single-table OCC: stage (append/update) then commit_*; NOT a cross-table
+	 * distributed atomic commit. */
+	DlErrCode (*append)(const MetaCtx *, const MetaAppendRequest *, MetaStageResult *);
+	DlErrCode (*commit_append)(const MetaCtx *, const MetaCommitAppendRequest *, MetaCommitResult *);
+	DlErrCode (*update)(const MetaCtx *, const MetaUpdateRequest *, MetaStageResult *);
+	DlErrCode (*commit_update)(const MetaCtx *, const MetaCommitUpdateRequest *, MetaCommitResult *);
+
+	DlErrCode (*get_fragment)(const MetaCtx *, const char *metadata_location,
+						  const MetaFilterExpr *, uint32_t batch_hint, MetaFragmentIter **);
+	DlErrCode (*plan_file_groups)(const MetaCtx *, const char *plan_options_json, MetaFileGroupIter **);
+	DlErrCode (*commit_file_groups)(const MetaCtx *, const MetaFileGroupList *, const char *, MetaCommitResult *);
+	DlErrCode (*alter_table)(const MetaCtx *, const MetaAlterTableRequest *, MetaCommitResult *);
+	DlErrCode (*truncate_table)(const MetaCtx *, const MetaTruncateRequest *, MetaCommitResult *);
+
+	/* iterator close callbacks are "void cleanup ABI": noexcept, idempotent, never ereport */
+	DlErrCode (*fragment_iter_next_batch)(MetaFragmentIter *, MetaFragmentBatch **);
+	void      (*fragment_iter_close)(MetaFragmentIter *);
+	DlErrCode (*file_group_iter_next)(MetaFileGroupIter *, MetaFileGroup **);
+	void      (*file_group_iter_close)(MetaFileGroupIter *);
+} IcebergMetaEngine;
+
+#define DL_CAP_TABLE_LIFECYCLE (UINT64CONST(1) << 0) /* load_table, create_table, drop_table, table_exists */
+#define DL_CAP_STATISTICS      (UINT64CONST(1) << 1) /* get_statistics */
+#define DL_CAP_APPEND          (UINT64CONST(1) << 2) /* append, commit_append */
+#define DL_CAP_UPDATE          (UINT64CONST(1) << 3) /* update, commit_update */
+#define DL_CAP_GET_FRAGMENT    (UINT64CONST(1) << 4) /* get_fragment, fragment_iter_next_batch, fragment_iter_close */
+#define DL_CAP_REWRITE         (UINT64CONST(1) << 5) /* plan_file_groups, commit_file_groups, file_group_iter_next, file_group_iter_close */
+#define DL_CAP_ALTER           (UINT64CONST(1) << 6) /* alter_table */
+#define DL_CAP_TRUNCATE        (UINT64CONST(1) << 7) /* truncate_table */
+
+extern DlErrCode RegisterMetaEngine(const IcebergMetaEngine *engine);
+
+/*
+ * Returns the engine every lake table goes through.  The engine is not
+ * selectable: nothing in a table's definition, and no configuration setting,
+ * picks between implementations, so a table can never be reinterpreted by a
+ * later change.  The vtable indirection remains because the implementation
+ * behind it is expected to change -- the Java agent today, an in-process C++
+ * one once it exists -- not because a deployment gets to choose.
+ */
+extern const IcebergMetaEngine *get_meta_engine(void);
+
+extern DlErrCode meta_engine_create_table(const IcebergMetaEngine *, const MetaCtx *,
+								  const MetaTableDef *, MetaTable **);
+extern DlErrCode meta_engine_drop_table(const IcebergMetaEngine *, const MetaCtx *,
+								bool purge);
+extern DlErrCode meta_engine_table_exists(const IcebergMetaEngine *, const MetaCtx *, bool *);
+extern DlErrCode meta_engine_load_table(const IcebergMetaEngine *, const MetaCtx *, MetaTable **);
+
+/* Remaining method families follow the same central-dispatch pattern in later PRs. */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif						/* ICEBERG_META_ENGINE_H */
diff --git a/contrib/datalake_fdw/src/meta/meta_engine_init.c b/contrib/datalake_fdw/src/meta/meta_engine_init.c
new file mode 100644
index 00000000000..689b3d2c8d1
--- /dev/null
+++ b/contrib/datalake_fdw/src/meta/meta_engine_init.c
@@ -0,0 +1,49 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * meta_engine_init.c
+ *	  Registration of the metadata engine this build provides.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/meta/meta_engine_init.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "common/dl_err.h"
+#include "meta/engine_stub/stub_engine.h"
+#include "meta/meta_engine_init.h"
+
+/*
+ * Called from _PG_init (extensible.c, later task); agent and builtin engines
+ * join in later PRs. SQL-visible NOTICE behavior is covered by skel-regress;
+ * this skeleton has no separate C test harness.
+ */
+void
+DatalakeRegisterMetaEngines(void)
+{
+	DlErrCode	rc;
+
+	rc = RegisterStubMetaEngine();
+	if (rc != DL_OK)
+		elog(ERROR, "datalake_fdw: failed to register stub meta engine: %s",
+			 dl_err_message(rc));
+}
diff --git a/contrib/datalake_fdw/src/meta/meta_engine_init.h b/contrib/datalake_fdw/src/meta/meta_engine_init.h
new file mode 100644
index 00000000000..c20bc5fd6ba
--- /dev/null
+++ b/contrib/datalake_fdw/src/meta/meta_engine_init.h
@@ -0,0 +1,34 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * meta_engine_init.h
+ *	  Registration of the metadata engine this build provides.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/meta/meta_engine_init.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef META_ENGINE_INIT_H
+#define META_ENGINE_INIT_H
+
+extern void DatalakeRegisterMetaEngines(void);
+
+#endif						/* META_ENGINE_INIT_H */
diff --git a/contrib/datalake_fdw/src/meta/meta_engine_registry.c b/contrib/datalake_fdw/src/meta/meta_engine_registry.c
new file mode 100644
index 00000000000..d4bb021c123
--- /dev/null
+++ b/contrib/datalake_fdw/src/meta/meta_engine_registry.c
@@ -0,0 +1,245 @@
+/*-------------------------------------------------------------------------
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ * meta_engine_registry.c
+ *	  Metadata engine registry, capability checks and dispatch.
+ *
+ * IDENTIFICATION
+ *	  contrib/datalake_fdw/src/meta/meta_engine_registry.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include <stddef.h>
+#include <string.h>
+
+#include "meta/iceberg_meta_engine.h"
+
+/* Registered engine pointers are borrowed; each engine must have static lifetime. */
+static const IcebergMetaEngine *engines[8];
+static int n_engines;
+
+/*
+ * v1 minimal prefix = through file_group_iter_close; the registry must never
+ * touch fields beyond engine->struct_size. Do NOT compare against
+ * sizeof(IcebergMetaEngine) -- that breaks prefix compatibility once the struct
+ * grows.
+ */
+#define DL_META_ENGINE_V1_MIN_SIZE \
+	(offsetof(IcebergMetaEngine, file_group_iter_close) + \
+	 sizeof(((IcebergMetaEngine *) 0)->file_group_iter_close))
+
+typedef struct DlCapabilityFamily
+{
+	uint64		bit;
+	const char *family;
+	size_t		offsets[5];
+	int			n;
+} DlCapabilityFamily;
+
+static const DlCapabilityFamily capability_families[] =
+{
+	{DL_CAP_TABLE_LIFECYCLE, "table lifecycle",
+		{offsetof(IcebergMetaEngine, load_table),
+		 offsetof(IcebergMetaEngine, create_table),
+		 offsetof(IcebergMetaEngine, drop_table),
+		 offsetof(IcebergMetaEngine, table_exists)}, 4},
+	{DL_CAP_STATISTICS, "statistics",
+		{offsetof(IcebergMetaEngine, get_statistics)}, 1},
+	{DL_CAP_APPEND, "append",
+		{offsetof(IcebergMetaEngine, append),
+		 offsetof(IcebergMetaEngine, commit_append)}, 2},
+	{DL_CAP_UPDATE, "update",
+		{offsetof(IcebergMetaEngine, update),
+		 offsetof(IcebergMetaEngine, commit_update)}, 2},
+	{DL_CAP_GET_FRAGMENT, "get fragment",
+		{offsetof(IcebergMetaEngine, get_fragment),
+		 offsetof(IcebergMetaEngine, fragment_iter_next_batch),
+		 offsetof(IcebergMetaEngine, fragment_iter_close)}, 3},
+	{DL_CAP_REWRITE, "rewrite",
+		{offsetof(IcebergMetaEngine, plan_file_groups),
+		 offsetof(IcebergMetaEngine, commit_file_groups),
+		 offsetof(IcebergMetaEngine, file_group_iter_next),
+		 offsetof(IcebergMetaEngine, file_group_iter_close)}, 4},
+	{DL_CAP_ALTER, "alter",
+		{offsetof(IcebergMetaEngine, alter_table)}, 1},
+	{DL_CAP_TRUNCATE, "truncate",
+		{offsetof(IcebergMetaEngine, truncate_table)}, 1}
+};
+
+/*
+ * Is the method at this offset present, and set?
+ *
+ * A method that falls beyond the engine's struct_size is not part of the
+ * object at all: reading it would run past what the engine allocated.  Such a
+ * method counts as absent, which is exactly what prefix compatibility means --
+ * an engine built against an older header stays loadable, and every capability
+ * whose family reaches into the missing tail must be left unset.
+ */
+static bool
+meta_engine_method_is_nonnull(const IcebergMetaEngine *engine, size_t offset)
+{
+	void		(*method)(void);
+
+	if (offset + sizeof(method) > engine->struct_size)
+		return false;
+
+	memcpy(&method, (const char *) engine + offset, sizeof(method));
+	return method != NULL;
+}
+
+DlErrCode
+RegisterMetaEngine(const IcebergMetaEngine *engine)
+{
+	int			i;
+	int			j;
+
+	if (engine == NULL)
+		return DL_ERR_INVALID_OPTION;
+	if (engine->abi_version != DL_META_ENGINE_ABI_VERSION)
+		return DL_ERR_INVALID_OPTION;
+	if (engine->struct_size < DL_META_ENGINE_V1_MIN_SIZE)
+		return DL_ERR_INVALID_OPTION;
+	if (engine->name == NULL)
+		return DL_ERR_INVALID_OPTION;
+
+	for (i = 0; i < n_engines; i++)
+	{
+		if (strcmp(engines[i]->name, engine->name) == 0)
+			return DL_ERR_ALREADY_EXISTS;
+	}
+	if (n_engines >= lengthof(engines))
+		return DL_ERR_INTERNAL;
+
+	for (i = 0; i < lengthof(capability_families); i++)
+	{
+		const DlCapabilityFamily *family = &capability_families[i];
+		bool				capability_set =
+			(engine->capabilities & family->bit) != 0;
+
+		for (j = 0; j < family->n; j++)
+		{
+			bool		method_is_nonnull =
+				meta_engine_method_is_nonnull(engine, family->offsets[j]);
+
+			if (capability_set != method_is_nonnull)
+			{
+				elog(WARNING,
+					 "datalake_fdw: meta engine \"%s\" has an invalid %s capability family",
+					 engine->name, family->family);
+				return DL_ERR_INVALID_OPTION;
+			}
+		}
+	}
+
+	/*
+	 * One engine per build, by design: nothing selects between implementations
+	 * at run time, so a second registration would silently decide which one
+	 * every table goes through, depending on registration order.
+	 */
+	if (n_engines > 0)
+		return DL_ERR_ALREADY_EXISTS;
+
+	engines[n_engines++] = engine;
+	return DL_OK;
+}
+
+const IcebergMetaEngine *
+get_meta_engine(void)
+{
+	/*
+	 * Exactly one engine is registered, by DatalakeRegisterMetaEngines(); the
+	 * array exists so that adding a second implementation later is a matter of
+	 * changing what gets registered, not of reworking the call sites.
+	 */
+	if (n_engines != 1)
+		elog(ERROR,
+			 "datalake_fdw: expected exactly one metadata engine, found %d",
+			 n_engines);
+
+	return engines[0];
+}
+
+/*
+ * What every dispatch wrapper does before reaching the engine: discard detail
+ * recorded by an earlier call, so that a later report can only describe this
+ * one, and refuse a method the engine does not advertise.
+ *
+ * The reset happens before the capability check on purpose.  A refusal produced
+ * here has no detail of its own, and leaving an earlier one in place would let
+ * it be reported as the cause.
+ */
+static DlErrCode
+meta_engine_enter(const IcebergMetaEngine *engine, uint64 capability)
+{
+	dl_error_reset();
+
+	if (engine == NULL)
+		return DL_ERR_INTERNAL;
+	if ((engine->capabilities & capability) == 0)
+		return DL_ERR_NOT_SUPPORTED;
+
+	return DL_OK;
+}
+
+DlErrCode
+meta_engine_create_table(const IcebergMetaEngine *engine, const MetaCtx *ctx,
+					 const MetaTableDef *def, MetaTable **out)
+{
+	DlErrCode	rc = meta_engine_enter(engine, DL_CAP_TABLE_LIFECYCLE);
+
+	if (rc != DL_OK)
+		return rc;
+	return engine->create_table(ctx, def, out);
+}
+
+DlErrCode
+meta_engine_drop_table(const IcebergMetaEngine *engine, const MetaCtx *ctx,
+				   bool purge)
+{
+	DlErrCode	rc = meta_engine_enter(engine, DL_CAP_TABLE_LIFECYCLE);
+
+	if (rc != DL_OK)
+		return rc;
+	return engine->drop_table(ctx, purge);
+}
+
+DlErrCode
+meta_engine_table_exists(const IcebergMetaEngine *engine, const MetaCtx *ctx,
+					 bool *exists)
+{
+	DlErrCode	rc = meta_engine_enter(engine, DL_CAP_TABLE_LIFECYCLE);
+
+	if (rc != DL_OK)
+		return rc;
+	return engine->table_exists(ctx, exists);
+}
+
+DlErrCode
+meta_engine_load_table(const IcebergMetaEngine *engine, const MetaCtx *ctx,
+				   MetaTable **out)
+{
+	DlErrCode	rc = meta_engine_enter(engine, DL_CAP_TABLE_LIFECYCLE);
+
+	if (rc != DL_OK)
+		return rc;
+	return engine->load_table(ctx, out);
+}
diff --git a/contrib/datalake_fdw/test/automation/Makefile b/contrib/datalake_fdw/test/automation/Makefile
new file mode 100644
index 00000000000..fcedd800c0b
--- /dev/null
+++ b/contrib/datalake_fdw/test/automation/Makefile
@@ -0,0 +1,52 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# contrib/datalake_fdw/test/automation/Makefile
+
+.PHONY: all test smoke-test check-services list-categories help clean
+
+all: test
+
+help:
+	@echo 'datalake_fdw automation tests'
+	@echo
+	@echo '  make test             run the smoke categories (default)'
+	@echo '  make smoke-test       same'
+	@echo '  make check-services   report which external services answer'
+	@echo '  make list-categories  list categories and what each one needs'
+	@echo '  make clean            remove run output'
+	@echo
+	@echo '  CATEGORIES="..."      run only these categories'
+	@echo
+	@echo 'Service addresses come from config/test_config.env, which reads them'
+	@echo 'from the environment first.  A category whose services are absent is'
+	@echo 'skipped and reported as skipped.'
+
+test: smoke-test
+
+smoke-test:
+	@bash scripts/test/run_smoke_tests.sh
+
+check-services:
+	@bash scripts/setup/check_services.sh
+
+list-categories:
+	@printf '%-16s %s\n' 'CATEGORY' 'REQUIRES'
+	@printf '%-16s %s\n' 'iceberg_am' '(nothing external)'
+
+clean:
+	rm -rf sqlrepo/smoke/*/results
diff --git a/contrib/datalake_fdw/test/automation/README.md b/contrib/datalake_fdw/test/automation/README.md
new file mode 100644
index 00000000000..f6586ed0e5c
--- /dev/null
+++ b/contrib/datalake_fdw/test/automation/README.md
@@ -0,0 +1,80 @@
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+# datalake_fdw automation tests
+
+Lake tables are only half local.  Once the metadata engine is connected, the
+behaviour worth testing is what happens against a real Hive metastore, real
+object storage and a real HDFS -- which comparison against a recorded transcript
+cannot express, because the interesting cases are the ones where an external
+service is slow, absent, or disagrees.  This directory is where those tests go,
+and it exists now so that they are added here rather than somewhere new.
+
+Everything currently here needs no external service.
+
+## Running
+
+```sh
+make test              # run the smoke categories
+make check-services    # what answers right now
+make list-categories   # categories, and what each one needs
+```
+
+Service addresses come from `config/test_config.env`, which takes them from the
+environment first, so a run against an existing deployment needs no edit:
+
+```sh
+DL_HMS_HOST=metastore.example DL_S3_ENDPOINT=http://minio:9000 make test
+```
+
+A category whose services are absent is **skipped and reported as skipped**, so
+a developer without a metastore still gets a useful run and nobody reads a skip
+as a pass.
+
+## Layout
+
+```
+config/                 service addresses and switches
+scripts/setup/          service probes
+scripts/test/           category runners
+scripts/utils/          shared shell helpers
+sqlrepo/smoke/          one directory per category
+  iceberg_am/           DDL, refusals and privileges -- no external service
+```
+
+`sqlrepo/smoke/iceberg_am` holds the cases pg_regress runs; the module's
+`Makefile` points `--inputdir` here, so `make installcheck` from the module
+directory and `make test` from this one run the same cases.  They live here
+rather than in a `sql/` directory of their own so that there is one place to look
+for test material.
+
+## What arrives with the metadata engine
+
+Named here so the shape is known before the code lands, rather than reserved as
+empty directories:
+
+- `docker/` -- compose definitions bringing up a metastore, MinIO and a
+  single-node HDFS, so a category can run anywhere
+- `prepare/` -- fixture loading per service: create the warehouse, the bucket,
+  the namespaces
+- `lib/` -- SQL and shell fragments shared by categories
+- `tools/` -- data generators for the volume and scale categories
+- `sqlrepo/smoke/iceberg_hive`, `iceberg_s3`, `iceberg_hdfs` -- the read and
+  write paths against each service
+- `sqlrepo/feature`, `sqlrepo/negative` -- everything past the smoke level
diff --git a/contrib/datalake_fdw/test/automation/config/test_config.env b/contrib/datalake_fdw/test/automation/config/test_config.env
new file mode 100644
index 00000000000..1389becc489
--- /dev/null
+++ b/contrib/datalake_fdw/test/automation/config/test_config.env
@@ -0,0 +1,39 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# Where the external services live.  Overridden from the environment, so a run
+# against an existing deployment needs no edit here.
+#
+# Nothing in the smoke suite needs any of these yet: the categories that do
+# arrive with the metadata engine.  They are named now because the runner
+# already decides what to skip from them.
+
+# Hive metastore, for catalog type "hive".
+DL_HMS_HOST="${DL_HMS_HOST:-localhost}"
+DL_HMS_PORT="${DL_HMS_PORT:-9083}"
+
+# S3-compatible object storage, for volumes with an s3:// base path.
+DL_S3_ENDPOINT="${DL_S3_ENDPOINT:-http://localhost:9000}"
+DL_S3_BUCKET="${DL_S3_BUCKET:-datalake-test}"
+DL_S3_REGION="${DL_S3_REGION:-us-east-1}"
+
+# HDFS namenode, for volumes with an hdfs:// base path.
+DL_HDFS_HOST="${DL_HDFS_HOST:-localhost}"
+DL_HDFS_PORT="${DL_HDFS_PORT:-8020}"
+
+# How long a service probe waits before calling the service absent.
+DL_PROBE_TIMEOUT="${DL_PROBE_TIMEOUT:-3}"
diff --git a/contrib/datalake_fdw/test/automation/scripts/setup/check_services.sh b/contrib/datalake_fdw/test/automation/scripts/setup/check_services.sh
new file mode 100755
index 00000000000..dc300d9dc45
--- /dev/null
+++ b/contrib/datalake_fdw/test/automation/scripts/setup/check_services.sh
@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# Report which external services are reachable.
+#
+# Informational on purpose: it exits 0 whether or not anything answered, because
+# its output decides which categories the runner skips, and a missing service is
+# a reason to skip a category rather than to fail a run.
+
+set -u
+
+script_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=../utils/common_functions.sh
+. "$script_dir/../utils/common_functions.sh"
+
+dl_load_config
+
+report()
+{
+	local name="$1" where="$2" state="$3"
+
+	printf '%-16s %-32s %s\n' "$name" "$where" "$state"
+}
+
+printf '%-16s %-32s %s\n' 'SERVICE' 'ADDRESS' 'STATE'
+
+if dl_tcp_is_open "$DL_HMS_HOST" "$DL_HMS_PORT" "$DL_PROBE_TIMEOUT"; then
+	report 'hive-metastore' "$DL_HMS_HOST:$DL_HMS_PORT" 'available'
+else
+	report 'hive-metastore' "$DL_HMS_HOST:$DL_HMS_PORT" 'absent'
+fi
+
+if dl_http_is_open "$DL_S3_ENDPOINT" "$DL_PROBE_TIMEOUT"; then
+	report 's3' "$DL_S3_ENDPOINT" 'available'
+else
+	report 's3' "$DL_S3_ENDPOINT" 'absent'
+fi
+
+if dl_tcp_is_open "$DL_HDFS_HOST" "$DL_HDFS_PORT" "$DL_PROBE_TIMEOUT"; then
+	report 'hdfs' "$DL_HDFS_HOST:$DL_HDFS_PORT" 'available'
+else
+	report 'hdfs' "$DL_HDFS_HOST:$DL_HDFS_PORT" 'absent'
+fi
+
+exit 0
diff --git a/contrib/datalake_fdw/test/automation/scripts/test/run_smoke_tests.sh b/contrib/datalake_fdw/test/automation/scripts/test/run_smoke_tests.sh
new file mode 100755
index 00000000000..ce707a1fed3
--- /dev/null
+++ b/contrib/datalake_fdw/test/automation/scripts/test/run_smoke_tests.sh
@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# Run the smoke categories under sqlrepo/smoke.
+#
+# A category names its required services in REQUIRED_SERVICES below.  One with
+# none is always run; one whose services are absent is skipped and reported as
+# skipped, so a developer without a Hive metastore still gets a useful run and
+# nobody mistakes a skip for a pass.
+
+set -u -o pipefail
+
+script_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=../utils/common_functions.sh
+. "$script_dir/../utils/common_functions.sh"
+
+automation_dir="$(dl_automation_dir)"
+module_dir="$(cd -- "$automation_dir/../.." && pwd)"
+
+dl_load_config
+
+# category:services   -- an empty service list means "no external dependency"
+CATEGORY_SERVICES="
+iceberg_am:
+"
+
+categories="${CATEGORIES:-iceberg_am}"
+
+services_for()
+{
+	local category="$1" line
+
+	while read -r line; do
+		[ -n "$line" ] || continue
+		case "$line" in
+			"$category":*) printf '%s' "${line#*:}"; return 0 ;;
+		esac
+	done <<-EOF
+	$CATEGORY_SERVICES
+	EOF
+
+	printf 'unknown'
+}
+
+service_is_available()
+{
+	case "$1" in
+		hive-metastore)
+			dl_tcp_is_open "$DL_HMS_HOST" "$DL_HMS_PORT" "$DL_PROBE_TIMEOUT" ;;
+		s3)
+			dl_http_is_open "$DL_S3_ENDPOINT" "$DL_PROBE_TIMEOUT" ;;
+		hdfs)
+			dl_tcp_is_open "$DL_HDFS_HOST" "$DL_HDFS_PORT" "$DL_PROBE_TIMEOUT" ;;
+		*)
+			return 1 ;;
+	esac
+}
+
+run_iceberg_am()
+{
+	# These cases are expected-output cases, so pg_regress runs them; the module
+	# Makefile already points it at sqlrepo/smoke/iceberg_am.
+	make -C "$module_dir" USE_PGXS=1 installcheck
+}
+
+failed=0
+skipped=0
+ran=0
+
+for category in $categories; do
+	required="$(services_for "$category")"
+
+	if [ "$required" = 'unknown' ]; then
+		dl_warn "unknown category \"$category\""
+		failed=$((failed + 1))
+		continue
+	fi
+
+	missing=''
+	for service in $required; do
+		service_is_available "$service" || missing="$missing $service"
+	done
+
+	if [ -n "$missing" ]; then
+		dl_info "SKIP $category (absent:$missing)"
+		skipped=$((skipped + 1))
+		continue
+	fi
+
+	dl_info "RUN  $category"
+	case "$category" in
+		iceberg_am) run_iceberg_am ;;
+		*) dl_warn "category \"$category\" has no runner"; false ;;
+	esac
+
+	if [ $? -eq 0 ]; then
+		ran=$((ran + 1))
+	else
+		dl_warn "FAIL $category"
+		failed=$((failed + 1))
+	fi
+done
+
+dl_info "passed=$ran skipped=$skipped failed=$failed"
+[ "$failed" -eq 0 ]
diff --git a/contrib/datalake_fdw/test/automation/scripts/utils/common_functions.sh b/contrib/datalake_fdw/test/automation/scripts/utils/common_functions.sh
new file mode 100644
index 00000000000..3a9d92298e1
--- /dev/null
+++ b/contrib/datalake_fdw/test/automation/scripts/utils/common_functions.sh
@@ -0,0 +1,100 @@
+#!/usr/bin/env bash
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# Shared helpers.  Sourced, never executed.
+
+# Absolute path of the automation directory, whichever directory the caller
+# started from.
+dl_automation_dir()
+{
+	local here
+	here="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+	cd -- "$here/../.." && pwd
+}
+
+dl_load_config()
+{
+	local automation_dir
+	automation_dir="$(dl_automation_dir)"
+
+	# shellcheck source=../../config/test_config.env
+	. "$automation_dir/config/test_config.env"
+}
+
+dl_info()
+{
+	printf '[automation] %s\n' "$*"
+}
+
+dl_warn()
+{
+	printf '[automation] %s\n' "$*" >&2
+}
+
+dl_die()
+{
+	dl_warn "$*"
+	exit 1
+}
+
+# Name of a working timeout command, or empty when there is none.  macOS ships
+# neither; coreutils installs it as gtimeout.
+dl_timeout_command()
+{
+	local candidate
+
+	for candidate in timeout gtimeout; do
+		if command -v "$candidate" >/dev/null 2>&1; then
+			printf '%s' "$candidate"
+			return 0
+		fi
+	done
+
+	return 1
+}
+
+# True when something is listening on host:port.  Uses bash's own /dev/tcp so
+# that a probe needs no tool that might not be installed.
+#
+# Host and port are passed as arguments rather than interpolated into the
+# program text: they come from the environment, and a shell metacharacter in one
+# would otherwise be executed.  Being unable to probe is reported as a harness
+# failure, not as "service absent" -- silently skipping a category because a
+# tool is missing is how a suite stops testing anything without saying so.
+dl_tcp_is_open()
+{
+	local host="$1" port="$2" seconds="${3:-3}" timeout_cmd
+
+	if ! timeout_cmd="$(dl_timeout_command)"; then
+		dl_die "no timeout command found (install coreutils for gtimeout)"
+	fi
+
+	"$timeout_cmd" "$seconds" bash -c \
+		'exec 3<>/dev/tcp/"$1"/"$2"' _ "$host" "$port" 2>/dev/null
+}
+
+# True when an HTTP endpoint answers at all; any status counts, because a probe
+# asks whether the service is there, not whether a request would succeed.
+dl_http_is_open()
+{
+	local url="$1" timeout="${2:-3}"
+
+	command -v curl >/dev/null 2>&1 || return 1
+	curl --silent --show-error --output /dev/null \
+		 --max-time "$timeout" "$url" 2>/dev/null
+}
diff --git a/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/expected/iceberg_am_acl.out b/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/expected/iceberg_am_acl.out
new file mode 100644
index 00000000000..c03534b1ca3
--- /dev/null
+++ b/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/expected/iceberg_am_acl.out
@@ -0,0 +1,75 @@
+-- Foreign-server USAGE is required; user mappings remain optional.
+SET client_min_messages = warning;
+RESET ROLE;
+DROP SCHEMA IF EXISTS dlskel_s CASCADE;
+DROP SERVER IF EXISTS dlskel_acl_cat CASCADE;
+DROP SERVER IF EXISTS dlskel_acl_vol CASCADE;
+DROP ROLE IF EXISTS dlskel_user;
+RESET client_min_messages;
+-- Quiet, so that the output does not depend on whether another test in the
+-- same database created the extension first.
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS datalake_fdw;
+RESET client_min_messages;
+CREATE SERVER dlskel_acl_cat
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083');
+CREATE SERVER dlskel_acl_vol
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://dlskel-bucket/acl',
+           endpoint 'http://fake:9000');
+-- Which NOTICE CREATE ROLE emits depends on gp_resource_manager, and neither
+-- is what this case is about.
+SET client_min_messages = warning;
+CREATE ROLE dlskel_user LOGIN;
+RESET client_min_messages;
+CREATE SCHEMA dlskel_s;
+GRANT CREATE, USAGE ON SCHEMA dlskel_s TO dlskel_user;
+SET ROLE dlskel_user;
+CREATE TABLE dlskel_s.t (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_acl_cat', volume = 'dlskel_acl_vol');
+ERROR:  permission denied for foreign server dlskel_acl_cat
+RESET ROLE;
+GRANT USAGE ON FOREIGN SERVER dlskel_acl_cat TO dlskel_user;
+SET ROLE dlskel_user;
+CREATE TABLE dlskel_s.t (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_acl_cat', volume = 'dlskel_acl_vol');
+ERROR:  permission denied for foreign server dlskel_acl_vol
+RESET ROLE;
+GRANT USAGE ON FOREIGN SERVER dlskel_acl_vol TO dlskel_user;
+SET ROLE dlskel_user;
+CREATE TABLE dlskel_s.t (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_acl_cat', volume = 'dlskel_acl_vol');
+NOTICE:  stub engine: created iceberg table "dlskel_s.t" in catalog "dlskel_acl_cat"
+CREATE USER MAPPING FOR dlskel_user
+  SERVER dlskel_acl_cat
+  OPTIONS (username 'u', auth_method 'simple');
+-- AWS temporary credentials are three values; the mapping has to be able to
+-- hold all of them.
+CREATE USER MAPPING FOR dlskel_user
+  SERVER dlskel_acl_vol
+  OPTIONS (access_key_id 'k', secret_access_key 's', session_token 't');
+-- A server-side key is not a user mapping key.
+ALTER USER MAPPING FOR dlskel_user
+  SERVER dlskel_acl_cat
+  OPTIONS (ADD warehouse 'x');
+ERROR:  invalid iceberg catalog user mapping option "warehouse"
+RESET ROLE;
+DROP SCHEMA dlskel_s CASCADE;
+NOTICE:  drop cascades to table dlskel_s.t
+NOTICE:  stub engine: dropped iceberg table "dlskel_s.t" from catalog "dlskel_acl_cat", keeping data
+DROP USER MAPPING FOR dlskel_user SERVER dlskel_acl_cat;
+DROP USER MAPPING FOR dlskel_user SERVER dlskel_acl_vol;
+DROP SERVER dlskel_acl_cat;
+DROP SERVER dlskel_acl_vol;
+DROP ROLE dlskel_user;
+SET client_min_messages = warning;
+RESET ROLE;
+DROP SCHEMA IF EXISTS dlskel_s CASCADE;
+DROP SERVER IF EXISTS dlskel_acl_cat CASCADE;
+DROP SERVER IF EXISTS dlskel_acl_vol CASCADE;
+DROP ROLE IF EXISTS dlskel_user;
+RESET client_min_messages;
diff --git a/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/expected/iceberg_am_ddl.out b/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/expected/iceberg_am_ddl.out
new file mode 100644
index 00000000000..eb61b4a08b0
--- /dev/null
+++ b/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/expected/iceberg_am_ddl.out
@@ -0,0 +1,227 @@
+-- Happy-path DDL, binding persistence, distributed catalog state, and drops.
+SET client_min_messages = warning;
+DROP TABLE IF EXISTS dlskel_t, dlskel_t2, dlskel_t3, dlskel_t_dump,
+  dlskel_t_keep, dlskel_t_purge CASCADE;
+DROP SERVER IF EXISTS dlskel_cat CASCADE;
+DROP SERVER IF EXISTS dlskel_cat_rest CASCADE;
+DROP SERVER IF EXISTS dlskel_vol CASCADE;
+RESET client_min_messages;
+-- Quiet, so that the output does not depend on whether another test in the
+-- same database created the extension first.
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS datalake_fdw;
+RESET client_min_messages;
+CREATE SERVER dlskel_cat
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083');
+CREATE SERVER dlskel_cat_rest
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'rest', uri 'https://fake:443');
+DROP SERVER dlskel_cat_rest;
+CREATE SERVER dlskel_vol
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://dlskel-bucket/prefix',
+           endpoint 'http://fake:9000');
+CREATE TABLE dlskel_t (a int, b text)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+NOTICE:  stub engine: created iceberg table "public.dlskel_t" in catalog "dlskel_cat"
+SELECT relname, amname, reloptions
+FROM pg_class c
+JOIN pg_am a ON a.oid = c.relam
+WHERE relname = 'dlskel_t';
+ relname  | amname  |               reloptions               
+----------+---------+----------------------------------------
+ dlskel_t | iceberg | {catalog=dlskel_cat,volume=dlskel_vol}
+(1 row)
+
+SELECT policytype, distkey
+FROM gp_distribution_policy
+WHERE localoid = 'dlskel_t'::regclass;
+ policytype | distkey 
+------------+---------
+ p          | 
+(1 row)
+
+-- Exactly one pg_class row on each primary segment.  Counting rows in total
+-- would accept one segment missing its row as long as another had two, which is
+-- the very divergence this is here to catch; so compare the set of segments that
+-- have exactly one row against the set of primaries.
+SELECT count(*) = 0 AS every_segment_has_exactly_one
+FROM (SELECT content FROM gp_segment_configuration
+      WHERE content >= 0 AND role = 'p'
+      EXCEPT
+      SELECT gp_segment_id FROM gp_dist_random('pg_class')
+      WHERE relname = 'dlskel_t'
+      GROUP BY gp_segment_id HAVING count(*) = 1) missing_or_duplicated;
+ every_segment_has_exactly_one 
+-------------------------------
+ t
+(1 row)
+
+SELECT oid AS dlskel_cat_oid
+FROM pg_foreign_server
+WHERE srvname = 'dlskel_cat'
+\gset
+SELECT oid AS dlskel_vol_oid
+FROM pg_foreign_server
+WHERE srvname = 'dlskel_vol'
+\gset
+SELECT 'dlskel_t'::regclass::oid AS dlskel_t_oid
+\gset
+SELECT b.binding,
+       NOT EXISTS (SELECT content FROM gp_segment_configuration
+                   WHERE content >= 0 AND role = 'p'
+                   EXCEPT
+                   SELECT gp_segment_id FROM gp_dist_random('pg_depend')
+                   WHERE classid = 'pg_class'::regclass
+                     AND objid = :dlskel_t_oid
+                     AND refclassid = 'pg_foreign_server'::regclass
+                     AND refobjid = b.refobjid
+                   GROUP BY gp_segment_id HAVING count(*) = 1)
+       AS every_segment_has_exactly_one
+FROM (VALUES ('catalog', :dlskel_cat_oid::oid),
+             ('volume', :dlskel_vol_oid::oid)) AS b(binding, refobjid)
+ORDER BY b.binding;
+ binding | every_segment_has_exactly_one 
+---------+-------------------------------
+ catalog | t
+ volume  | t
+(2 rows)
+
+ANALYZE dlskel_t;
+VACUUM dlskel_t;
+SELECT reltuples IN (-1, 0) AS no_local_stats
+FROM pg_class
+WHERE oid = 'dlskel_t'::regclass;
+ no_local_stats 
+----------------
+ t
+(1 row)
+
+-- pg_dump writes DISTRIBUTED RANDOMLY into the CREATE TABLE it emits, so this
+-- is the statement a restore replays; refusing it would mean refusing to
+-- restore a dump this module produced.  It has to yield the same policy as the
+-- clause the module injects on its own.
+CREATE TABLE dlskel_t_dump (a int, b text)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol')
+  DISTRIBUTED RANDOMLY;
+NOTICE:  stub engine: created iceberg table "public.dlskel_t_dump" in catalog "dlskel_cat"
+SELECT policytype, distkey
+FROM gp_distribution_policy
+WHERE localoid = 'dlskel_t_dump'::regclass;
+ policytype | distkey 
+------------+---------
+ p          | 
+(1 row)
+
+DROP TABLE dlskel_t_dump;
+NOTICE:  stub engine: dropped iceberg table "public.dlskel_t_dump" from catalog "dlskel_cat", keeping data
+-- Dropping the table drops this database's reference to it; the lake data stays
+-- unless the table said otherwise.  The default and the explicit form both have
+-- to be observable, which is why the stub reports which one it was asked for.
+CREATE TABLE dlskel_t_keep (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+NOTICE:  stub engine: created iceberg table "public.dlskel_t_keep" in catalog "dlskel_cat"
+DROP TABLE dlskel_t_keep;
+NOTICE:  stub engine: dropped iceberg table "public.dlskel_t_keep" from catalog "dlskel_cat", keeping data
+CREATE TABLE dlskel_t_purge (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol',
+        purge_on_drop = true);
+NOTICE:  stub engine: created iceberg table "public.dlskel_t_purge" in catalog "dlskel_cat"
+SELECT reloptions FROM pg_class WHERE relname = 'dlskel_t_purge';
+                        reloptions                         
+-----------------------------------------------------------
+ {catalog=dlskel_cat,volume=dlskel_vol,purge_on_drop=true}
+(1 row)
+
+DROP TABLE dlskel_t_purge;
+NOTICE:  stub engine: dropped iceberg table "public.dlskel_t_purge" from catalog "dlskel_cat", purging data
+SET iceberg.default_catalog = 'dlskel_cat';
+SET iceberg.default_volume = 'dlskel_vol';
+CREATE TABLE dlskel_t2 (a int) USING iceberg;
+NOTICE:  stub engine: created iceberg table "public.dlskel_t2" in catalog "dlskel_cat"
+SELECT relname, amname, reloptions
+FROM pg_class c
+JOIN pg_am a ON a.oid = c.relam
+WHERE relname = 'dlskel_t2';
+  relname  | amname  |               reloptions               
+-----------+---------+----------------------------------------
+ dlskel_t2 | iceberg | {catalog=dlskel_cat,volume=dlskel_vol}
+(1 row)
+
+RESET iceberg.default_catalog;
+RESET iceberg.default_volume;
+SET default_table_access_method = iceberg;
+SET iceberg.default_catalog = 'dlskel_cat';
+SET iceberg.default_volume = 'dlskel_vol';
+CREATE TABLE dlskel_t3 (a int);
+NOTICE:  stub engine: created iceberg table "public.dlskel_t3" in catalog "dlskel_cat"
+\set HIDE_TABLEAM off
+\d+ dlskel_t3
+                                 Table "public.dlskel_t3"
+ Column |  Type   | Collation | Nullable | Default | Storage | Stats target | Description 
+--------+---------+-----------+----------+---------+---------+--------------+-------------
+ a      | integer |           |          |         | plain   |              | 
+Distributed randomly
+Access method: iceberg
+Options: catalog=dlskel_cat, volume=dlskel_vol
+
+RESET default_table_access_method;
+RESET iceberg.default_catalog;
+RESET iceberg.default_volume;
+DROP SERVER dlskel_cat;
+ERROR:  cannot drop server dlskel_cat because other objects depend on it
+DETAIL:  table dlskel_t depends on server dlskel_cat
+table dlskel_t2 depends on server dlskel_cat
+table dlskel_t3 depends on server dlskel_cat
+HINT:  Use DROP ... CASCADE to drop the dependent objects too.
+DROP SERVER dlskel_vol;
+ERROR:  cannot drop server dlskel_vol because other objects depend on it
+DETAIL:  table dlskel_t depends on server dlskel_vol
+table dlskel_t2 depends on server dlskel_vol
+table dlskel_t3 depends on server dlskel_vol
+HINT:  Use DROP ... CASCADE to drop the dependent objects too.
+DROP TABLE dlskel_t;
+NOTICE:  stub engine: dropped iceberg table "public.dlskel_t" from catalog "dlskel_cat", keeping data
+SELECT b.binding,
+       NOT EXISTS (SELECT 1 FROM gp_dist_random('pg_depend')
+                   WHERE classid = 'pg_class'::regclass
+                     AND objid = :dlskel_t_oid
+                     AND refclassid = 'pg_foreign_server'::regclass
+                     AND refobjid = b.refobjid)
+       AS gone_from_every_segment
+FROM (VALUES ('catalog', :dlskel_cat_oid::oid),
+             ('volume', :dlskel_vol_oid::oid)) AS b(binding, refobjid)
+ORDER BY b.binding;
+ binding | gone_from_every_segment 
+---------+-------------------------
+ catalog | t
+ volume  | t
+(2 rows)
+
+DROP SERVER dlskel_cat CASCADE;
+NOTICE:  drop cascades to 2 other objects
+DETAIL:  drop cascades to table dlskel_t2
+drop cascades to table dlskel_t3
+NOTICE:  stub engine: dropped iceberg table "public.dlskel_t3" from catalog "dlskel_cat", keeping data
+NOTICE:  stub engine: dropped iceberg table "public.dlskel_t2" from catalog "dlskel_cat", keeping data
+DROP SERVER dlskel_vol CASCADE;
+SELECT gp_segment_id, relname
+FROM gp_dist_random('pg_class')
+WHERE relname LIKE 'dlskel\_%' ESCAPE '\'
+ORDER BY 1, 2;
+ gp_segment_id | relname 
+---------------+---------
+(0 rows)
+
+SET client_min_messages = warning;
+DROP TABLE IF EXISTS dlskel_t, dlskel_t2, dlskel_t3, dlskel_t_dump,
+  dlskel_t_keep, dlskel_t_purge CASCADE;
+DROP SERVER IF EXISTS dlskel_cat CASCADE;
+DROP SERVER IF EXISTS dlskel_cat_rest CASCADE;
+DROP SERVER IF EXISTS dlskel_vol CASCADE;
+RESET client_min_messages;
diff --git a/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/expected/iceberg_am_reject.out b/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/expected/iceberg_am_reject.out
new file mode 100644
index 00000000000..db5fde07cf4
--- /dev/null
+++ b/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/expected/iceberg_am_reject.out
@@ -0,0 +1,457 @@
+-- Unsupported data paths, CREATE/ALTER guards, and binding validators.
+-- Errors raised on a segment carry its address and pid, which vary per run.
+-- start_matchsubs
+-- m/  \(seg[0-9]+[^)]* pid=[0-9]+\)/
+-- s/  \(seg[0-9]+[^)]* pid=[0-9]+\)//
+-- end_matchsubs
+SET client_min_messages = warning;
+DROP MATERIALIZED VIEW IF EXISTS dlskel_mv CASCADE;
+DROP TABLE IF EXISTS
+  dlskel_r, dlskel_r2, dlskel_bad, dlskel_bad_dist,
+  dlskel_bad_part, dlskel_bad_inherits, dlskel_bad_typed,
+  dlskel_bad_temp, dlskel_bad_unlogged, dlskel_bad_oncommit,
+  dlskel_bad_tablespace, dlskel_bad_missing_server,
+  dlskel_bad_wrong_catalog, dlskel_bad_no_catalog,
+  dlskel_bad_reloption, dlskel_bad_engine, dlskel_r_new, dlskel_heap,
+  dlskel_bad_repl, dlskel_bad_purge
+  CASCADE;
+DROP SERVER IF EXISTS dlskel_cat CASCADE;
+DROP SERVER IF EXISTS dlskel_cat2 CASCADE;
+DROP SERVER IF EXISTS dlskel_vol CASCADE;
+DROP SERVER IF EXISTS dlskel_free CASCADE;
+DROP SERVER IF EXISTS dlskel_free2 CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_server CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_secret CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_secret CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_token CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_user CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_keytab CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_clientid CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_keyid CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_secret CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_token CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_case CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_type CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_hadoop CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_builtin CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_nourl CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_realm CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_empty CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_bool CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_nopath CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_scheme CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_authority CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_query CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_userinfo CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_bucket CASCADE;
+DROP SCHEMA IF EXISTS dlskel_sch CASCADE;
+DROP SCHEMA IF EXISTS dlskel_sch2 CASCADE;
+DROP SCHEMA IF EXISTS dlskel_plain CASCADE;
+DROP SCHEMA IF EXISTS dlskel_plain2 CASCADE;
+DROP TYPE IF EXISTS dlskel_type CASCADE;
+DROP ROLE IF EXISTS dlskel_role;
+RESET client_min_messages;
+-- Quiet, so that the output does not depend on whether another test in the
+-- same database created the extension first.
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS datalake_fdw;
+RESET client_min_messages;
+CREATE SERVER dlskel_cat
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083');
+CREATE SERVER dlskel_vol
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://dlskel-bucket/reject',
+           endpoint 'http://fake:9000');
+CREATE SERVER dlskel_free
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://free:9083');
+-- Which NOTICE CREATE ROLE emits depends on gp_resource_manager, and neither
+-- is what this case is about.
+SET client_min_messages = warning;
+CREATE ROLE dlskel_role;
+RESET client_min_messages;
+CREATE TYPE dlskel_type AS (a int);
+CREATE TABLE dlskel_r (a int, b text)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+NOTICE:  stub engine: created iceberg table "public.dlskel_r" in catalog "dlskel_cat"
+SELECT * FROM dlskel_r;
+ERROR:  iceberg: SELECT is not supported yet  (seg0 slice1 172.17.0.2:40000 pid=92001)
+INSERT INTO dlskel_r VALUES (1, 'x');
+ERROR:  iceberg: INSERT is not supported yet  (seg1 172.17.0.2:40001 pid=92002)
+UPDATE dlskel_r SET a = 1;
+ERROR:  iceberg: SELECT is not supported yet  (seg0 172.17.0.2:40000 pid=92001)
+DELETE FROM dlskel_r;
+ERROR:  iceberg: SELECT is not supported yet  (seg0 172.17.0.2:40000 pid=92001)
+COPY dlskel_r FROM stdin;
+ERROR:  iceberg: INSERT is not supported yet
+CONTEXT:  COPY dlskel_r, line 1
+COPY dlskel_r TO stdout;
+ERROR:  iceberg: SELECT is not supported yet
+CREATE INDEX ON dlskel_r (a);
+ERROR:  iceberg: CREATE INDEX is not supported yet
+SELECT * FROM dlskel_r TABLESAMPLE BERNOULLI (10);
+ERROR:  iceberg: SELECT is not supported yet  (seg0 slice1 172.17.0.2:40000 pid=92001)
+-- A table from an earlier transaction takes the new-filelocator path rather
+-- than the access method's truncate callback, so this is the case that would
+-- silently report success if only the callback rejected it.
+TRUNCATE dlskel_r;
+ERROR:  iceberg: TRUNCATE is not supported yet
+-- Same for a table created in this transaction, which does reach the callback.
+BEGIN;
+CREATE TABLE dlskel_r_new (a int, b text)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+NOTICE:  stub engine: created iceberg table "public.dlskel_r_new" in catalog "dlskel_cat"
+TRUNCATE dlskel_r_new;
+ERROR:  iceberg: TRUNCATE is not supported yet
+ROLLBACK;
+-- A multi-table TRUNCATE must refuse before truncating the heap beside it, so
+-- the row below has to survive the attempt.
+CREATE TABLE dlskel_heap (a int) DISTRIBUTED BY (a);
+INSERT INTO dlskel_heap VALUES (1);
+TRUNCATE dlskel_heap, dlskel_r;
+ERROR:  iceberg: TRUNCATE is not supported yet
+SELECT count(*) AS heap_rows_kept FROM dlskel_heap;
+ heap_rows_kept 
+----------------
+              1
+(1 row)
+
+VACUUM FULL dlskel_r;
+ERROR:  iceberg: VACUUM FULL on iceberg tables is not supported yet
+SELECT * FROM dlskel_r FOR UPDATE;
+ERROR:  iceberg: SELECT is not supported yet  (seg0 slice1 172.17.0.2:40000 pid=92001)
+CREATE TABLE dlskel_bad_dist (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol')
+  DISTRIBUTED BY (a);
+ERROR:  iceberg: DISTRIBUTED BY is not supported yet
+CREATE TABLE dlskel_bad_part (a int)
+  PARTITION BY RANGE (a)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+ERROR:  iceberg: partitioned tables is not supported yet
+CREATE TABLE dlskel_bad_inherits (b text)
+  INHERITS (dlskel_r)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+ERROR:  iceberg: INHERITS is not supported yet
+CREATE TABLE dlskel_bad_typed OF dlskel_type
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+ERROR:  iceberg: typed tables (OF type) is not supported yet
+CREATE TEMP TABLE dlskel_bad_temp (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+ERROR:  iceberg: TEMP tables is not supported yet
+CREATE UNLOGGED TABLE dlskel_bad_unlogged (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+ERROR:  iceberg: UNLOGGED tables is not supported yet
+BEGIN;
+CREATE TABLE dlskel_bad_oncommit (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol')
+  ON COMMIT DROP;
+ERROR:  iceberg: ON COMMIT is not supported yet
+ROLLBACK;
+CREATE TABLE dlskel_bad_tablespace (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol')
+  TABLESPACE pg_default;
+ERROR:  iceberg: TABLESPACE is not supported yet
+CREATE TABLE dlskel_bad USING iceberg AS SELECT 1;
+ERROR:  iceberg: CREATE TABLE AS / CREATE MATERIALIZED VIEW is not supported yet
+CREATE MATERIALIZED VIEW dlskel_mv USING iceberg AS SELECT 1;
+ERROR:  iceberg: CREATE TABLE AS / CREATE MATERIALIZED VIEW is not supported yet
+-- Converting a heap into a lake table has to be refused too: the relation is
+-- still a heap when the statement arrives, so the guard above does not see it.
+ALTER TABLE dlskel_heap SET ACCESS METHOD iceberg;
+ERROR:  iceberg: ALTER TABLE ... SET ACCESS METHOD iceberg is not supported yet
+SET iceberg.default_catalog = 'dlskel_cat';
+SET iceberg.default_volume = 'dlskel_vol';
+ALTER TABLE dlskel_heap SET ACCESS METHOD iceberg;
+ERROR:  iceberg: ALTER TABLE ... SET ACCESS METHOD iceberg is not supported yet
+RESET iceberg.default_catalog;
+RESET iceberg.default_volume;
+-- A column-bearing clause still cannot be honoured, and neither can a
+-- replicated policy.
+CREATE TABLE dlskel_bad_repl (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol')
+  DISTRIBUTED REPLICATED;
+ERROR:  iceberg: DISTRIBUTED REPLICATED is not supported yet
+-- Renaming a schema would repoint its lake tables at a different external
+-- namespace, so a schema holding one is refused -- and, just as importantly, a
+-- schema holding none is not: the guard has to be no wider than the problem.
+CREATE SCHEMA dlskel_sch;
+CREATE TABLE dlskel_sch.t (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+NOTICE:  stub engine: created iceberg table "dlskel_sch.t" in catalog "dlskel_cat"
+BEGIN;
+ALTER SCHEMA dlskel_sch RENAME TO dlskel_sch2;
+ERROR:  iceberg: RENAME on schemas containing iceberg tables is not supported yet
+ROLLBACK;
+CREATE SCHEMA dlskel_plain;
+ALTER SCHEMA dlskel_plain RENAME TO dlskel_plain2;
+DROP SCHEMA dlskel_plain2;
+-- Renaming a wrapper breaks every mapping lookup at once, including the one
+-- DROP needs, so it is refused whether or not a table exists yet.
+-- Each attempt is rolled back: if the guard ever regresses, an accepted rename
+-- would leave the extension's own wrapper under a different name, which nothing
+-- in the cleanup below can undo and which breaks every later run.
+BEGIN;
+ALTER FOREIGN DATA WRAPPER iceberg_catalog_fdw RENAME TO dlskel_other_fdw;
+ERROR:  iceberg: RENAME on the iceberg foreign-data wrappers is not supported yet
+ROLLBACK;
+BEGIN;
+ALTER FOREIGN DATA WRAPPER iceberg_volume_fdw RENAME TO dlskel_other_fdw;
+ERROR:  iceberg: RENAME on the iceberg foreign-data wrappers is not supported yet
+ROLLBACK;
+ALTER TABLE dlskel_r ADD COLUMN c int;
+ERROR:  iceberg: ALTER TABLE on iceberg tables is not supported yet
+ALTER TABLE dlskel_r SET (fillfactor = 90);
+ERROR:  iceberg: ALTER TABLE on iceberg tables is not supported yet
+ALTER TABLE dlskel_r SET ACCESS METHOD heap;
+ERROR:  iceberg: ALTER TABLE on iceberg tables is not supported yet
+ALTER TABLE dlskel_r SET DISTRIBUTED BY (a);
+ERROR:  iceberg: ALTER TABLE on iceberg tables is not supported yet
+ALTER TABLE dlskel_r RENAME TO dlskel_r2;
+ERROR:  iceberg: RENAME on iceberg tables is not supported yet
+ALTER TABLE dlskel_r RENAME COLUMN a TO aa;
+ERROR:  iceberg: RENAME on iceberg tables is not supported yet
+ALTER TABLE dlskel_r SET SCHEMA public;
+ERROR:  iceberg: SET SCHEMA on iceberg tables is not supported yet
+-- OWNER TO is the one ALTER TABLE form that goes through: pg_dump writes it for
+-- every table, and ownership cannot reach the external table.  Put it back
+-- afterwards so the rest of the file still owns what it created.
+ALTER TABLE dlskel_r OWNER TO dlskel_role;
+SELECT relname, pg_get_userbyid(relowner) AS owner
+FROM pg_class WHERE relname = 'dlskel_r';
+ relname  |    owner    
+----------+-------------
+ dlskel_r | dlskel_role
+(1 row)
+
+ALTER TABLE dlskel_r OWNER TO CURRENT_USER;
+ALTER SERVER dlskel_cat
+  OPTIONS (SET uri 'thrift://other:9083');
+ERROR:  iceberg: ALTER SERVER on servers referenced by iceberg tables is not supported yet
+ALTER SERVER dlskel_cat VERSION '2';
+ERROR:  iceberg: ALTER SERVER on servers referenced by iceberg tables is not supported yet
+ALTER SERVER dlskel_cat RENAME TO dlskel_cat2;
+ERROR:  iceberg: RENAME on servers referenced by iceberg tables is not supported yet
+ALTER SERVER dlskel_cat OWNER TO dlskel_role;
+ERROR:  iceberg: ALTER OWNER on servers referenced by iceberg tables is not supported yet
+ALTER SERVER dlskel_free
+  OPTIONS (SET uri 'thrift://other:9083');
+ALTER SERVER dlskel_free VERSION '2';
+ALTER SERVER dlskel_free OWNER TO dlskel_role;
+ALTER SERVER dlskel_free RENAME TO dlskel_free2;
+RESET iceberg.default_catalog;
+RESET iceberg.default_volume;
+CREATE TABLE dlskel_bad_missing_server (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_missing', volume = 'dlskel_vol');
+ERROR:  server "dlskel_missing" does not exist
+CREATE TABLE dlskel_bad_wrong_catalog (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_vol', volume = 'dlskel_vol');
+ERROR:  server "dlskel_vol" is not an iceberg catalog server
+CREATE TABLE dlskel_bad_no_catalog (a int)
+  USING iceberg
+  WITH (volume = 'dlskel_vol');
+ERROR:  no catalog specified
+HINT:  Specify WITH (catalog = '...') or SET iceberg.default_catalog.
+CREATE TABLE dlskel_bad_purge (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol',
+        purge_on_drop = 'perhaps');
+ERROR:  invalid value for boolean option "purge_on_drop": perhaps
+CREATE TABLE dlskel_bad_reloption (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol', nonsense = 'x');
+ERROR:  unrecognized parameter "nonsense"
+CREATE SERVER dlskel_bad_server
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083', nonsense 'x');
+ERROR:  invalid iceberg catalog server option "nonsense"
+HINT:  Allowed options are "type", "uri", "catalog_name", "warehouse" and "polaris_server_realm".
+CREATE SERVER dlskel_bad_secret
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (secret_key 'x');
+ERROR:  credential option "secret_key" is not allowed on an iceberg volume server
+HINT:  credentials belong in CREATE USER MAPPING ... OPTIONS (...)
+-- The catalog wrapper has its own allowlist, and its own credential keys.
+CREATE SERVER dlskel_bad_cat_secret
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083', password 'x');
+ERROR:  credential option "password" is not allowed on an iceberg catalog server
+HINT:  credentials belong in CREATE USER MAPPING ... OPTIONS (...)
+CREATE SERVER dlskel_bad_cat_token
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'polaris', uri 'https://fake:443', client_secret 'x');
+ERROR:  credential option "client_secret" is not allowed on an iceberg catalog server
+HINT:  credentials belong in CREATE USER MAPPING ... OPTIONS (...)
+-- Every key the credential list mirrors from an option module, so that a key
+-- renamed in one place and not the other fails here instead of silently
+-- ceasing to be caught.
+CREATE SERVER dlskel_bad_cat_user
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083', username 'u');
+ERROR:  credential option "username" is not allowed on an iceberg catalog server
+HINT:  credentials belong in CREATE USER MAPPING ... OPTIONS (...)
+CREATE SERVER dlskel_bad_cat_keytab
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083', krb_client_keytab '/k');
+ERROR:  credential option "krb_client_keytab" is not allowed on an iceberg catalog server
+HINT:  credentials belong in CREATE USER MAPPING ... OPTIONS (...)
+CREATE SERVER dlskel_bad_cat_clientid
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'rest', uri 'https://fake:443', client_id 'i');
+ERROR:  credential option "client_id" is not allowed on an iceberg catalog server
+HINT:  credentials belong in CREATE USER MAPPING ... OPTIONS (...)
+CREATE SERVER dlskel_bad_vol_token
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://dlskel-bucket/p', session_token 't');
+ERROR:  credential option "session_token" is not allowed on an iceberg volume server
+HINT:  credentials belong in CREATE USER MAPPING ... OPTIONS (...)
+CREATE SERVER dlskel_bad_vol_keyid
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://dlskel-bucket/p', access_key_id 'k');
+ERROR:  credential option "access_key_id" is not allowed on an iceberg volume server
+HINT:  credentials belong in CREATE USER MAPPING ... OPTIONS (...)
+CREATE SERVER dlskel_bad_vol_secret
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://dlskel-bucket/p', secret_access_key 's');
+ERROR:  credential option "secret_access_key" is not allowed on an iceberg volume server
+HINT:  credentials belong in CREATE USER MAPPING ... OPTIONS (...)
+-- Option names are matched exactly, as the server itself matches them; a quoted
+-- variant is a different, unknown option rather than a second spelling.
+CREATE SERVER dlskel_bad_cat_case
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS ("TYPE" 'hive', uri 'thrift://fake:9083');
+ERROR:  invalid iceberg catalog server option "TYPE"
+HINT:  Allowed options are "type", "uri", "catalog_name", "warehouse" and "polaris_server_realm".
+-- A catalog type outside the vocabulary, and one that is in it but has no
+-- implementation behind it yet.
+CREATE SERVER dlskel_bad_cat_type
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'nosuchcatalog', uri 'thrift://fake:9083');
+ERROR:  invalid iceberg catalog type "nosuchcatalog"
+HINT:  Allowed types are "hive", "rest" and "builtin"; "polaris" is accepted as an alias of "rest".
+CREATE SERVER dlskel_bad_cat_hadoop
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hadoop', uri 'hdfs://fake:8020');
+ERROR:  iceberg: catalog type "hadoop" is not supported yet
+-- builtin needs no url; supplying one means the two disagree.
+CREATE SERVER dlskel_bad_cat_builtin
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'builtin', uri 'thrift://fake:9083');
+ERROR:  iceberg catalog type "builtin" forbids server option "uri"
+-- hive does need one.
+CREATE SERVER dlskel_bad_cat_nourl
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive');
+ERROR:  iceberg catalog type "hive" requires server option "uri"
+-- The realm applies to one catalog type only.
+CREATE SERVER dlskel_bad_cat_realm
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083',
+           polaris_server_realm 'OTHER');
+ERROR:  iceberg catalog server option "polaris_server_realm" applies only to catalog type "rest"
+-- An empty value is refused where it is written, not where it is first read.
+CREATE SERVER dlskel_bad_cat_empty
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri '');
+ERROR:  iceberg catalog server option "uri" cannot be empty
+-- Not a boolean.
+CREATE SERVER dlskel_bad_vol_bool
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://dlskel-bucket/p', path_style_access 'perhaps');
+ERROR:  invalid boolean value "perhaps" for option "path_style_access"
+CREATE SERVER dlskel_bad_nopath
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (endpoint 'http://fake:9000');
+ERROR:  iceberg volume server option "base_path" is required
+CREATE SERVER dlskel_bad_scheme
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 'ftp://x/y');
+ERROR:  invalid iceberg volume base_path "ftp://x/y"
+DETAIL:  location URI "ftp://x/y" has unsupported scheme; expected s3 or hdfs
+CREATE SERVER dlskel_bad_authority
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://');
+ERROR:  invalid iceberg volume base_path "s3://"
+DETAIL:  location URI "s3://" has an empty authority
+CREATE SERVER dlskel_bad_query
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://b/p?versionId=3');
+ERROR:  invalid iceberg volume base_path "s3://b/p?versionId=3"
+DETAIL:  location URI "s3://b/p?versionId=3" must not contain a query
+CREATE SERVER dlskel_bad_userinfo
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://user@b/p');
+ERROR:  invalid iceberg volume base_path "s3://user@b/p"
+DETAIL:  location URI "s3://user@b/p" must not contain userinfo
+CREATE SERVER dlskel_bad_bucket
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://UPPER_case/p');
+ERROR:  invalid iceberg volume base_path "s3://UPPER_case/p"
+DETAIL:  s3 bucket in location URI "s3://UPPER_case/p" must start and end with a lowercase letter or digit
+-- The metadata engine is not selectable, so naming one is an unknown option.
+CREATE TABLE dlskel_bad_engine (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol',
+        engine = 'agent');
+ERROR:  unrecognized parameter "engine"
+SET client_min_messages = warning;
+DROP MATERIALIZED VIEW IF EXISTS dlskel_mv CASCADE;
+DROP TABLE IF EXISTS
+  dlskel_r, dlskel_r2, dlskel_bad, dlskel_bad_dist,
+  dlskel_bad_part, dlskel_bad_inherits, dlskel_bad_typed,
+  dlskel_bad_temp, dlskel_bad_unlogged, dlskel_bad_oncommit,
+  dlskel_bad_tablespace, dlskel_bad_missing_server,
+  dlskel_bad_wrong_catalog, dlskel_bad_no_catalog,
+  dlskel_bad_reloption, dlskel_bad_engine, dlskel_r_new, dlskel_heap,
+  dlskel_bad_repl, dlskel_bad_purge
+  CASCADE;
+DROP SERVER IF EXISTS dlskel_cat CASCADE;
+DROP SERVER IF EXISTS dlskel_cat2 CASCADE;
+DROP SERVER IF EXISTS dlskel_vol CASCADE;
+DROP SERVER IF EXISTS dlskel_free CASCADE;
+DROP SERVER IF EXISTS dlskel_free2 CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_server CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_secret CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_secret CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_token CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_user CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_keytab CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_clientid CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_keyid CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_secret CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_token CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_case CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_type CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_hadoop CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_builtin CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_nourl CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_realm CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_empty CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_bool CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_nopath CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_scheme CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_authority CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_query CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_userinfo CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_bucket CASCADE;
+DROP SCHEMA IF EXISTS dlskel_sch CASCADE;
+DROP SCHEMA IF EXISTS dlskel_sch2 CASCADE;
+DROP SCHEMA IF EXISTS dlskel_plain CASCADE;
+DROP SCHEMA IF EXISTS dlskel_plain2 CASCADE;
+DROP TYPE IF EXISTS dlskel_type CASCADE;
+DROP ROLE IF EXISTS dlskel_role;
+RESET client_min_messages;
diff --git a/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/sql/iceberg_am_acl.sql b/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/sql/iceberg_am_acl.sql
new file mode 100644
index 00000000000..40d2020a0ce
--- /dev/null
+++ b/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/sql/iceberg_am_acl.sql
@@ -0,0 +1,78 @@
+-- Foreign-server USAGE is required; user mappings remain optional.
+
+SET client_min_messages = warning;
+RESET ROLE;
+DROP SCHEMA IF EXISTS dlskel_s CASCADE;
+DROP SERVER IF EXISTS dlskel_acl_cat CASCADE;
+DROP SERVER IF EXISTS dlskel_acl_vol CASCADE;
+DROP ROLE IF EXISTS dlskel_user;
+RESET client_min_messages;
+
+-- Quiet, so that the output does not depend on whether another test in the
+-- same database created the extension first.
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS datalake_fdw;
+RESET client_min_messages;
+
+CREATE SERVER dlskel_acl_cat
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083');
+CREATE SERVER dlskel_acl_vol
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://dlskel-bucket/acl',
+           endpoint 'http://fake:9000');
+-- Which NOTICE CREATE ROLE emits depends on gp_resource_manager, and neither
+-- is what this case is about.
+SET client_min_messages = warning;
+CREATE ROLE dlskel_user LOGIN;
+RESET client_min_messages;
+CREATE SCHEMA dlskel_s;
+GRANT CREATE, USAGE ON SCHEMA dlskel_s TO dlskel_user;
+
+SET ROLE dlskel_user;
+CREATE TABLE dlskel_s.t (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_acl_cat', volume = 'dlskel_acl_vol');
+
+RESET ROLE;
+GRANT USAGE ON FOREIGN SERVER dlskel_acl_cat TO dlskel_user;
+SET ROLE dlskel_user;
+CREATE TABLE dlskel_s.t (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_acl_cat', volume = 'dlskel_acl_vol');
+
+RESET ROLE;
+GRANT USAGE ON FOREIGN SERVER dlskel_acl_vol TO dlskel_user;
+SET ROLE dlskel_user;
+CREATE TABLE dlskel_s.t (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_acl_cat', volume = 'dlskel_acl_vol');
+
+CREATE USER MAPPING FOR dlskel_user
+  SERVER dlskel_acl_cat
+  OPTIONS (username 'u', auth_method 'simple');
+-- AWS temporary credentials are three values; the mapping has to be able to
+-- hold all of them.
+CREATE USER MAPPING FOR dlskel_user
+  SERVER dlskel_acl_vol
+  OPTIONS (access_key_id 'k', secret_access_key 's', session_token 't');
+-- A server-side key is not a user mapping key.
+ALTER USER MAPPING FOR dlskel_user
+  SERVER dlskel_acl_cat
+  OPTIONS (ADD warehouse 'x');
+
+RESET ROLE;
+DROP SCHEMA dlskel_s CASCADE;
+DROP USER MAPPING FOR dlskel_user SERVER dlskel_acl_cat;
+DROP USER MAPPING FOR dlskel_user SERVER dlskel_acl_vol;
+DROP SERVER dlskel_acl_cat;
+DROP SERVER dlskel_acl_vol;
+DROP ROLE dlskel_user;
+
+SET client_min_messages = warning;
+RESET ROLE;
+DROP SCHEMA IF EXISTS dlskel_s CASCADE;
+DROP SERVER IF EXISTS dlskel_acl_cat CASCADE;
+DROP SERVER IF EXISTS dlskel_acl_vol CASCADE;
+DROP ROLE IF EXISTS dlskel_user;
+RESET client_min_messages;
diff --git a/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/sql/iceberg_am_ddl.sql b/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/sql/iceberg_am_ddl.sql
new file mode 100644
index 00000000000..365fe7e0b00
--- /dev/null
+++ b/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/sql/iceberg_am_ddl.sql
@@ -0,0 +1,162 @@
+-- Happy-path DDL, binding persistence, distributed catalog state, and drops.
+
+SET client_min_messages = warning;
+DROP TABLE IF EXISTS dlskel_t, dlskel_t2, dlskel_t3, dlskel_t_dump,
+  dlskel_t_keep, dlskel_t_purge CASCADE;
+DROP SERVER IF EXISTS dlskel_cat CASCADE;
+DROP SERVER IF EXISTS dlskel_cat_rest CASCADE;
+DROP SERVER IF EXISTS dlskel_vol CASCADE;
+RESET client_min_messages;
+
+-- Quiet, so that the output does not depend on whether another test in the
+-- same database created the extension first.
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS datalake_fdw;
+RESET client_min_messages;
+
+CREATE SERVER dlskel_cat
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083');
+CREATE SERVER dlskel_cat_rest
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'rest', uri 'https://fake:443');
+DROP SERVER dlskel_cat_rest;
+CREATE SERVER dlskel_vol
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://dlskel-bucket/prefix',
+           endpoint 'http://fake:9000');
+
+CREATE TABLE dlskel_t (a int, b text)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+
+SELECT relname, amname, reloptions
+FROM pg_class c
+JOIN pg_am a ON a.oid = c.relam
+WHERE relname = 'dlskel_t';
+
+SELECT policytype, distkey
+FROM gp_distribution_policy
+WHERE localoid = 'dlskel_t'::regclass;
+
+-- Exactly one pg_class row on each primary segment.  Counting rows in total
+-- would accept one segment missing its row as long as another had two, which is
+-- the very divergence this is here to catch; so compare the set of segments that
+-- have exactly one row against the set of primaries.
+SELECT count(*) = 0 AS every_segment_has_exactly_one
+FROM (SELECT content FROM gp_segment_configuration
+      WHERE content >= 0 AND role = 'p'
+      EXCEPT
+      SELECT gp_segment_id FROM gp_dist_random('pg_class')
+      WHERE relname = 'dlskel_t'
+      GROUP BY gp_segment_id HAVING count(*) = 1) missing_or_duplicated;
+
+SELECT oid AS dlskel_cat_oid
+FROM pg_foreign_server
+WHERE srvname = 'dlskel_cat'
+\gset
+SELECT oid AS dlskel_vol_oid
+FROM pg_foreign_server
+WHERE srvname = 'dlskel_vol'
+\gset
+SELECT 'dlskel_t'::regclass::oid AS dlskel_t_oid
+\gset
+
+SELECT b.binding,
+       NOT EXISTS (SELECT content FROM gp_segment_configuration
+                   WHERE content >= 0 AND role = 'p'
+                   EXCEPT
+                   SELECT gp_segment_id FROM gp_dist_random('pg_depend')
+                   WHERE classid = 'pg_class'::regclass
+                     AND objid = :dlskel_t_oid
+                     AND refclassid = 'pg_foreign_server'::regclass
+                     AND refobjid = b.refobjid
+                   GROUP BY gp_segment_id HAVING count(*) = 1)
+       AS every_segment_has_exactly_one
+FROM (VALUES ('catalog', :dlskel_cat_oid::oid),
+             ('volume', :dlskel_vol_oid::oid)) AS b(binding, refobjid)
+ORDER BY b.binding;
+
+ANALYZE dlskel_t;
+VACUUM dlskel_t;
+SELECT reltuples IN (-1, 0) AS no_local_stats
+FROM pg_class
+WHERE oid = 'dlskel_t'::regclass;
+
+-- pg_dump writes DISTRIBUTED RANDOMLY into the CREATE TABLE it emits, so this
+-- is the statement a restore replays; refusing it would mean refusing to
+-- restore a dump this module produced.  It has to yield the same policy as the
+-- clause the module injects on its own.
+CREATE TABLE dlskel_t_dump (a int, b text)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol')
+  DISTRIBUTED RANDOMLY;
+SELECT policytype, distkey
+FROM gp_distribution_policy
+WHERE localoid = 'dlskel_t_dump'::regclass;
+DROP TABLE dlskel_t_dump;
+
+-- Dropping the table drops this database's reference to it; the lake data stays
+-- unless the table said otherwise.  The default and the explicit form both have
+-- to be observable, which is why the stub reports which one it was asked for.
+CREATE TABLE dlskel_t_keep (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+DROP TABLE dlskel_t_keep;
+CREATE TABLE dlskel_t_purge (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol',
+        purge_on_drop = true);
+SELECT reloptions FROM pg_class WHERE relname = 'dlskel_t_purge';
+DROP TABLE dlskel_t_purge;
+
+SET iceberg.default_catalog = 'dlskel_cat';
+SET iceberg.default_volume = 'dlskel_vol';
+CREATE TABLE dlskel_t2 (a int) USING iceberg;
+SELECT relname, amname, reloptions
+FROM pg_class c
+JOIN pg_am a ON a.oid = c.relam
+WHERE relname = 'dlskel_t2';
+RESET iceberg.default_catalog;
+RESET iceberg.default_volume;
+
+SET default_table_access_method = iceberg;
+SET iceberg.default_catalog = 'dlskel_cat';
+SET iceberg.default_volume = 'dlskel_vol';
+CREATE TABLE dlskel_t3 (a int);
+\set HIDE_TABLEAM off
+\d+ dlskel_t3
+RESET default_table_access_method;
+RESET iceberg.default_catalog;
+RESET iceberg.default_volume;
+
+DROP SERVER dlskel_cat;
+DROP SERVER dlskel_vol;
+
+DROP TABLE dlskel_t;
+SELECT b.binding,
+       NOT EXISTS (SELECT 1 FROM gp_dist_random('pg_depend')
+                   WHERE classid = 'pg_class'::regclass
+                     AND objid = :dlskel_t_oid
+                     AND refclassid = 'pg_foreign_server'::regclass
+                     AND refobjid = b.refobjid)
+       AS gone_from_every_segment
+FROM (VALUES ('catalog', :dlskel_cat_oid::oid),
+             ('volume', :dlskel_vol_oid::oid)) AS b(binding, refobjid)
+ORDER BY b.binding;
+
+DROP SERVER dlskel_cat CASCADE;
+DROP SERVER dlskel_vol CASCADE;
+
+SELECT gp_segment_id, relname
+FROM gp_dist_random('pg_class')
+WHERE relname LIKE 'dlskel\_%' ESCAPE '\'
+ORDER BY 1, 2;
+
+SET client_min_messages = warning;
+DROP TABLE IF EXISTS dlskel_t, dlskel_t2, dlskel_t3, dlskel_t_dump,
+  dlskel_t_keep, dlskel_t_purge CASCADE;
+DROP SERVER IF EXISTS dlskel_cat CASCADE;
+DROP SERVER IF EXISTS dlskel_cat_rest CASCADE;
+DROP SERVER IF EXISTS dlskel_vol CASCADE;
+RESET client_min_messages;
diff --git a/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/sql/iceberg_am_reject.sql b/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/sql/iceberg_am_reject.sql
new file mode 100644
index 00000000000..6f376f61e49
--- /dev/null
+++ b/contrib/datalake_fdw/test/automation/sqlrepo/smoke/iceberg_am/sql/iceberg_am_reject.sql
@@ -0,0 +1,379 @@
+-- Unsupported data paths, CREATE/ALTER guards, and binding validators.
+-- Errors raised on a segment carry its address and pid, which vary per run.
+-- start_matchsubs
+-- m/  \(seg[0-9]+[^)]* pid=[0-9]+\)/
+-- s/  \(seg[0-9]+[^)]* pid=[0-9]+\)//
+-- end_matchsubs
+
+SET client_min_messages = warning;
+DROP MATERIALIZED VIEW IF EXISTS dlskel_mv CASCADE;
+DROP TABLE IF EXISTS
+  dlskel_r, dlskel_r2, dlskel_bad, dlskel_bad_dist,
+  dlskel_bad_part, dlskel_bad_inherits, dlskel_bad_typed,
+  dlskel_bad_temp, dlskel_bad_unlogged, dlskel_bad_oncommit,
+  dlskel_bad_tablespace, dlskel_bad_missing_server,
+  dlskel_bad_wrong_catalog, dlskel_bad_no_catalog,
+  dlskel_bad_reloption, dlskel_bad_engine, dlskel_r_new, dlskel_heap,
+  dlskel_bad_repl, dlskel_bad_purge
+  CASCADE;
+DROP SERVER IF EXISTS dlskel_cat CASCADE;
+DROP SERVER IF EXISTS dlskel_cat2 CASCADE;
+DROP SERVER IF EXISTS dlskel_vol CASCADE;
+DROP SERVER IF EXISTS dlskel_free CASCADE;
+DROP SERVER IF EXISTS dlskel_free2 CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_server CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_secret CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_secret CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_token CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_user CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_keytab CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_clientid CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_keyid CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_secret CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_token CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_case CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_type CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_hadoop CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_builtin CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_nourl CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_realm CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_empty CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_bool CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_nopath CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_scheme CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_authority CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_query CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_userinfo CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_bucket CASCADE;
+DROP SCHEMA IF EXISTS dlskel_sch CASCADE;
+DROP SCHEMA IF EXISTS dlskel_sch2 CASCADE;
+DROP SCHEMA IF EXISTS dlskel_plain CASCADE;
+DROP SCHEMA IF EXISTS dlskel_plain2 CASCADE;
+DROP TYPE IF EXISTS dlskel_type CASCADE;
+DROP ROLE IF EXISTS dlskel_role;
+RESET client_min_messages;
+
+-- Quiet, so that the output does not depend on whether another test in the
+-- same database created the extension first.
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS datalake_fdw;
+RESET client_min_messages;
+
+CREATE SERVER dlskel_cat
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083');
+CREATE SERVER dlskel_vol
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://dlskel-bucket/reject',
+           endpoint 'http://fake:9000');
+CREATE SERVER dlskel_free
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://free:9083');
+-- Which NOTICE CREATE ROLE emits depends on gp_resource_manager, and neither
+-- is what this case is about.
+SET client_min_messages = warning;
+CREATE ROLE dlskel_role;
+RESET client_min_messages;
+CREATE TYPE dlskel_type AS (a int);
+
+CREATE TABLE dlskel_r (a int, b text)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+
+SELECT * FROM dlskel_r;
+INSERT INTO dlskel_r VALUES (1, 'x');
+UPDATE dlskel_r SET a = 1;
+DELETE FROM dlskel_r;
+COPY dlskel_r FROM stdin;
+1	x
+\.
+COPY dlskel_r TO stdout;
+CREATE INDEX ON dlskel_r (a);
+SELECT * FROM dlskel_r TABLESAMPLE BERNOULLI (10);
+
+-- A table from an earlier transaction takes the new-filelocator path rather
+-- than the access method's truncate callback, so this is the case that would
+-- silently report success if only the callback rejected it.
+TRUNCATE dlskel_r;
+
+-- Same for a table created in this transaction, which does reach the callback.
+BEGIN;
+CREATE TABLE dlskel_r_new (a int, b text)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+TRUNCATE dlskel_r_new;
+ROLLBACK;
+
+-- A multi-table TRUNCATE must refuse before truncating the heap beside it, so
+-- the row below has to survive the attempt.
+CREATE TABLE dlskel_heap (a int) DISTRIBUTED BY (a);
+INSERT INTO dlskel_heap VALUES (1);
+TRUNCATE dlskel_heap, dlskel_r;
+SELECT count(*) AS heap_rows_kept FROM dlskel_heap;
+
+VACUUM FULL dlskel_r;
+SELECT * FROM dlskel_r FOR UPDATE;
+
+CREATE TABLE dlskel_bad_dist (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol')
+  DISTRIBUTED BY (a);
+CREATE TABLE dlskel_bad_part (a int)
+  PARTITION BY RANGE (a)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+CREATE TABLE dlskel_bad_inherits (b text)
+  INHERITS (dlskel_r)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+CREATE TABLE dlskel_bad_typed OF dlskel_type
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+CREATE TEMP TABLE dlskel_bad_temp (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+CREATE UNLOGGED TABLE dlskel_bad_unlogged (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+BEGIN;
+CREATE TABLE dlskel_bad_oncommit (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol')
+  ON COMMIT DROP;
+ROLLBACK;
+CREATE TABLE dlskel_bad_tablespace (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol')
+  TABLESPACE pg_default;
+
+CREATE TABLE dlskel_bad USING iceberg AS SELECT 1;
+CREATE MATERIALIZED VIEW dlskel_mv USING iceberg AS SELECT 1;
+
+-- Converting a heap into a lake table has to be refused too: the relation is
+-- still a heap when the statement arrives, so the guard above does not see it.
+ALTER TABLE dlskel_heap SET ACCESS METHOD iceberg;
+SET iceberg.default_catalog = 'dlskel_cat';
+SET iceberg.default_volume = 'dlskel_vol';
+ALTER TABLE dlskel_heap SET ACCESS METHOD iceberg;
+RESET iceberg.default_catalog;
+RESET iceberg.default_volume;
+
+-- A column-bearing clause still cannot be honoured, and neither can a
+-- replicated policy.
+CREATE TABLE dlskel_bad_repl (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol')
+  DISTRIBUTED REPLICATED;
+
+-- Renaming a schema would repoint its lake tables at a different external
+-- namespace, so a schema holding one is refused -- and, just as importantly, a
+-- schema holding none is not: the guard has to be no wider than the problem.
+CREATE SCHEMA dlskel_sch;
+CREATE TABLE dlskel_sch.t (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol');
+BEGIN;
+ALTER SCHEMA dlskel_sch RENAME TO dlskel_sch2;
+ROLLBACK;
+CREATE SCHEMA dlskel_plain;
+ALTER SCHEMA dlskel_plain RENAME TO dlskel_plain2;
+DROP SCHEMA dlskel_plain2;
+
+-- Renaming a wrapper breaks every mapping lookup at once, including the one
+-- DROP needs, so it is refused whether or not a table exists yet.
+-- Each attempt is rolled back: if the guard ever regresses, an accepted rename
+-- would leave the extension's own wrapper under a different name, which nothing
+-- in the cleanup below can undo and which breaks every later run.
+BEGIN;
+ALTER FOREIGN DATA WRAPPER iceberg_catalog_fdw RENAME TO dlskel_other_fdw;
+ROLLBACK;
+BEGIN;
+ALTER FOREIGN DATA WRAPPER iceberg_volume_fdw RENAME TO dlskel_other_fdw;
+ROLLBACK;
+
+ALTER TABLE dlskel_r ADD COLUMN c int;
+ALTER TABLE dlskel_r SET (fillfactor = 90);
+ALTER TABLE dlskel_r SET ACCESS METHOD heap;
+ALTER TABLE dlskel_r SET DISTRIBUTED BY (a);
+ALTER TABLE dlskel_r RENAME TO dlskel_r2;
+ALTER TABLE dlskel_r RENAME COLUMN a TO aa;
+ALTER TABLE dlskel_r SET SCHEMA public;
+-- OWNER TO is the one ALTER TABLE form that goes through: pg_dump writes it for
+-- every table, and ownership cannot reach the external table.  Put it back
+-- afterwards so the rest of the file still owns what it created.
+ALTER TABLE dlskel_r OWNER TO dlskel_role;
+SELECT relname, pg_get_userbyid(relowner) AS owner
+FROM pg_class WHERE relname = 'dlskel_r';
+ALTER TABLE dlskel_r OWNER TO CURRENT_USER;
+
+ALTER SERVER dlskel_cat
+  OPTIONS (SET uri 'thrift://other:9083');
+ALTER SERVER dlskel_cat VERSION '2';
+ALTER SERVER dlskel_cat RENAME TO dlskel_cat2;
+ALTER SERVER dlskel_cat OWNER TO dlskel_role;
+
+ALTER SERVER dlskel_free
+  OPTIONS (SET uri 'thrift://other:9083');
+ALTER SERVER dlskel_free VERSION '2';
+ALTER SERVER dlskel_free OWNER TO dlskel_role;
+ALTER SERVER dlskel_free RENAME TO dlskel_free2;
+
+RESET iceberg.default_catalog;
+RESET iceberg.default_volume;
+CREATE TABLE dlskel_bad_missing_server (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_missing', volume = 'dlskel_vol');
+CREATE TABLE dlskel_bad_wrong_catalog (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_vol', volume = 'dlskel_vol');
+CREATE TABLE dlskel_bad_no_catalog (a int)
+  USING iceberg
+  WITH (volume = 'dlskel_vol');
+CREATE TABLE dlskel_bad_purge (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol',
+        purge_on_drop = 'perhaps');
+CREATE TABLE dlskel_bad_reloption (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol', nonsense = 'x');
+
+CREATE SERVER dlskel_bad_server
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083', nonsense 'x');
+CREATE SERVER dlskel_bad_secret
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (secret_key 'x');
+-- The catalog wrapper has its own allowlist, and its own credential keys.
+CREATE SERVER dlskel_bad_cat_secret
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083', password 'x');
+CREATE SERVER dlskel_bad_cat_token
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'polaris', uri 'https://fake:443', client_secret 'x');
+-- Every key the credential list mirrors from an option module, so that a key
+-- renamed in one place and not the other fails here instead of silently
+-- ceasing to be caught.
+CREATE SERVER dlskel_bad_cat_user
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083', username 'u');
+CREATE SERVER dlskel_bad_cat_keytab
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083', krb_client_keytab '/k');
+CREATE SERVER dlskel_bad_cat_clientid
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'rest', uri 'https://fake:443', client_id 'i');
+CREATE SERVER dlskel_bad_vol_token
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://dlskel-bucket/p', session_token 't');
+CREATE SERVER dlskel_bad_vol_keyid
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://dlskel-bucket/p', access_key_id 'k');
+CREATE SERVER dlskel_bad_vol_secret
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://dlskel-bucket/p', secret_access_key 's');
+-- Option names are matched exactly, as the server itself matches them; a quoted
+-- variant is a different, unknown option rather than a second spelling.
+CREATE SERVER dlskel_bad_cat_case
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS ("TYPE" 'hive', uri 'thrift://fake:9083');
+-- A catalog type outside the vocabulary, and one that is in it but has no
+-- implementation behind it yet.
+CREATE SERVER dlskel_bad_cat_type
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'nosuchcatalog', uri 'thrift://fake:9083');
+CREATE SERVER dlskel_bad_cat_hadoop
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hadoop', uri 'hdfs://fake:8020');
+-- builtin needs no url; supplying one means the two disagree.
+CREATE SERVER dlskel_bad_cat_builtin
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'builtin', uri 'thrift://fake:9083');
+-- hive does need one.
+CREATE SERVER dlskel_bad_cat_nourl
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive');
+-- The realm applies to one catalog type only.
+CREATE SERVER dlskel_bad_cat_realm
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri 'thrift://fake:9083',
+           polaris_server_realm 'OTHER');
+-- An empty value is refused where it is written, not where it is first read.
+CREATE SERVER dlskel_bad_cat_empty
+  FOREIGN DATA WRAPPER iceberg_catalog_fdw
+  OPTIONS (type 'hive', uri '');
+-- Not a boolean.
+CREATE SERVER dlskel_bad_vol_bool
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://dlskel-bucket/p', path_style_access 'perhaps');
+CREATE SERVER dlskel_bad_nopath
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (endpoint 'http://fake:9000');
+CREATE SERVER dlskel_bad_scheme
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 'ftp://x/y');
+CREATE SERVER dlskel_bad_authority
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://');
+CREATE SERVER dlskel_bad_query
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://b/p?versionId=3');
+CREATE SERVER dlskel_bad_userinfo
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://user@b/p');
+CREATE SERVER dlskel_bad_bucket
+  FOREIGN DATA WRAPPER iceberg_volume_fdw
+  OPTIONS (base_path 's3://UPPER_case/p');
+
+-- The metadata engine is not selectable, so naming one is an unknown option.
+CREATE TABLE dlskel_bad_engine (a int)
+  USING iceberg
+  WITH (catalog = 'dlskel_cat', volume = 'dlskel_vol',
+        engine = 'agent');
+
+SET client_min_messages = warning;
+DROP MATERIALIZED VIEW IF EXISTS dlskel_mv CASCADE;
+DROP TABLE IF EXISTS
+  dlskel_r, dlskel_r2, dlskel_bad, dlskel_bad_dist,
+  dlskel_bad_part, dlskel_bad_inherits, dlskel_bad_typed,
+  dlskel_bad_temp, dlskel_bad_unlogged, dlskel_bad_oncommit,
+  dlskel_bad_tablespace, dlskel_bad_missing_server,
+  dlskel_bad_wrong_catalog, dlskel_bad_no_catalog,
+  dlskel_bad_reloption, dlskel_bad_engine, dlskel_r_new, dlskel_heap,
+  dlskel_bad_repl, dlskel_bad_purge
+  CASCADE;
+DROP SERVER IF EXISTS dlskel_cat CASCADE;
+DROP SERVER IF EXISTS dlskel_cat2 CASCADE;
+DROP SERVER IF EXISTS dlskel_vol CASCADE;
+DROP SERVER IF EXISTS dlskel_free CASCADE;
+DROP SERVER IF EXISTS dlskel_free2 CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_server CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_secret CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_secret CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_token CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_user CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_keytab CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_clientid CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_keyid CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_secret CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_token CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_case CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_type CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_hadoop CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_builtin CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_nourl CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_realm CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_cat_empty CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_vol_bool CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_nopath CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_scheme CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_authority CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_query CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_userinfo CASCADE;
+DROP SERVER IF EXISTS dlskel_bad_bucket CASCADE;
+DROP SCHEMA IF EXISTS dlskel_sch CASCADE;
+DROP SCHEMA IF EXISTS dlskel_sch2 CASCADE;
+DROP SCHEMA IF EXISTS dlskel_plain CASCADE;
+DROP SCHEMA IF EXISTS dlskel_plain2 CASCADE;
+DROP TYPE IF EXISTS dlskel_type CASCADE;
+DROP ROLE IF EXISTS dlskel_role;
+RESET client_min_messages;
diff --git a/src/Makefile.global.in b/src/Makefile.global.in
index 74ba8d0c370..f00f0be7091 100644
--- a/src/Makefile.global.in
+++ b/src/Makefile.global.in
@@ -231,6 +231,7 @@ enable_orafce		= @enable_orafce@
 enable_mapreduce    = @enable_mapreduce@
 enable_shared_postgres_backend    = @enable_shared_postgres_backend@
 enable_link_postgres_with_shared  = @enable_link_postgres_with_shared@
+enable_datalake_fdw = @enable_datalake_fdw@
 enable_gpcloud 	    = @enable_gpcloud@
 enable_ic_proxy     = @enable_ic_proxy@
 enable_ic_udp2      = @enable_ic_udp2@


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cloudberry.apache.org
For additional commands, e-mail: commits-help@cloudberry.apache.org