You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@fluss.apache.org by yu...@apache.org on 2025/08/07 10:13:51 UTC

(fluss) branch main updated: [lake] Introduce Union read lake base interfaces (#1480)

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

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


The following commit(s) were added to refs/heads/main by this push:
     new d0290506d [lake] Introduce Union read lake base interfaces (#1480)
d0290506d is described below

commit d0290506dd910e7759990eeac582d0c6299fed2c
Author: Junbo Wang <be...@gmail.com>
AuthorDate: Thu Aug 7 18:13:47 2025 +0800

    [lake] Introduce Union read lake base interfaces (#1480)
---
 .../fluss/lake/lakestorage/LakeStorage.java        |  12 ++
 .../lake/lakestorage/PluginLakeStorageWrapper.java |   6 +
 .../com/alibaba/fluss/lake/source/LakeSource.java  | 149 +++++++++++++++++++++
 .../com/alibaba/fluss/lake/source/LakeSplit.java   |  58 ++++++++
 .../LakeStorage.java => source/Planner.java}       |  28 ++--
 .../LakeStorage.java => source/RecordReader.java}  |  29 ++--
 .../fluss/lake/source/SortedRecordReader.java      |  49 +++++++
 .../fluss/lake/lakestorage/LakeStorageTest.java    |   6 +
 .../fluss/lake/iceberg/IcebergLakeStorage.java     |   7 +
 .../alibaba/fluss/lake/lance/LanceLakeStorage.java |   7 +
 .../fluss/lake/paimon/PaimonLakeStorage.java       |   7 +
 .../lakehouse/TestingPaimonStoragePlugin.java      |   6 +
 fluss-test-coverage/pom.xml                        |   2 +
 13 files changed, 342 insertions(+), 24 deletions(-)

diff --git a/fluss-common/src/main/java/com/alibaba/fluss/lake/lakestorage/LakeStorage.java b/fluss-common/src/main/java/com/alibaba/fluss/lake/lakestorage/LakeStorage.java
index 64b50b57f..9d6331d5e 100644
--- a/fluss-common/src/main/java/com/alibaba/fluss/lake/lakestorage/LakeStorage.java
+++ b/fluss-common/src/main/java/com/alibaba/fluss/lake/lakestorage/LakeStorage.java
@@ -18,7 +18,9 @@
 package com.alibaba.fluss.lake.lakestorage;
 
 import com.alibaba.fluss.annotation.PublicEvolving;
+import com.alibaba.fluss.lake.source.LakeSource;
 import com.alibaba.fluss.lake.writer.LakeTieringFactory;
+import com.alibaba.fluss.metadata.TablePath;
 
 /**
  * The LakeStorage interface defines how to implement lakehouse storage system such as Paimon and
@@ -38,4 +40,14 @@ public interface LakeStorage {
 
     /** Create lake catalog. */
     LakeCatalog createLakeCatalog();
+
+    /**
+     * Creates a lake source instance for reading lakehouse data from the specified table path. The
+     * lake source provides capabilities for split planning and record reading, enabling efficient
+     * distributed processing of lakehouse data.
+     *
+     * @param tablePath the logical path identifying the table in the lakehouse storage
+     * @return a configured lake source instance for the specified table
+     */
+    LakeSource<?> createLakeSource(TablePath tablePath);
 }
diff --git a/fluss-common/src/main/java/com/alibaba/fluss/lake/lakestorage/PluginLakeStorageWrapper.java b/fluss-common/src/main/java/com/alibaba/fluss/lake/lakestorage/PluginLakeStorageWrapper.java
index fd17fe202..457f6747d 100644
--- a/fluss-common/src/main/java/com/alibaba/fluss/lake/lakestorage/PluginLakeStorageWrapper.java
+++ b/fluss-common/src/main/java/com/alibaba/fluss/lake/lakestorage/PluginLakeStorageWrapper.java
@@ -19,6 +19,7 @@ package com.alibaba.fluss.lake.lakestorage;
 
 import com.alibaba.fluss.config.Configuration;
 import com.alibaba.fluss.exception.TableAlreadyExistException;
+import com.alibaba.fluss.lake.source.LakeSource;
 import com.alibaba.fluss.lake.writer.LakeTieringFactory;
 import com.alibaba.fluss.metadata.TableDescriptor;
 import com.alibaba.fluss.metadata.TablePath;
