lbug 0.12.3-dev.26 → 0.12.3-dev.28

package/lbug-source/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.15)
 
-project(Lbug VERSION 0.12.3.26 LANGUAGES CXX C)
+project(Lbug VERSION 0.12.3.28 LANGUAGES CXX C)
 
 option(SINGLE_THREADED "Single-threaded mode" FALSE)
 if(SINGLE_THREADED)

package/lbug-source/Makefile

@@ -14,7 +14,7 @@
 	benchmark example \
 	extension-test-build extension-test extension-json-test-build extension-json-test \
 	extension-debug extension-release \
-	shell-test \
+	shell shell-debug shell-test \
 	tidy tidy-analyzer clangd-diagnostics \
 	install \
 	clean-extension clean-python-api clean-java clean
@@ -234,7 +234,7 @@ example:
 	$(call run-cmake-release, -DBUILD_EXAMPLES=TRUE)
 
 extension-build:
-	$(call run-cmake-relwithdebinfo,-DBUILD_EXTENSIONS="$(EXTENSION_LIST)")
+	$(call run-cmake-relwithdebinfo,-DBUILD_EXTENSIONS="$(EXTENSION_LIST)" -DEXTENSION_STATIC_LINK_LIST="$(EXTENSION_STATIC_LINK_LIST)")
 
 extension-test-build:
 	$(call run-cmake-relwithdebinfo, \
@@ -294,6 +294,18 @@ extension-release:
 		-DBUILD_LBUG=FALSE \
 	)
 
