ladybug 0.22.0.dev20261017__tar.gz → 0.22.0.dev20261024__tar.gz

sdist/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ladybug
-Version: 0.22.0.dev20261017
+Version: 0.22.0.dev20261024
 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.20261017 LANGUAGES CXX C)
+project(Lbug VERSION 0.22.0.20261024 LANGUAGES CXX C)
 
 option(SINGLE_THREADED "Single-threaded mode" FALSE)
 if(SINGLE_THREADED)

sdist/ladybug-source/scripts/choco-install.ps1

@@ -0,0 +1,26 @@
+# Installs a Chocolatey package, retrying while the community feed is unavailable.
+# choco can exit 0 after "Unable to find package", so success also requires the
+# package to be listed as installed.
+param(
+    [Parameter(Mandatory = $true)][string]$Package,
+    [string]$Version,
+    [string]$PackageParameters
+)
+
+$chocoArgs = @('install', $Package, '-y')
+if ($Version) { $chocoArgs += "--version=$Version" }
+if ($PackageParameters) { $chocoArgs += "--params=$PackageParameters" }
+
+$attempts = 3
+for ($attempt = 1; $attempt -le $attempts; $attempt++) {
+    & choco @chocoArgs
+    if ($LASTEXITCODE -eq 0 -and (choco list --exact $Package --limit-output)) {
+        exit 0
+    }
+    if ($attempt -lt $attempts) {
+        Write-Host "choco install $Package failed (attempt $attempt of $attempts), retrying in 60s"
+        Start-Sleep -Seconds 60
+    }
+}
+Write-Host "choco install $Package failed after $attempts attempts"
+exit 1

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

@@ -1,5 +1,6 @@
 #include <algorithm>
 #include <unordered_set>
+#include <utility>
 
 #include "binder/binder.h"
 #include "binder/expression/expression_util.h"
@@ -124,6 +125,9 @@ static expression_vector getAggregateExpressions(const std::shared_ptr<Expressio
 }
 
 BoundProjectionList Binder::bindProjectionList(const ProjectionBody& projectionBody) {
+    auto& config = expressionBinder.config;
+    auto outerAggregateNames = std::exchange(config.projectionAggregateNames, {});
+    auto outerBindingProjectionList = std::exchange(config.bindingProjectionList, true);
     expression_vector projectionExprs;
     std::vector<std::string> aliases;
     std::vector<const ParsedExpression*> parsedItems;
@@ -162,6 +166,8 @@ BoundProjectionList Binder::bindProjectionList(const ProjectionBody& projectionB
             parsedItems.push_back(parsedExpr.get());
         }
     }
+    config.bindingProjectionList = outerBindingProjectionList;
+    config.projectionAggregateNames = std::move(outerAggregateNames);
     return {std::move(projectionExprs), std::move(aliases), std::move(parsedItems)};
 }
 

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

@@ -1,9 +1,18 @@
+#include <algorithm>
+
 #include "binder/binder.h"
 #include "binder/expression/aggregate_function_expression.h"
+#include "binder/expression/expression_util.h"
+#include "binder/expression/node_expression.h"
+#include "binder/expression/property_expression.h"
 #include "binder/expression/scalar_function_expression.h"
 #include "binder/expression_binder.h"
+#include "binder/expression_visitor.h"
 #include "catalog/catalog.h"
+#include "catalog/catalog_entry/node_table_catalog_entry.h"
+#include "common/enums/storage_format.h"
 #include "common/exception/binder.h"
+#include "function/aggregate/count.h"
 #include "function/arithmetic/vector_arithmetic_functions.h"
 #include "function/built_in_function_utils.h"
 #include "function/cast/vector_cast_functions.h"
@@ -12,6 +21,8 @@
 #include "function/uuid/vector_uuid_functions.h"
 #include "parser/expression/parsed_expression_visitor.h"
 #include "parser/expression/parsed_function_expression.h"
+#include "storage/storage_manager.h"
+#include "storage/table/node_table.h"
 #include "transaction/transaction.h"
 #include <format>
 
