kuzu 0.10.1.dev41__tar.gz → 0.10.1.dev43__tar.gz

sdist/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuzu
-Version: 0.10.1.dev41
+Version: 0.10.1.dev43
 Summary: Highly scalable, extremely fast, easy-to-use embeddable graph database
 Home-page: https://github.com/kuzudb/kuzu
 License: MIT License

sdist/kuzu-source/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.15)
 
-project(Kuzu VERSION 0.10.1.41 LANGUAGES CXX C)
+project(Kuzu VERSION 0.10.1.43 LANGUAGES CXX C)
 
 option(SINGLE_THREADED "Single-threaded mode" FALSE)
 if(SINGLE_THREADED)

sdist/kuzu-source/scripts/antlr4/Cypher.g4

@@ -385,7 +385,8 @@ kU_AlterOptions
         | kU_DropProperty
         | kU_RenameTable
         | kU_RenameProperty
-        | kU_AddFromToConnection;
+        | kU_AddFromToConnection
+        | kU_DropFromToConnection;
 
 kU_AddProperty
     : ADD SP (kU_IfNotExists SP)? oC_PropertyKeyName SP kU_DataType ( SP kU_Default )? ;
@@ -403,7 +404,10 @@ kU_RenameProperty
     : RENAME SP oC_PropertyKeyName SP TO SP oC_PropertyKeyName ;
 
 kU_AddFromToConnection
-    : ADD SP kU_FromToConnection ;
+    : ADD SP (kU_IfNotExists SP)? kU_FromToConnection ;
+
+kU_DropFromToConnection
+    : DROP SP (kU_IfExists SP)? kU_FromToConnection ;
 
 kU_ColumnDefinitions: kU_ColumnDefinition ( SP? ',' SP? kU_ColumnDefinition )* ;
 

sdist/kuzu-source/scripts/antlr4/hash.md5

@@ -1 +1 @@
-567a0f306e010f245ff575499552caac
+8908fae875ccf47f64fa086eefd53a1a

sdist/kuzu-source/scripts/export-dbs.py

@@ -0,0 +1,129 @@
+import argparse
+import os
+import sys
+import subprocess
+import re
+
+
+# Get version number like 0.10.0.5.
+def getVersion(executablePath):
+    try:
+        result = subprocess.run(
+            [executablePath, "--version"],
+            capture_output=True, text=True, check=True)
+        output = result.stdout.strip()
+        match = re.search(r"\b(\d+\.\d+\.\d+\.\d+)\b", output)
+        if match:
+            return match.group(1)
+        else:
+            print("Version number not found in output.")
+            return None
+    except subprocess.CalledProcessError as e:
+        print(f"Error running executable: {e}")
+        return None
+
+
+# Parse schema.cypher and copy.cypher files.
+def createCypherQueries(filePath):
+    commands = []
+    try:
+        with open(filePath, "r") as f:
+            for line in f:
+                stripped = line.strip()
+                if not stripped:
+                    continue
+                if not stripped.endswith(";"):
+                    stripped += ";"
+                commands.append(stripped)
+    except Exception:
+        pass
+    return commands
+
+
+# Find all datasets that have a schema.cypher and copy.cypher file.
+def findValidDatasetDirs(datasetRoot):
+    validDirs = []
+
+    for root, dirs, files in os.walk(datasetRoot):
+        # This script creates a tmp directory with the exported dbs, we should
+        # skip it in our search.
+        if "tmp" in root.split(os.sep):
+            continue
+        fileSet = set(files)
+
+        if "schema.cypher" in fileSet:
+            validDirs.append(root)
+
+    return validDirs
+
+
+# We must update all relative paths in copy.cypher to use full paths.
+# This expands all matches of a relative path beginning with dataset to a
+# full path.
+def replaceDatasetPaths(command, datasetRoot):
+    def replace_match(match):
+        quote = match.group(1)
+        folder = match.group(2)  # 'dataset' or 'extension'
+        relative_path = match.group(3)
+        full_path = os.path.join(datasetRoot, folder, relative_path)
+        return f'{quote}{full_path}{quote}'
+
+    return re.sub(r'(["\'])(dataset|extension)/([^"\']+)\1', replace_match, command)
+
+
+# Example scripts/export-dbs.py build/debug/tools/shell/kuzu dataset.
+def main():
+    parser = argparse.ArgumentParser(description="""Export DBS with
+    KUZU shell and dataset paths""")
+
+    parser.add_argument("executablePath", help="Path to the KUZU shell")
+    parser.add_argument("datasetPath", help="Path to the dataset directory")
+    args = parser.parse_args()
+
+    argExecutablePath = os.path.abspath(args.executablePath)
+    argDatasetPath = os.path.abspath(args.datasetPath)
+
+    if not os.path.isfile(argExecutablePath):
+        print(f"Error: Executable not found at {argExecutablePath}")
+        return 1
+    if not os.path.exists(argDatasetPath):
+        print(f"Error: Dataset path not found at {argDatasetPath}")
+        return 1
+
+    version = getVersion(argExecutablePath)
+    if not version:
+        print(f"Could not pull version number from {argExecutablePath}")
+        return 1
+
+    validDatasets = findValidDatasetDirs(argDatasetPath)
+    # This is done to construct a full path to replace the relative paths found
+    # in copy.cypher files.
+    scriptDir = os.path.dirname(os.path.realpath(__file__))
+    rootDir = os.path.abspath(os.path.join(scriptDir, ".."))
+    for datasetPath in validDatasets:
+        schemaCommands = createCypherQueries(os.path.join(datasetPath, "schema.cypher"))
+        copyCommands = createCypherQueries(os.path.join(datasetPath, "copy.cypher"))
+        rawCopyCommands = createCypherQueries(os.path.join(datasetPath, "copy.cypher"))
+        copyCommands = [replaceDatasetPaths(cmd, rootDir) for cmd in rawCopyCommands]
+        combinedCommands = schemaCommands + copyCommands
+        datasetName = os.path.relpath(datasetPath, argDatasetPath)
+        exportPath = os.path.join(argDatasetPath, "tmp", version, datasetName)
+        exportCommand = f"EXPORT DATABASE '{exportPath}' (format=\"csv\", header=true);"
+        combinedCommands.append(exportCommand)
+        print(f"Exporting {datasetPath} to {exportPath}")
+
+        process = subprocess.Popen(
+            [argExecutablePath],
+            stdin=subprocess.PIPE,
+            text=True
+        )
+
+        for cmd in combinedCommands:
+            process.stdin.write(cmd.strip() + "\n")
+        process.stdin.close()
+        process.wait()
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