+shell:
+	BM_MALLOC=1 $(call run-cmake-release, \
+		-DBUILD_SHELL=TRUE \
+		-DEXTENSION_STATIC_LINK_LIST=duckdb \
+	)
+
+shell-debug:
+	BM_MALLOC=1 $(call run-cmake-debug, \
+		-DBUILD_SHELL=TRUE \
+		-DEXTENSION_STATIC_LINK_LIST=duckdb \
+	)
+
 shell-test:
 	$(call run-cmake-relwithdebinfo, \
 		-DBUILD_SHELL=TRUE \

package/lbug-source/extension/duckdb/src/catalog/duckdb_catalog.cpp

@@ -91,7 +91,7 @@ void DuckDBCatalog::createForeignTable(const std::string& tableName) {
     auto duckdbTableInfo =
         connector.getTableScanInfo(getQuery(*info), std::move(columnTypes), columnNames);
     auto tableEntry = std::make_unique<catalog::DuckDBTableCatalogEntry>(info->tableName,
-        getScanFunction(duckdbTableInfo));
+        getScanFunction(duckdbTableInfo), duckdbTableInfo);
     for (auto& definition : extraInfo->propertyDefinitions) {
         tableEntry->addProperty(definition);
     }

package/lbug-source/extension/duckdb/src/catalog/duckdb_table_catalog_entry.cpp

@@ -1,21 +1,60 @@
 #include "catalog/duckdb_table_catalog_entry.h"
 
-#include "binder/ddl/bound_create_table_info.h"
+#include "binder/bound_scan_source.h"
+#include "binder/expression/variable_expression.h"
+#include "common/constants.h"
+#include "function/duckdb_scan.h"
 
 namespace lbug {
 namespace catalog {
 
 DuckDBTableCatalogEntry::DuckDBTableCatalogEntry(std::string name,
-    function::TableFunction scanFunction)
+    function::TableFunction scanFunction,
+    std::shared_ptr<duckdb_extension::DuckDBTableScanInfo> scanInfo)
     : TableCatalogEntry{CatalogEntryType::FOREIGN_TABLE_ENTRY, std::move(name)},
-      scanFunction{std::move(scanFunction)} {}
+      scanFunction{std::move(scanFunction)}, scanInfo{std::move(scanInfo)} {}
 
 common::TableType DuckDBTableCatalogEntry::getTableType() const {
     return common::TableType::FOREIGN;
 }
 
+std::unique_ptr<binder::BoundTableScanInfo> DuckDBTableCatalogEntry::getBoundScanInfo(
+    main::ClientContext* context, const std::string& nodeUniqueName) {
+    auto columnNames = scanInfo->getColumnNames();
+    auto columnTypes = scanInfo->getColumnTypes(*context);
+    binder::expression_vector columns;
+
+    // Add rowid as _ID (internal ID) if nodeUniqueName is provided
+    if (!nodeUniqueName.empty()) {
+        auto idUniqueName = nodeUniqueName + "." + std::string(common::InternalKeyword::ID);
+        columns.push_back(std::make_shared<binder::VariableExpression>(common::LogicalType::INT64(),
+            idUniqueName, "rowid"));
+    }
+
+    for (auto i = 0u; i < columnNames.size(); i++) {
+        std::string uniqueName = columnNames[i];
+        if (!nodeUniqueName.empty()) {
+            uniqueName = nodeUniqueName + "." + columnNames[i];
+        }
+        columns.push_back(std::make_shared<binder::VariableExpression>(std::move(columnTypes[i]),
+            uniqueName, columnNames[i]));
+    }
+
+    // Build column names for DuckDB query - include rowid if needed
+    std::vector<std::string> duckdbColumnNames;
+    if (!nodeUniqueName.empty()) {
+        duckdbColumnNames.push_back("rowid");
+    }
+    duckdbColumnNames.insert(duckdbColumnNames.end(), columnNames.begin(), columnNames.end());
+
+    auto bindData =
+        std::make_unique<duckdb_extension::DuckDBScanBindData>(scanInfo->getTemplateQuery(*context),
+            duckdbColumnNames, scanInfo->getConnector(), std::move(columns));
+    return std::make_unique<binder::BoundTableScanInfo>(scanFunction, std::move(bindData));
+}
+
 std::unique_ptr<TableCatalogEntry> DuckDBTableCatalogEntry::copy() const {
-    auto other = std::make_unique<DuckDBTableCatalogEntry>(name, scanFunction);
+    auto other = std::make_unique<DuckDBTableCatalogEntry>(name, scanFunction, scanInfo);
     other->copyFrom(*this);
     return other;
 }

package/lbug-source/extension/duckdb/src/connector/duckdb_result_converter.cpp

@@ -121,10 +121,16 @@ void DuckDBResultConverter::convertDuckDBResultToVector(duckdb::DataChunk& duckD
     for (auto i = 0u; i < conversionFunctions.size(); i++) {
         result.state->getSelVectorUnsafe().setSelSize(duckDBResult.size());
         if (columnSkips && columnSkips.value()[i]) {
+            // For rowid (first column), we always fetch it from DuckDB but skip writing to output.
+            // This keeps DuckDB result columns aligned with our expected order.
+            if (i == 0) {
+                duckdbResultColIdx++;
+            }
             continue;
         }
         KU_ASSERT(duckDBResult.data[duckdbResultColIdx].GetVectorType() ==
                   duckdb::VectorType::FLAT_VECTOR);
+        // Write to output vector at position i (the original column index)
         conversionFunctions[i](duckDBResult.data[duckdbResultColIdx],
             result.getValueVectorMutable(i), result.state->getSelVector().getSelSize());
         duckdbResultColIdx++;

package/lbug-source/extension/duckdb/src/connector/duckdb_secret_manager.cpp

@@ -18,7 +18,7 @@ static std::string getDuckDBExtensionOptions(httpfs_extension::S3AuthParams lbug
 std::string DuckDBSecretManager::getRemoteS3FSSecret(main::ClientContext* context,
     const httpfs_extension::S3FileSystemConfig& config) {
     KU_ASSERT(config.fsName == "S3" || config.fsName == "GCS");
-    std::string templateQuery = R"(CREATE SECRET {}_secret (
+    static constexpr std::string_view templateQuery = R"(CREATE SECRET {}_secret (
         {}
         TYPE {}
     );)";

package/lbug-source/extension/duckdb/src/function/duckdb_scan.cpp

@@ -15,21 +15,56 @@ namespace duckdb_extension {
 
 std::string DuckDBScanBindData::getColumnsToSelect() const {
     std::string columnNames = "";
+    auto columnSkips = getColumnSkips();
     auto numSkippedColumns =
         std::count_if(columnSkips.begin(), columnSkips.end(), [](auto item) { return item; });
     if (getNumColumns() == numSkippedColumns) {
-        columnNames = columnNamesInDuckDB[0];
+        return columnNamesInDuckDB[0];
     }
+    bool first = true;
     for (auto i = 0u; i < getNumColumns(); i++) {
-        if (columnSkips[i]) {
+        // Always include rowid (first column) even if marked as skipped.
+        // This ensures consistent column ordering between DuckDB results and the converter.
+        bool isRowid =
+            (i == 0 && !columnNamesInDuckDB.empty() && columnNamesInDuckDB[0] == "rowid");
+        if (columnSkips[i] && !isRowid) {
             continue;
         }
+        if (!first) {
+            columnNames += ",";
+        }
         columnNames += columnNamesInDuckDB[i];
-        columnNames += (i == getNumColumns() - 1) ? "" : ",";
+        first = false;
     }
     return columnNames;
 }
 
+std::string DuckDBScanBindData::getDescription() const {
+    auto columns = getColumnsToSelect();
+    std::string predicatesString = "";
+    for (auto& predicates : getColumnPredicates()) {
+        if (predicates.isEmpty()) {
+            continue;
+        }
+        if (predicatesString.empty()) {
+            predicatesString = " WHERE " + predicates.toString();
+        } else {
+            predicatesString += common::stringFormat(" AND {}", predicates.toString());
+        }
+    }
+    std::string q = query;
+    size_t pos = q.find("{}");
+    if (pos != std::string::npos) {
+        q.replace(pos, 2, columns);
+    }
+    q += predicatesString;
+    q += getOrderBy();
+    if (getLimitNum() != common::INVALID_ROW_IDX) {
+        q += common::stringFormat(" LIMIT {}", getLimitNum());
+    }
+    return q;
+}
+
 DuckDBScanSharedState::DuckDBScanSharedState(
     std::shared_ptr<duckdb::MaterializedQueryResult> queryResult)
     : function::TableFuncSharedState{queryResult->RowCount()}, queryResult{std::move(queryResult)} {
@@ -66,7 +101,16 @@ std::unique_ptr<TableFuncSharedState> DuckDBScanFunction::initSharedState(
             predicatesString += stringFormat(" AND {}", predicates.toString());
         }
     }
-    auto finalQuery = stringFormat(scanBindData->query, columnNames) + predicatesString;
+    std::string finalQuery = scanBindData->query;
+    size_t pos = finalQuery.find("{}");
+    if (pos != std::string::npos) {
+        finalQuery.replace(pos, 2, columnNames);
+    }
+    finalQuery += predicatesString;
+    finalQuery += scanBindData->getOrderBy();
+    if (scanBindData->getLimitNum() != INVALID_ROW_IDX) {
+        finalQuery += stringFormat(" LIMIT {}", scanBindData->getLimitNum());
+    }
     auto result = scanBindData->connector.executeQuery(finalQuery);
     if (result->HasError()) {
         throw RuntimeException(
@@ -117,6 +161,7 @@ TableFunction getScanFunction(std::shared_ptr<DuckDBTableScanInfo> scanInfo) {
         std::placeholders::_2);
     function.initSharedStateFunc = DuckDBScanFunction::initSharedState;
     function.initLocalStateFunc = DuckDBScanFunction::initLocalState;
+    function.supportsPushDownFunc = [] { return true; };
     return function;
 }
 

package/lbug-source/extension/duckdb/src/include/catalog/duckdb_table_catalog_entry.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "catalog/catalog_entry/table_catalog_entry.h"
+#include "function/duckdb_scan.h"
 #include "function/table/table_function.h"
 
 namespace lbug {
@@ -11,13 +12,16 @@ public:
     //===--------------------------------------------------------------------===//
     // constructors
     //===--------------------------------------------------------------------===//
-    DuckDBTableCatalogEntry(std::string name, function::TableFunction scanFunction);
+    DuckDBTableCatalogEntry(std::string name, function::TableFunction scanFunction,
+        std::shared_ptr<duckdb_extension::DuckDBTableScanInfo> scanInfo);
 
     //===--------------------------------------------------------------------===//
     // getter & setter
     //===--------------------------------------------------------------------===//
     common::TableType getTableType() const override;
     function::TableFunction getScanFunction() override { return scanFunction; }
+    std::unique_ptr<binder::BoundTableScanInfo> getBoundScanInfo(main::ClientContext* context,
+        const std::string& nodeUniqueName = "") override;
 
     //===--------------------------------------------------------------------===//
     // serialization & deserialization
@@ -30,6 +34,7 @@ private:
 
 private:
     function::TableFunction scanFunction;
+    std::shared_ptr<duckdb_extension::DuckDBTableScanInfo> scanInfo;
 };
 
 } // namespace catalog

package/lbug-source/extension/duckdb/src/include/function/duckdb_scan.h

@@ -60,6 +60,8 @@ struct DuckDBScanBindData : function::TableFuncBindData {
 
     std::string getColumnsToSelect() const;
 
+    std::string getDescription() const override;
+
     std::unique_ptr<TableFuncBindData> copy() const override {
         return std::make_unique<DuckDBScanBindData>(*this);
     }

package/lbug-source/extension/duckdb/test/test_files/duckdb.test

@@ -321,3 +321,31 @@ Attached database successfully.
 7|Elizabeth|1|False|True|20|4.700000|1980-10-26|1976-12-23 11:21:42|48:24:11|[2]|[Ein]|[[6],[7],[8]]|1.463000|a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a15|[96,59,65,88]
 8|Farooq|2|True|False|25|4.500000|1980-10-26|1972-07-31 13:22:30.678559|00:18:00.024|[3,4,5,6,7]|[Fesdwe]|[[8]]|1.510000|a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a16|[80,78,34,83]
 9|Greg|2|False|False|40|4.900000|1980-10-26|1976-12-23 11:21:42|10 years 5 months 13:00:00.000024|[1]|[Grad]|[[10]]|1.600000|a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a17|[43,83,67,43]
+
+-CASE DuckDBNodeTable
+-LOAD_DYNAMIC_EXTENSION duckdb
+-STATEMENT ATTACH '${LBUG_ROOT_DIRECTORY}/dataset/databases/duckdb_database/tinysnb.db' as ts (dbtype duckdb, skip_unsupported_table = true);
+---- 1
+Attached database successfully.
+-STATEMENT MATCH (a:ts.person) RETURN count(*);
+---- 1
+8
+-STATEMENT MATCH (a:ts.person) WHERE a.age > 30 RETURN count(*);
+---- 1
+4
+-STATEMENT MATCH (a:ts.person) RETURN a.ID ORDER BY a.ID LIMIT 3;
+---- 3
+0
+2
+3
+-STATEMENT MATCH (a:ts.person) RETURN a.ID ORDER BY a.ID DESC LIMIT 3;
+---- 3
+10
+9
+8
+-STATEMENT MATCH (a:ts.person) WHERE a.age > 20 RETURN a.ID ORDER BY a.age DESC LIMIT 2;
+---- 2
+10
+3
+-STATEMENT DETACH ts;
+---- ok

package/lbug-source/extension/extension_config.cmake

@@ -1,8 +1,6 @@
 set(EXTENSION_LIST azure delta duckdb fts httpfs iceberg json llm postgres sqlite unity_catalog vector neo4j algo)
 
 #set(EXTENSION_STATIC_LINK_LIST fts)
-string(JOIN ", " joined_extensions ${EXTENSION_STATIC_LINK_LIST})
-message(STATUS "Static link extensions: ${joined_extensions}")
 foreach(extension IN LISTS EXTENSION_STATIC_LINK_LIST)
     add_static_link_extension(${extension})
 endforeach()
@@ -30,3 +28,6 @@ if(${BUILD_SWIFT})
     add_static_link_extension(vector)
     add_static_link_extension(algo)
 endif()
+
+string(JOIN ", " joined_extensions ${STATICALLY_LINKED_EXTENSIONS})
+message(STATUS "Static link extensions: ${joined_extensions}")

package/lbug-source/scripts/antlr4/Cypher.g4

@@ -699,7 +699,7 @@ oC_UpperBound
     : DecimalInteger ;
 
 oC_LabelName
-    : oC_SchemaName ;
+    : oC_SchemaName ( '.' oC_SchemaName )? ;
 
 oC_RelTypeName
     : oC_SchemaName ;

package/lbug-source/scripts/antlr4/hash.md5

@@ -1 +1 @@
-52606d4848c2f224b8e480fec2923081
+d606604ea3991978c8b514d4ac36b8f6

package/lbug-source/src/antlr4/Cypher.g4

@@ -452,7 +452,7 @@ oC_UpperBound
     : DecimalInteger ;
 
 oC_LabelName
-    : oC_SchemaName ;
+    : oC_SchemaName ( '.' oC_SchemaName )? ;
 
 oC_RelTypeName
     : oC_SchemaName ;

package/lbug-source/src/binder/bind/bind_graph_pattern.cpp

@@ -15,6 +15,7 @@
 #include "function/rewrite_function.h"
 #include "function/schema/vector_node_rel_functions.h"
 #include "main/client_context.h"
+#include "main/database_manager.h"
 #include "transaction/transaction.h"
 
 using namespace lbug::common;
@@ -644,7 +645,8 @@ std::vector<TableCatalogEntry*> Binder::bindNodeTableEntries(
     } else {
         for (auto& name : tableNames) {
             auto entry = bindNodeTableEntry(name);
-            if (entry->getType() != CatalogEntryType::NODE_TABLE_ENTRY) {
+            if (entry->getType() != CatalogEntryType::NODE_TABLE_ENTRY &&
+                entry->getType() != CatalogEntryType::FOREIGN_TABLE_ENTRY) {
                 throw BinderException(
                     stringFormat("Cannot bind {} as a node pattern label.", entry->getName()));
             }
@@ -658,10 +660,35 @@ TableCatalogEntry* Binder::bindNodeTableEntry(const std::string& name) const {
     auto transaction = transaction::Transaction::Get(*clientContext);
     auto catalog = Catalog::Get(*clientContext);
     auto useInternal = clientContext->useInternalCatalogEntry();
-    if (!catalog->containsTable(transaction, name, useInternal)) {
+
+    std::string dbName;
+    std::string tableName = name;
+    auto dotPos = name.find('.');
+    if (dotPos != std::string::npos) {
+        dbName = name.substr(0, dotPos);
+        tableName = name.substr(dotPos + 1);
+    }
+
+    if (!dbName.empty()) {
+        // Qualified name: db.table
+        auto attachedDB = main::DatabaseManager::Get(*clientContext)->getAttachedDatabase(dbName);
+        if (!attachedDB) {
+            throw BinderException(stringFormat("Attached database {} does not exist.", dbName));
+        }
+        auto attachedCatalog = attachedDB->getCatalog();
+        if (!attachedCatalog->containsTable(transaction, tableName, useInternal)) {
+            throw BinderException(stringFormat("Table {} does not exist in attached database {}.",
+                tableName, dbName));
+        }
+        return attachedCatalog->getTableCatalogEntry(transaction, tableName, useInternal);
+    } else {
+        // Unqualified name: only search main catalog
+        // Foreign tables require qualified names (db.table) to avoid ambiguity
+        if (catalog->containsTable(transaction, name, useInternal)) {
+            return catalog->getTableCatalogEntry(transaction, name, useInternal);
+        }
         throw BinderException(stringFormat("Table {} does not exist.", name));
     }
-    return catalog->getTableCatalogEntry(transaction, name, useInternal);
 }
 
 std::vector<TableCatalogEntry*> Binder::bindRelGroupEntries(

package/lbug-source/src/catalog/catalog_set.cpp

@@ -246,6 +246,7 @@ void CatalogSet::serialize(Serializer serializer) const {
         case CatalogEntryType::COPY_FUNCTION_ENTRY:
         case CatalogEntryType::TABLE_FUNCTION_ENTRY:
         case CatalogEntryType::STANDALONE_TABLE_FUNCTION_ENTRY:
+        case CatalogEntryType::FOREIGN_TABLE_ENTRY:
             continue;
         default: {
             auto committedEntry = getCommittedEntryNoLock(entry.get());

package/lbug-source/src/function/table/table_function.cpp

@@ -100,8 +100,17 @@ std::unique_ptr<PhysicalOperator> TableFunction::getPhysicalPlan(PlanMapper* pla
     auto initInput =
         TableFuncInitSharedStateInput(info.bindData.get(), planMapper->executionContext);
     auto sharedState = info.function.initSharedStateFunc(initInput);
-    auto printInfo = std::make_unique<TableFunctionCallPrintInfo>(call.getTableFunc().name,
-        call.getBindData()->columns);
+    // Filter columns for print info based on column skips
+    binder::expression_vector printExprs;
+    auto columnSkips = call.getBindData()->getColumnSkips();
+    for (auto i = 0u; i < call.getBindData()->columns.size(); ++i) {
+        if (columnSkips.empty() || !columnSkips[i]) {
+            printExprs.push_back(call.getBindData()->columns[i]);
+        }
+    }
+    auto desc = call.getBindData()->getDescription();
+    auto printInfo = std::make_unique<TableFunctionCallPrintInfo>(
+        desc.empty() ? call.getTableFunc().name : desc, printExprs);
     return std::make_unique<TableFunctionCall>(std::move(info), sharedState,
         planMapper->getOperatorID(), std::move(printInfo));
 }

package/lbug-source/src/include/catalog/catalog_entry/table_catalog_entry.h

@@ -2,6 +2,7 @@
 
 #include <vector>
 
+#include "binder/bound_scan_source.h"
 #include "binder/ddl/bound_alter_info.h"
 #include "binder/ddl/bound_create_table_info.h"
 #include "catalog/catalog_entry/catalog_entry.h"
@@ -43,6 +44,12 @@ public:
 
     virtual function::TableFunction getScanFunction() { KU_UNREACHABLE; }
 
+    virtual std::unique_ptr<binder::BoundTableScanInfo> getBoundScanInfo(
+        [[maybe_unused]] main::ClientContext* context,
+        [[maybe_unused]] const std::string& nodeUniqueName = "") {
+        return nullptr;
+    }
+
     common::column_id_t getMaxColumnID() const;
     void vacuumColumnIDs(common::column_id_t nextColumnID);
     std::vector<binder::PropertyDefinition> getProperties() const {

package/lbug-source/src/include/common/string_format.h

@@ -14,8 +14,8 @@ namespace common {
 #if USE_STD_FORMAT
 
 template<typename... Args>
-inline std::string stringFormat(std::format_string<Args...> format, Args&&... args) {
-    return std::format(format, std::forward<Args>(args)...);
+inline std::string stringFormat(std::string_view format, Args&&... args) {
+    return std::vformat(format, std::make_format_args(args...));
 }
 
 #else

package/lbug-source/src/include/function/table/bind_data.h

@@ -25,7 +25,8 @@ struct LBUG_API TableFuncBindData {
     TableFuncBindData(const TableFuncBindData& other)
         : columns{other.columns}, numRows{other.numRows},
           optionalParams{other.optionalParams == nullptr ? nullptr : other.optionalParams->copy()},
-          columnSkips{other.columnSkips}, columnPredicates{copyVector(other.columnPredicates)} {}
+          columnSkips{other.columnSkips}, columnPredicates{copyVector(other.columnPredicates)},
+          limitNum{other.limitNum}, orderBy{other.orderBy} {}
     TableFuncBindData& operator=(const TableFuncBindData& other) = delete;
     virtual ~TableFuncBindData() = default;
 
@@ -46,10 +47,18 @@ struct LBUG_API TableFuncBindData {
         return columnPredicates;
     }
 
+    void setLimitNum(common::row_idx_t limit) { limitNum = limit; }
+    common::row_idx_t getLimitNum() const { return limitNum; }
+
+    void setOrderBy(std::string orderBy) { this->orderBy = orderBy; }
+    std::string getOrderBy() const { return orderBy; }
+
     virtual bool getIgnoreErrorsOption() const;
 
     virtual std::unique_ptr<TableFuncBindData> copy() const;
 
+    virtual std::string getDescription() const { return ""; }
+
     template<class TARGET>
     const TARGET* constPtrCast() const {
         return common::ku_dynamic_cast<const TARGET*>(this);
@@ -63,6 +72,8 @@ struct LBUG_API TableFuncBindData {
 protected:
     std::vector<bool> columnSkips;
     std::vector<storage::ColumnPredicateSet> columnPredicates;
+    common::row_idx_t limitNum = common::INVALID_ROW_IDX;
+    std::string orderBy;
 };
 
 } // namespace function

package/lbug-source/src/include/function/table/table_function.h

@@ -133,6 +133,7 @@ using table_func_init_local_t =
 using table_func_init_output_t =
     std::function<std::unique_ptr<TableFuncOutput>(const TableFuncInitOutputInput&)>;
 using table_func_can_parallel_t = std::function<bool()>;
+using table_func_supports_push_down_t = std::function<bool()>;
 using table_func_progress_t = std::function<double(TableFuncSharedState* sharedState)>;
 using table_func_finalize_t =
     std::function<void(const processor::ExecutionContext*, TableFuncSharedState*)>;
@@ -153,6 +154,7 @@ struct LBUG_API TableFunction final : Function {
     table_func_init_local_t initLocalStateFunc = nullptr;
     table_func_init_output_t initOutputFunc = nullptr;
     table_func_can_parallel_t canParallelFunc = [] { return true; };
+    table_func_supports_push_down_t supportsPushDownFunc = [] { return false; };
     table_func_progress_t progressFunc = [](TableFuncSharedState*) { return 0.0; };
     table_func_finalize_t finalizeFunc = [](auto, auto) {};
     table_func_rewrite_t rewriteFunc = nullptr;

package/lbug-source/src/include/optimizer/order_by_push_down_optimizer.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "planner/operator/logical_plan.h"
+
+namespace lbug {
+namespace optimizer {
+
+class OrderByPushDownOptimizer {
+public:
+    void rewrite(planner::LogicalPlan* plan);
+
+private:
+    std::shared_ptr<planner::LogicalOperator> visitOperator(
+        std::shared_ptr<planner::LogicalOperator> op, std::string currentOrderBy = "");
+
+    static std::string buildOrderByString(const binder::expression_vector& expressions,
+        const std::vector<bool>& isAscOrders);
+};
+
+} // namespace optimizer
+} // namespace lbug

package/lbug-source/src/include/planner/operator/logical_table_function_call.h

@@ -27,11 +27,18 @@ public:
     void setColumnPredicates(std::vector<storage::ColumnPredicateSet> predicates) {
         bindData->setColumnPredicates(std::move(predicates));
     }
+    void setLimitNum(common::row_idx_t limit) { bindData->setLimitNum(limit); }
+    void setOrderBy(std::string orderBy) { bindData->setOrderBy(orderBy); }
 
     void computeFlatSchema() override;
     void computeFactorizedSchema() override;
 
-    std::string getExpressionsForPrinting() const override { return tableFunc.name; }
+    std::string getExpressionsForPrinting() const override {
+        auto desc = bindData->getDescription();
+        return desc.empty() ? tableFunc.name : desc;
+    }
+
+    std::unique_ptr<OPPrintInfo> getPrintInfo() const override;
 
     std::unique_ptr<LogicalOperator> copy() override {
         return std::make_unique<LogicalTableFunctionCall>(tableFunc, bindData->copy());
@@ -42,5 +49,11 @@ private:
     std::unique_ptr<function::TableFuncBindData> bindData;
 };
 
+struct LogicalTableFunctionCallPrintInfo final : OPPrintInfo {
+    std::string desc;
+    explicit LogicalTableFunctionCallPrintInfo(std::string desc) : desc{std::move(desc)} {}
+    std::string toString() const override { return desc; }
+};
+
 } // namespace planner
 } // namespace lbug

package/lbug-source/src/optimizer/CMakeLists.txt

@@ -15,7 +15,8 @@ add_library(lbug_optimizer
         remove_factorization_rewriter.cpp
         remove_unnecessary_join_optimizer.cpp
         top_k_optimizer.cpp
-        limit_push_down_optimizer.cpp)
+        limit_push_down_optimizer.cpp
+        order_by_push_down_optimizer.cpp)
 
 set(ALL_OBJECT_FILES
         ${ALL_OBJECT_FILES} $<TARGET_OBJECTS:lbug_optimizer>

package/lbug-source/src/optimizer/limit_push_down_optimizer.cpp

@@ -6,6 +6,7 @@
 #include "planner/operator/logical_distinct.h"
 #include "planner/operator/logical_hash_join.h"
 #include "planner/operator/logical_limit.h"
+#include "planner/operator/logical_table_function_call.h"
 
 using namespace lbug::binder;
 using namespace lbug::common;
@@ -34,10 +35,21 @@ void LimitPushDownOptimizer::visitOperator(planner::LogicalOperator* op) {
     case LogicalOperatorType::MULTIPLICITY_REDUCER:
     case LogicalOperatorType::EXPLAIN:
     case LogicalOperatorType::ACCUMULATE:
+    case LogicalOperatorType::FILTER:
     case LogicalOperatorType::PROJECTION: {
         visitOperator(op->getChild(0).get());
         return;
     }
+    case LogicalOperatorType::TABLE_FUNCTION_CALL: {
+        if (limitNumber == INVALID_LIMIT && skipNumber == 0) {
+            return;
+        }
+        auto& tableFuncCall = op->cast<LogicalTableFunctionCall>();
+        if (tableFuncCall.getTableFunc().supportsPushDownFunc()) {
+            tableFuncCall.setLimitNum(skipNumber + limitNumber);
+        }
+        return;
+    }
     case LogicalOperatorType::DISTINCT: {
         if (limitNumber == INVALID_LIMIT && skipNumber == 0) {
             return;

package/lbug-source/src/optimizer/optimizer.cpp

@@ -9,6 +9,7 @@
 #include "optimizer/factorization_rewriter.h"
 #include "optimizer/filter_push_down_optimizer.h"
 #include "optimizer/limit_push_down_optimizer.h"
+#include "optimizer/order_by_push_down_optimizer.h"
 #include "optimizer/projection_push_down_optimizer.h"
 #include "optimizer/remove_factorization_rewriter.h"
 #include "optimizer/remove_unnecessary_join_optimizer.h"
@@ -45,6 +46,9 @@ void Optimizer::optimize(planner::LogicalPlan* plan, main::ClientContext* contex
             ProjectionPushDownOptimizer(context->getClientConfig()->recursivePatternSemantic);
         projectionPushDownOptimizer.rewrite(plan);
 
+        auto orderByPushDownOptimizer = OrderByPushDownOptimizer();
+        orderByPushDownOptimizer.rewrite(plan);
+
         auto limitPushDownOptimizer = LimitPushDownOptimizer();
         limitPushDownOptimizer.rewrite(plan);