@@ -116,5 +117,10 @@ public class PluginLakeStorageWrapper implements LakeStoragePlugin {
                 return new ClassLoaderFixingLakeCatalog(inner.createLakeCatalog(), loader);
             }
         }
+
+        @Override
+        public LakeSource<?> createLakeSource(TablePath tablePath) {
+            return inner.createLakeSource(tablePath);
+        }
     }
 }
diff --git a/fluss-common/src/main/java/com/alibaba/fluss/lake/source/LakeSource.java b/fluss-common/src/main/java/com/alibaba/fluss/lake/source/LakeSource.java
new file mode 100644
index 000000000..08c65cd9e
--- /dev/null
+++ b/fluss-common/src/main/java/com/alibaba/fluss/lake/source/LakeSource.java
@@ -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.
+ */
+
+package com.alibaba.fluss.lake.source;
+
+import com.alibaba.fluss.annotation.PublicEvolving;
+import com.alibaba.fluss.lake.serializer.SimpleVersionedSerializer;
+import com.alibaba.fluss.predicate.Predicate;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * A generic interface for lake data sources that defines how to plan splits and read data. Any data
+ * lake format supporting reading from data tiered in lake as Fluss records should implement this
+ * interface.
+ *
+ * <p>This interface provides methods for projection, filtering, limiting to enable query engine to
+ * push to lake source. Implementations must ensure that split planning and record reading
+ * operations properly account for these pushed-down operations during execution.
+ *
+ * @param <Split> The type of data split, which must extend {@link LakeSplit}
+ * @since 0.8
+ */
+@PublicEvolving
+public interface LakeSource<Split extends LakeSplit> extends Serializable {
+
+    /**
+     * Applies column projection to the data source. it provides the field index paths that should
+     * be used for a projection. The indices are 0-based and support fields within (possibly nested)
+     * structures.
+     *
+     * <p>For nested, given the following SQL, CREATE TABLE t (i INT, r ROW < d DOUBLE, b BOOLEAN>,
+     * s STRING); SELECT s, r.d FROM t; the project will be [[2], [1, 0]]
+     */
+    void withProject(int[][] project);
+
+    /** Applies a row limit to the lake source. */
+    void withLimit(int limit);
+
+    /** Applies filters to the lake source. */
+    FilterPushDownResult withFilters(List<Predicate> predicates);
+
+    /**
+     * Creates a planner for plan splits to be read.
+     *
+     * @param context The planning context providing necessary planning information
+     * @return A planner instance for this lake source
+     * @throws IOException if an error occurs during planner creation
+     */
+    Planner<Split> createPlanner(PlannerContext context) throws IOException;
+
+    /**
+     * Creates a record reader for reading data from the lake source for the specified split.
+     *
+     * @param context The reader context containing the split to be read
+     * @return A record reader instance for the given split
+     * @throws IOException if an error occurs during reader creation
+     */
+    RecordReader createRecordReader(ReaderContext<Split> context) throws IOException;
+
+    /**
+     * Returns the serializer for the data split, used to transfer split information in distributed
+     * environment.
+     *
+     * @return The serializer for the split
+     */
+    SimpleVersionedSerializer<Split> getSplitSerializer();
+
+    /**
+     * Context interface for planners, providing the snapshot id of the table in data-lake to plan
+     * splits.
+     */
+    interface PlannerContext extends Serializable {
+        long snapshotId();
+    }
+
+    /**
+     * Context interface for record readers, providing access to the lake split being read.
+     *
+     * @param <Split> The type of lake split
+     */
+    interface ReaderContext<Split extends LakeSplit> extends Serializable {
+        Split lakeSplit();
+    }
+
+    /**
+     * Represents the result of a filter push down operation to lake source, indicating which
+     * predicates were accepted by the source and which remain to be evaluated.
+     *
+     * @since 0.8
+     */
+    @PublicEvolving
+    final class FilterPushDownResult {
+        private final List<Predicate> acceptedPredicates;
+        private final List<Predicate> remainingPredicates;
+
+        private FilterPushDownResult(
+                List<Predicate> acceptedPredicates, List<Predicate> remainingPredicates) {
+            this.acceptedPredicates = acceptedPredicates;
+            this.remainingPredicates = remainingPredicates;
+        }
+
+        /**
+         * Creates a new FilterPushDownResult instance.
+         *
+         * @param acceptedPredicates The accepted predicates
+         * @param remainingPredicates The remaining predicates
+         * @return A new FilterPushDownResult instance
+         */
+        public static FilterPushDownResult of(
+                List<Predicate> acceptedPredicates, List<Predicate> remainingPredicates) {
+            return new FilterPushDownResult(acceptedPredicates, remainingPredicates);
+        }
+
+        /**
+         * Returns the predicates that were accepted by the source.
+         *
+         * @return The list of accepted predicates
+         */
+        public List<Predicate> acceptedPredicates() {
+            return acceptedPredicates;
+        }
+
+        /**
+         * Returns the predicates that remain to be evaluated.
+         *
+         * @return The list of remaining predicates
+         */
+        public List<Predicate> remainingPredicates() {
+            return remainingPredicates;
+        }
+    }
+}
diff --git a/fluss-common/src/main/java/com/alibaba/fluss/lake/source/LakeSplit.java b/fluss-common/src/main/java/com/alibaba/fluss/lake/source/LakeSplit.java
new file mode 100644
index 000000000..99e375ef9
--- /dev/null
+++ b/fluss-common/src/main/java/com/alibaba/fluss/lake/source/LakeSplit.java
@@ -0,0 +1,58 @@
+/*
+ * 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.
+ */
+
+package com.alibaba.fluss.lake.source;
+
+import com.alibaba.fluss.annotation.PublicEvolving;
+
+import java.util.List;
+
+/**
+ * Represents a logical partition or segment of data in data-lake.
+ *
+ * @since 0.8
+ */
+@PublicEvolving
+public interface LakeSplit {
+
+    /**
+     * Returns the bucket id for this data split. Any data split in lake must belong to a Fluss
+     * bucket. The bucket id is used to aggregate splits that in same Fluss bucket into same reader
+     * in bucket-aware table, such primary key table, log table with pre-defined bucket keys. If
+     * it's not bucket-aware table, it's also feasible to return -1 directly for all data splits.
+     *
+     * @return the bucket id
+     */
+    int bucket();
+
+    /**
+     * Returns the hierarchical partition values for this split, or an empty list if the split
+     * doesn't belong to a specific partition in non-partitioned table.
+     *
+     * <p>The returned list represents the complete partition path, with each element corresponding
+     * to one level of the partitioning hierarchy in order. For example, in a table partitioned by
+     * {@code dt=20250101/hr=12}, this method would return {@code ["20250101", "12"]}.
+     *
+     * <p>The list size should match the table's partition column count, and each element's position
+     * corresponds to the declared partition column order. Values should be in their
+     * string-represented form as they would appear in the filesystem path.
+     *
+     * @return the resolved partition values specification, or {@code null} if this split doesn't
+     *     belong to a specific partition in non-partitioned table.
+     */
+    List<String> partition();
+}
diff --git a/fluss-common/src/main/java/com/alibaba/fluss/lake/lakestorage/LakeStorage.java b/fluss-common/src/main/java/com/alibaba/fluss/lake/source/Planner.java
similarity index 53%
copy from fluss-common/src/main/java/com/alibaba/fluss/lake/lakestorage/LakeStorage.java
copy to fluss-common/src/main/java/com/alibaba/fluss/lake/source/Planner.java
index 64b50b57f..13e1be11a 100644
--- a/fluss-common/src/main/java/com/alibaba/fluss/lake/lakestorage/LakeStorage.java
+++ b/fluss-common/src/main/java/com/alibaba/fluss/lake/source/Planner.java
@@ -15,27 +15,31 @@
  * limitations under the License.
  */
 
