Adding table access tracking

Shriram Rajagopalan · Shriram Rajagopalan · commit ce5b6d1f4ddb · 2018-11-12T18:03:26.000-05:00
diff --git a/src/sql/CreateStatement.h b/src/sql/CreateStatement.h
@@ -2,6 +2,7 @@
 #define SQLPARSER_CREATE_STATEMENT_H
 
 #include "SQLStatement.h"
+#include "TableAccess.h"
 
 #include <ostream>
 
@@ -53,7 +54,14 @@ namespace hsql {
   struct CreateStatement : SQLStatement {
     CreateStatement(CreateType type);
     virtual ~CreateStatement();
-
+    void tablesAccessed(TableAccessMap& accessMap) const override {
+      if (select != nullptr) {
+        select->tablesAccessed(accessMap);
+      }
+      if (tableName != nullptr) {
+        TableAccess::addWriteEntry(accessMap, tableName, schema);
+      }
+    };
     CreateType type;
     bool ifNotExists; // default: false
     char* filePath;   // default: nullptr
diff --git a/src/sql/DeleteStatement.h b/src/sql/DeleteStatement.h
@@ -12,7 +12,14 @@ namespace hsql {
   struct DeleteStatement : SQLStatement {
     DeleteStatement();
     virtual ~DeleteStatement();
-
+    void tablesAccessed(TableAccessMap& accessMap) const override {
+      if (expr != nullptr) {
+        expr->tablesAccessed(accessMap);
+      }
+      if (tableName != nullptr) {
+       TableAccess::addWriteEntry(accessMap, tableName, schema);
+      }
+    }
     char* schema;
     char* tableName;
     Expr* expr;
diff --git a/src/sql/DropStatement.h b/src/sql/DropStatement.h
@@ -20,7 +20,11 @@ namespace hsql {
 
     DropStatement(DropType type);
     virtual ~DropStatement();
-
+      void tablesAccessed(TableAccessMap& accessMap) const override {
+        if (name != nullptr) {
+          TableAccess::addWriteEntry(accessMap, name, schema);
+        }
+      };
     DropType type;
     bool ifExists;
     char* schema;
diff --git a/src/sql/ExecuteStatement.h b/src/sql/ExecuteStatement.h
@@ -10,6 +10,13 @@ namespace hsql {
   struct ExecuteStatement : SQLStatement {
     ExecuteStatement();
     virtual ~ExecuteStatement();
+      void tablesAccessed(TableAccessMap& accessMap) const override {
+        if (parameters != nullptr) {
+          for (auto it = parameters->begin(); it != parameters->end(); ++it) {
+            (*it)->tablesAccessed(accessMap);
+          }
+        }
+      };
 
     char* name;
     std::vector<Expr*>* parameters;
diff --git a/src/sql/Expr.cpp b/src/sql/Expr.cpp
@@ -251,4 +251,26 @@ char* substr(const char* source, int from, int to) {
     copy[len] = '\0';
     return copy;
 }
+
+void Expr::tablesAccessed(TableAccessMap& accessMap) const {
+    if (expr != nullptr) {
+        expr->tablesAccessed(accessMap);
+    }
+    if (expr2 != nullptr) {
+        expr2->tablesAccessed(accessMap);
+    }
+    if (exprList != nullptr) {
+        for (Expr* e : *exprList) {
+            if (e != nullptr) {
+                e->tablesAccessed(accessMap);
+            }
+        }
+    }
+    if (select != nullptr) {
+        select->tablesAccessed(accessMap);
+    }
+    if (table != nullptr) {
+        TableAccess::addReadEntry(accessMap, table, nullptr);
+    }
+}
 }  // namespace hsql
diff --git a/src/sql/Expr.h b/src/sql/Expr.h
@@ -4,7 +4,7 @@
 #include <stdlib.h>
 #include <memory>
 #include <vector>
-
+#include "TableAccess.h"
 namespace hsql {
 struct SelectStatement;
 
@@ -84,7 +84,7 @@ typedef struct Expr Expr;
 // Represents SQL expressions (i.e. literals, operators, column_refs).
 // TODO: When destructing a placeholder expression, we might need to alter the
 // placeholder_list.
-struct Expr {
+struct Expr :  public TableAccess {
     Expr(ExprType type);
     virtual ~Expr();
 
@@ -107,6 +107,9 @@ struct Expr {
     OperatorType opType;
     bool distinct;
 
+    // TableAccess
+    void tablesAccessed(TableAccessMap& accessMap) const override;
+
     // Convenience accessor methods.
 
     bool isType(ExprType exprType) const;
diff --git a/src/sql/ImportStatement.h b/src/sql/ImportStatement.h
@@ -13,6 +13,11 @@ namespace hsql {
   struct ImportStatement : SQLStatement {
     ImportStatement(ImportType type);
     virtual ~ImportStatement();
+      void tablesAccessed(TableAccessMap& accessMap) const override {
+        if (tableName != nullptr) {
+          TableAccess::addWriteEntry(accessMap, tableName, schema);
+        }
+      };
 
     ImportType type;
     char* filePath;
diff --git a/src/sql/InsertStatement.h b/src/sql/InsertStatement.h
@@ -15,6 +15,19 @@ namespace hsql {
   struct InsertStatement : SQLStatement {
     InsertStatement(InsertType type);
     virtual ~InsertStatement();
+      void tablesAccessed(TableAccessMap& accessMap) const override {
+        if (tableName != nullptr) {
+          TableAccess::addWriteEntry(accessMap, tableName, schema);
+        }
+        if (values != nullptr) {
+          for (auto it = values->begin(); it != values->end(); ++it) {
+            (*it)->tablesAccessed(accessMap);
+          }
+        }
+        if (select != nullptr) {
+          select->tablesAccessed(accessMap);
+        }
+      };
 
     InsertType type;
     char* schema;
diff --git a/src/sql/PrepareStatement.h b/src/sql/PrepareStatement.h
@@ -10,6 +10,8 @@ namespace hsql {
   struct PrepareStatement : SQLStatement {
     PrepareStatement();
     virtual ~PrepareStatement();
+      void tablesAccessed(TableAccessMap& accessMap) const override {
+      };
 
     char* name;
 
diff --git a/src/sql/SQLStatement.cpp b/src/sql/SQLStatement.cpp
@@ -28,5 +28,4 @@ namespace hsql {
   bool SQLStatement::is(StatementType type) const {
     return isType(type);
   }
-
 }
diff --git a/src/sql/SQLStatement.h b/src/sql/SQLStatement.h
@@ -2,7 +2,7 @@
 #define SQLPARSER_SQLSTATEMENT_H
 
 #include <vector>
-
+#include "TableAccess.h"
 #include "Expr.h"
 
 namespace hsql {
@@ -24,7 +24,7 @@ namespace hsql {
   };
 
   // Base struct for every SQL statement
-  struct SQLStatement {
+  struct SQLStatement : public TableAccess {
 
     SQLStatement(StatementType type);
 
@@ -44,7 +44,6 @@ namespace hsql {
 
    private:
     StatementType type_;
-
   };
 
 } // namespace hsql
diff --git a/src/sql/SelectStatement.h b/src/sql/SelectStatement.h
@@ -46,6 +46,22 @@ namespace hsql {
   struct SelectStatement : SQLStatement {
     SelectStatement();
     virtual ~SelectStatement();
+      void tablesAccessed(TableAccessMap& accessMap) const override {
+        if (fromTable != nullptr) {
+          fromTable->tablesAccessed(accessMap, TableOperation::Read);
+        }
+        if (selectList != nullptr) {
+          for (auto it = selectList->begin(); it != selectList->end(); ++it) {
+            (*it)->tablesAccessed(accessMap);
+          }
+        }
+        if (whereClause != nullptr) {
+          whereClause->tablesAccessed(accessMap);
+        }
+        if (unionSelect != nullptr) {
+          unionSelect->tablesAccessed(accessMap);
+        }
+      };
 
     TableRef* fromTable;
     bool selectDistinct;
diff --git a/src/sql/ShowStatement.h b/src/sql/ShowStatement.h
@@ -17,6 +17,9 @@ namespace hsql {
 
     ShowStatement(ShowType type);
     virtual ~ShowStatement();
+      void tablesAccessed(TableAccessMap& accessMap) const override {
+        TableAccess::addReadEntry(accessMap, name, schema);
+      };
 
     ShowType type;
     char* schema;
diff --git a/src/sql/Table.h b/src/sql/Table.h
@@ -36,6 +36,7 @@ namespace hsql {
   struct TableRef {
     TableRef(TableRefType type);
     virtual ~TableRef();
+    void tablesAccessed(TableAccessMap& accessMap, TableOperation op) const;
 
     TableRefType type;
 
@@ -68,6 +69,7 @@ namespace hsql {
   struct JoinDefinition {
     JoinDefinition();
     virtual ~JoinDefinition();
+    void tablesAccessed(TableAccessMap& accessMap, TableOperation op) const;
 
     TableRef* left;
     TableRef* right;
diff --git a/src/sql/TableAccess.h b/src/sql/TableAccess.h
@@ -0,0 +1,48 @@
+#ifndef SQLPARSER_TABLEACCESS_H
+#define SQLPARSER_TABLEACCESS_H
+
+#include <vector>
+#include <map>
+#include <iterator>
+#include <unordered_map>
+
+namespace hsql {
+    enum class TableOperation {
+        Read,
+        Modify
+    };
+    typedef std::unordered_map<std::string, TableOperation> TableAccessMap;
+
+    class TableAccess {
+    public:
+        virtual void tablesAccessed(TableAccessMap &t) const = 0;
+        static void addReadEntry(TableAccessMap& t, const char *table, const char *db)  {
+          std::string key = buildKey(table, db);
+          TableAccessMap::const_iterator it = t.find(key);
+          if (it == t.end()) {
+            t[key] = TableOperation::Read;
+          }
+        }
+        static void addWriteEntry(TableAccessMap& t, const char *table, const char *db)  {
+            t[buildKey(table, db)] = TableOperation::Modify;
+        }
+        static void addOperation(TableAccessMap &t, const char *table, const char *db, TableOperation op)  {
+            if (op == TableOperation::Read) {
+                addReadEntry(t, table, db);
+            } else {
+                addWriteEntry(t, table, db);
+            }
+        }
+    private:
+        static std::string buildKey(const char *table, const char *db) {
+          std::string key;
+          if (db != nullptr) {
+            key.append(db);
+          }
+          key.append(".").append(table);
+          return key;
+        }
+    };
+} // namespace hsql
+
+#endif // SQLPARSER_TABLEACCESS_H
diff --git a/src/sql/UpdateStatement.h b/src/sql/UpdateStatement.h
@@ -15,6 +15,19 @@ namespace hsql {
   struct UpdateStatement : SQLStatement {
     UpdateStatement();
     virtual ~UpdateStatement();
+      void tablesAccessed(TableAccessMap& accessMap) const override {
+        if (updates != nullptr) {
+          for (auto it = updates->begin(); it != updates->end(); ++it) {
+            (*it)->value->tablesAccessed(accessMap);
+          }
+        }
+        if (where != nullptr) {
+          where->tablesAccessed(accessMap);
+        }
+        if (table != nullptr) {
+          table->tablesAccessed(accessMap, TableOperation::Modify);
+        }
+      };
 
     // TODO: switch to char* instead of TableRef
     TableRef* table;
diff --git a/src/sql/statements.cpp b/src/sql/statements.cpp
@@ -328,6 +328,33 @@ namespace hsql {
     else return name;
   }
 
+    void TableRef::tablesAccessed(TableAccessMap& accessMap, TableOperation op) const {
+      switch (type) {
+        case kTableName:
+          if (name != nullptr) {
+            TableAccess::addOperation(accessMap, name, schema, op);
+          }
+              break;
+        case kTableSelect:
+          if (select != nullptr) {
+            select->tablesAccessed(accessMap);
+          }
+              break;
+        case kTableCrossProduct:
+          if (list != nullptr) {
+            for (auto it = list->begin(); it != list->end(); ++it) {
+              (*it)->tablesAccessed(accessMap, op);
+            }
+          }
+              break;
+        case kTableJoin:
+          if (join != nullptr) {
+            join->tablesAccessed(accessMap, op);
+          }
+
+      }
+    }
+
   // JoinDefinition
   JoinDefinition::JoinDefinition() :
     left(nullptr),
@@ -340,5 +367,15 @@ namespace hsql {
     delete right;
     delete condition;
   }
-
+    void JoinDefinition::tablesAccessed(TableAccessMap& accessMap, TableOperation op) const  {
+      if (left != nullptr) {
+        left->tablesAccessed(accessMap, op);
+      }
+      if (right != nullptr) {
+        right->tablesAccessed(accessMap, op);
+      }
+      if (condition != nullptr) {
+        condition->tablesAccessed(accessMap);
+      }
+    };
 } // namespace hsql
diff --git a/src/util/sqlhelper.cpp b/src/util/sqlhelper.cpp

Original file line number	Diff line number	Diff line change
`@@ -28,5 +28,4 @@ namespace hsql {`
`28`	`28`	`bool SQLStatement::is(StatementType type) const {`
`29`	`29`	`return isType(type);`
`30`	`30`	`}`
`31`		`-`
`32`	`31`	`}`