sdist/kuzu-source/src/antlr4/Cypher.g4

@@ -148,7 +148,8 @@ kU_AlterOptions
         | kU_DropProperty
         | kU_RenameTable
         | kU_RenameProperty
-        | kU_AddFromToConnection;
+        | kU_AddFromToConnection
+        | kU_DropFromToConnection;
 
 kU_AddProperty
     : ADD SP (kU_IfNotExists SP)? oC_PropertyKeyName SP kU_DataType ( SP kU_Default )? ;
@@ -166,7 +167,10 @@ kU_RenameProperty
     : RENAME SP oC_PropertyKeyName SP TO SP oC_PropertyKeyName ;
 
 kU_AddFromToConnection
-    : ADD SP kU_FromToConnection ;
+    : ADD SP (kU_IfNotExists SP)? kU_FromToConnection ;
+
+kU_DropFromToConnection
+    : DROP SP (kU_IfExists SP)? kU_FromToConnection ;
 
 kU_ColumnDefinitions: kU_ColumnDefinition ( SP? ',' SP? kU_ColumnDefinition )* ;
 

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

@@ -8,7 +8,6 @@
 #include "catalog/catalog.h"
 #include "catalog/catalog_entry/index_catalog_entry.h"
 #include "catalog/catalog_entry/node_table_catalog_entry.h"
-#include "catalog/catalog_entry/rel_group_catalog_entry.h"
 #include "catalog/catalog_entry/sequence_catalog_entry.h"
 #include "common/enums/extend_direction_util.h"
 #include "common/exception/binder.h"
