compile_commands.json

@@ -16,5 +16,47 @@
     "command": "clang++ -Isrc/obelisk.p -Isrc -I../src -fcolor-diagnostics -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -Wnon-virtual-dtor -Wextra -Wpedantic -std=c++17 -O0 -g -MD -MQ src/obelisk.p/parser.cpp.o -MF src/obelisk.p/parser.cpp.o.d -o src/obelisk.p/parser.cpp.o -c ../src/parser.cpp",
     "file": "../src/parser.cpp",
     "output": "src/obelisk.p/parser.cpp.o"
+  },
+  {
+    "directory": "/mnt/data/ubb/courses/proyecto-titulo/obelisk/builddir",
+    "command": "clang++ -Isrc/obelisk.p -Isrc -I../src -fcolor-diagnostics -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -Wnon-virtual-dtor -Wextra -Wpedantic -std=c++17 -O0 -g -MD -MQ src/obelisk.p/knowledge_base.cpp.o -MF src/obelisk.p/knowledge_base.cpp.o.d -o src/obelisk.p/knowledge_base.cpp.o -c ../src/knowledge_base.cpp",
+    "file": "../src/knowledge_base.cpp",
+    "output": "src/obelisk.p/knowledge_base.cpp.o"
+  },
+  {
+    "directory": "/mnt/data/ubb/courses/proyecto-titulo/obelisk/builddir",
+    "command": "clang++ -Isrc/obelisk.p -Isrc -I../src -fcolor-diagnostics -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -Wnon-virtual-dtor -Wextra -Wpedantic -std=c++17 -O0 -g -MD -MQ src/obelisk.p/models_action.cpp.o -MF src/obelisk.p/models_action.cpp.o.d -o src/obelisk.p/models_action.cpp.o -c ../src/models/action.cpp",
+    "file": "../src/models/action.cpp",
+    "output": "src/obelisk.p/models_action.cpp.o"
+  },
+  {
+    "directory": "/mnt/data/ubb/courses/proyecto-titulo/obelisk/builddir",
+    "command": "clang++ -Isrc/obelisk.p -Isrc -I../src -fcolor-diagnostics -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -Wnon-virtual-dtor -Wextra -Wpedantic -std=c++17 -O0 -g -MD -MQ src/obelisk.p/models_entity.cpp.o -MF src/obelisk.p/models_entity.cpp.o.d -o src/obelisk.p/models_entity.cpp.o -c ../src/models/entity.cpp",
+    "file": "../src/models/entity.cpp",
+    "output": "src/obelisk.p/models_entity.cpp.o"
+  },
+  {
+    "directory": "/mnt/data/ubb/courses/proyecto-titulo/obelisk/builddir",
+    "command": "clang++ -Isrc/obelisk.p -Isrc -I../src -fcolor-diagnostics -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -Wnon-virtual-dtor -Wextra -Wpedantic -std=c++17 -O0 -g -MD -MQ src/obelisk.p/models_fact.cpp.o -MF src/obelisk.p/models_fact.cpp.o.d -o src/obelisk.p/models_fact.cpp.o -c ../src/models/fact.cpp",
+    "file": "../src/models/fact.cpp",
+    "output": "src/obelisk.p/models_fact.cpp.o"
+  },
+  {
+    "directory": "/mnt/data/ubb/courses/proyecto-titulo/obelisk/builddir",
+    "command": "clang++ -Isrc/obelisk.p -Isrc -I../src -fcolor-diagnostics -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -Wnon-virtual-dtor -Wextra -Wpedantic -std=c++17 -O0 -g -MD -MQ src/obelisk.p/models_rule.cpp.o -MF src/obelisk.p/models_rule.cpp.o.d -o src/obelisk.p/models_rule.cpp.o -c ../src/models/rule.cpp",
+    "file": "../src/models/rule.cpp",
+    "output": "src/obelisk.p/models_rule.cpp.o"
+  },
+  {
+    "directory": "/mnt/data/ubb/courses/proyecto-titulo/obelisk/builddir",
+    "command": "clang++ -Isrc/obelisk.p -Isrc -I../src -fcolor-diagnostics -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -Wnon-virtual-dtor -Wextra -Wpedantic -std=c++17 -O0 -g -MD -MQ src/obelisk.p/models_suggest_action.cpp.o -MF src/obelisk.p/models_suggest_action.cpp.o.d -o src/obelisk.p/models_suggest_action.cpp.o -c ../src/models/suggest_action.cpp",
+    "file": "../src/models/suggest_action.cpp",
+    "output": "src/obelisk.p/models_suggest_action.cpp.o"
+  },
+  {
+    "directory": "/mnt/data/ubb/courses/proyecto-titulo/obelisk/builddir",
+    "command": "clang++ -Isrc/obelisk.p -Isrc -I../src -fcolor-diagnostics -D_FILE_OFFSET_BITS=64 -Wall -Winvalid-pch -Wnon-virtual-dtor -Wextra -Wpedantic -std=c++17 -O0 -g -MD -MQ src/obelisk.p/models_verb.cpp.o -MF src/obelisk.p/models_verb.cpp.o.d -o src/obelisk.p/models_verb.cpp.o -c ../src/models/verb.cpp",
+    "file": "../src/models/verb.cpp",
+    "output": "src/obelisk.p/models_verb.cpp.o"
   }
 ]

