ladybug 0.22.0.dev20261024__tar.gz → 0.22.3__tar.gz

sdist/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ladybug
-Version: 0.22.0.dev20261024
+Version: 0.22.3
 Summary: Highly scalable, extremely fast, easy-to-use embeddable graph database
 Home-page: https://github.com/LadybugDB/ladybug
 License: MIT

sdist/ladybug-source/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.15)
 
-project(Lbug VERSION 0.22.0.20261024 LANGUAGES CXX C)
+project(Lbug VERSION 0.22.3 LANGUAGES CXX C)
 
 option(SINGLE_THREADED "Single-threaded mode" FALSE)
 if(SINGLE_THREADED)
@@ -553,7 +553,7 @@ unset(LBUG_LINK_LIBRARIES)
 
 add_definitions(-DLBUG_ROOT_DIRECTORY="${PROJECT_SOURCE_DIR}")
 add_definitions(-DLBUG_CMAKE_VERSION="${CMAKE_PROJECT_VERSION}")
-add_definitions(-DLBUG_EXTENSION_VERSION="dev")
+add_definitions(-DLBUG_EXTENSION_VERSION="0.22.0")
 
 if(BUILD_LBUG OR LBUG_API_USE_PRECOMPILED_LIB)
 include_directories(

sdist/ladybug-source/pixi.toml

@@ -5,5 +5,13 @@ platforms = ["linux-64", "linux-aarch64", "osx-64", "osx-arm64", "win-64"]
 
 [dependencies]
 libadbc-driver-manager = ">=1.11.0,<2"
-libarrow = ">=25.0.0"
+# Keep the conda libarrow on 25.x: the algo extension builds against the
+# system Apache Arrow 26 (libarrow.so.2600 from packages.apache.org), while
+# the pixi env only needs Arrow 25 for libadbc-driver-manager. Letting this
+# float to >=26 shadows the system 2600 at runtime via LD_LIBRARY_PATH, and
+# conda-forge's libarrow 26.0.0 currently resolves with simdjson 5.0.8
+# (libsimdjson.so.35) while its DT_NEEDED asks for libsimdjson.so.34,
+# breaking `LOAD EXTENSION 'algo'` with "libsimdjson.so.34: cannot open
+# shared object file". Revisit once conda-forge's arrow/simdjson are coherent.
+libarrow = ">=25.0.0,<26"
 llvm-openmp = ">=22.1.8,<23"

sdist/ladybug-source/src/binder/bind/bind_ddl.cpp

@@ -324,10 +324,11 @@ BoundCreateTableInfo Binder::bindCreateRelTableGroupInfo(const CreateTableInfo*
     if (!storage.empty()) {
         auto dotPos = storage.find('.');
         // Check if storage is database.table format by verifying the attached database exists
-        // Handle special case where icebug-disk storage could contain a dot
+        // Handle special case where columnar storage paths (e.g. icebug-disk, lance)
+        // could contain a dot. Only unformatted storage is probed as database.table.
         // Otherwise, treat as file path (e.g., "dataset/demo-db/icebug-disk/demo" or
         // "data.parquet")
-        if (storageFormat != StorageFormat::ICEBUG_DISK && dotPos != std::string::npos) {
+        if (storageFormat == StorageFormat::NONE && dotPos != std::string::npos) {
             std::string dbName = storage.substr(0, dotPos);
             std::string tableName = storage.substr(dotPos + 1);
             if (!dbName.empty()) {
@@ -422,22 +423,25 @@ BoundCreateTableInfo Binder::bindCreateRelTableGroupInfo(const CreateTableInfo*
             }
         }
 
-        bool isSrcIcebugDisk = srcEntry->getType() == CatalogEntryType::NODE_TABLE_ENTRY ?
-                                   srcEntry->ptrCast<NodeTableCatalogEntry>()->getStorageFormat() ==
-                                       StorageFormat::ICEBUG_DISK :
-                                   false;
-        bool isDstIcebugDisk = dstEntry->getType() == CatalogEntryType::NODE_TABLE_ENTRY ?
-                                   dstEntry->ptrCast<NodeTableCatalogEntry>()->getStorageFormat() ==
-                                       StorageFormat::ICEBUG_DISK :
-                                   false;
-        bool isRelIcebugDisk = (storageFormat == StorageFormat::ICEBUG_DISK);
-
-        // We don't allow mixing icebug-disk tables with non-icebug-disk tables
-        // We only allow icebug-disk rel tables to connect icebug-disk node tables
-        if ((!isRelIcebugDisk && (isSrcIcebugDisk || isDstIcebugDisk)) ||
-            (isRelIcebugDisk && (!isSrcIcebugDisk || !isDstIcebugDisk))) {
-            throw BinderException(
-                "Cannot mix icebug-disk tables with non-icebug-disk tables in CREATE REL TABLE.");
+        auto getEntryStorageFormat = [](TableCatalogEntry* entry) {
+            return entry->getType() == CatalogEntryType::NODE_TABLE_ENTRY ?
+                       entry->ptrCast<NodeTableCatalogEntry>()->getStorageFormat() :
+                       StorageFormat::NONE;
+        };
+        const auto srcStorageFormat = getEntryStorageFormat(srcEntry);
+        const auto dstStorageFormat = getEntryStorageFormat(dstEntry);
+
+        // We don't allow mixing columnar-format tables (e.g. icebug-disk, lance) with
+        // tables of another format. A rel table must use the same storage format as the
+        // node tables it connects.
+        if (storageFormat != srcStorageFormat || storageFormat != dstStorageFormat) {
+            const auto oddFormat = storageFormat != StorageFormat::NONE    ? storageFormat :
+                                   srcStorageFormat != StorageFormat::NONE ? srcStorageFormat :
+                                                                             dstStorageFormat;
+            const auto oddName = StorageFormatUtils::toString(oddFormat);
+            throw BinderException(std::format("Cannot mix {} tables with non-{} tables in CREATE "
+                                              "REL TABLE.",
+                oddName, oddName));
         }
 
         // Use the actual shadow table IDs, not FOREIGN_TABLE_ID
@@ -906,6 +910,14 @@ std::unique_ptr<BoundStatement> Binder::bindAlterFromToConnection(
     auto info = alter.getInfo();
     auto extraInfo = info->extraInfo->constPtrCast<ExtraAddFromToConnection>();
     auto tableName = info->tableName;
+    // Only a rel table has FROM/TO connections; Alter would cast any other entry to one.
+    auto catalog = Catalog::Get(*clientContext);
+    auto transaction = transaction::Transaction::Get(*clientContext);
+    if (catalog->containsTable(transaction, tableName) &&
+        catalog->getTableCatalogEntry(transaction, tableName)->getType() !=
+            CatalogEntryType::REL_GROUP_ENTRY) {
+        throw BinderException(std::format("{} is not of type REL.", tableName));
+    }
     auto [srcTableEntry, srcDbName] = bindNodeTableEntry(extraInfo->srcTableName);
     auto [dstTableEntry, dstDbName] = bindNodeTableEntry(extraInfo->dstTableName);
     auto srcTableID = srcTableEntry->getTableID();

sdist/ladybug-source/src/binder/bind/bind_file_scan.cpp

@@ -198,9 +198,9 @@ std::unique_ptr<BoundBaseScanSource> Binder::bindQueryScanSource(const BaseScanS
         throw BinderException(std::format("Query returns {} columns but {} columns were expected.",
             columns.size(), columnNames.size()));
     }
-    for (auto i = 0u; i < columns.size(); ++i) {
-        columns[i]->setAlias(columnNames[i]);
-    }
+    // The columns are matched to columnNames by position when the COPY operator is bound. They
+    // must not be renamed here: a RETURN list can bind the same Expression object more than once
+    // (e.g. RETURN i, i), and setAlias would leave that shared object holding one name only.
     auto scanInfo = BoundQueryScanSourceInfo(bindParsingOptions(options));
     return std::make_unique<BoundQueryScanSource>(std::move(boundStatement), std::move(scanInfo));
 }

sdist/ladybug-source/src/binder/bind/copy/bind_copy_from.cpp

@@ -116,18 +116,26 @@ static void bindExpectedRelColumns(const RelGroupCatalogEntry& entry,
     const CopyFromColumnInfo& info, std::vector<std::string>& columnNames,
     std::vector<LogicalType>& columnTypes);
 
+// Returns the source column that feeds a table property. A scan source names its leading columns
+// from expectedColumnNames by position, so the position decides which column a property reads.
+// The name of the bound expression cannot be used for this: a query source may return one shared
+// Expression object for several columns (e.g. RETURN i, i). Columns past the expected ones carry
+// copy warnings. A source bound without expected names, such as a table whose only column is
+// SERIAL, keeps the names it read from the file and is matched by those names.
 static std::pair<ColumnEvaluateType, std::shared_ptr<Expression>> matchColumnExpression(
-    const expression_vector& columns, const PropertyDefinition& property,
-    ExpressionBinder& expressionBinder) {
-    for (auto& column : columns) {
-        if (property.getName() == column->toString()) {
-            if (column->dataType == property.getType()) {
-                return {ColumnEvaluateType::REFERENCE, column};
-            } else {
-                return {ColumnEvaluateType::CAST,
-                    expressionBinder.forceCast(column, property.getType())};
-            }
+    const expression_vector& columns, const std::vector<std::string>& expectedColumnNames,
+    const PropertyDefinition& property, ExpressionBinder& expressionBinder) {
+    for (auto i = 0u; i < columns.size(); ++i) {
+        auto columnName =
+            i < expectedColumnNames.size() ? expectedColumnNames[i] : columns[i]->toString();
+        if (property.getName() != columnName) {
+            continue;
+        }
+        auto& column = columns[i];
+        if (column->dataType == property.getType()) {
+            return {ColumnEvaluateType::REFERENCE, column};
         }
+        return {ColumnEvaluateType::CAST, expressionBinder.forceCast(column, property.getType())};
     }
     return {ColumnEvaluateType::DEFAULT, expressionBinder.bindExpression(*property.defaultExpr)};
 }
@@ -163,8 +171,8 @@ BoundCopyFromInfo Binder::bindCopyNodeFromInfo(std::string tableName,
     expression_vector columns;
     std::vector<ColumnEvaluateType> evaluateTypes;
     for (auto& property : properties) {
-        auto [evaluateType, column] =
-            matchColumnExpression(boundSource->getColumns(), property, expressionBinder);
+        auto [evaluateType, column] = matchColumnExpression(boundSource->getColumns(),
+            expectedColumnNames, property, expressionBinder);
         columns.push_back(column);
         evaluateTypes.push_back(evaluateType);
     }
@@ -247,8 +255,8 @@ BoundCopyFromInfo Binder::bindCopyRelFromInfo(std::string tableName,
         ColumnEvaluateType::REFERENCE, ColumnEvaluateType::REFERENCE};
     for (auto i = 1u; i < properties.size(); ++i) { // skip internal ID
         auto& property = properties[i];
-        auto [evaluateType, column] =
-            matchColumnExpression(boundSource->getColumns(), property, expressionBinder);
+        auto [evaluateType, column] = matchColumnExpression(boundSource->getColumns(),
+            expectedColumnNames, property, expressionBinder);
         columnExprs.push_back(column);
         evaluateTypes.push_back(evaluateType);
     }

sdist/ladybug-source/src/binder/bind_expression/bind_case_expression.cpp

@@ -1,7 +1,10 @@
+#include <algorithm>
+
 #include "binder/binder.h"
 #include "binder/expression/case_expression.h"
 #include "binder/expression/expression_util.h"
 #include "binder/expression_binder.h"
+#include "function/cast/vector_cast_functions.h"
 #include "parser/expression/parsed_case_expression.h"
 
 using namespace lbug::common;
@@ -10,23 +13,40 @@ using namespace lbug::parser;
 namespace lbug {
 namespace binder {
 
+// Whether implicitCastIfNecessary would accept casting the expression to the type.
+static bool canImplicitlyCast(const Expression& expression, const LogicalType& type) {
+    return expression.dataType == type || type.containsAny() ||
+           ExpressionUtil::canCastStatically(expression, type) ||
+           function::CastFunction::hasImplicitCast(expression.dataType, type);
+}
+
 std::shared_ptr<Expression> ExpressionBinder::bindCaseExpression(
     const ParsedExpression& parsedExpression) {
     auto& parsedCaseExpression = parsedExpression.constCast<ParsedCaseExpression>();
-    auto resultType = LogicalType::ANY();
-    // Resolve result type by checking each then expression type.
+    // The result type is the common type of every THEN and the ELSE, as for coalesce.
+    expression_vector results;
     for (auto i = 0u; i < parsedCaseExpression.getNumCaseAlternative(); ++i) {
-        auto alternative = parsedCaseExpression.getCaseAlternative(i);
-        auto boundThen = bindExpression(*alternative->thenExpression);
-        if (boundThen->getDataType().getLogicalTypeID() != LogicalTypeID::ANY) {
-            resultType = boundThen->getDataType().copy();
-        }
+        results.push_back(
+            bindExpression(*parsedCaseExpression.getCaseAlternative(i)->thenExpression));
+    }
+    if (parsedCaseExpression.hasElseExpression()) {
+        results.push_back(bindExpression(*parsedCaseExpression.getElseExpression()));
     }
-    // Resolve result type by else expression if above resolving fails.
-    if (resultType.getLogicalTypeID() == LogicalTypeID::ANY &&
-        parsedCaseExpression.hasElseExpression()) {
-        auto elseExpression = bindExpression(*parsedCaseExpression.getElseExpression());
-        resultType = elseExpression->getDataType().copy();
+    auto resultType = LogicalType::ANY();
+    if (!ExpressionUtil::tryCombineDataType(results, resultType) ||
+        !std::all_of(results.begin(), results.end(),
+            [&](const auto& result) { return canImplicitlyCast(*result, resultType); })) {
+        // No common type: take the last typed THEN, else the ELSE, and cast the rest to it.
+        resultType = LogicalType::ANY();
+        for (auto i = 0u; i < parsedCaseExpression.getNumCaseAlternative(); ++i) {
+            if (results[i]->getDataType().getLogicalTypeID() != LogicalTypeID::ANY) {
+                resultType = results[i]->getDataType().copy();
+            }
+        }
+        if (resultType.getLogicalTypeID() == LogicalTypeID::ANY &&
+            parsedCaseExpression.hasElseExpression()) {
+            resultType = results.back()->getDataType().copy();
+        }
     }
     auto name = binder->getUniqueExpressionName(parsedExpression.getRawName());
     // bind ELSE ...

sdist/ladybug-source/src/binder/query/query_graph.cpp

@@ -99,16 +99,22 @@ std::vector<uint32_t> SubqueryGraph::getConnectedNodePos(const SubqueryGraph& nb
 
 std::unordered_set<uint32_t> SubqueryGraph::getNodePositionsIgnoringNodeSelector() const {
     std::unordered_set<uint32_t> result;
+    const auto nodes = getNodesSelectorWithRelEndpoints();
     for (auto nodePos = 0u; nodePos < queryGraph.getNumQueryNodes(); ++nodePos) {
-        if (queryNodesSelector[nodePos]) {
+        if (nodes[nodePos]) {
             result.insert(nodePos);
         }
     }
+    return result;
+}
+
+std::bitset<MAX_NUM_QUERY_VARIABLES> SubqueryGraph::getNodesSelectorWithRelEndpoints() const {
+    auto result = queryNodesSelector;
     for (auto relPos = 0u; relPos < queryGraph.getNumQueryRels(); ++relPos) {
-        auto rel = queryGraph.getQueryRel(relPos);
         if (queryRelsSelector[relPos]) {
-            result.insert(queryGraph.getQueryNodeIdx(rel->getSrcNodeName()));
-            result.insert(queryGraph.getQueryNodeIdx(rel->getDstNodeName()));
+            auto rel = queryGraph.getQueryRel(relPos);
+            result[queryGraph.getQueryNodeIdx(rel->getSrcNodeName())] = true;
+            result[queryGraph.getQueryNodeIdx(rel->getDstNodeName())] = true;
         }
     }
     return result;

sdist/ladybug-source/src/c_api/version.cpp

@@ -7,7 +7,7 @@ char* lbug_get_version() {
     LBUG_C_API_GUARD_BEGIN
     auto version = lbug::main::Version::getVersion();
     if (version == nullptr || version[0] == '\0') {
-        version = "0.21.2";
+        version = "0.22.3";
     }
     return convertToOwnedCString(version);
     LBUG_C_API_GUARD_END(nullptr)

sdist/ladybug-source/src/catalog/catalog_entry/node_table_catalog_entry.cpp

@@ -31,6 +31,8 @@ static void upgradeLegacyStorageFormat(const std::string& storage,
     const auto lowerStorage = common::StringUtils::getLower(storage);
     if (lowerStorage.ends_with("parquet")) {
         storageFormat = common::StorageFormat::ICEBUG_DISK;
+    } else if (lowerStorage.ends_with(".lance")) {
+        storageFormat = common::StorageFormat::LANCE;
     }
 }
 

sdist/ladybug-source/src/catalog/catalog_entry/rel_group_catalog_entry.cpp

@@ -23,6 +23,8 @@ static void upgradeLegacyStorageFormat(const std::string& storage,
     const auto lowerStorage = common::StringUtils::getLower(storage);
     if (lowerStorage.ends_with("parquet")) {
         storageFormat = common::StorageFormat::ICEBUG_DISK;
+    } else if (lowerStorage.ends_with(".lance")) {
+        storageFormat = common::StorageFormat::LANCE;
     }
 }
 

sdist/ladybug-source/src/common/enums/storage_format.cpp

@@ -10,8 +10,28 @@ StorageFormat StorageFormatUtils::fromString(const std::string& str) {
     if (str == "icebug-disk") {
         return StorageFormat::ICEBUG_DISK;
     }
-    throw BinderException(
-        std::format("Unsupported storage format '{}'. Valid options are: icebug-disk.", str));
+    if (str == "lance") {
+        return StorageFormat::LANCE;
+    }
+    throw BinderException(std::format(
+        "Unsupported storage format '{}'. Valid options are: icebug-disk, lance.", str));
+}
+
+std::string StorageFormatUtils::toString(StorageFormat format) {
+    switch (format) {
+    case StorageFormat::NONE: {
+        return "none";
+    }
+    case StorageFormat::ICEBUG_DISK: {
+        return "icebug-disk";
+    }
+    case StorageFormat::LANCE: {
+        return "lance";
+    }
+    default: {
+        return "unknown";
+    }
+    }
 }
 
 } // namespace common

sdist/ladybug-source/src/common/serializer/buffered_file.cpp

@@ -1,5 +1,6 @@
 #include "common/serializer/buffered_file.h"
 
+#include <algorithm>
 #include <cstring>
 
 #include "common/assert.h"
@@ -78,20 +79,31 @@ void BufferedFileReader::read(uint8_t* data, uint64_t size) {
         // Clear read buffer.
         fileOffset -= bufferSize;
         fileOffset += bufferOffset;
+        bufferOffset = 0;
+        bufferSize = 0;
+        // readFromFile silently short-reads at EOF, so check the range first and throw a
+        // catchable error instead of returning uninitialized bytes. A torn WAL tail (e.g. a
+        // crash or ENOSPC mid-commit) must surface as a replay failure, not a native crash.
+        if (fileOffset > fileSize || size > fileSize - fileOffset) {
+            throw RuntimeException(
+                std::format("Reading past the end of the file {} with size {} at offset {}",
+                    fileInfo.path, fileSize, fileOffset));
+        }
         fileInfo.readFromFile(data, size, fileOffset);
         fileOffset += size;
-        bufferOffset = bufferSize;
-    } else if (bufferOffset + size <= bufferSize) {
-        memcpy(data, &buffer[bufferOffset], size);
-        bufferOffset += size;
     } else {
-        auto toCopy = bufferSize - bufferOffset;
-        memcpy(data, &buffer[bufferOffset], toCopy);
-        bufferOffset += toCopy;
-        readNextPage();
-        auto remaining = size - toCopy;
-        memcpy(data + toCopy, buffer.get(), remaining);
-        bufferOffset += remaining;
+        // Loop across page boundaries: the final page of a torn file may hold fewer bytes
+        // than requested, and copying the full remainder would overrun the heap buffer.
+        while (size > 0) {
+            if (bufferOffset >= bufferSize) {
+                readNextPage();
+            }
+            const auto toCopy = std::min(size, bufferSize - bufferOffset);
+            memcpy(data, &buffer[bufferOffset], toCopy);
+            bufferOffset += toCopy;
+            data += toCopy;
+            size -= toCopy;
+        }
     }
 }
 

sdist/ladybug-source/src/common/vector/value_vector.cpp

@@ -643,7 +643,7 @@ void ListVector::copyListEntryAndBufferMetaData(ValueVector& vector,
     for (auto i = 0u; i < otherSelVector.getSelSize(); ++i) {
         auto pos = selVector[i];
         auto otherPos = otherSelVector[i];
-        vector.setNull(pos, other.isNull(pos));
+        vector.setNull(pos, other.isNull(otherPos));
         if (!other.isNull(otherPos)) {
             vector.setValue(pos, other.getValue<list_entry_t>(otherPos));
         }

sdist/ladybug-source/src/expression_evaluator/lambda_evaluator.cpp

@@ -1,5 +1,7 @@
 #include "expression_evaluator/lambda_evaluator.h"
 
+#include <cstring>
+
 #include "binder/expression/lambda_expression.h"
 #include "common/exception/runtime.h"
 #include "expression_evaluator/expression_evaluator_visitor.h"
@@ -18,6 +20,141 @@ using namespace lbug::storage;
 namespace lbug {
 namespace evaluator {
 
+// Points dst's lists at src's list data, so evaluators that keep a list's data vector when they
+// are compiled, such as properties(), read the elements that gatherSlice references.
+static void shareListData(const ValueVector& dst, const ValueVector& src) {
+    switch (src.dataType.getPhysicalType()) {
+    case PhysicalTypeID::STRUCT: {
+        const auto& dstFields = StructVector::getFieldVectors(&dst);
+        const auto& srcFields = StructVector::getFieldVectors(&src);
+        for (auto i = 0u; i < srcFields.size(); ++i) {
+            shareListData(*dstFields[i], *srcFields[i]);
+        }
+    } break;
+    case PhysicalTypeID::LIST:
+    case PhysicalTypeID::ARRAY: {
+        // Sharing the data vector also shares the structs and lists inside it.
+        ListVector::setDataVector(&dst, ListVector::getSharedDataVector(&src));
+    } break;
+    case PhysicalTypeID::ANY:
+    case PhysicalTypeID::BOOL:
+    case PhysicalTypeID::INT64:
+    case PhysicalTypeID::INT32:
+    case PhysicalTypeID::INT16:
+    case PhysicalTypeID::INT8:
+    case PhysicalTypeID::UINT64:
+    case PhysicalTypeID::UINT32:
+    case PhysicalTypeID::UINT16:
+    case PhysicalTypeID::UINT8:
+    case PhysicalTypeID::INT128:
+    case PhysicalTypeID::DOUBLE:
+    case PhysicalTypeID::FLOAT:
+    case PhysicalTypeID::INTERVAL:
+    case PhysicalTypeID::INTERNAL_ID:
+    case PhysicalTypeID::ALP_EXCEPTION_FLOAT:
+    case PhysicalTypeID::ALP_EXCEPTION_DOUBLE:
+    case PhysicalTypeID::UINT128:
+    case PhysicalTypeID::STRING:
+    case PhysicalTypeID::JSON:
+    case PhysicalTypeID::POINTER:
+        break;
+    }
+}
+
+static_assert(sizeof(bool) == sizeof(uint8_t), "BOOL values are gathered as uint8_t");
+static_assert(sizeof(float) == sizeof(uint32_t), "FLOAT values are gathered as uint32_t");
+static_assert(sizeof(double) == sizeof(uint64_t), "DOUBLE values are gathered as uint64_t");
+static_assert(sizeof(uint128_t) == sizeof(int128_t), "UINT128 values are gathered as int128_t");
+
+template<typename T>
+static void gatherValues(ValueVector& dst, const ValueVector& src, const SelectionVector& srcSel) {
+    DASSERT(src.getNumBytesPerValue() == sizeof(T));
+    auto* dstValues = reinterpret_cast<T*>(dst.getData());
+    const auto* srcValues = reinterpret_cast<const T*>(src.getData());
+    for (sel_t i = 0; i < srcSel.getSelSize(); ++i) {
+        dstValues[i] = srcValues[srcSel[i]];
+    }
+}
+
+static void gatherBytes(ValueVector& dst, const ValueVector& src, const SelectionVector& srcSel) {
+    const auto numBytes = src.getNumBytesPerValue();
+    for (sel_t i = 0; i < srcSel.getSelSize(); ++i) {
+        memcpy(dst.getData() + i * numBytes, src.getData() + srcSel[i] * numBytes, numBytes);
+    }
+}
+
+// Copies the values of src at srcSel's positions to positions 0 to srcSel.getSelSize() - 1 of dst.
+// Strings and the elements of lists are referenced rather than copied, which holds because src is
+// not modified while the lambda evaluates the slice.
+static void gatherSlice(ValueVector& dst, const SelectionVector& dstSel, const ValueVector& src,
+    const SelectionVector& srcSel) {
+    if (src.hasNoNullsGuarantee()) {
+        dst.setAllNonNull();
+    } else {
+        for (sel_t i = 0; i < srcSel.getSelSize(); ++i) {
+            dst.setNull(i, src.isNull(srcSel[i]));
+        }
+    }
+    switch (src.dataType.getPhysicalType()) {
+    case PhysicalTypeID::STRUCT: {
+        const auto& dstFields = StructVector::getFieldVectors(&dst);
+        const auto& srcFields = StructVector::getFieldVectors(&src);
+        for (auto i = 0u; i < srcFields.size(); ++i) {
+            gatherSlice(*dstFields[i], dstSel, *srcFields[i], srcSel);
+        }
+    } break;
+    case PhysicalTypeID::LIST:
+    case PhysicalTypeID::ARRAY: {
+        // Evaluators compiled against dst's data vector at init would read stale elements.
+        if (ListVector::getDataVector(&dst) != ListVector::getDataVector(&src)) {
+            throw RuntimeException("A list lambda's input replaced its data vector after init.");
+        }
+        ListVector::copyListEntryAndBufferMetaData(dst, dstSel, src, srcSel);
+    } break;
+    case PhysicalTypeID::BOOL:
+    case PhysicalTypeID::INT8:
+    case PhysicalTypeID::UINT8: {
+        gatherValues<uint8_t>(dst, src, srcSel);
+    } break;
+    case PhysicalTypeID::INT16:
+    case PhysicalTypeID::UINT16: {
+        gatherValues<uint16_t>(dst, src, srcSel);
+    } break;
+    case PhysicalTypeID::INT32:
+    case PhysicalTypeID::UINT32:
+    case PhysicalTypeID::FLOAT: {
+        gatherValues<uint32_t>(dst, src, srcSel);
+    } break;
+    case PhysicalTypeID::INT64:
+    case PhysicalTypeID::UINT64:
+    case PhysicalTypeID::DOUBLE: {
+        gatherValues<uint64_t>(dst, src, srcSel);
+    } break;
+    case PhysicalTypeID::INT128:
+    case PhysicalTypeID::UINT128: {
+        gatherValues<int128_t>(dst, src, srcSel);
+    } break;
+    case PhysicalTypeID::INTERVAL: {
+        gatherValues<interval_t>(dst, src, srcSel);
+    } break;
+    case PhysicalTypeID::INTERNAL_ID: {
+        gatherValues<internalID_t>(dst, src, srcSel);
+    } break;
+    case PhysicalTypeID::STRING:
+    case PhysicalTypeID::JSON: {
+        gatherValues<string_t>(dst, src, srcSel);
+    } break;
+    // Not list element types: ANY and POINTER vectors are never built, and ALP exceptions exist
+    // only in storage.
+    case PhysicalTypeID::ANY:
+    case PhysicalTypeID::POINTER:
+    case PhysicalTypeID::ALP_EXCEPTION_FLOAT:
+    case PhysicalTypeID::ALP_EXCEPTION_DOUBLE: {
+        gatherBytes(dst, src, srcSel);
+    } break;
+    }
+}
+
 void ListLambdaEvaluator::init(const ResultSet& resultSet, ClientContext* clientContext) {
     for (auto& child : children) {
         child->init(resultSet, clientContext);
@@ -30,20 +167,23 @@ void ListLambdaEvaluator::init(const ResultSet& resultSet, ClientContext* client
     auto evaluators = collector.getEvaluators();
     auto lambdaVarState = std::make_shared<DataChunkState>();
     memoryManager = MemoryManager::Get(*clientContext);
+    const auto& elementType = ListType::getChildType(listInputVector->dataType);
+    if (listLambdaType != ListLambdaType::LIST_REDUCE && !evaluators.empty()) {
+        sliceParamVector = std::make_shared<ValueVector>(elementType.copy(), memoryManager);
+    }
     for (auto& evaluator : evaluators) {
-        // For list_filter, list_transform:
-        // The resultVector of lambdaEvaluator should be the list dataVector.
-        // For list_reduce:
-        // We should create two vectors for each lambda variable resultVector since we are going to
-        // update the list elements during execution.
+        // list_reduce updates each lambda variable separately during execution, so each gets its
+        // own vector. The other lambdas read every use of their variable from sliceParamVector.
         evaluator->resultVector =
-            listLambdaType != ListLambdaType::LIST_REDUCE ?
-                ListVector::getSharedDataVector(listInputVector) :
-                std::make_shared<ValueVector>(
-                    ListType::getChildType(listInputVector->dataType).copy(), memoryManager);
+            sliceParamVector != nullptr ?
+                sliceParamVector :
+                std::make_shared<ValueVector>(elementType.copy(), memoryManager);
         evaluator->resultVector->state = lambdaVarState;
         lambdaParamEvaluators.push_back(evaluator->ptrCast<LambdaParamEvaluator>());
     }
+    if (sliceParamVector != nullptr) {
+        shareListData(*sliceParamVector, *ListVector::getDataVector(listInputVector));
+    }
     lambdaRootEvaluator->init(resultSet, clientContext);
     resolveResultVector(resultSet, memoryManager);
     params.push_back(children[0]->resultVector);
@@ -63,10 +203,24 @@ void ListLambdaEvaluator::evaluateInternal() {
     auto selVectors = SelectionVector::fromValueVectors(params);
     do {
         sliceInfo.nextSlice();
+        if (sliceParamVector != nullptr) {
+            copySliceToParamVector(sliceInfo, *inputVector);
+        }
         execFunc(params, selVectors, *resultVector, resultVector->getSelVectorPtr(), &bindData);
     } while (!sliceInfo.done());
 }
 
+// Many evaluators read an operand at the position they write its result to. The lambda variable
+// therefore holds the slice's elements at positions 0 to sliceSize - 1, where the vectors computed
+// from it hold their values, instead of selecting them at their offsets in the list data vector.
+void ListLambdaEvaluator::copySliceToParamVector(const ListSliceInfo& sliceInfo,
+    const ValueVector& listVector) const {
+    auto& paramSelVector = sliceParamVector->state->getSelVectorUnsafe();
+    paramSelVector.setToUnfiltered(sliceInfo.getSliceSize());
+    gatherSlice(*sliceParamVector, paramSelVector, *ListVector::getDataVector(&listVector),
+        sliceInfo.getDataSelVector());
+}
+
 void ListLambdaEvaluator::evaluate() {
     DASSERT(children.size() == 1);
     children[0]->evaluate();