@@ -408,8 +407,9 @@ std::unique_ptr<BoundStatement> Binder::bindAlter(const Statement& statement) {
     case AlterType::COMMENT: {
         return bindCommentOn(statement);
     }
-    case AlterType::ADD_FROM_TO_CONNECTION: {
-        return bindAddFromToConnection(statement);
+    case AlterType::ADD_FROM_TO_CONNECTION:
+    case AlterType::DROP_FROM_TO_CONNECTION: {
+        return bindAlterFromToConnection(statement);
     }
     default: {
         KU_UNREACHABLE;
@@ -491,7 +491,8 @@ std::unique_ptr<BoundStatement> Binder::bindCommentOn(const Statement& statement
     return std::make_unique<BoundAlter>(std::move(boundInfo));
 }
 
-std::unique_ptr<BoundStatement> Binder::bindAddFromToConnection(const Statement& statement) const {
+std::unique_ptr<BoundStatement> Binder::bindAlterFromToConnection(
+    const Statement& statement) const {
     auto& alter = statement.constCast<Alter>();
     auto info = alter.getInfo();
     auto extraInfo = info->extraInfo->constPtrCast<ExtraAddFromToConnection>();
@@ -500,15 +501,9 @@ std::unique_ptr<BoundStatement> Binder::bindAddFromToConnection(const Statement&
     auto dstTableEntry = bindNodeTableEntry(extraInfo->dstTableName);
     auto srcTableID = srcTableEntry->getTableID();
     auto dstTableID = dstTableEntry->getTableID();
-    auto relGroupEntry = bindRelGroupEntries({tableName})[0]->constPtrCast<RelGroupCatalogEntry>();
-    if (relGroupEntry->hasRelEntryInfo(srcTableID, dstTableID)) {
-        throw BinderException{
-            common::stringFormat("Node table pair: {}->{} already exists in the {} table.",
-                srcTableEntry->getName(), dstTableEntry->getName(), tableName)};
-    }
-    auto boundExtraInfo = std::make_unique<BoundExtraAddFromToConnection>(srcTableID, dstTableID);
-    auto boundInfo = BoundAlterInfo(AlterType::ADD_FROM_TO_CONNECTION, tableName,
-        std::move(boundExtraInfo), info->onConflict);
+    auto boundExtraInfo = std::make_unique<BoundExtraAlterFromToConnection>(srcTableID, dstTableID);
+    auto boundInfo =
+        BoundAlterInfo(info->type, tableName, std::move(boundExtraInfo), info->onConflict);
     return std::make_unique<BoundAlter>(std::move(boundInfo));
 }
 

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

@@ -14,11 +14,23 @@ using namespace kuzu::main;
 namespace kuzu {
 namespace catalog {
 
-void RelGroupCatalogEntry::addFromToConnection(common::table_id_t srcTableID,
-    common::table_id_t dstTableID, common::oid_t oid) {
+void RelGroupCatalogEntry::addFromToConnection(table_id_t srcTableID, table_id_t dstTableID,
+    oid_t oid) {
     relTableInfos.emplace_back(NodeTableIDPair{srcTableID, dstTableID}, oid);
 }
 
+void RelGroupCatalogEntry::dropFromToConnection(table_id_t srcTableID, table_id_t dstTableID) {
+    auto tmpInfos = relTableInfos;
+    relTableInfos.clear();
+    for (auto& tmpInfo : tmpInfos) {
+        if (tmpInfo.nodePair.srcTableID == srcTableID &&
+            tmpInfo.nodePair.dstTableID == dstTableID) {
+            continue;
+        }
+        relTableInfos.emplace_back(tmpInfo);
+    }
+}
+
 void RelTableCatalogInfo::serialize(Serializer& ser) const {
     ser.writeDebuggingInfo("nodePair");
     ser.serializeValue(nodePair);

sdist/kuzu-source/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -38,11 +38,16 @@ std::unique_ptr<TableCatalogEntry> TableCatalogEntry::alter(transaction_t timest
         newEntry->setComment(commentInfo.comment);
     } break;
     case AlterType::ADD_FROM_TO_CONNECTION: {
-        auto& fromToConnectionInfo =
-            *alterInfo.extraInfo->constPtrCast<BoundExtraAddFromToConnection>();
-        newEntry->ptrCast<RelGroupCatalogEntry>()->addFromToConnection(
-            fromToConnectionInfo.srcTableID, fromToConnectionInfo.dstTableID,
-            tables->getNextOIDNoLock());
+        auto& connectionInfo =
+            *alterInfo.extraInfo->constPtrCast<BoundExtraAlterFromToConnection>();
+        newEntry->ptrCast<RelGroupCatalogEntry>()->addFromToConnection(connectionInfo.fromTableID,
+            connectionInfo.toTableID, tables->getNextOIDNoLock());
+    } break;
+    case AlterType::DROP_FROM_TO_CONNECTION: {
+        auto& connectionInfo =
+            *alterInfo.extraInfo->constPtrCast<BoundExtraAlterFromToConnection>();
+        newEntry->ptrCast<RelGroupCatalogEntry>()->dropFromToConnection(connectionInfo.fromTableID,
+            connectionInfo.toTableID);
     } break;
     default: {
         KU_UNREACHABLE;

sdist/kuzu-source/src/catalog/catalog_set.cpp

@@ -194,7 +194,8 @@ void CatalogSet::alterTableEntry(Transaction* transaction,
     case AlterType::ADD_PROPERTY:
     case AlterType::DROP_PROPERTY:
     case AlterType::RENAME_PROPERTY:
-    case AlterType::ADD_FROM_TO_CONNECTION: {
+    case AlterType::ADD_FROM_TO_CONNECTION:
+    case AlterType::DROP_FROM_TO_CONNECTION: {
         emplaceNoLock(std::move(newEntry));
         if (transaction->shouldAppendToUndoBuffer()) {
             transaction->pushAlterCatalogEntry(*this, *entry, alterInfo);

sdist/kuzu-source/src/common/data_chunk/data_chunk_collection.cpp

@@ -31,18 +31,7 @@ void DataChunkCollection::append(DataChunk& chunk) {
     }
 }
 
-void DataChunkCollection::merge(DataChunk chunk) {
-    if (chunks.empty()) {
-        initTypes(chunk);
-    }
-    KU_ASSERT(chunk.getNumValueVectors() == types.size());
-    for (auto vectorIdx = 0u; vectorIdx < chunk.getNumValueVectors(); vectorIdx++) {
-        KU_ASSERT(chunk.getValueVector(vectorIdx).dataType == types[vectorIdx]);
-    }
-    chunks.push_back(std::move(chunk));
-}
-
-void DataChunkCollection::initTypes(DataChunk& chunk) {
+void DataChunkCollection::initTypes(const DataChunk& chunk) {
     types.clear();
     types.reserve(chunk.getNumValueVectors());
     for (auto vectorIdx = 0u; vectorIdx < chunk.getNumValueVectors(); vectorIdx++) {
@@ -50,7 +39,7 @@ void DataChunkCollection::initTypes(DataChunk& chunk) {
     }
 }
 
-void DataChunkCollection::allocateChunk(DataChunk& chunk) {
+void DataChunkCollection::allocateChunk(const DataChunk& chunk) {
     if (chunks.empty()) {
         types.reserve(chunk.getNumValueVectors());
         for (auto vectorIdx = 0u; vectorIdx < chunk.getNumValueVectors(); vectorIdx++) {

sdist/kuzu-source/src/common/data_chunk/data_chunk_state.cpp

@@ -1,8 +1,6 @@
 #include "common/data_chunk/data_chunk_state.h"
 
-#include "common/data_chunk/sel_vector.h"
 #include "common/system_config.h"
-#include "common/types/types.h"
 
 namespace kuzu {
 namespace common {
@@ -16,16 +14,5 @@ std::shared_ptr<DataChunkState> DataChunkState::getSingleValueDataChunkState() {
     return state;
 }
 
-void DataChunkState::slice(offset_t offset) {
-    // NOTE: this operation has performance penalty. Ideally we should directly modify selVector
-    // instead of creating a new one.
-    auto slicedSelVector = std::make_shared<SelectionVector>(DEFAULT_VECTOR_CAPACITY);
-    for (auto i = 0u; i < selVector->getSelSize() - offset; i++) {
-        slicedSelVector->getMutableBuffer()[i] = selVector->operator[](i + offset);
-    }
-    slicedSelVector->setToFiltered(selVector->getSelSize() - offset);
-    selVector = std::move(slicedSelVector);
-}
-
 } // namespace common
 } // namespace kuzu

sdist/kuzu-source/src/common/data_chunk/sel_vector.cpp

@@ -18,8 +18,8 @@ static const std::array<sel_t, DEFAULT_VECTOR_CAPACITY> INCREMENTAL_SELECTED_POS
         return selectedPos;
     }();
 
-SelectionView::SelectionView(sel_t startPos, sel_t selectedSize)
-    : selectedPositions{INCREMENTAL_SELECTED_POS.data() + startPos}, selectedSize{selectedSize},
+SelectionView::SelectionView(sel_t selectedSize)
+    : selectedPositions{INCREMENTAL_SELECTED_POS.data()}, selectedSize{selectedSize},
       state{State::STATIC} {}
 
 SelectionVector::SelectionVector() : SelectionVector{DEFAULT_VECTOR_CAPACITY} {}

sdist/kuzu-source/src/common/serializer/metadata_writer.cpp

@@ -31,24 +31,34 @@ void MetaWriter::write(const uint8_t* data, uint64_t size) {
 
 storage::PageRange MetaWriter::flush(storage::FileHandle* fileHandle,
     storage::ShadowFile& shadowFile) const {
-    auto numPagesToFlush = pages.size();
+    auto numPagesToFlush = getNumPagesToFlush();
     auto pageManager = fileHandle->getPageManager();
-    auto numPages = fileHandle->getNumPages();
     auto pageRange = pageManager->allocatePageRange(numPagesToFlush);
-    for (auto i = 0u; i < pageRange.numPages; i++) {
-        auto pageIdx = pageRange.startPageIdx + i;
-        auto insertingNewPage = pageIdx >= numPages;
+    flush(pageRange, fileHandle, shadowFile);
+    return pageRange;
+}
+
+void MetaWriter::flush(storage::PageRange allocatedPageRange, storage::FileHandle* fileHandle,
+    storage::ShadowFile& shadowFile) const {
+    KU_ASSERT(allocatedPageRange.numPages >= getNumPagesToFlush());
+    auto numPagesBeforeAllocate = allocatedPageRange.startPageIdx;
+    for (auto i = 0u; i < getNumPagesToFlush(); i++) {
+        auto pageIdx = allocatedPageRange.startPageIdx + i;
+        auto insertingNewPage = pageIdx >= numPagesBeforeAllocate;
         auto shadowPageAndFrame = storage::ShadowUtils::createShadowVersionIfNecessaryAndPinPage(
             pageIdx, insertingNewPage, *fileHandle, shadowFile);
         memcpy(shadowPageAndFrame.frame, pages[i]->getData(), KUZU_PAGE_SIZE);
         shadowFile.getShadowingFH().unpinPage(shadowPageAndFrame.shadowPage);
     }
-    return pageRange;
 }
 
 bool MetaWriter::needNewBuffer(uint64_t size) const {
     return pages.empty() || pageOffset + size > KUZU_PAGE_SIZE;
 }
 
+uint64_t MetaWriter::getPageSize() {
+    return KUZU_PAGE_SIZE;
+}
+
 } // namespace common
 } // namespace kuzu

sdist/kuzu-source/src/common/utils.cpp

@@ -25,45 +25,5 @@ bool isLittleEndian() {
     return *(uint8_t*)&testNumber == 1;
 }
 
-template<>
-bool integerFitsIn<int64_t>(int64_t) {
-    return true;
-}
-
-template<>
-bool integerFitsIn<int32_t>(int64_t val) {
-    return val >= INT32_MIN && val <= INT32_MAX;
-}
-
-template<>
-bool integerFitsIn<int16_t>(int64_t val) {
-    return val >= INT16_MIN && val <= INT16_MAX;
-}
-
-template<>
-bool integerFitsIn<int8_t>(int64_t val) {
-    return val >= INT8_MIN && val <= INT8_MAX;
-}
-
-template<>
-bool integerFitsIn<uint64_t>(int64_t val) {
-    return val >= 0;
-}
-
-template<>
-bool integerFitsIn<uint32_t>(int64_t val) {
-    return val >= 0 && val <= UINT32_MAX;
-}
-
-template<>
-bool integerFitsIn<uint16_t>(int64_t val) {
-    return val >= 0 && val <= UINT16_MAX;
-}
-
-template<>
-bool integerFitsIn<uint8_t>(int64_t val) {
-    return val >= 0 && val <= UINT8_MAX;
-}
-
 } // namespace common
 } // namespace kuzu

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

@@ -397,7 +397,7 @@ std::unique_ptr<ValueVector> ValueVector::deSerialize(Deserializer& deSer,
     deSer.validateDebuggingInfo(key, "data_type");
     auto dataType = LogicalType::deserialize(deSer);
     auto result = std::make_unique<ValueVector>(std::move(dataType), mm);
-    result->state = dataChunkState;
+    result->setState(dataChunkState);
     deSer.validateDebuggingInfo(key, "num_values");
     sel_t numValues = 0;
     deSer.deserializeValue<sel_t>(numValues);

sdist/kuzu-source/src/function/cast_from_string_functions.cpp

@@ -296,7 +296,7 @@ template<typename T>
 static bool splitCStringList(const char* input, uint64_t len, T& state, const CSVOption* option) {
     auto end = input + len;
     uint64_t lvl = 1;
-    bool seen_value = false;
+    bool seenValue = false;
 
     // locate [
     skipWhitespace(input, end);
@@ -305,33 +305,37 @@ static bool splitCStringList(const char* input, uint64_t len, T& state, const CS
     }
     skipWhitespace(++input, end);
 
-    auto start_ptr = input;
+    bool justFinishedEntry = true; // true at start
+    auto startPtr = input;
     while (input < end) {
         auto ch = *input;
         if (ch == CopyConstants::DEFAULT_CSV_LIST_BEGIN_CHAR) {
             if (!skipToClose(input, end, ++lvl, CopyConstants::DEFAULT_CSV_LIST_END_CHAR, option)) {
                 return false;
             }
-        } else if (ch == '\'' || ch == '"') {
+        } else if ((ch == '\'' || ch == '"') && justFinishedEntry) {
+            const char* prevInput = input;
             if (!skipToCloseQuotes(input, end)) {
-                return false;
+                input = prevInput;
             }
         } else if (ch == '{') {
             uint64_t struct_lvl = 0;
             skipToClose(input, end, struct_lvl, '}', option);
         } else if (ch == ',' || ch == CopyConstants::DEFAULT_CSV_LIST_END_CHAR) { // split
-            if (ch != CopyConstants::DEFAULT_CSV_LIST_END_CHAR || start_ptr < input || seen_value) {
-                state.handleValue(start_ptr, input, option);
-                seen_value = true;
+            if (ch != CopyConstants::DEFAULT_CSV_LIST_END_CHAR || startPtr < input || seenValue) {
+                state.handleValue(startPtr, input, option);
+                seenValue = true;
             }
             if (ch == CopyConstants::DEFAULT_CSV_LIST_END_CHAR) { // last ]
                 lvl--;
                 break;
             }
             skipWhitespace(++input, end);
-            start_ptr = input;
+            startPtr = input;
+            justFinishedEntry = true;
             continue;
         }
+        justFinishedEntry = false;
         input++;
     }
     skipWhitespace(++input, end);

sdist/kuzu-source/src/function/gds/gds.cpp

@@ -2,6 +2,7 @@
 
 #include "binder/binder.h"
 #include "binder/query/reading_clause/bound_table_function_call.h"
+#include "catalog/catalog.h"
 #include "catalog/catalog_entry/rel_group_catalog_entry.h"
 #include "common/exception/binder.h"
 #include "graph/graph_entry_set.h"

sdist/kuzu-source/src/function/list/list_slice_function.cpp

@@ -12,20 +12,18 @@ static void normalizeIndices(int64_t& startIdx, int64_t& endIdx, uint64_t size)
     if (startIdx < 0) {
         startIdx = size + startIdx + 1;
     }
-    if (endIdx <= 0) {
-        endIdx = size + endIdx + 1;
-    }
-
     if (startIdx <= 0) {
         startIdx = 1;
     }
-
-    if ((uint64_t)endIdx > size) {
-        endIdx = size + 1;
+    if (endIdx < 0) {
+        endIdx = size + endIdx + 1;
     }
-
-    if (startIdx > endIdx) {
-        endIdx = startIdx;
+    if (endIdx > (int64_t)size) {
+        endIdx = size;
+    }
+    if (endIdx < startIdx) {
+        startIdx = 1;
+        endIdx = 0;
     }
 }
 
@@ -38,12 +36,12 @@ struct ListSlice {
         auto startIdx = begin;
         auto endIdx = end;
         normalizeIndices(startIdx, endIdx, listEntry.size);
-        result = common::ListVector::addList(&resultVector, endIdx - startIdx);
+        result = common::ListVector::addList(&resultVector, endIdx - startIdx + 1);
         auto srcDataVector = common::ListVector::getDataVector(&listVector);
         auto srcPos = listEntry.offset + startIdx - 1;
         auto dstDataVector = common::ListVector::getDataVector(&resultVector);
         auto dstPos = result.offset;
-        for (; startIdx < endIdx; startIdx++) {
+        for (; startIdx <= endIdx; startIdx++) {
             dstDataVector->copyFromVectorData(dstPos++, srcDataVector, srcPos++);
         }
     }