src/knowledge_base.cpp

@@ -1,10 +1,14 @@
 #include "knowledge_base.h"
+#include "models/action.h"
+#include "models/entity.h"
+#include "models/fact.h"
+#include "models/rule.h"
+#include "models/suggest_action.h"
+#include "models/verb.h"
 
+#include <filesystem>
 #include <iostream>
 
-const std::string obelisk::Sql::create_facts_table
-    = "CREATE TABLE fact (id INT PRIMARY KEY NOT NULL);";
-
 obelisk::KnowledgeBase::KnowledgeBase(const char* filename)
 {
     KnowledgeBase(filename, DEFAULT_FLAGS);
@@ -15,22 +19,23 @@ obelisk::KnowledgeBase::KnowledgeBase(const char* filename, int flags)
     filename_ = std::move(filename);
     flags_    = std::move(flags);
 
+    std::filesystem::path path {filename};
+    auto dbExists = std::filesystem::exists(path);
+
     auto result = sqlite3_open_v2(filename, &dbConnection_, flags, NULL);
     if (result != SQLITE_OK)
     {
         logSqliteError(result);
     }
 
-    char* tmp;
+    if (!dbExists)
-    result = sqlite3_exec(dbConnection_,
-        obelisk::Sql::create_facts_table.c_str(),
-        NULL,
-        NULL,
-        &tmp);
-    if (tmp)
     {
-        std::string errmsg(tmp);
+        createTable(obelisk::Action::createTable);
-        throw obelisk::KnowledgeBaseException(errmsg);
+        createTable(obelisk::Entity::createTable);
+        createTable(obelisk::Verb::createTable);
+        createTable(obelisk::Fact::createTable);
+        createTable(obelisk::Rule::createTable);
+        createTable(obelisk::SuggestAction::createTable);
     }
 }
 
@@ -39,21 +44,37 @@ obelisk::KnowledgeBase::~KnowledgeBase()
     sqlite3_close_v2(dbConnection_);
 }
 
+void obelisk::KnowledgeBase::createTable(std::function<const char*()> function)
+{
+    char* tmp;
+    auto result = sqlite3_exec(dbConnection_, function(), NULL, NULL, &tmp);
+    if (result != SQLITE_OK)
+    {
+        logSqliteError(result);
+        throw obelisk::KnowledgeBaseException("something happened");
+    }
+    if (tmp)
+    {
+        std::string errmsg(tmp);
+        throw obelisk::KnowledgeBaseException(errmsg);
+    }
+}
+
 // TODO: log files?
 void obelisk::KnowledgeBase::logSqliteError(int result)
 {
     std::cout << sqlite3_errstr(result) << std::endl;
 }
 
