Basic support for emitting SQL queries

TODO: Emit the WHERE clause from dag.

Author: mshockwave

CMakeLists.txt

@@ -34,6 +34,7 @@ set(_SOURCE_FILES
     sqlgen.cpp
     SQLEmitter.cpp
     SQLInsertEmitter.cpp
+    SQLQueryEmitter.cpp
     SQLTableEmitter.cpp
     )
 

Error.cpp

@@ -1,9 +1,7 @@
 #include "Error.h"
 
-using namespace llvm;
+char llvm::SMLocError::ID = 0;
 
-char SMLocError::ID = 0;
-
-Error llvm::createTGStringError(SMLoc Loc, const Twine &S) {
+llvm::Error llvm::createTGStringError(SMLoc Loc, const Twine &S) {
   return make_error<SMLocError>(Loc, inconvertibleErrorCode(), S);
 }

Error.h

@@ -1,12 +1,11 @@
+#ifndef SQLGEN_ERROR_H
+#define SQLGEN_ERROR_H
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/SMLoc.h"
 
 namespace llvm {
-class SMLocError : public ErrorInfo<SMLocError, StringError> {
-  using ErrorInfo<SMLocError, StringError>::ErrorInfo;
-
-public:
+struct SMLocError : public ErrorInfo<SMLocError, StringError> {
   static char ID;
   SMLoc Loc;
 
@@ -16,3 +15,4 @@ class SMLocError : public ErrorInfo<SMLocError, StringError> {
 
 Error createTGStringError(SMLoc Loc, const Twine &S);
 } // end namespace llvm
+#endif

SQLEmitter.cpp

@@ -4,33 +4,44 @@
 #include "llvm/TableGen/Record.h"
 
 #include "SQLInsertEmitter.h"
+#include "SQLQueryEmitter.h"
 #include "SQLTableEmitter.h"
 
 using namespace llvm;
 
 Error emitSQL(raw_ostream &OS, RecordKeeper &Records) {
 
-  // Generate SQL tables
-  const auto &Classes = Records.getClasses();
-  SmallVector<const Record *, 4> TableClasses;
-  for (const auto &P : Classes) {
-    if (P.second->isSubClassOf("Table"))
-      TableClasses.push_back(P.second.get());
+  if (const auto *TableClass = Records.getClass("Table")) {
+    // Generate SQL tables
+    const auto &Classes = Records.getClasses();
+    SmallVector<const Record *, 4> TableClasses;
+    for (const auto &P : Classes) {
+      if (P.second->isSubClassOf(TableClass))
+        TableClasses.push_back(P.second.get());
+    }
+    SQLTableEmitter TableEmitter(OS);
+    if (auto E = TableEmitter.run(TableClasses))
+      return std::move(E);
+
+    auto getPrimaryKey = [&](const Record *Class) -> Optional<StringRef> {
+      return TableEmitter.getPrimaryKey(Class);
+    };
+
+    // Generate SQL rows
+    auto SQLRows = Records.getAllDerivedDefinitions("Table");
+    // RecordKeeper::getAllDerivedDefinitions will only
+    // return concrete records, so we don't need to filter out
+    // class `Record` instances.
+    if (auto E = SQLInsertEmitter(OS, getPrimaryKey).run(SQLRows))
+      return std::move(E);
+  }
+
+  if (Records.getClass("Operator") && Records.getClass("Query")) {
+    auto SQLOperators = Records.getAllDerivedDefinitions("Operator");
+    auto SQLQueries = Records.getAllDerivedDefinitions("Query");
+    if (auto E = SQLQueryEmitter(OS).run(SQLQueries, SQLOperators))
+      return std::move(E);
   }
-  SQLTableEmitter TableEmitter(OS);
-  if (auto E = TableEmitter.run(TableClasses))
-    return std::move(E);
-
-  auto getPrimaryKey = [&](const Record *Class) -> Optional<StringRef> {
-    return TableEmitter.getPrimaryKey(Class);
-  };
-
-  // RecordKeeper::getAllDerivedDefinitions will only
-  // return concrete records, so we don't need to filter out
-  // class `Record` instances.
-  auto SQLRows = Records.getAllDerivedDefinitions("Table");
-  if (auto E = SQLInsertEmitter(OS, getPrimaryKey).run(SQLRows))
-    return std::move(E);
 
   return Error::success();
 }

SQLQueryEmitter.cpp

@@ -0,0 +1,91 @@
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringMap.h"
+#include "Error.h"
+#include "SQLQueryEmitter.h"
+
+using namespace llvm;
+
+namespace {
+class SQLWhereClauseEmitter {
+  raw_ostream &OS;
+
+public:
+  SQLWhereClauseEmitter(raw_ostream &OS) : OS(OS) {}
+
+  Error run(const DagInit *WhereClause);
+};
+} // end anonymous namespace
+
+Error SQLWhereClauseEmitter::run(const DagInit *WhereClause) {
+  // TODO: Build an operator tree and visit it in an infix fashion.
+  return Error::success();
+}
+
+Error SQLQueryEmitter::run(ArrayRef<const Record *> Queries,
+                           ArrayRef<const Record *> Operators) {
+  // Map from the tag name to its corresponding SQL table field name.
+  StringMap<StringRef> FieldTagMap;
+
+  for (const auto *QueryRecord : Queries) {
+    auto MaybeTableName = QueryRecord->getValueAsOptionalString("TableName");
+    if (!MaybeTableName || MaybeTableName->empty())
+      return createTGStringError(QueryRecord->getLoc()[0], "SQL table name "
+                                 "is missing");
+    auto TableName = *MaybeTableName;
+
+    OS << "SELECT ";
+
+    const DagInit *FieldsInit = QueryRecord->getValueAsDag("Fields");
+    auto FieldOpName = FieldsInit->getOperator()->getAsString();
+    if (FieldOpName == "all")
+      OS << "*";
+    else if (FieldOpName != "fields")
+      // FIXME: This is a terrible SMLoc to use here.
+      return createTGStringError(QueryRecord->getLoc()[0], "Invalid dag operator"
+                                 " \"" + FieldOpName + "\"");
+
+    FieldTagMap.clear();
+    {
+      ListSeparator LS;
+      for (unsigned i = 0U; i != FieldsInit->arg_size(); ++i)
+        if (const auto *Field = dyn_cast<StringInit>(FieldsInit->getArg(i))) {
+          OS << LS << Field->getValue();
+          if (const auto *Tag = FieldsInit->getArgName(i))
+            FieldTagMap.insert({Tag->getValue(), Field->getValue()});
+        }
+    }
+
+    OS << " FROM " << TableName;
+
+    const DagInit *WhereClause = QueryRecord->getValueAsDag("WhereClause");
+    if (WhereClause->getOperator()->getAsString() != "none") {
+      OS << "\n";
+      if (auto E = SQLWhereClauseEmitter(OS).run(WhereClause))
+        return std::move(E);
+    }
+
+    auto OrderedBy = QueryRecord->getValueAsListOfStrings("OrderedBy");
+    if (OrderedBy.size()) {
+      OS << "\n";
+      OS << "ORDER BY ";
+      ListSeparator LS;
+      for (auto FieldOrTag : OrderedBy) {
+        auto FieldName = FieldOrTag;
+        if (FieldOrTag.startswith("$")) {
+          // It's a tag
+          auto TagName = FieldOrTag.drop_front(1);
+          auto I = FieldTagMap.find(TagName);
+          if (I == FieldTagMap.end())
+            return createTGStringError(QueryRecord->getLoc()[0], "Unrecognized "
+                                       "tag \"" + TagName + "\"");
+          FieldName = I->second;
+        }
+        OS << LS << FieldName;
+      }
+    }
+
+    OS << ";\n\n";
+  }
+
+  return Error::success();
+}

SQLQueryEmitter.h

@@ -0,0 +1,20 @@
+#ifndef SQLGEN_SQLQUERYEMITTER_H
+#define SQLGEN_SQLQUERYEMITTER_H
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/TableGen/Record.h"
+
+namespace llvm {
+class SQLQueryEmitter {
+  raw_ostream &OS;
+
+public:
+  explicit
+  SQLQueryEmitter(raw_ostream &OS) : OS(OS) {}
+
+  Error run(ArrayRef<const Record *> Queries,
+            ArrayRef<const Record *> Operators);
+};
+} // end namespace llvm
+#endif

SQLTableEmitter.h

@@ -12,6 +12,7 @@ class SQLTableEmitter {
   DenseMap<const Record *, StringRef> PrimaryKeys;
 
 public:
+  explicit
   SQLTableEmitter(raw_ostream &OS) : OS(OS) {}
 
   Error run(ArrayRef<const Record *> Classes);