@@ -23,6 +34,14 @@ using namespace lbug::catalog;
 namespace lbug {
 namespace binder {
 
+static bool containsExpressionNamed(const Expression& expression, const std::string& uniqueName) {
+    if (expression.getUniqueName() == uniqueName) {
+        return true;
+    }
+    return std::ranges::any_of(ExpressionChildrenCollector::collectChildren(expression),
+        [&](const auto& child) { return containsExpressionNamed(*child, uniqueName); });
+}
+
 std::shared_ptr<Expression> ExpressionBinder::bindFunctionExpression(const ParsedExpression& expr) {
     auto funcExpr = expr.constPtrCast<ParsedFunctionExpression>();
     auto functionName = funcExpr->getNormalizedFunctionName();
@@ -154,12 +173,76 @@ std::shared_ptr<Expression> ExpressionBinder::bindRewriteFunctionExpression(
     return function->rewriteFunc(input);
 }
 
+// A primary key enforced by the table's primary-key index is unique, never null, and null exactly
+// when the node is unbound, so COUNT over it equals COUNT over the internal ID. Counting the
+// internal ID keeps the planner from scanning the node table only to read the key.
+static std::shared_ptr<Expression> rewritePrimaryKeyToInternalID(const Expression& expr,
+    const BinderScope& scope, main::ClientContext* context) {
+    if (expr.expressionType != ExpressionType::PROPERTY) {
+        return nullptr;
+    }
+    auto& property = expr.constCast<PropertyExpression>();
+    if (!property.isSingleLabel() || !property.isPrimaryKey() ||
+        !scope.contains(property.getRawVariableName())) {
+        return nullptr;
+    }
+    auto variable = scope.getExpression(property.getRawVariableName());
+    if (!ExpressionUtil::isNodePattern(*variable) ||
+        variable->getUniqueName() != property.getVariableName()) {
+        return nullptr;
+    }
+    auto& node = variable->constCast<NodeExpression>();
+    if (node.getNumEntries() != 1) {
+        return nullptr;
+    }
+    auto* entry = node.getEntry(0);
+    const auto tableID = entry->getTableID();
+    if (entry->getType() != CatalogEntryType::NODE_TABLE_ENTRY ||
+        tableID != property.getSingleTableID()) {
+        return nullptr;
+    }
+    // Storage is found by table ID, and IDs repeat across attached databases, so only an entry
+    // of the active catalog backed by the active storage manager can be checked. Attached tables
+    // and partition children keep the property.
+    auto transaction = transaction::Transaction::Get(*context);
+    auto catalog = Catalog::Get(*context);
+    if (!catalog->containsTable(transaction, tableID) ||
+        catalog->getTableCatalogEntry(transaction, tableID) != entry) {
+        return nullptr;
+    }
+    // Icebug-disk and Arrow tables carry a default hash index that does not enforce the key of
+    // their files.
+    auto* nodeEntry = entry->ptrCast<NodeTableCatalogEntry>();
+    if (nodeEntry->getScanFunction().has_value() || nodeEntry->getReferencedEntry() != nullptr ||
+        !nodeEntry->getForeignDatabaseName().empty() || !nodeEntry->getStorage().empty() ||
+        nodeEntry->getStorageFormat() != StorageFormat::NONE) {
+        return nullptr;
+    }
+    auto* storageManager = storage::StorageManager::Get(*context);
+    if (!storageManager->containsTable(tableID)) {
+        return nullptr;
+    }
+    auto* table = dynamic_cast<storage::NodeTable*>(storageManager->getTable(tableID));
+    if (table == nullptr || table->tryGetPrimaryKeyIndex() == nullptr) {
+        return nullptr;
+    }
+    // The alias keeps the key in the aggregate's text, which names an unaliased result column.
+    std::shared_ptr<Expression> internalID = node.getInternalID()->copy();
+    internalID->setAlias(property.toString());
+    return internalID;
+}
+
 std::shared_ptr<Expression> ExpressionBinder::bindAggregateFunctionExpression(
     const ParsedExpression& parsedExpression, const std::string& functionName, bool isDistinct) {
     std::vector<LogicalType> childrenTypes;
     expression_vector children;
     for (auto i = 0u; i < parsedExpression.getNumChildren(); ++i) {
         auto child = bindExpression(*parsedExpression.getChild(i));
+        if (functionName == CountFunction::name) {
+            if (auto internalID = rewritePrimaryKeyToInternalID(*child, binder->scope, context)) {
+                child = std::move(internalID);
+            }
+        }
         childrenTypes.push_back(child->dataType.copy());
         children.push_back(std::move(child));
     }
@@ -180,6 +263,18 @@ std::shared_ptr<Expression> ExpressionBinder::bindAggregateFunctionExpression(
         AggregateFunctionExpression::getUniqueName(function.name, children, function.isDistinct);
     if (children.empty()) {
         uniqueExpressionName = binder->getUniqueExpressionName(uniqueExpressionName);
+    } else if (config.bindingProjectionList &&
+               std::ranges::any_of(binder->scope.getExpressions(), [&](const auto& expr) {
+                   return containsExpressionNamed(*expr, uniqueExpressionName);
+               })) {
+        // The name is structural, so this aggregate would share it, and its column, with the
+        // earlier clause's result, e.g. the group key c in WITH x, count(x) AS c RETURN c,
+        // count(x), or count(x) inside c in WITH x, count(x) + x AS c RETURN c, count(x) + x.
+        auto [entry, isNew] = config.projectionAggregateNames.try_emplace(uniqueExpressionName);
+        if (isNew) {
+            entry->second = binder->getUniqueExpressionName(uniqueExpressionName);
+        }
+        uniqueExpressionName = entry->second;
     }
     std::unique_ptr<FunctionBindData> bindData;
     if (function.bindFunc) {

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

@@ -1,3 +1,5 @@
+#include <utility>
+
 #include "binder/binder.h"
 #include "binder/expression/expression_util.h"
 #include "binder/expression/lambda_expression.h"
@@ -20,8 +22,13 @@ void ExpressionBinder::bindLambdaExpression(const Expression& lambdaInput,
     for (auto& varName : parsedLambdaExpr.getVarNames()) {
         binder->createVariable(varName, listChildType);
     }
+    // The projection does not compute aggregates inside a lambda body, so they keep their
+    // structural names and read the earlier clause's column, as before.
+    auto& config = binder->getExpressionBinder()->config;
+    auto bindingProjectionList = std::exchange(config.bindingProjectionList, false);
     auto funcExpr =
         binder->getExpressionBinder()->bindExpression(*parsedLambdaExpr.getFunctionExpr());
+    config.bindingProjectionList = bindingProjectionList;
     binder->restoreScope(std::move(prevScope));
     boundLambdaExpr.cast(funcExpr->getDataType().copy());
     boundLambdaExpr.setFunctionExpr(std::move(funcExpr));

sdist/ladybug-source/src/binder/ddl/property_definition.cpp

@@ -15,6 +15,16 @@ PropertyDefinition::PropertyDefinition(ColumnDefinition columnDefinition)
     defaultExpr = std::make_unique<ParsedLiteralExpression>(Value::createNullValue(), "NULL");
 }
 
+bool PropertyDefinition::hasDefault() const {
+    if (defaultExpr == nullptr) {
+        return false;
+    }
+    if (defaultExpr->getExpressionType() == common::ExpressionType::LITERAL) {
+        return !defaultExpr->constCast<parser::ParsedLiteralExpression>().getValue().isNull();
+    }
+    return !defaultExpr->getRawName().empty();
+}
+
 void PropertyDefinition::serialize(Serializer& serializer) const {
     serializer.serializeValue(columnDefinition.name);
     columnDefinition.type.serialize(serializer);

sdist/ladybug-source/src/binder/expression_binder.cpp

@@ -183,13 +183,7 @@ std::shared_ptr<Expression> ExpressionBinder::bindExpression(
         throw NotImplementedException(
             "bindExpression(" + ExpressionTypeUtil::toString(expressionType) + ").");
     }
-    // A direct reference to a variable returns an expression of an earlier clause, simplified when
-    // it was bound; it is not simplified again, as a new object would escape the binder's identity
-    // check for expressions an earlier clause computed. References nested in a larger expression
-    // rely on each simplifier returning an already simplified input unchanged.
-    if (expressionType != ExpressionType::VARIABLE) {
-        expression = simplifyExpression(expression);
-    }
+    expression = simplifyExpression(expression);
     if (ConstantExpressionVisitor::needFold(*expression)) {
         return tryFoldExpression(expression);
     }
@@ -198,6 +192,11 @@ std::shared_ptr<Expression> ExpressionBinder::bindExpression(
 
 std::shared_ptr<Expression> ExpressionBinder::simplifyExpression(
     const std::shared_ptr<Expression>& expression) {
+    // Earlier clauses' expressions are recognised by identity, so a scope expression is never
+    // simplified again, and no simplifier returns a part of one in place of its parent.
+    if (binder->scope.contains(*expression)) {
+        return expression;
+    }
     switch (expression->expressionType) {
     case ExpressionType::AND:
     case ExpressionType::OR:
@@ -263,6 +262,12 @@ std::shared_ptr<Expression> ExpressionBinder::simplifyArithmeticExpression(
     if (expression->dataType != survivor->dataType) {
         return expression;
     }
+    // A projection names its item by setting the alias on the expression, so an identity over a
+    // scope expression stays as written: returning the operand would let the alias rename the
+    // variable, e.g. x in WITH x + 0 AS y, x.
+    if (binder->scope.contains(*survivor)) {
+        return expression;
+    }
     // Preserve the original expression name, mirroring foldExpression: without this,
     // e.g. RETURN t.age, t.age + 0 would produce two identically-named columns.
     if (expression->hasAlias()) {
@@ -286,7 +291,7 @@ std::shared_ptr<Expression> ExpressionBinder::simplifyBooleanExpression(
         if (isBoolLiteral(*child, false)) {
             return createLiteralExpression(Value(true));
         }
-        if (child->expressionType == ExpressionType::NOT) {
+        if (child->expressionType == ExpressionType::NOT && !binder->scope.contains(*child)) {
             return child->getChild(0);
         }
         if (child != expression->getChild(0)) {

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

@@ -15,7 +15,8 @@ lbug_state lbug_database_init(const char* database_path, lbug_system_config conf
         auto systemConfig = SystemConfig(config.buffer_pool_size, config.max_num_threads,
             config.enable_compression, config.read_only, config.max_db_size, config.auto_checkpoint,
             config.checkpoint_threshold, true, config.throw_on_wal_replay_failure,
-            config.enable_checksums, config.enable_multi_writes, config.enable_default_hash_index);
+            config.enable_checksums, config.enable_multi_writes, config.enable_default_hash_index,
+            config.physical_plan_pool_per_thread);
 
 #if defined(__APPLE__)
         systemConfig.threadQos = config.thread_qos;
@@ -54,6 +55,7 @@ lbug_system_config lbug_default_system_config() {
     cSystemConfig.enable_checksums = config.enableChecksums;
     cSystemConfig.enable_multi_writes = config.enableMultiWrites;
     cSystemConfig.enable_default_hash_index = config.enableDefaultHashIndex;
+    cSystemConfig.physical_plan_pool_per_thread = config.physicalPlanPoolPerThread;
 #if defined(__APPLE__)
     cSystemConfig.thread_qos = config.threadQos;
 #endif

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

@@ -3,6 +3,7 @@
 #include "c_api/helpers.h"
 #include "c_api/lbug.h"
 #include "common/constants.h"
+#include "common/type_utils.h"
 #include "common/types/types.h"
 #include "common/types/value/nested.h"
 #include "common/types/value/node.h"
@@ -40,7 +41,7 @@ static bool canCopyValueForNested(const Value& value, const LogicalType& targetT
     if (value.getDataType() == targetType) {
         return true;
     }
-    if (value.isNull() && value.getDataType().getLogicalTypeID() == LogicalTypeID::ANY) {
+    if (value.isNull()) {
         return true;
     }
     if (isEmptyNestedWithAny(value)) {
@@ -51,8 +52,45 @@ static bool canCopyValueForNested(const Value& value, const LogicalType& targetT
         targetType.getLogicalTypeID() == LogicalTypeID::FLOAT) {
         return true;
     }
-    return value.getDataType().getLogicalTypeID() == targetType.getLogicalTypeID() &&
-           value.getDataType().containsAny();
+    if (LogicalTypeUtils::isIntegral(value.getDataType()) &&
+        LogicalTypeUtils::isIntegral(targetType)) {
+        return true;
+    }
+    if (value.getDataType().getLogicalTypeID() != targetType.getLogicalTypeID()) {
+        return false;
+    }
+    const auto* nested = &value;
+    if (targetType.getLogicalTypeID() == LogicalTypeID::LIST) {
+        const auto& childType = ListType::getChildType(targetType);
+        for (auto i = 0u; i < NestedVal::getChildrenSize(nested); ++i) {
+            if (!canCopyValueForNested(*NestedVal::getChildVal(nested, i), childType)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (targetType.getLogicalTypeID() == LogicalTypeID::MAP) {
+        const auto& keyType = MapType::getKeyType(targetType);
+        const auto& valueType = MapType::getValueType(targetType);
+        for (auto i = 0u; i < NestedVal::getChildrenSize(nested); ++i) {
+            auto* mapEntry = NestedVal::getChildVal(nested, i);
+            if (!canCopyValueForNested(*NestedVal::getChildVal(mapEntry, 0), keyType) ||
+                !canCopyValueForNested(*NestedVal::getChildVal(mapEntry, 1), valueType)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (targetType.getLogicalTypeID() == LogicalTypeID::STRUCT) {
+        for (auto i = 0u; i < NestedVal::getChildrenSize(nested); ++i) {
+            if (!canCopyValueForNested(*NestedVal::getChildVal(nested, i),
+                    StructType::getFieldType(targetType, static_cast<struct_field_idx_t>(i)))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return value.getDataType().containsAny();
 }
 
 static std::string incompatibleParameterTypeMessage(const LogicalType& left,
@@ -69,28 +107,54 @@ static lbug_value* createCAPIValue(std::unique_ptr<Value> value) {
     return c_value;
 }
 
+// The target comes from LogicalTypeUtils::tryGetMaxLogicalType, which joins two integer types only
+// into one that holds both: implicit integer casts only widen, and a signed/unsigned pair becomes a
+// wider signed type. So the cast below is exact. CreateListAllIntegerPairs pins this.
+static std::unique_ptr<Value> castIntegerForNested(const Value& value,
+    const LogicalType& targetType) {
+    // A null of the target type keeps its exact type: SERIAL's default value is an INT64.
+    auto result = std::make_unique<Value>(Value::createNullValue(targetType));
+    result->setNull(false);
+    TypeUtils::visit(
+        value.getDataType(),
+        [&]<IntegerTypes SRC>(SRC) {
+            TypeUtils::visit(
+                targetType,
+                [&]<IntegerTypes DST>(DST) {
+                    auto castValue = static_cast<DST>(value.getValue<SRC>());
+                    result->copyFromRowLayout(reinterpret_cast<const uint8_t*>(&castValue));
+                },
+                [](auto) { UNREACHABLE_CODE; });
+        },
+        [](auto) { UNREACHABLE_CODE; });
+    return result;
+}
+
 static std::unique_ptr<Value> copyValueForNested(const Value& value,
     const LogicalType& targetType) {
-    if (value.isNull() && value.getDataType().getLogicalTypeID() == LogicalTypeID::ANY) {
+    if (value.getDataType() == targetType) {
+        return value.copy();
+    }
+    if (value.isNull()) {
         return std::make_unique<Value>(Value::createNullValue(targetType));
     }
-    if (value.getDataType() != targetType && isEmptyNestedWithAny(value)) {
+    if (isEmptyNestedWithAny(value)) {
         return std::make_unique<Value>(Value::createDefaultValue(targetType));
     }
-    if (value.getDataType() != targetType &&
-        targetType.getLogicalTypeID() == LogicalTypeID::STRING) {
+    if (targetType.getLogicalTypeID() == LogicalTypeID::STRING) {
         return std::make_unique<Value>(Value::createValue<std::string>(value.toString()));
     }
-    if (value.getDataType() != targetType &&
-        targetType.getLogicalTypeID() == LogicalTypeID::DOUBLE) {
+    if (targetType.getLogicalTypeID() == LogicalTypeID::DOUBLE) {
         return std::make_unique<Value>(std::stod(value.toString()));
     }
-    if (value.getDataType() != targetType &&
-        targetType.getLogicalTypeID() == LogicalTypeID::FLOAT) {
+    if (targetType.getLogicalTypeID() == LogicalTypeID::FLOAT) {
         return std::make_unique<Value>(static_cast<float>(std::stof(value.toString())));
     }
-    if (value.getDataType() != targetType &&
-        value.getDataType().getLogicalTypeID() == LogicalTypeID::LIST &&
+    if (LogicalTypeUtils::isIntegral(value.getDataType()) &&
+        LogicalTypeUtils::isIntegral(targetType)) {
+        return castIntegerForNested(value, targetType);
+    }
+    if (value.getDataType().getLogicalTypeID() == LogicalTypeID::LIST &&
         targetType.getLogicalTypeID() == LogicalTypeID::LIST) {
         std::vector<std::unique_ptr<Value>> children;
         const auto& childType = ListType::getChildType(targetType);
@@ -100,8 +164,7 @@ static std::unique_ptr<Value> copyValueForNested(const Value& value,
         }
         return std::make_unique<Value>(targetType.copy(), std::move(children));
     }
-    if (value.getDataType() != targetType &&
-        value.getDataType().getLogicalTypeID() == LogicalTypeID::MAP &&
+    if (value.getDataType().getLogicalTypeID() == LogicalTypeID::MAP &&
         targetType.getLogicalTypeID() == LogicalTypeID::MAP) {
         std::vector<std::unique_ptr<Value>> children;
         const auto& keyType = MapType::getKeyType(targetType);
@@ -121,6 +184,15 @@ static std::unique_ptr<Value> copyValueForNested(const Value& value,
         }
         return std::make_unique<Value>(targetType.copy(), std::move(children));
     }
+    if (value.getDataType().getLogicalTypeID() == LogicalTypeID::STRUCT &&
+        targetType.getLogicalTypeID() == LogicalTypeID::STRUCT) {
+        std::vector<std::unique_ptr<Value>> children;
+        for (auto i = 0u; i < NestedVal::getChildrenSize(&value); ++i) {
+            children.push_back(copyValueForNested(*NestedVal::getChildVal(&value, i),
+                StructType::getFieldType(targetType, static_cast<struct_field_idx_t>(i))));
+        }
+        return std::make_unique<Value>(targetType.copy(), std::move(children));
+    }
     return value.copy();
 }
 

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

@@ -15,6 +15,7 @@
 #include "common/partition_routing_hook.h"
 #include "common/serializer/deserializer.h"
 #include "common/serializer/serializer.h"
+#include "common/string_utils.h"
 #include "extension/extension_manager.h"
 #include "function/function_collection.h"
 #include "main/client_context.h"
@@ -587,7 +588,7 @@ std::vector<FunctionCatalogEntry*> Catalog::getFunctionEntries(
 }
 
 bool Catalog::containsMacro(const Transaction* transaction, const std::string& macroName) const {
-    return macros->containsEntry(transaction, macroName);
+    return macros->containsEntry(transaction, StringUtils::getUpper(macroName));
 }
 
 function::ScalarMacroFunction* Catalog::getScalarMacroFunction(const Transaction* transaction,
@@ -627,11 +628,12 @@ std::vector<std::string> Catalog::getMacroNames(const Transaction* transaction)
 }
 
 void Catalog::dropMacro(Transaction* transaction, std::string& name) {
-    if (!containsMacro(transaction, name)) {
+    auto macroName = StringUtils::getUpper(name);
+    if (!macros->containsEntry(transaction, macroName)) {
         throw CatalogException{std::format("Macro {} doesn't exist.", name)};
     }
-    auto entry = getFunctionEntry(transaction, name);
-    macros->dropEntry(transaction, name, entry->getOID());
+    auto entry = macros->getEntry(transaction, macroName);
+    macros->dropEntry(transaction, macroName, entry->getOID());
 }
 
 void Catalog::registerBuiltInFunctions() {

sdist/ladybug-source/src/catalog/property_definition_collection.cpp

@@ -134,7 +134,11 @@ std::string PropertyDefinitionCollection::toCypher() const {
         if (typeStr.find("MAP") != std::string::npos) {
             StringUtils::replaceAll(typeStr, "  ", ",");
         }
-        ss << common::StringUtils::quoteIdentifier(def.getName()) << " " << typeStr << ",";
+        ss << common::StringUtils::quoteIdentifier(def.getName()) << " " << typeStr;
+        if (dataType.getLogicalTypeID() != LogicalTypeID::SERIAL && def.hasDefault()) {
+            ss << " DEFAULT " << def.getDefaultExpressionName();
+        }
+        ss << ",";
     }
     return ss.str();
 }