-void obelisk::KnowledgeBase::getFloat(float* result1,
+void obelisk::KnowledgeBase::getFloat(float& result1,
-    float* result2,
+    float& result2,
     double var)
 {
-    *result1 = (float) var;
+    result1 = (float) var;
-    *result2 = (float) (var - (double) *result1);
+    result2 = (float) (var - (double) result1);
 }
 
-void obelisk::KnowledgeBase::getDouble(double* result, float var1, float var2)
+void obelisk::KnowledgeBase::getDouble(double& result, float var1, float var2)
 {
-    *result = (double) ((double) var2 + (double) var1);
+    result = (double) ((double) var2 + (double) var1);
 }

src/knowledge_base.h

@@ -3,6 +3,7 @@
 
 #include <sqlite3.h>
 
+#include <functional>
 #include <iostream>
 #include <string>
 
@@ -18,6 +19,8 @@ namespace obelisk
             int flags_;
             void logSqliteError(int result);
 
+            void createTable(std::function<const char*()> function);
+
         public:
             KnowledgeBase(const char* filename);
             KnowledgeBase(const char* filename, int flags);
@@ -30,23 +33,17 @@ namespace obelisk
             int addRules(std::string verb, T leftEntities, U rightEntities);
             template<typename T, typename U> int addActions();
 
-            void getDouble(double* result, float var1, float var2);
+            void getDouble(double& result, float var1, float var2);
-            void getFloat(float* result1, float* result2, double var);
+            void getFloat(float& result1, float& result2, double var);
-    };
-
-    class Sql
-    {
-        public:
-            static const std::string create_facts_table;
     };
 
     class KnowledgeBaseException : public std::exception
     {
         private:
-            std::string errorMessage_;
+            const std::string errorMessage_;
 
         public:
-            KnowledgeBaseException(std::string errorMessage) :
+            KnowledgeBaseException(const std::string& errorMessage) :
                 errorMessage_(errorMessage)
             {
             }

src/meson.build

@@ -10,6 +10,9 @@ sqlite3 = dependency('sqlite3')
 subdir('ast')
 obelisk_sources += obelisk_ast_sources
 
+subdir('models')
+obelisk_sources += obelisk_model_sources
+
 executable('obelisk',
     obelisk_sources,
     dependencies : [sqlite3],

src/models/action.cpp

@@ -0,0 +1,32 @@
+#include "models/action.h"
+
+const char* obelisk::Action::createTable()
+{
+    return R"(
+        CREATE TABLE "action" (
+            "id"   INTEGER NOT NULL UNIQUE,
+            "name" TEXT NOT NULL CHECK(trim(name) != '') UNIQUE,
+            PRIMARY KEY("id" AUTOINCREMENT)
+        );
+    )";
+}
+
+int obelisk::Action::getId()
+{
+    return id_;
+}
+
+void obelisk::Action::setId(int id)
+{
+    id_ = id;
+}
+
+std::string obelisk::Action::getName()
+{
+    return name_;
+}
+
+void obelisk::Action::setName(std::string name)
+{
+    name_ = name;
+}

src/models/action.h

@@ -0,0 +1,49 @@
+#ifndef OBELISK_MODELS_ACTION_H
+#define OBELISK_MODELS_ACTION_H
+
+#include <string>
+
+namespace obelisk
+{
+    class Action
+    {
+        private:
+            int id_;
+            std::string name_;
+
+        public:
+            Action() :
+                id_(0),
+                name_("")
+            {
+            }
+
+            Action(int id) :
+                id_(id),
+                name_("")
+            {
+            }
+
+            Action(std::string name) :
+                id_(0),
+                name_(name)
+            {
+            }
+
+            Action(int id, std::string name) :
+                id_(id),
+                name_(name)
+            {
+            }
+
+            static const char* createTable();
+
+            int getId();
+            void setId(int id);
+
+            std::string getName();
+            void setName(std::string name);
+    };
+} // namespace obelisk
+
+#endif

src/models/entity.cpp

@@ -1,12 +1,14 @@
 #include "models/entity.h"
 
-obelisk::Entity::Entity()
+const char* obelisk::Entity::createTable()
 {
-}
+    return R"(
-
+        CREATE TABLE "entity" (
-obelisk::Entity::Entity(std::string name)
+            "id"   INTEGER NOT NULL UNIQUE,
-{
+            "name" TEXT NOT NULL CHECK(trim(name) != '') UNIQUE,
-    name = name;
+            PRIMARY KEY("id" AUTOINCREMENT)
+        );
+    )";
 }
 
 int obelisk::Entity::getId()
@@ -26,5 +28,5 @@ std::string obelisk::Entity::getName()
 
 void obelisk::Entity::setName(std::string name)
 {
-    name_ = name_;
+    name_ = name;
 }

