#include "common/exception/runtime.h" #include "common/file_system/virtual_file_system.h" #include "extension/mapper_extension.h" #include "main/client_context.h" #include "planner/operator/simple/logical_attach_database.h" #include "planner/operator/simple/logical_detach_database.h" #include "planner/operator/simple/logical_export_db.h" #include "planner/operator/simple/logical_extension.h" #include "planner/operator/simple/logical_graph.h" #include "planner/operator/simple/logical_import_db.h" #include "planner/operator/simple/logical_use_database.h" #include "processor/operator/persistent/copy_to.h" #include "processor/operator/simple/attach_database.h" #include "processor/operator/simple/detach_database.h" #include "processor/operator/simple/export_db.h" #include "processor/operator/simple/import_db.h" #include "processor/operator/simple/install_extension.h" #include "processor/operator/simple/load_extension.h" #include "processor/operator/simple/uninstall_extension.h" #include "processor/operator/simple/use_database.h" #include "processor/operator/simple/use_graph.h" #include "processor/plan_mapper.h" #include "processor/result/factorized_table_util.h" #include "storage/buffer_manager/memory_manager.h" #include namespace lbug { namespace processor { using namespace lbug::planner; using namespace lbug::common; using namespace lbug::storage; using namespace lbug::extension; std::unique_ptr PlanMapper::mapUseDatabase( const LogicalOperator* logicalOperator) { auto useDatabase = logicalOperator->constPtrCast(); auto printInfo = std::make_unique(useDatabase->getDBName()); auto messageTable = FactorizedTableUtils::getSingleStringColumnFTable(MemoryManager::Get(*clientContext)); return std::make_unique(useDatabase->getDBName(), std::move(messageTable), getOperatorID(), std::move(printInfo)); } std::unique_ptr PlanMapper::mapAttachDatabase( const LogicalOperator* logicalOperator) { auto attachDatabase = logicalOperator->constPtrCast(); auto info = attachDatabase->getAttachInfo(); auto printInfo = std::make_unique(info.dbAlias, info.dbPath); auto messageTable = FactorizedTableUtils::getSingleStringColumnFTable(MemoryManager::Get(*clientContext)); return std::make_unique(std::move(info), std::move(messageTable), getOperatorID(), std::move(printInfo)); } std::unique_ptr PlanMapper::mapDetachDatabase( const LogicalOperator* logicalOperator) { auto detachDatabase = logicalOperator->constPtrCast(); auto printInfo = std::make_unique(); auto messageTable = FactorizedTableUtils::getSingleStringColumnFTable(MemoryManager::Get(*clientContext)); return std::make_unique(detachDatabase->getDBName(), std::move(messageTable), getOperatorID(), std::move(printInfo)); } static void exportDatabaseCollectParallelFlags(const std::unique_ptr& sink) { auto exportDB = sink->getChild(0)->ptrCast(); for (auto i = 1u; i < sink->getNumChildren(); ++i) { const auto& tableFuncCall = sink->getChild(i); ASSERT(tableFuncCall->getChild(0)->getOperatorType() == PhysicalOperatorType::COPY_TO); const auto& [file, parallelFlag] = tableFuncCall->getChild(0)->ptrCast()->getParallelFlag(); exportDB->addToParallelReaderMap(file, parallelFlag); } } std::unique_ptr PlanMapper::mapExportDatabase( const LogicalOperator* logicalOperator) { auto exportDatabase = logicalOperator->constPtrCast(); auto fs = VirtualFileSystem::GetUnsafe(*clientContext); auto boundFileInfo = exportDatabase->getBoundFileInfo(); DASSERT(boundFileInfo->filePaths.size() == 1); auto filePath = boundFileInfo->filePaths[0]; if (fs->fileOrPathExists(filePath, clientContext)) { throw RuntimeException(std::format("Directory {} already exists.", filePath)); } fs->createDir(filePath); auto printInfo = std::make_unique(filePath, boundFileInfo->options); auto messageTable = FactorizedTableUtils::getSingleStringColumnFTable(MemoryManager::Get(*clientContext)); auto exportDB = std::make_unique(boundFileInfo->copy(), exportDatabase->isSchemaOnly(), messageTable, getOperatorID(), std::move(printInfo)); auto sink = std::make_unique(messageTable, getOperatorID()); sink->addChild(std::move(exportDB)); for (auto child : exportDatabase->getChildren()) { sink->addChild(mapOperator(child.get())); } exportDatabaseCollectParallelFlags(sink); return sink; } std::unique_ptr PlanMapper::mapImportDatabase( const LogicalOperator* logicalOperator) { auto importDatabase = logicalOperator->constPtrCast(); auto printInfo = std::make_unique(); auto messageTable = FactorizedTableUtils::getSingleStringColumnFTable(MemoryManager::Get(*clientContext)); return std::make_unique(importDatabase->getQuery(), importDatabase->getIndexQuery(), std::move(messageTable), getOperatorID(), std::move(printInfo)); } std::unique_ptr PlanMapper::mapExtension(const LogicalOperator* logicalOperator) { auto logicalExtension = logicalOperator->constPtrCast(); auto& auxInfo = logicalExtension->getAuxInfo(); auto path = auxInfo.path; auto messageTable = FactorizedTableUtils::getSingleStringColumnFTable(MemoryManager::Get(*clientContext)); switch (auxInfo.action) { case ExtensionAction::INSTALL: { auto installAuxInfo = auxInfo.contCast(); InstallExtensionInfo info{path, installAuxInfo.extensionRepo, installAuxInfo.forceInstall}; auto printInfo = std::make_unique(path); return std::make_unique(std::move(info), std::move(messageTable), getOperatorID(), std::move(printInfo)); } case ExtensionAction::UNINSTALL: { auto printInfo = std::make_unique(path); return std::make_unique(path, std::move(messageTable), getOperatorID(), std::move(printInfo)); } case ExtensionAction::LOAD: { auto printInfo = std::make_unique(path); return std::make_unique(path, std::move(messageTable), getOperatorID(), std::move(printInfo)); } default: UNREACHABLE_CODE; } } std::unique_ptr PlanMapper::mapExtensionClause( const LogicalOperator* logicalOperator) { for (auto& mapperExtension : mapperExtensions) { auto physicalOP = mapperExtension->map(logicalOperator, clientContext, getOperatorID()); if (physicalOP) { return physicalOP; } } UNREACHABLE_CODE; } std::unique_ptr PlanMapper::mapCreateGraph( const LogicalOperator* logicalOperator) { auto createGraph = logicalOperator->constPtrCast(); auto printInfo = std::make_unique(); auto messageTable = FactorizedTableUtils::getSingleStringColumnFTable(MemoryManager::Get(*clientContext)); return std::make_unique(createGraph->getGraphName(), createGraph->isAnyGraph(), std::move(messageTable), getOperatorID(), std::move(printInfo)); } std::unique_ptr PlanMapper::mapUseGraph(const LogicalOperator* logicalOperator) { auto useGraph = logicalOperator->constPtrCast(); auto printInfo = std::make_unique(useGraph->getGraphName()); auto messageTable = FactorizedTableUtils::getSingleStringColumnFTable(MemoryManager::Get(*clientContext)); return std::make_unique(useGraph->getGraphName(), std::move(messageTable), getOperatorID(), std::move(printInfo)); } } // namespace processor } // namespace lbug