LingoDB源码编译与分析

1
#include "frontend/SQL/Parser.h"
2
#include "mlir/Dialect/SubOperator/SubOperatorDialect.h"
3
#include "mlir/Dialect/SubOperator/SubOperatorOps.h"
4
#include "runtime/Session.h"
5
void printMLIR(std::string sql, std::shared_ptr<runtime::Catalog> catalog) {
6
   mlir::MLIRContext context;
7
   mlir::DialectRegistry registry;
8
   registry.insert<mlir::BuiltinDialect>();
9
   registry.insert<mlir::relalg::RelAlgDialect>();
10
   registry.insert<mlir::subop::SubOperatorDialect>();
11
   registry.insert<mlir::tuples::TupleStreamDialect>();
12
   registry.insert<mlir::db::DBDialect>();
13
   registry.insert<mlir::func::FuncDialect>();
14
   registry.insert<mlir::arith::ArithDialect>();
15

16
   registry.insert<mlir::memref::MemRefDialect>();
17
   registry.insert<mlir::util::UtilDialect>();
18
   registry.insert<mlir::scf::SCFDialect>();
19
   registry.insert<mlir::LLVM::LLVMDialect>();
20
   context.appendDialectRegistry(registry);
21
   context.loadAllAvailableDialects();
22
   context.loadDialect<mlir::relalg::RelAlgDialect>();
23
   mlir::OpBuilder builder(&context);
24
   mlir::ModuleOp moduleOp = builder.create<mlir::ModuleOp>(builder.getUnknownLoc());
25
   frontend::sql::Parser translator(sql, *catalog, moduleOp);
26

27
   builder.setInsertionPointToStart(moduleOp.getBody());
28
   auto* queryBlock = new mlir::Block;
29
   {
30
      mlir::OpBuilder::InsertionGuard guard(builder);
31
      builder.setInsertionPointToStart(queryBlock);
32
      auto val = translator.translate(builder);
33
      if (val.has_value()) {
34
         builder.create<mlir::subop::SetResultOp>(builder.getUnknownLoc(), 0, val.value());
35
      }
36
      builder.create<mlir::func::ReturnOp>(builder.getUnknownLoc());
37
   }
38
   mlir::func::FuncOp funcOp = builder.create<mlir::func::FuncOp>(builder.getUnknownLoc(), "main", builder.getFunctionType({}, {}));
39
   funcOp.getBody().push_back(queryBlock);
40

41
   mlir::OpPrintingFlags flags;
42
   flags.assumeVerified();
43
   moduleOp->print(llvm::outs(), flags);
44
}
45
int main(int argc, char** argv) {
46
   std::string filename = std::string(argv[1]);
47
   auto catalog = runtime::Catalog::createEmpty();
48
   if (argc >= 3) {
49
      std::string dbDir = std::string(argv[2]);
50
      catalog = runtime::DBCatalog::create(catalog, dbDir, false);
51
   }
52
   std::ifstream istream{filename};
53
   std::stringstream buffer;
54
   buffer << istream.rdbuf();
55
   while (true) {
56
      std::stringstream query;
57
      std::string line;
58
      std::getline(buffer, line);
59
      while (true) {
60
         if (!buffer.good()) {
61
            if (buffer.eof()) {
62
               query << line << std::endl;
63
            }
64
            break;
65
         }
66
         query << line << std::endl;
67
         if (!line.empty() && line.find(';') == line.size() - 1) {
68
            break;
69
         }
70
         std::getline(buffer, line);
71
      }
72
      printMLIR(query.str(),catalog);
73
      if (buffer.eof()) {
74
         //exit from repl loop
75
         break;
76
      }
77
   }
78
   return 0;
79
}