src/models/entity.h

@@ -12,8 +12,31 @@ namespace obelisk
             std::string name_;
 
         public:
-            Entity();
+            Entity() :
-            Entity(std::string name);
+                id_(0),
+                name_("")
+            {
+            }
+
+            Entity(int id) :
+                id_(id),
+                name_("")
+            {
+            }
+
+            Entity(std::string name) :
+                id_(0),
+                name_(name)
+            {
+            }
+
+            Entity(int id, std::string name) :
+                id_(id),
+                name_(name)
+            {
+            }
+
+            static const char* createTable();
 
             int getId();
             void setId(int id);

src/models/fact.cpp

@@ -0,0 +1,57 @@
+#include "models/fact.h"
+
+const char* obelisk::Fact::createTable()
+{
+    return R"(
+        CREATE TABLE "fact" (
+            "id"           INTEGER NOT NULL UNIQUE,
+            "left_entity"  INTEGER NOT NULL,
+            "right_entity" INTEGER NOT NULL,
+            "verb"         INTEGER NOT NULL,
+            PRIMARY KEY("id" AUTOINCREMENT),
+            FOREIGN KEY("verb") REFERENCES "verb"("id") ON DELETE RESTRICT,
+            FOREIGN KEY("right_entity") REFERENCES "entity"("id") ON DELETE RESTRICT,
+            FOREIGN KEY("left_entity") REFERENCES "entity"("id") ON DELETE RESTRICT
+        );
+    )";
+}
+
+int obelisk::Fact::getId()
+{
+    return id_;
+}
+
+void obelisk::Fact::setId(int id)
+{
+    id_ = id;
+}
+
+obelisk::Entity obelisk::Fact::getLeftEntity()
+{
+    return leftEntity_;
+}
+
+void obelisk::Fact::setLeftEntity(obelisk::Entity leftEntity)
+{
+    leftEntity_ = leftEntity;
+}
+
+obelisk::Entity obelisk::Fact::getRightEntity()
+{
+    return rightEntity_;
+}
+
+void obelisk::Fact::setRightEntity(obelisk::Entity rightEntity)
+{
+    rightEntity_ = rightEntity;
+}
+
+obelisk::Verb obelisk::Fact::getVerb()
+{
+    return verb_;
+}
+
+void obelisk::Fact::setVerb(obelisk::Verb verb)
+{
+    verb_ = verb;
+}

src/models/fact.h

@@ -0,0 +1,73 @@
+#ifndef OBELISK_MODELS_FACT_H
+#define OBELISK_MODELS_FACT_H
+
+#include "models/entity.h"
+#include "models/verb.h"
+
+#include <string>
+
+namespace obelisk
+{
+    class Fact
+    {
+        private:
+            int id_;
+            obelisk::Entity leftEntity_;
+            obelisk::Entity rightEntity_;
+            obelisk::Verb verb_;
+
+        public:
+            Fact() :
+                id_(0),
+                leftEntity_(),
+                rightEntity_(),
+                verb_()
+            {
+            }
+
+            Fact(int id) :
+                id_(id),
+                leftEntity_(),
+                rightEntity_(),
+                verb_()
+            {
+            }
+
+            Fact(obelisk::Entity leftEntity,
+                obelisk::Entity rightEntity,
+                obelisk::Verb verb) :
+                id_(0),
+                leftEntity_(leftEntity),
+                rightEntity_(rightEntity),
+                verb_(verb)
+            {
+            }
+
+            Fact(int id,
+                obelisk::Entity leftEntity,
+                obelisk::Entity rightEntity,
+                obelisk::Verb verb) :
+                id_(id),
+                leftEntity_(leftEntity),
+                rightEntity_(rightEntity),
+                verb_(verb)
+            {
+            }
+
+            static const char* createTable();
+
+            int getId();
+            void setId(int id);
+
+            obelisk::Entity getLeftEntity();
+            void setLeftEntity(obelisk::Entity leftEntity);
+
+            obelisk::Entity getRightEntity();
+            void setRightEntity(obelisk::Entity leftEntity);
+
+            obelisk::Verb getVerb();
+            void setVerb(obelisk::Verb verb);
+    };
+} // namespace obelisk
+
+#endif

src/models/meson.build