-package com.alibaba.fluss.lake.lakestorage;
+package com.alibaba.fluss.lake.source;
 
 import com.alibaba.fluss.annotation.PublicEvolving;
-import com.alibaba.fluss.lake.writer.LakeTieringFactory;
+
+import java.io.IOException;
+import java.util.List;
 
 /**
- * The LakeStorage interface defines how to implement lakehouse storage system such as Paimon and
- * Iceberg. It provides a method to create a lake tiering factory.
+ * A planner interface for generating readable splits for lake data sources.
+ *
+ * <p>Implementations of this interface are responsible for determining how to divide the data into
+ * manageable splits that can be read in parallel. The planning should consider the pushed-down
+ * optimizations (filters, limits, etc.) from {@link LakeSource}.
  *
- * @since 0.7
+ * @param <Split> the type of data split this planner generates, must extend {@link LakeSplit}
+ * @since 0.8
  */
 @PublicEvolving
-public interface LakeStorage {
+public interface Planner<Split extends LakeSplit> {
 
     /**
-     * Creates a lake tiering factory to create lake writers and committers.
+     * Plans and generates a list of readable data splits in parallel.
      *
-     * @return the lake tiering factory
+     * @return the list of readable data splits
+     * @throws IOException if an I/O error occurs
      */
-    LakeTieringFactory<?, ?> createLakeTieringFactory();
-
-    /** Create lake catalog. */
-    LakeCatalog createLakeCatalog();
+    List<Split> plan() throws IOException;
 }
diff --git a/fluss-common/src/main/java/com/alibaba/fluss/lake/lakestorage/LakeStorage.java b/fluss-common/src/main/java/com/alibaba/fluss/lake/source/RecordReader.java
similarity index 52%
copy from fluss-common/src/main/java/com/alibaba/fluss/lake/lakestorage/LakeStorage.java
copy to fluss-common/src/main/java/com/alibaba/fluss/lake/source/RecordReader.java
index 64b50b57f..e6f3d6838 100644
--- a/fluss-common/src/main/java/com/alibaba/fluss/lake/lakestorage/LakeStorage.java
+++ b/fluss-common/src/main/java/com/alibaba/fluss/lake/source/RecordReader.java
@@ -15,27 +15,32 @@
  * limitations under the License.
  */
 
-package com.alibaba.fluss.lake.lakestorage;
+package com.alibaba.fluss.lake.source;
 
 import com.alibaba.fluss.annotation.PublicEvolving;
-import com.alibaba.fluss.lake.writer.LakeTieringFactory;
+import com.alibaba.fluss.record.LogRecord;
+import com.alibaba.fluss.utils.CloseableIterator;
+
+import java.io.IOException;
 
 /**
- * The LakeStorage interface defines how to implement lakehouse storage system such as Paimon and
- * Iceberg. It provides a method to create a lake tiering factory.
+ * An interface for reading records from {@link LakeSplit}.
+ *
+ * <p>Implementations of this interface provide an iterator-style access to records, allowing
+ * efficient sequential reading of potentially large datasets without loading all data into memory
+ * at once. The reading should consider the pushed-down optimizations (project, filters, limits,
+ * etc.) from {@link LakeSource}.
  *
- * @since 0.7
+ * @since 0.8
  */
 @PublicEvolving
-public interface LakeStorage {
+public interface RecordReader {
 
     /**
-     * Creates a lake tiering factory to create lake writers and committers.
+     * Read a {@link LakeSplit} into a closeable iterator.
      *
-     * @return the lake tiering factory
+     * @return the closeable iterator of records
+     * @throws IOException if an I/O error occurs
      */
-    LakeTieringFactory<?, ?> createLakeTieringFactory();
-
-    /** Create lake catalog. */
-    LakeCatalog createLakeCatalog();
+    CloseableIterator<LogRecord> read() throws IOException;
 }
diff --git a/fluss-common/src/main/java/com/alibaba/fluss/lake/source/SortedRecordReader.java b/fluss-common/src/main/java/com/alibaba/fluss/lake/source/SortedRecordReader.java
new file mode 100644
index 000000000..f69589683
--- /dev/null
+++ b/fluss-common/src/main/java/com/alibaba/fluss/lake/source/SortedRecordReader.java
@@ -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.
+ */
+
+package com.alibaba.fluss.lake.source;
+
+import com.alibaba.fluss.annotation.PublicEvolving;
+import com.alibaba.fluss.row.InternalRow;
+
+import java.util.Comparator;
+
+/**
+ * A specialized {@link RecordReader} that produces records in a defined sorted order.
+ *
+ * <p>Extends the basic record reading capability with sorting semantics, ensuring that records are
+ * returned according to a specified ordering.
+ *
+ * <p>Implementations must guarantee that the {@link #read()} method returns records in the order
+ * defined by the comparator from {@link #order()}.
+ *
+ * <p>Note: This is mainly used for union read primary key table since we will do sort merge records
+ * in lake and fluss. The records in primary key table for lake may should implement this method for
+ * union read with a better performance.
+ *
+ * @since 0.8
+ */
+@PublicEvolving
+public interface SortedRecordReader extends RecordReader {
+
+    /**
+     * Returns the comparator that defines the sort order of the records.
+     *
+     * @return a non-null comparator defining the sort order of the records
+     */
+    Comparator<InternalRow> order();
+}
diff --git a/fluss-common/src/test/java/com/alibaba/fluss/lake/lakestorage/LakeStorageTest.java b/fluss-common/src/test/java/com/alibaba/fluss/lake/lakestorage/LakeStorageTest.java
index 4c3492337..9c8ae73d4 100644
--- a/fluss-common/src/test/java/com/alibaba/fluss/lake/lakestorage/LakeStorageTest.java
+++ b/fluss-common/src/test/java/com/alibaba/fluss/lake/lakestorage/LakeStorageTest.java
@@ -18,6 +18,7 @@ package com.alibaba.fluss.lake.lakestorage;
 
 import com.alibaba.fluss.config.Configuration;
 import com.alibaba.fluss.exception.TableAlreadyExistException;
+import com.alibaba.fluss.lake.source.LakeSource;
 import com.alibaba.fluss.lake.writer.LakeTieringFactory;
 import com.alibaba.fluss.metadata.TableDescriptor;
 import com.alibaba.fluss.metadata.TablePath;
@@ -131,6 +132,11 @@ class LakeStorageTest {
         public TestPaimonLakeCatalog createLakeCatalog() {
             return new TestPaimonLakeCatalog();
         }
+
+        @Override
+        public LakeSource<?> createLakeSource(TablePath tablePath) {
+            throw new UnsupportedOperationException("Not implemented");
+        }
     }
 
     private static class TestPaimonLakeCatalog implements LakeCatalog {
diff --git a/fluss-lake/fluss-lake-iceberg/src/main/java/com/alibaba/fluss/lake/iceberg/IcebergLakeStorage.java b/fluss-lake/fluss-lake-iceberg/src/main/java/com/alibaba/fluss/lake/iceberg/IcebergLakeStorage.java
index 932dd2b9e..fab753afe 100644
--- a/fluss-lake/fluss-lake-iceberg/src/main/java/com/alibaba/fluss/lake/iceberg/IcebergLakeStorage.java
+++ b/fluss-lake/fluss-lake-iceberg/src/main/java/com/alibaba/fluss/lake/iceberg/IcebergLakeStorage.java
@@ -20,7 +20,9 @@ package com.alibaba.fluss.lake.iceberg;
 import com.alibaba.fluss.config.Configuration;
 import com.alibaba.fluss.lake.lakestorage.LakeCatalog;
 import com.alibaba.fluss.lake.lakestorage.LakeStorage;
+import com.alibaba.fluss.lake.source.LakeSource;
 import com.alibaba.fluss.lake.writer.LakeTieringFactory;
+import com.alibaba.fluss.metadata.TablePath;
 
 /** Iceberg implementation of {@link LakeStorage}. */
 public class IcebergLakeStorage implements LakeStorage {
@@ -40,4 +42,9 @@ public class IcebergLakeStorage implements LakeStorage {
     public LakeCatalog createLakeCatalog() {
         throw new UnsupportedOperationException("Not implemented");
     }
+
+    @Override
+    public LakeSource<?> createLakeSource(TablePath tablePath) {
+        throw new UnsupportedOperationException("Not implemented");
+    }
 }
diff --git a/fluss-lake/fluss-lake-lance/src/main/java/com/alibaba/fluss/lake/lance/LanceLakeStorage.java b/fluss-lake/fluss-lake-lance/src/main/java/com/alibaba/fluss/lake/lance/LanceLakeStorage.java
index 11e6fef28..5864ccf77 100644
--- a/fluss-lake/fluss-lake-lance/src/main/java/com/alibaba/fluss/lake/lance/LanceLakeStorage.java
+++ b/fluss-lake/fluss-lake-lance/src/main/java/com/alibaba/fluss/lake/lance/LanceLakeStorage.java
@@ -21,7 +21,9 @@ import com.alibaba.fluss.config.Configuration;
 import com.alibaba.fluss.lake.lakestorage.LakeStorage;
 import com.alibaba.fluss.lake.lance.tiering.LanceCommittable;
 import com.alibaba.fluss.lake.lance.tiering.LanceWriteResult;
+import com.alibaba.fluss.lake.source.LakeSource;
 import com.alibaba.fluss.lake.writer.LakeTieringFactory;
+import com.alibaba.fluss.metadata.TablePath;
 
 /** Lance implementation of {@link LakeStorage}. */
 public class LanceLakeStorage implements LakeStorage {
@@ -40,4 +42,9 @@ public class LanceLakeStorage implements LakeStorage {
     public LanceLakeCatalog createLakeCatalog() {
         return new LanceLakeCatalog(config);
     }
+
+    @Override
+    public LakeSource<?> createLakeSource(TablePath tablePath) {
+        throw new UnsupportedOperationException("Not implemented");
+    }
 }
diff --git a/fluss-lake/fluss-lake-paimon/src/main/java/com/alibaba/fluss/lake/paimon/PaimonLakeStorage.java b/fluss-lake/fluss-lake-paimon/src/main/java/com/alibaba/fluss/lake/paimon/PaimonLakeStorage.java
index a4da3fb54..03da696a0 100644
--- a/fluss-lake/fluss-lake-paimon/src/main/java/com/alibaba/fluss/lake/paimon/PaimonLakeStorage.java
+++ b/fluss-lake/fluss-lake-paimon/src/main/java/com/alibaba/fluss/lake/paimon/PaimonLakeStorage.java
@@ -22,7 +22,9 @@ import com.alibaba.fluss.lake.lakestorage.LakeStorage;
 import com.alibaba.fluss.lake.paimon.tiering.PaimonCommittable;
 import com.alibaba.fluss.lake.paimon.tiering.PaimonLakeTieringFactory;
 import com.alibaba.fluss.lake.paimon.tiering.PaimonWriteResult;
+import com.alibaba.fluss.lake.source.LakeSource;
 import com.alibaba.fluss.lake.writer.LakeTieringFactory;
+import com.alibaba.fluss.metadata.TablePath;
 
 /** Paimon implementation of {@link LakeStorage}. */
 public class PaimonLakeStorage implements LakeStorage {
@@ -42,4 +44,9 @@ public class PaimonLakeStorage implements LakeStorage {
     public PaimonLakeCatalog createLakeCatalog() {
         return new PaimonLakeCatalog(paimonConfig);
     }
+
+    @Override
+    public LakeSource<?> createLakeSource(TablePath tablePath) {
+        throw new UnsupportedOperationException("Not implemented");
+    }
 }
diff --git a/fluss-server/src/test/java/com/alibaba/fluss/server/lakehouse/TestingPaimonStoragePlugin.java b/fluss-server/src/test/java/com/alibaba/fluss/server/lakehouse/TestingPaimonStoragePlugin.java
index b42789761..da9258e5f 100644
--- a/fluss-server/src/test/java/com/alibaba/fluss/server/lakehouse/TestingPaimonStoragePlugin.java
+++ b/fluss-server/src/test/java/com/alibaba/fluss/server/lakehouse/TestingPaimonStoragePlugin.java
@@ -22,6 +22,7 @@ import com.alibaba.fluss.exception.TableAlreadyExistException;
 import com.alibaba.fluss.lake.lakestorage.LakeCatalog;
 import com.alibaba.fluss.lake.lakestorage.LakeStorage;
 import com.alibaba.fluss.lake.lakestorage.LakeStoragePlugin;
+import com.alibaba.fluss.lake.source.LakeSource;
 import com.alibaba.fluss.lake.writer.LakeTieringFactory;
 import com.alibaba.fluss.metadata.DataLakeFormat;
 import com.alibaba.fluss.metadata.TableDescriptor;
@@ -57,6 +58,11 @@ public class TestingPaimonStoragePlugin implements LakeStoragePlugin {
         public LakeCatalog createLakeCatalog() {
             return new TestingPaimonCatalog();
         }
+
+        @Override
+        public LakeSource<?> createLakeSource(TablePath tablePath) {
+            throw new UnsupportedOperationException("Not implemented");
+        }
     }
 
     /** Paimon implementation of LakeCatalog for testing purpose. */
diff --git a/fluss-test-coverage/pom.xml b/fluss-test-coverage/pom.xml
index 5feb9c8ae..d4015908b 100644
--- a/fluss-test-coverage/pom.xml
+++ b/fluss-test-coverage/pom.xml
@@ -324,6 +324,8 @@
                                         <exclude>com.alibaba.fluss.tools.ci.*</exclude>
                                         <!-- end exclude for predicate -->
                                         <exclude>com.alibaba.fluss.predicate.*</exclude>
+                                        <!-- end exclude for lake source -->
+                                        <exclude>com.alibaba.fluss.lake.source.*</exclude>
                                         <!-- exclude for dummy class -->
                                         <exclude>com.alibaba.fluss.dist.DummyClass</exclude>
                                         <exclude>com.alibaba.fluss.flink.DummyClass120</exclude>