1
std::optional<mlir::Value> frontend::sql::Parser::translate(mlir::OpBuilder& builder) {
2
   if (result.tree && result.tree->length == 1) {
3
      auto* statement = static_cast<Node*>(result.tree->head->data.ptr_value);
4
      switch (statement->type) {
5
         case T_VariableSetStmt: {
6
            auto* variableSetStatement = reinterpret_cast<VariableSetStmt*>(statement);
7
            translateVariableSetStatement(builder, variableSetStatement);
8
            break;
9
         }
10
         case T_CreateStmt: {
11
            translateCreateStatement(builder, reinterpret_cast<CreateStmt*>(statement));
12
            break;
13
         }
14
         case T_CopyStmt: {
15
            auto* copyStatement = reinterpret_cast<CopyStmt*>(statement);
16
            translateCopyStatement(builder, copyStatement);
17
            break;
18
         }
19
         case T_SelectStmt: {
20
            parallelismAllowed = true;
21
            TranslationContext context;
22
            auto scope = context.createResolverScope();
23
            auto [tree, targetInfo] = translateSelectStmt(builder, reinterpret_cast<SelectStmt*>(statement), context, scope);
24
            //::mlir::Type result, ::mlir::Value rel, ::mlir::ArrayAttr attrs, ::mlir::ArrayAttr columns
25
            std::vector<mlir::Attribute> attrs;
26
            std::vector<mlir::Attribute> names;
27
            std::vector<mlir::Attribute> colMemberNames;
28
            std::vector<mlir::Attribute> colTypes;
29
            auto& memberManager = builder.getContext()->getLoadedDialect<mlir::subop::SubOperatorDialect>()->getMemberManager();
30
            for (auto x : targetInfo.namedResults) {
31
               if (x.first == "primaryKeyHashValue") continue;
32
               names.push_back(builder.getStringAttr(x.first));
33
               auto colMemberName = memberManager.getUniqueMember(x.first.empty() ? "unnamed" : x.first);
34
               auto columnType = x.second->type;
35
               attrs.push_back(attrManager.createRef(x.second));
36
               colTypes.push_back(mlir::TypeAttr::get(columnType));
37
               colMemberNames.push_back(builder.getStringAttr(colMemberName));
38
            }
39
            auto resultTableType = mlir::subop::ResultTableType::get(builder.getContext(), mlir::subop::StateMembersAttr::get(builder.getContext(), builder.getArrayAttr(colMemberNames), builder.getArrayAttr(colTypes)));
40
            return builder.create<mlir::relalg::MaterializeOp>(builder.getUnknownLoc(), resultTableType, tree, builder.getArrayAttr(attrs), builder.getArrayAttr(names));
41
         }
42
         case T_InsertStmt: {
43
            translateInsertStmt(builder, reinterpret_cast<InsertStmt*>(statement));
44
            break;
45
         }
46
         default:
47
           throw std::runtime_error("unsupported statement type");
48
      }
49
   }
50
   return {};
51
}

1
docker pull ghcr.io/lingo-db/lingo-db:latest
2
docker run -it --name lingo  ghcr.io/lingo-db/lingo-db /bin/bash

1
apt install gdb

1
{
2
    // Use IntelliSense to learn about possible attributes.
3
    // Hover to view descriptions of existing attributes.
4
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
5
    "version": "0.2.0",
6
    "configurations": [
7
        {
8
            "name": "(gdb) Launch sql-to-mlir",
9
            "type": "cppdbg",
10
            "request": "launch",
11
            "program": "${workspaceFolder}/build/lingodb-debug/sql-to-mlir",
12
            "args": ["./build/lingodb-debug/test.sql","./resources/data/uni/"],
13
            "stopAtEntry": false,
14
            "cwd": "${workspaceFolder}",
15
            "environment": [],
16
            "externalConsole": false,
17
            "MIMode": "gdb",
18
            "setupCommands": [
19
                {
20
                    "description": "Enable pretty-printing for gdb",
21
                    "text": "-enable-pretty-printing",
22
                    "ignoreFailures": true
23
                },
24
                {
25
                    "description": "Set Disassembly Flavor to Intel",
26
                    "text": "-gdb-set disassembly-flavor intel",
27
                    "ignoreFailures": true
28
                }
29
            ]
30
        },
31
    ]
32
}

1
gitlab.db.in.tum.de:5005/lingo-db/lingo-db/lingodb-dev:latest

1
if (auto functionType = mlir::dyn_cast_or_null<mlir::FunctionType>(op.getType())) {