@@ -0,0 +1,8 @@
+obelisk_model_sources = files(
+    'action.cpp',
+    'entity.cpp',
+    'fact.cpp',
+    'rule.cpp',
+    'suggest_action.cpp',
+    'verb.cpp'
+)

src/models/rule.cpp

@@ -0,0 +1,45 @@
+#include "models/rule.h"
+
+const char* obelisk::Rule::createTable()
+{
+    return R"(
+        CREATE TABLE "rule" (
+            "id"     INTEGER NOT NULL UNIQUE,
+            "fact"   INTEGER NOT NULL,
+            "reason" INTEGER NOT NULL CHECK("reason" != "fact"),
+            PRIMARY KEY("id" AUTOINCREMENT),
+            FOREIGN KEY("fact") REFERENCES "fact"("id") ON DELETE RESTRICT,
+            FOREIGN KEY("reason") REFERENCES "fact"("id") ON DELETE RESTRICT
+        );
+    )";
+}
+
+int obelisk::Rule::getId()
+{
+    return id_;
+}
+
+void obelisk::Rule::setId(int id)
+{
+    id_ = id;
+}
+
+obelisk::Fact obelisk::Rule::getFact()
+{
+    return fact_;
+}
+
+void obelisk::Rule::setFact(obelisk::Fact fact)
+{
+    fact_ = fact;
+}
+
+obelisk::Fact obelisk::Rule::getReason()
+{
+    return reason_;
+}
+
+void obelisk::Rule::setReason(obelisk::Fact reason)
+{
+    reason_ = reason;
+}

src/models/rule.h

@@ -0,0 +1,59 @@
+#ifndef OBELISK_MODELS_RULE_H
+#define OBELISK_MODELS_RULE_H
+
+#include "models/fact.h"
+
+#include <string>
+
+namespace obelisk
+{
+    class Rule
+    {
+        private:
+            int id_;
+            obelisk::Fact fact_;
+            obelisk::Fact reason_;
+
+        public:
+            Rule() :
+                id_(0),
+                fact_(),
+                reason_()
+            {
+            }
+
+            Rule(int id) :
+                id_(id),
+                fact_(),
+                reason_()
+            {
+            }
+
+            Rule(obelisk::Fact fact, obelisk::Fact reason) :
+                id_(0),
+                fact_(fact),
+                reason_(reason)
+            {
+            }
+
+            Rule(int id, obelisk::Fact fact, obelisk::Fact reason) :
+                id_(id),
+                fact_(fact),
+                reason_(reason)
+            {
+            }
+
+            static const char* createTable();
+
+            int getId();
+            void setId(int id);
+
+            obelisk::Fact getFact();
+            void setFact(obelisk::Fact fact);
+
+            obelisk::Fact getReason();
+            void setReason(obelisk::Fact reason);
+    };
+} // namespace obelisk
+
+#endif

src/models/suggest_action.cpp

@@ -0,0 +1,57 @@
+#include "models/suggest_action.h"
+
+const char* obelisk::SuggestAction::createTable()
+{
+    return R"(
+        CREATE TABLE "suggest_action" (
+            "id"           INTEGER NOT NULL UNIQUE,
+            "fact"         INTEGER NOT NULL,
+            "true_action"  INTEGER NOT NULL,
+            "false_action" INTEGER NOT NULL,
+            PRIMARY KEY("id" AUTOINCREMENT),
+            FOREIGN KEY("fact") REFERENCES "fact"("id") ON DELETE RESTRICT,
+            FOREIGN KEY("true_action") REFERENCES "action"("id") ON DELETE RESTRICT,
+            FOREIGN KEY("false_action") REFERENCES "action"("id") ON DELETE RESTRICT
+        );
+    )";
+}
+
+int obelisk::SuggestAction::getId()
+{
+    return id_;
+}
+
+void obelisk::SuggestAction::setId(int id)
+{
+    id_ = id;
+}
+
+obelisk::Fact obelisk::SuggestAction::getFact()
+{
+    return fact_;
+}
+
+void obelisk::SuggestAction::setFact(obelisk::Fact fact)
+{
+    fact_ = fact;
+}
+
+obelisk::Action obelisk::SuggestAction::getTrueAction()
+{
+    return trueAction_;
+}
+
+void obelisk::SuggestAction::setTrueAction(obelisk::Action trueAction)
+{
+    trueAction_ = trueAction;
+}
+
+obelisk::Action obelisk::SuggestAction::getFalseAction()
+{
+    return falseAction_;
+}
+
+void obelisk::SuggestAction::setFalseAction(obelisk::Action falseAction)
+{
+    falseAction_ = falseAction;
+}

src/models/suggest_action.h

@@ -0,0 +1,73 @@
+#ifndef OBELISK_MODELS_SUGGEST_ACTION_H
+#define OBELISK_MODELS_SUGGEST_ACTION_H
+
+#include "models/action.h"
+#include "models/fact.h"
+
+#include <string>
+
+namespace obelisk
+{
+    class SuggestAction
+    {
+        private:
+            int id_;
+            obelisk::Fact fact_;
+            obelisk::Action trueAction_;
+            obelisk::Action falseAction_;
+
+        public:
+            SuggestAction() :
+                id_(0),
+                fact_(),
+                trueAction_(),
+                falseAction_()
+            {
+            }
+
+            SuggestAction(int id) :
+                id_(id),
+                fact_(),
+                trueAction_(),
+                falseAction_()
+            {
+            }
+
+            SuggestAction(obelisk::Fact fact,
+                obelisk::Action trueAction,
+                obelisk::Action falseAction) :
+                id_(0),
+                fact_(fact),
+                trueAction_(trueAction),
+                falseAction_(falseAction)
+            {
+            }
+
+            SuggestAction(int id,
+                obelisk::Fact fact,
+                obelisk::Action trueAction,
+                obelisk::Action falseAction) :
+                id_(id),
+                fact_(fact),
+                trueAction_(trueAction),
+                falseAction_(falseAction)
+            {
+            }
+
+            static const char* createTable();
+
+            int getId();
+            void setId(int id);
+
+            obelisk::Fact getFact();
+            void setFact(obelisk::Fact fact);
+
+            obelisk::Action getTrueAction();
+            void setTrueAction(obelisk::Action trueAction);
+
+            obelisk::Action getFalseAction();
+            void setFalseAction(obelisk::Action falseAction);
+    };
+} // namespace obelisk
+
+#endif

src/models/verb.cpp

@@ -1,18 +1,14 @@
 #include "models/verb.h"
 
-obelisk::Verb::Verb()
+const char* obelisk::Verb::createTable()
 {
-}
+    return R"(
-
+        CREATE TABLE "verb" (
-obelisk::Verb::Verb(std::string verb)
+            "id"   INTEGER NOT NULL UNIQUE,
-{
+            "name" TEXT NOT NULL CHECK(trim(name) != "") UNIQUE,
-    verb_ = verb;
+            PRIMARY KEY("id" AUTOINCREMENT)
-}
+        );
-
+    )";
-obelisk::Verb::Verb(int id, std::string verb)
-{
-    id_   = id;
-    verb_ = verb;
 }
 
 int obelisk::Verb::getId()
@@ -25,12 +21,12 @@ void obelisk::Verb::setId(int id)
     id_ = id;
 }
 
-std::string obelisk::Verb::getVerb()
+std::string obelisk::Verb::getName()
 {
-    return verb_;
+    return name_;
 }
 
-void obelisk::Verb::setVerb(std::string verb)
+void obelisk::Verb::setName(std::string name)
 {
-    verb_ = verb;
+    name_ = name;
 }

src/models/verb.h

@@ -9,18 +9,40 @@ namespace obelisk
     {
         private:
             int id_;
-            std::string verb_;
+            std::string name_;
 
         public:
-            Verb();
+            Verb() :
-            Verb(std::string verb);
+                id_(0),
-            Verb(int id, std::string verb);
+                name_("")
+            {
+            }
+
+            Verb(int id) :
+                id_(id),
+                name_("")
+            {
+            }
+
+            Verb(std::string name) :
+                id_(0),
+                name_(name)
+            {
+            }
+
+            Verb(int id, std::string name) :
+                id_(id),
+                name_(name)
+            {
+            }
+
+            static const char* createTable();
 
             int getId();
             void setId(int id);
 
-            std::string getVerb();
+            std::string getName();
-            void setVerb(std::string verb);
+            void setName(std::string name);
     };
 } // namespace obelisk