21 files changed, 4043 insertions, 477 deletions

@@ -8,11 +8,15 @@ pkg_check_modules(YamlCpp yaml-cpp REQUIRED)
 pkg_check_modules(sqlite3 sqlite3 REQUIRED)
 find_package(libxml2 REQUIRED)
 
+add_library(verbly verbly/data.cpp verbly/adjective.cpp verbly/noun.cpp verbly/verb.cpp verbly/adverb.cpp verbly/token.cpp verbly/word.cpp)
+set_property(TARGET verbly PROPERTY CXX_STANDARD 11)
+set_property(TARGET verbly PROPERTY CXX_STANDARD_REQUIRED ON)
+
 include_directories(vendor/twitcurl/libtwitcurl ${LIBXML2_INCLUDE_DIR} ${sqlite3_INCLUDE_DIR})
 add_executable(furries furries.cpp)
 set_property(TARGET furries PROPERTY CXX_STANDARD 11)
 set_property(TARGET furries PROPERTY CXX_STANDARD_REQUIRED ON)
-target_link_libraries(furries ${sqlite3_LIBRARIES} ${YamlCpp_LIBRARIES} twitcurl curl)
+target_link_libraries(furries ${sqlite3_LIBRARIES} ${YamlCpp_LIBRARIES} twitcurl curl verbly)
 
 add_executable(generator generator.cpp)
 set_property(TARGET generator PROPERTY CXX_STANDARD 11)
@@ -20,7 +20,7 @@ class fill_blanks {
     {
       switch (it->token_type())
       {
-        case verbly::type::utterance:
+        case verbly::token::type::utterance:
         {
           auto& action = *dynamic_cast<verbly::utterance_token*>(it.get());
           for (auto& tkn : action)
@@ -36,14 +36,14 @@ class fill_blanks {
           break;
         }
         
-        case verbly::type::fillin:
+        case verbly::token::type::fillin:
         {
           auto& tkn = *dynamic_cast<verbly::fillin_token*>(it.get());
           switch (tkn.fillin_type())
           {
             case verbly::fillin_type::participle_phrase:
             {
-              const verbly::verb& v = database.verbs().random(true).limit(1).run().front();
+              verbly::verb v = database.verbs().random(true).limit(1).run().front();
               /*verbly::utterance_token phrase = verbly::random(v.frames).make_utterance();
               while (std::begin(phrase)->token_type() != verbly::type::verb)
               {
@@ -53,7 +53,7 @@ class fill_blanks {
               *std::begin(phrase) = verbly::verb_token(v).conjugate(verbly::conjugation::present_participle);
               *it = phrase;*/
               auto avt = std::make_unique<verbly::verb_token>(v);
-              avt->conjugate(verbly::conjugation::present_participle);
+              avt->inflect(verbly::verb_token::inflection::ing_form);
               it = std::move(avt);
   
               break;
@@ -61,16 +61,16 @@ class fill_blanks {
             
             case verbly::fillin_type::adjective:
             {
-              const verbly::adjective& adj = database.adjectives().random(true).limit(1).run().front();
-              it = std::make_unique<verbly::string_token>(adj.form);
+              verbly::adjective adj = database.adjectives().random(true).limit(1).run().front();
+              it = std::make_unique<verbly::string_token>(adj.base_form());
               
               break;
             }
             
             case verbly::fillin_type::adverb:
             {
-              const verbly::adverb& adv = database.adverbs().random(true).limit(1).run().front();
-              it = std::make_unique<verbly::string_token>(adv.form);
+              verbly::adverb adv = database.adverbs().random(true).limit(1).run().front();
+              it = std::make_unique<verbly::string_token>(adv.base_form());
               
               break;
             }
@@ -9,6 +9,8 @@
 #include <sqlite3.h>
 #include <sstream>
 #include <regex>
+#include <list>
+#include "progress.h"
 
 struct verb {
   std::string infinitive;
@@ -18,6 +20,17 @@ struct verb {
   std::string s_form;
 };
 
+struct adjective {
+  std::string base;
+  std::string comparative;
+  std::string superlative;
+};
+
+struct noun {
+  std::string singular;
+  std::string plural;
+};
+
 struct group {
   std::string id;
   std::set<std::string> members;
@@ -25,21 +38,33 @@ struct group {
 
 std::map<std::string, group> groups;
 std::map<std::string, verb> verbs;
+std::map<std::string, adjective> adjectives;
+std::map<std::string, noun> nouns;
 std::map<int, std::map<int, int>> wn;
+std::map<std::string, std::set<std::string>> pronunciations;
 
 void print_usage()
 {
   std::cout << "Verbly Datafile Generator" << std::endl;
   std::cout << "-------------------------" << std::endl;
-  std::cout << "Requires exactly four arguments." << std::endl;
+  std::cout << "Requires exactly six arguments." << std::endl;
   std::cout << "1. The path to a VerbNet data directory." << std::endl;
   std::cout << "2. The path to a SemLink vnpbMappings file." << std::endl;
   std::cout << "3. The path to an AGID infl.txt file." << std::endl;
   std::cout << "4. The path to a WordNet prolog data directory." << std::endl;
-  std::cout << "5. Datafile output path." << std::endl;
+  std::cout << "5. The path to a CMUDICT pronunciation file." << std::endl;
+  std::cout << "6. Datafile output path." << std::endl;
   
   exit(1);
 }
+
+void db_error(sqlite3* ppdb, std::string)
+{
+  std::cout << "Error writing to output database: " << sqlite3_errmsg(ppdb) << std::endl;
+  sqlite3_close_v2(ppdb);
+  print_usage();
+}
+
 /*
 void parse_group(xmlNodePtr top, std::string filename)
 {
@@ -87,7 +112,7 @@ void parse_group(xmlNodePtr top, std::string filename)
 
 int main(int argc, char** argv)
 {
-  if (argc != 6)
+  if (argc != 7)
   {
     print_usage();
   }
@@ -137,7 +162,7 @@ int main(int argc, char** argv)
   closedir(dir);*/
   
   // Get verbs from AGID
-  std::cout << "Reading verb inflection..." << std::endl;
+  std::cout << "Reading inflections..." << std::endl;
   
   std::ifstream agidfile(argv[3]);
   if (!agidfile.is_open())
@@ -162,11 +187,7 @@ int main(int argc, char** argv)
     int divider = line.find_first_of(" ");
     std::string word = line.substr(0, divider);
     line = line.substr(divider+1);
-    
-    if (line[0] != 'V')
-    {
-      continue;
-    }
+    char type = line[0];
     
     if (line[1] == '?')
     {
@@ -174,7 +195,7 @@ int main(int argc, char** argv)
     } else {
       line.erase(0, 3);
     }
-    
+
     std::vector<std::string> forms;
     while (!line.empty())
     {
@@ -187,52 +208,129 @@ int main(int argc, char** argv)
         inflection = line;
         line = "";
       }
-      
+  
       if ((divider = inflection.find_first_of(",?")) != std::string::npos)
       {
         inflection = inflection.substr(0, divider);
       }
-      
+  
       forms.push_back(inflection);
     }
     
-    verb v;
-    v.infinitive = word;
-    if (forms.size() == 4)
+    switch (type)
     {
-      v.past_tense = forms[0];
-      v.past_participle = forms[1];
-      v.ing_form = forms[2];
-      v.s_form = forms[3];
-    } else if (forms.size() == 3)
+      case 'V':
+      {
+        verb v;
+        v.infinitive = word;
+        if (forms.size() == 4)
+        {
+          v.past_tense = forms[0];
+          v.past_participle = forms[1];
+          v.ing_form = forms[2];
+          v.s_form = forms[3];
+        } else if (forms.size() == 3)
+        {
+          v.past_tense = forms[0];
+          v.past_participle = forms[0];
+          v.ing_form = forms[1];
+          v.s_form = forms[2];
+        } else if (forms.size() == 8)
+        {
+          // As of AGID 2014.08.11, this is only "to be"
+          v.past_tense = forms[0];
+          v.past_participle = forms[2];
+          v.ing_form = forms[3];
+          v.s_form = forms[4];
+        } else {
+          // Words that don't fit the cases above as of AGID 2014.08.11:
+          // - may and shall do not conjugate the way we want them to
+          // - methinks only has a past tense and is an outlier
+          // - wit has five forms, and is archaic/obscure enough that we can ignore it for now
+          std::cout << "Ignoring verb \"" << word << "\" due to non-standard number of forms." << std::endl;
+        }
+    
+        verbs[word] = v;
+        
+        break;
+      }
+      
+      case 'A':
+      {
+        adjective adj;
+        adj.base = word;
+        if (forms.size() == 2)
+        {
+          adj.comparative = forms[0];
+          adj.superlative = forms[1];
+        } else {
+          // As of AGID 2014.08.11, this is only "only", which has only the form "onliest"
+          std::cout << "Ignoring adjective/adverb \"" << word << "\" due to non-standard number of forms." << std::endl;
+        }
+        
+        adjectives[word] = adj;
+        
+        break;
+      }
+      
+      case 'N':
+      {
+        noun n;
+        n.singular = word;
+        if (forms.size() == 1)
+        {
+          n.plural = forms[0];
+        } else {
+          // As of AGID 2014.08.11, this is non-existent.
+          std::cout << "Ignoring noun \"" << word << "\" due to non-standard number of forms." << std::endl;
+        }
+        
+        nouns[word] = n;
+        
+        break;
+      }
+    }
+  }
+  
+  // Pronounciations
+  std::cout << "Reading pronunciations..." << std::endl;
+  
+  std::ifstream pronfile(argv[5]);
+  if (!pronfile.is_open())
+  {
+    std::cout << "Could not open CMUDICT file: " << argv[5] << std::endl;
+    print_usage();
+  }
+  
+  for (;;)
+  {
+    std::string line;
+    if (!getline(pronfile, line))
     {
-      v.past_tense = forms[0];
-      v.past_participle = forms[0];
-      v.ing_form = forms[1];
-      v.s_form = forms[2];
-    } else if (forms.size() == 8)
+      break;
+    }
+    
+    if (line.back() == '\r')
     {
-      // As of AGID 2014.08.11, this is only "to be"
-      v.past_tense = forms[0];
-      v.past_participle = forms[2];
-      v.ing_form = forms[3];
-      v.s_form = forms[4];
-    } else {
-      // Words that don't fit the cases above as of AGID 2014.08.11:
-      // - may and shall do not conjugate the way we want them to
-      // - methinks only has a past tense and is an outlier
-      // - wit has five forms, and is archaic/obscure enough that we can ignore it for now
-      std::cout << "Ignoring verb \"" << word << "\" due to non-standard number of forms." << std::endl;
+      line.pop_back();
     }
     
-    verbs[word] = v;
+    std::regex phoneme("([A-Z][^ \\(]*)(?:\\(\\d+\\))?  ([A-Z 0-9]+)");
+    std::smatch phoneme_data;
+    if (std::regex_search(line, phoneme_data, phoneme))
+    {
+      std::string canonical(phoneme_data[1]);
+      std::transform(std::begin(canonical), std::end(canonical), std::begin(canonical), ::tolower);
+      
+      pronunciations[canonical].insert(phoneme_data[2]);
+    }
   }
   
   // Start writing output
-  std::cout << "Writing output..." << std::endl;
+  std::cout << "Writing schema..." << std::endl;
   
   sqlite3* ppdb;
-  if (sqlite3_open_v2(argv[5], &ppdb, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL) != SQLITE_OK)
+  if (sqlite3_open_v2(argv[6], &ppdb, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL) != SQLITE_OK)
   {
     std::cout << "Error opening output datafile: " << sqlite3_errmsg(ppdb) << std::endl;
     print_usage();
@@ -278,47 +376,82 @@ int main(int argc, char** argv)
     sqlite3_stmt* schmstmt;
     if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &schmstmt, NULL) != SQLITE_OK)
     {
-      std::cout << "Error writing to output database: " << sqlite3_errmsg(ppdb) << std::endl;
-      sqlite3_close_v2(ppdb);
-      print_usage();
+      db_error(ppdb, query);
     }
   
     if (sqlite3_step(schmstmt) != SQLITE_DONE)
     {
-      std::cout << "Error writing to output database: " << sqlite3_errmsg(ppdb) << std::endl;
-      sqlite3_close_v2(ppdb);
-      print_usage();
+      db_error(ppdb, query);
     }
   
     sqlite3_finalize(schmstmt);
   }
   
-  std::cout << "Writing verbs..." << std::endl;
-  for (auto& mapping : verbs)
   {
-    sqlite3_stmt* ppstmt;
-    std::string query("INSERT INTO verbs (infinitive, past_tense, past_participle, ing_form, s_form) VALUES (?, ?, ?, ?, ?)");
-    if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+    progress ppgs("Writing verbs...", verbs.size());
+    for (auto& mapping : verbs)
     {
-      std::cout << "Error writing to output database: " << sqlite3_errmsg(ppdb) << std::endl;
-      sqlite3_close_v2(ppdb);
-      print_usage();
-    }
+      sqlite3_stmt* ppstmt;
+      std::string query("INSERT INTO verbs (infinitive, past_tense, past_participle, ing_form, s_form) VALUES (?, ?, ?, ?, ?)");
+      if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+      {
+        db_error(ppdb, query);
+      }
     
-    sqlite3_bind_text(ppstmt, 1, mapping.second.infinitive.c_str(), mapping.second.infinitive.length(), SQLITE_STATIC);
-    sqlite3_bind_text(ppstmt, 2, mapping.second.past_tense.c_str(), mapping.second.past_tense.length(), SQLITE_STATIC);
-    sqlite3_bind_text(ppstmt, 3, mapping.second.past_participle.c_str(), mapping.second.past_participle.length(), SQLITE_STATIC);
-    sqlite3_bind_text(ppstmt, 4, mapping.second.ing_form.c_str(), mapping.second.ing_form.length(), SQLITE_STATIC);
-    sqlite3_bind_text(ppstmt, 5, mapping.second.s_form.c_str(), mapping.second.s_form.length(), SQLITE_STATIC);
+      sqlite3_bind_text(ppstmt, 1, mapping.second.infinitive.c_str(), mapping.second.infinitive.length(), SQLITE_STATIC);
+      sqlite3_bind_text(ppstmt, 2, mapping.second.past_tense.c_str(), mapping.second.past_tense.length(), SQLITE_STATIC);
+      sqlite3_bind_text(ppstmt, 3, mapping.second.past_participle.c_str(), mapping.second.past_participle.length(), SQLITE_STATIC);
+      sqlite3_bind_text(ppstmt, 4, mapping.second.ing_form.c_str(), mapping.second.ing_form.length(), SQLITE_STATIC);
+      sqlite3_bind_text(ppstmt, 5, mapping.second.s_form.c_str(), mapping.second.s_form.length(), SQLITE_STATIC);
     
-    if (sqlite3_step(ppstmt) != SQLITE_DONE)
-    {
-      std::cout << "Error writing to output database: " << sqlite3_errmsg(ppdb) << std::endl;
-      sqlite3_close_v2(ppdb);
-      print_usage();
-    }
+      if (sqlite3_step(ppstmt) != SQLITE_DONE)
+      {
+        db_error(ppdb, query);
+      }
     
-    sqlite3_finalize(ppstmt);
+      sqlite3_finalize(ppstmt);
+      
+      std::string canonical(mapping.second.infinitive);
+      std::transform(std::begin(canonical), std::end(canonical), std::begin(canonical), ::tolower);
+      if (pronunciations.count(canonical) == 1)
+      {
+        query = "SELECT last_insert_rowid()";
+        if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+        {
+          db_error(ppdb, query);
+        }
+    
+        if (sqlite3_step(ppstmt) != SQLITE_ROW)
+        {
+          db_error(ppdb, query);
+        }
+    
+        int rowid = sqlite3_column_int(ppstmt, 0);
+    
+        sqlite3_finalize(ppstmt);
+        
+        for (auto pronunciation : pronunciations[canonical])
+        {
+          query = "INSERT INTO verb_pronunciations (verb_id, pronunciation) VALUES (?, ?)";
+          if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_bind_int(ppstmt, 1, rowid);
+          sqlite3_bind_text(ppstmt, 2, pronunciation.c_str(), pronunciation.length(), SQLITE_STATIC);
+          
+          if (sqlite3_step(ppstmt) != SQLITE_DONE)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_finalize(ppstmt);
+        }
+      }
+      
+      ppgs.update();
+    }
   }
   
   // Get nouns/adjectives/adverbs from WordNet
@@ -342,110 +475,1046 @@ int main(int argc, char** argv)
     wnpref += '/';
   }
   
-  std::cout << "Reading words from WordNet..." << std::endl;
-  std::ifstream wnsfile(wnpref + "wn_s.pl");
-  if (!wnsfile.is_open())
+  // s table
   {
-    std::cout << "Invalid WordNet data directory." << std::endl;
-    print_usage();
+    std::ifstream wnsfile(wnpref + "wn_s.pl");
+    if (!wnsfile.is_open())
+    {
+      std::cout << "Invalid WordNet data directory." << std::endl;
+      print_usage();
+    }
+  
+    std::list<std::string> lines;
+    for (;;)
+    {
+      std::string line;
+      if (!getline(wnsfile, line))
+      {
+        break;
+      }
+    
+      if (line.back() == '\r')
+      {
+        line.pop_back();
+      }
+      
+      lines.push_back(line);
+    }
+    
+    progress ppgs("Writing nouns, adjectives, and adverbs...", lines.size());
+    for (auto line : lines)
+    {
+      ppgs.update();
+      
+      std::regex relation("^s\\(([134]\\d{8}),(\\d+),'([\\w ]+)',");
+      std::smatch relation_data;
+      if (!std::regex_search(line, relation_data, relation))
+      {
+        continue;
+      }
+    
+      int synset_id = stoi(relation_data[1]);
+      int wnum = stoi(relation_data[2]);
+      std::string word = relation_data[3];
+    
+      std::string query;
+      switch (synset_id / 100000000)
+      {
+        case 1: // Noun
+        {
+          if (nouns.count(word) == 1)
+          {
+            query = "INSERT INTO nouns (singular, plural) VALUES (?, ?)";
+          } else {
+            query = "INSERT INTO nouns (singular) VALUES (?)";
+          }
+        
+          break;
+        }
+      
+        case 2: // Verb
+        {
+          // Ignore
+        
+          break;
+        }
+      
+        case 3: // Adjective
+        {
+          if (adjectives.count(word) == 1)
+          {
+            query = "INSERT INTO adjectives (base_form, comparative, superlative) VALUES (?, ?, ?)";
+          } else {
+            query = "INSERT INTO adjectives (base_form) VALUES (?)";
+          }
+        
+          break;
+        }
+      
+        case 4: // Adverb
+        {
+          if (adjectives.count(word) == 1)
+          {
+            query = "INSERT INTO adverbs (base_form, comparative, superlative) VALUES (?, ?, ?)";
+          } else {
+            query = "INSERT INTO adverbs (base_form) VALUES (?)";
+          }
+        
+          break;
+        }
+      }
+    
+      sqlite3_stmt* ppstmt;
+      if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+      {
+        db_error(ppdb, query);
+      }
+    
+      sqlite3_bind_text(ppstmt, 1, word.c_str(), word.length(), SQLITE_STATIC);
+      switch (synset_id / 100000000)
+      {
+        case 1: // Noun
+        {
+          if (nouns.count(word) == 1)
+          {
+            sqlite3_bind_text(ppstmt, 2, nouns[word].plural.c_str(), nouns[word].plural.length(), SQLITE_STATIC);
+          }
+          
+          break;
+        }
+        
+        case 3: // Adjective
+        case 4: // Adverb
+        {
+          if (adjectives.count(word) == 1)
+          {
+            sqlite3_bind_text(ppstmt, 2, adjectives[word].comparative.c_str(), adjectives[word].comparative.length(), SQLITE_STATIC);
+            sqlite3_bind_text(ppstmt, 3, adjectives[word].superlative.c_str(), adjectives[word].superlative.length(), SQLITE_STATIC);
+          }
+          
+          break;
+        }
+      }
+    
+      if (sqlite3_step(ppstmt) != SQLITE_DONE)
+      {
+        db_error(ppdb, query);
+      }
+    
+      sqlite3_finalize(ppstmt);
+    
+      query = "SELECT last_insert_rowid()";
+      if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+      {
+        db_error(ppdb, query);
+      }
+    
+      if (sqlite3_step(ppstmt) != SQLITE_ROW)
+      {
+        db_error(ppdb, query);
+      }
+    
+      int rowid = sqlite3_column_int(ppstmt, 0);
+      wn[synset_id][wnum] = rowid;
+    
+      sqlite3_finalize(ppstmt);
+      
+      std::string canonical(word);
+      std::transform(std::begin(canonical), std::end(canonical), std::begin(canonical), ::tolower);
+      if (pronunciations.count(canonical) == 1)
+      {
+        for (auto pronunciation : pronunciations[canonical])
+        {
+          switch (synset_id / 100000000)
+          {
+            case 1: // Noun
+            {
+              query = "INSERT INTO noun_pronunciations (noun_id, pronunciation) VALUES (?, ?)";
+              
+              break;
+            }
+            
+            case 3: // Adjective
+            {
+              query = "INSERT INTO adjective_pronunciations (adjective_id, pronunciation) VALUES (?, ?)";
+              
+              break;
+            }
+            
+            case 4: // Adverb
+            {
+              query = "INSERT INTO adverb_pronunciations (adverb_id, pronunciation) VALUES (?, ?)";
+              
+              break;
+            }
+          }
+
+          if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+          {
+            db_error(ppdb, query);
+          }
+        
+          sqlite3_bind_int(ppstmt, 1, rowid);
+          sqlite3_bind_text(ppstmt, 2, pronunciation.c_str(), pronunciation.length(), SQLITE_STATIC);
+        
+          if (sqlite3_step(ppstmt) != SQLITE_DONE)
+          {
+            db_error(ppdb, query);
+          }
+        
+          sqlite3_finalize(ppstmt);
+        }
+      }
+    }
   }
   
-  for (;;)
+  // While we're working on s
   {
-    std::string line;
-    if (!getline(wnsfile, line))
+    progress ppgs("Writing word synonyms...", wn.size());
+    for (auto sense : wn)
     {
-      break;
+      ppgs.update();
+      
+      for (auto word1 : sense.second)
+      {
+        for (auto word2 : sense.second)
+        {
+          if (word1 != word2)
+          {
+            std::string query;
+            switch (sense.first / 100000000)
+            {
+              case 1: // Noun
+              {
+                query = "INSERT INTO noun_synonymy (noun_1_id, noun_2_id) VALUES (?, ?)";
+        
+                break;
+              }
+      
+              case 2: // Verb
+              {
+                // Ignore
+        
+                break;
+              }
+      
+              case 3: // Adjective
+              {
+                query = "INSERT INTO adjective_synonymy (adjective_1_id, adjective_2_id) VALUES (?, ?)";
+        
+                break;
+              }
+      
+              case 4: // Adverb
+              {
+                query = "INSERT INTO adverb_synonymy (adverb_1_id, adverb_2_id) VALUES (?, ?)";
+        
+                break;
+              }
+            }
+            
+            sqlite3_stmt* ppstmt;
+            if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+            {
+              db_error(ppdb, query);
+            }
+    
+            sqlite3_bind_int(ppstmt, 1, word1.second);
+            sqlite3_bind_int(ppstmt, 2, word2.second);
+    
+            if (sqlite3_step(ppstmt) != SQLITE_DONE)
+            {
+              db_error(ppdb, query);
+            }
+    
+            sqlite3_finalize(ppstmt);
+          }
+        }
+      }
+    }
+  }
+  
+  // ant table
+  {
+    std::ifstream wnantfile(wnpref + "wn_ant.pl");
+    if (!wnantfile.is_open())
+    {
+      std::cout << "Invalid WordNet data directory." << std::endl;
+      print_usage();
     }
+
+    std::list<std::string> lines;
+    for (;;)
+    {
+      std::string line;
+      if (!getline(wnantfile, line))
+      {
+        break;
+      }
     
-    if (line.back() == '\r')
+      if (line.back() == '\r')
+      {
+        line.pop_back();
+      }
+      
+      lines.push_back(line);
+    }
+    
+    progress ppgs("Writing antonyms...", lines.size());
+    for (auto line : lines)
     {
-      line.pop_back();
+      ppgs.update();
+      
+      std::regex relation("^ant\\(([134]\\d{8}),(\\d+),([134]\\d{8}),(\\d+)\\)\\.");
+      std::smatch relation_data;
+      if (!std::regex_search(line, relation_data, relation))
+      {
+        continue;
+      }
+    
+      int synset_id_1 = stoi(relation_data[1]);
+      int wnum_1 = stoi(relation_data[2]);
+      int synset_id_2 = stoi(relation_data[3]);
+      int wnum_2 = stoi(relation_data[4]);
+    
+      std::string query;
+      switch (synset_id_1 / 100000000)
+      {
+        case 1: // Noun
+        {
+          query = "INSERT INTO noun_antonymy (noun_1_id, noun_2_id) VALUES (?, ?)";
+        
+          break;
+        }
+      
+        case 2: // Verb
+        {
+          // Ignore
+        
+          break;
+        }
+      
+        case 3: // Adjective
+        {
+          query = "INSERT INTO adjective_antonymy (adjective_1_id, adjective_2_id) VALUES (?, ?)";
+        
+          break;
+        }
+      
+        case 4: // Adverb
+        {
+          query = "INSERT INTO adverb_antonymy (adverb_1_id, adverb_2_id) VALUES (?, ?)";
+        
+          break;
+        }
+      }
+    
+      sqlite3_stmt* ppstmt;
+      if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+      {
+        db_error(ppdb, query);
+      }
+    
+      sqlite3_bind_int(ppstmt, 1, wn[synset_id_1][wnum_1]);
+      sqlite3_bind_int(ppstmt, 2, wn[synset_id_2][wnum_2]);
+    
+      if (sqlite3_step(ppstmt) != SQLITE_DONE)
+      {
+        db_error(ppdb, query);
+      }
+    
+      sqlite3_finalize(ppstmt);
+    }
+  }
+  
+  // at table
+  {
+    std::ifstream wnatfile(wnpref + "wn_at.pl");
+    if (!wnatfile.is_open())
+    {
+      std::cout << "Invalid WordNet data directory." << std::endl;
+      print_usage();
     }
+
+    std::list<std::string> lines;
+    for (;;)
+    {
+      std::string line;
+      if (!getline(wnatfile, line))
+      {
+        break;
+      }
     
-    std::regex relation("^s\\(([134]\\d{8}),(\\d+),'([\\w ]+)',");
-    std::smatch relation_data;
-    if (!std::regex_search(line, relation_data, relation))
+      if (line.back() == '\r')
+      {
+        line.pop_back();
+      }
+      
+      lines.push_back(line);
+    }
+    
+    progress ppgs("Writing variations...", lines.size());
+    for (auto line : lines)
     {
-      continue;
+      ppgs.update();
+      
+      std::regex relation("^at\\((1\\d{8}),(3\\d{8})\\)\\.");
+      std::smatch relation_data;
+      if (!std::regex_search(line, relation_data, relation))
+      {
+        continue;
+      }
+      
+      int synset_id_1 = stoi(relation_data[1]);
+      int synset_id_2 = stoi(relation_data[2]);
+      std::string query("INSERT INTO variation (noun_id, adjective_id) VALUES (?, ?)");
+      
+      for (auto mapping1 : wn[synset_id_1])
+      {
+        for (auto mapping2 : wn[synset_id_2])
+        {
+          sqlite3_stmt* ppstmt;
+          if (sqlite3_prepare_v2(ppdb, query.c_str(), query.size(), &ppstmt, NULL) != SQLITE_OK)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_bind_int(ppstmt, 1, mapping1.second);
+          sqlite3_bind_int(ppstmt, 2, mapping2.second);
+          
+          if (sqlite3_step(ppstmt) != SQLITE_DONE)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_finalize(ppstmt);
+        }
+      }
     }
+  }
+  
+  // hyp table
+  {
+    std::ifstream wnhypfile(wnpref + "wn_hyp.pl");
+    if (!wnhypfile.is_open())
+    {
+      std::cout << "Invalid WordNet data directory." << std::endl;
+      print_usage();
+    }
+
+    std::list<std::string> lines;
+    for (;;)
+    {
+      std::string line;
+      if (!getline(wnhypfile, line))
+      {
+        break;
+      }
     
-    int synset_id = stoi(relation_data[1]);
-    int wnum = stoi(relation_data[2]);
-    std::string word = relation_data[3];
+      if (line.back() == '\r')
+      {
+        line.pop_back();
+      }
+      
+      lines.push_back(line);
+    }
     
-    std::string query;
-    switch (synset_id / 100000000)
+    progress ppgs("Writing hypernyms...", lines.size());
+    for (auto line : lines)
     {
-      case 1: // Noun
+      ppgs.update();
+      
+      std::regex relation("^hyp\\((1\\d{8}),(1\\d{8})\\)\\.");
+      std::smatch relation_data;
+      if (!std::regex_search(line, relation_data, relation))
+      {
+        continue;
+      }
+      
+      int synset_id_1 = stoi(relation_data[1]);
+      int synset_id_2 = stoi(relation_data[2]);
+      std::string query("INSERT INTO hypernymy (hyponym_id, hypernym_id) VALUES (?, ?)");
+      
+      for (auto mapping1 : wn[synset_id_1])
+      {
+        for (auto mapping2 : wn[synset_id_2])
+        {
+          sqlite3_stmt* ppstmt;
+          if (sqlite3_prepare_v2(ppdb, query.c_str(), query.size(), &ppstmt, NULL) != SQLITE_OK)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_bind_int(ppstmt, 1, mapping1.second);
+          sqlite3_bind_int(ppstmt, 2, mapping2.second);
+          
+          if (sqlite3_step(ppstmt) != SQLITE_DONE)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_finalize(ppstmt);
+        }
+      }
+    }
+  }
+  
+  // ins table
+  {
+    std::ifstream wninsfile(wnpref + "wn_ins.pl");
+    if (!wninsfile.is_open())
+    {
+      std::cout << "Invalid WordNet data directory." << std::endl;
+      print_usage();
+    }
+
+    std::list<std::string> lines;
+    for (;;)
+    {
+      std::string line;
+      if (!getline(wninsfile, line))
       {
-        query = "INSERT INTO nouns (form) VALUES (?)";
-        
         break;
       }
+    
+      if (line.back() == '\r')
+      {
+        line.pop_back();
+      }
       
-      case 2: // Verb
+      lines.push_back(line);
+    }
+    
+    progress ppgs("Writing instantiations...", lines.size());
+    for (auto line : lines)
+    {
+      ppgs.update();
+      
+      std::regex relation("^ins\\((1\\d{8}),(1\\d{8})\\)\\.");
+      std::smatch relation_data;
+      if (!std::regex_search(line, relation_data, relation))
+      {
+        continue;
+      }
+      
+      int synset_id_1 = stoi(relation_data[1]);
+      int synset_id_2 = stoi(relation_data[2]);
+      std::string query("INSERT INTO instantiation (instance_id, class_id) VALUES (?, ?)");
+      
+      for (auto mapping1 : wn[synset_id_1])
+      {
+        for (auto mapping2 : wn[synset_id_2])
+        {
+          sqlite3_stmt* ppstmt;
+          if (sqlite3_prepare_v2(ppdb, query.c_str(), query.size(), &ppstmt, NULL) != SQLITE_OK)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_bind_int(ppstmt, 1, mapping1.second);
+          sqlite3_bind_int(ppstmt, 2, mapping2.second);
+          
+          if (sqlite3_step(ppstmt) != SQLITE_DONE)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_finalize(ppstmt);
+        }
+      }
+    }
+  }
+  
+  // mm table
+  {
+    std::ifstream wnmmfile(wnpref + "wn_mm.pl");
+    if (!wnmmfile.is_open())
+    {
+      std::cout << "Invalid WordNet data directory." << std::endl;
+      print_usage();
+    }
+
+    std::list<std::string> lines;
+    for (;;)
+    {
+      std::string line;
+      if (!getline(wnmmfile, line))
       {
-        // Ignore
-        
         break;
       }
+    
+      if (line.back() == '\r')
+      {
+        line.pop_back();
+      }
+      
+      lines.push_back(line);
+    }
+    
+    progress ppgs("Writing member meronyms...", lines.size());
+    for (auto line : lines)
+    {
+      ppgs.update();
       
-      case 3: // Adjective
+      std::regex relation("^mm\\((1\\d{8}),(1\\d{8})\\)\\.");
+      std::smatch relation_data;
+      if (!std::regex_search(line, relation_data, relation))
+      {
+        continue;
+      }
+      
+      int synset_id_1 = stoi(relation_data[1]);
+      int synset_id_2 = stoi(relation_data[2]);
+      std::string query("INSERT INTO member_meronymy (holonym_id, meronym_id) VALUES (?, ?)");
+      
+      for (auto mapping1 : wn[synset_id_1])
+      {
+        for (auto mapping2 : wn[synset_id_2])
+        {
+          sqlite3_stmt* ppstmt;
+          if (sqlite3_prepare_v2(ppdb, query.c_str(), query.size(), &ppstmt, NULL) != SQLITE_OK)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_bind_int(ppstmt, 1, mapping1.second);
+          sqlite3_bind_int(ppstmt, 2, mapping2.second);
+          
+          if (sqlite3_step(ppstmt) != SQLITE_DONE)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_finalize(ppstmt);
+        }
+      }
+    }
+  }
+  
+  // ms table
+  {
+    std::ifstream wnmsfile(wnpref + "wn_ms.pl");
+    if (!wnmsfile.is_open())
+    {
+      std::cout << "Invalid WordNet data directory." << std::endl;
+      print_usage();
+    }
+
+    std::list<std::string> lines;
+    for (;;)
+    {
+      std::string line;
+      if (!getline(wnmsfile, line))
       {
-        query = "INSERT INTO adjectives (form) VALUES (?)";
-        
         break;
       }
+    
+      if (line.back() == '\r')
+      {
+        line.pop_back();
+      }
       
-      case 4: // Adverb
+      lines.push_back(line);
+    }
+    
+    progress ppgs("Writing substance meronyms...", lines.size());
+    for (auto line : lines)
+    {
+      ppgs.update();
+      
+      std::regex relation("^ms\\((1\\d{8}),(1\\d{8})\\)\\.");
+      std::smatch relation_data;
+      if (!std::regex_search(line, relation_data, relation))
+      {
+        continue;
+      }
+      
+      int synset_id_1 = stoi(relation_data[1]);
+      int synset_id_2 = stoi(relation_data[2]);
+      std::string query("INSERT INTO substance_meronymy (holonym_id, meronym_id) VALUES (?, ?)");
+      
+      for (auto mapping1 : wn[synset_id_1])
+      {
+        for (auto mapping2 : wn[synset_id_2])
+        {
+          sqlite3_stmt* ppstmt;
+          if (sqlite3_prepare_v2(ppdb, query.c_str(), query.size(), &ppstmt, NULL) != SQLITE_OK)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_bind_int(ppstmt, 1, mapping1.second);
+          sqlite3_bind_int(ppstmt, 2, mapping2.second);
+          
+          if (sqlite3_step(ppstmt) != SQLITE_DONE)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_finalize(ppstmt);
+        }
+      }
+    }
+  }
+  
+  // mm table
+  {
+    std::ifstream wnmpfile(wnpref + "wn_mp.pl");
+    if (!wnmpfile.is_open())
+    {
+      std::cout << "Invalid WordNet data directory." << std::endl;
+      print_usage();
+    }
+
+    std::list<std::string> lines;
+    for (;;)
+    {
+      std::string line;
+      if (!getline(wnmpfile, line))
       {
-        query = "INSERT INTO adverbs (form) VALUES (?)";
-        
         break;
       }
+    
+      if (line.back() == '\r')
+      {
+        line.pop_back();
+      }
+      
+      lines.push_back(line);
     }
     
-    sqlite3_stmt* ppstmt;
-    if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+    progress ppgs("Writing part meronyms...", lines.size());
+    for (auto line : lines)
+    {
+      ppgs.update();
+      
+      std::regex relation("^mp\\((1\\d{8}),(1\\d{8})\\)\\.");
+      std::smatch relation_data;
+      if (!std::regex_search(line, relation_data, relation))
+      {
+        continue;
+      }
+      
+      int synset_id_1 = stoi(relation_data[1]);
+      int synset_id_2 = stoi(relation_data[2]);
+      std::string query("INSERT INTO part_meronymy (holonym_id, meronym_id) VALUES (?, ?)");
+      
+      for (auto mapping1 : wn[synset_id_1])
+      {
+        for (auto mapping2 : wn[synset_id_2])
+        {
+          sqlite3_stmt* ppstmt;
+          if (sqlite3_prepare_v2(ppdb, query.c_str(), query.size(), &ppstmt, NULL) != SQLITE_OK)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_bind_int(ppstmt, 1, mapping1.second);
+          sqlite3_bind_int(ppstmt, 2, mapping2.second);
+          
+          if (sqlite3_step(ppstmt) != SQLITE_DONE)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_finalize(ppstmt);
+        }
+      }
+    }
+  }
+  
+  // per table
+  {
+    std::ifstream wnperfile(wnpref + "wn_per.pl");
+    if (!wnperfile.is_open())
     {
-      std::cout << "Error writing to output database: " << sqlite3_errmsg(ppdb) << std::endl;
-      sqlite3_close_v2(ppdb);
+      std::cout << "Invalid WordNet data directory." << std::endl;
       print_usage();
     }
+
+    std::list<std::string> lines;
+    for (;;)
+    {
+      std::string line;
+      if (!getline(wnperfile, line))
+      {
+        break;
+      }
+    
+      if (line.back() == '\r')
+      {
+        line.pop_back();
+      }
+      
+      lines.push_back(line);
+    }
+    
+    progress ppgs("Writing pertainyms and mannernyms...", lines.size());
+    for (auto line : lines)
+    {
+      ppgs.update();
+      
+      std::regex relation("^per\\(([34]\\d{8}),(\\d+),([13]\\d{8}),(\\d+)\\)\\.");
+      std::smatch relation_data;
+      if (!std::regex_search(line, relation_data, relation))
+      {
+        continue;
+      }
+      
+      int synset_id_1 = stoi(relation_data[1]);
+      int wnum_1 = stoi(relation_data[2]);
+      int synset_id_2 = stoi(relation_data[3]);
+      int wnum_2 = stoi(relation_data[4]);
+      std::string query;
+      switch (synset_id_1 / 100000000)
+      {
+        case 3: // Adjective
+        {
+          // This is a pertainym, the second word should be a noun
+          // Technically it can be an adjective but we're ignoring that
+          if (synset_id_2 / 100000000 != 1)
+          {
+            continue;
+          }
+          
+          query = "INSERT INTO pertainymy (pertainym_id, noun_id) VALUES (?, ?)";
+          
+          break;
+        }
+        
+        case 4: // Adverb
+        {
+          // This is a mannernym, the second word should be an adjective
+          if (synset_id_2 / 100000000 != 3)
+          {
+            continue;
+          }
+          
+          query = "INSERT INTO mannernymy (mannernym_id, adjective_id) VALUES (?, ?)";
+          
+          break;
+        }
+      }
+      
+      sqlite3_stmt* ppstmt;
+      if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+      {
+        db_error(ppdb, query);
+      }
     
-    sqlite3_bind_text(ppstmt, 1, word.c_str(), word.length(), SQLITE_STATIC);
+      sqlite3_bind_int(ppstmt, 1, wn[synset_id_1][wnum_1]);
+      sqlite3_bind_int(ppstmt, 2, wn[synset_id_2][wnum_2]);
     
-    if (sqlite3_step(ppstmt) != SQLITE_DONE)
+      if (sqlite3_step(ppstmt) != SQLITE_DONE)
+      {
+        db_error(ppdb, query);
+      }
+    
+      sqlite3_finalize(ppstmt);
+    }
+  }
+  
+  // sa table
+  {
+    std::ifstream wnsafile(wnpref + "wn_sa.pl");
+    if (!wnsafile.is_open())
     {
-      std::cout << "Error writing to output database: " << sqlite3_errmsg(ppdb) << std::endl;
-      sqlite3_close_v2(ppdb);
+      std::cout << "Invalid WordNet data directory." << std::endl;
       print_usage();
     }
+
+    std::list<std::string> lines;
+    for (;;)
+    {
+      std::string line;
+      if (!getline(wnsafile, line))
+      {
+        break;
+      }
+    
+      if (line.back() == '\r')
+      {
+        line.pop_back();
+      }
+      
+      lines.push_back(line);
+    }
     
-    sqlite3_finalize(ppstmt);
+    progress ppgs("Writing specifications...", lines.size());
+    for (auto line : lines)
+    {
+      ppgs.update();
+      
+      std::regex relation("^per\\((3\\d{8}),(\\d+),(3\\d{8}),(\\d+)\\)\\.");
+      std::smatch relation_data;
+      if (!std::regex_search(line, relation_data, relation))
+      {
+        continue;
+      }
+      
+      int synset_id_1 = stoi(relation_data[1]);
+      int wnum_1 = stoi(relation_data[2]);
+      int synset_id_2 = stoi(relation_data[3]);
+      int wnum_2 = stoi(relation_data[4]);
+      std::string query("INSERT INTO specification (general_id, specific_id) VALUES (?, ?)");
+      
+      sqlite3_stmt* ppstmt;
+      if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+      {
+        db_error(ppdb, query);
+      }
+    
+      sqlite3_bind_int(ppstmt, 1, wn[synset_id_1][wnum_1]);
+      sqlite3_bind_int(ppstmt, 2, wn[synset_id_2][wnum_2]);
     
-    query = "SELECT last_insert_rowid()";
-    if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+      if (sqlite3_step(ppstmt) != SQLITE_DONE)
+      {
+        db_error(ppdb, query);
+      }
+    
+      sqlite3_finalize(ppstmt);
+    }
+  }
+  /*
+  // sim table
+  {
+    std::ifstream wnsimfile(wnpref + "wn_sim.pl");
+    if (!wnsimfile.is_open())
     {
-      std::cout << "Error writing to output database: " << sqlite3_errmsg(ppdb) << std::endl;
-      sqlite3_close_v2(ppdb);
+      std::cout << "Invalid WordNet data directory." << std::endl;
       print_usage();
     }
+
+    std::list<std::string> lines;
+    for (;;)
+    {
+      std::string line;
+      if (!getline(wnsimfile, line))
+      {
+        break;
+      }
+    
+      if (line.back() == '\r')
+      {
+        line.pop_back();
+      }
+      
+      lines.push_back(line);
+    }
     
-    if (sqlite3_step(ppstmt) != SQLITE_ROW)
+    progress ppgs("Writing sense synonyms...", lines.size());
+    for (auto line : lines)
+    {
+      ppgs.update();
+      
+      std::regex relation("^sim\\((3\\d{8}),(3\\d{8})\\)\\.");
+      std::smatch relation_data;
+      if (!std::regex_search(line, relation_data, relation))
+      {
+        continue;
+      }
+      
+      int synset_id_1 = stoi(relation_data[1]);
+      int synset_id_2 = stoi(relation_data[2]);
+      std::string query("INSERT INTO adjective_synonymy (adjective_1_id, adjective_2_id) VALUES (?, ?)");
+      
+      for (auto mapping1 : wn[synset_id_1])
+      {
+        for (auto mapping2 : wn[synset_id_2])
+        {
+          sqlite3_stmt* ppstmt;
+          if (sqlite3_prepare_v2(ppdb, query.c_str(), query.size(), &ppstmt, NULL) != SQLITE_OK)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_bind_int(ppstmt, 1, mapping1.second);
+          sqlite3_bind_int(ppstmt, 2, mapping2.second);
+          
+          if (sqlite3_step(ppstmt) != SQLITE_DONE)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_reset(ppstmt);
+          sqlite3_clear_bindings(ppstmt);
+          
+          sqlite3_bind_int(ppstmt, 1, mapping2.second);
+          sqlite3_bind_int(ppstmt, 2, mapping1.second);
+          
+          if (sqlite3_step(ppstmt) != SQLITE_DONE)
+          {
+            db_error(ppdb, query);
+          }
+          
+          sqlite3_finalize(ppstmt);
+        }
+      }
+    }
+  }
+  */
+  // syntax table
+  {
+    std::ifstream wnsyntaxfile(wnpref + "wn_syntax.pl");
+    if (!wnsyntaxfile.is_open())
     {
-      std::cout << "Error writing to output database: " << sqlite3_errmsg(ppdb) << std::endl;
-      sqlite3_close_v2(ppdb);
+      std::cout << "Invalid WordNet data directory." << std::endl;
       print_usage();
     }
+
+    std::list<std::string> lines;
+    for (;;)
+    {
+      std::string line;
+      if (!getline(wnsyntaxfile, line))
+      {
+        break;
+      }
     
-    wn[synset_id][wnum] = sqlite3_column_int(ppstmt, 0);
+      if (line.back() == '\r')
+      {
+        line.pop_back();
+      }
+      
+      lines.push_back(line);
+    }
     
-    sqlite3_finalize(ppstmt);
+    progress ppgs("Writing adjective syntax markers...", lines.size());
+    for (auto line : lines)
+    {
+      ppgs.update();
+      
+      std::regex relation("^syntax\\((3\\d{8}),(\\d+),([ipa])p?\\)\\.");
+      std::smatch relation_data;
+      if (!std::regex_search(line, relation_data, relation))
+      {
+        continue;
+      }
+      
+      int synset_id = stoi(relation_data[1]);
+      int wnum = stoi(relation_data[2]);
+      std::string syn = relation_data[3];
+      std::string query("UPDATE adjectives SET position = ? WHERE adjective_id = ?");
+      
+      sqlite3_stmt* ppstmt;
+      if (sqlite3_prepare_v2(ppdb, query.c_str(), query.size(), &ppstmt, NULL) != SQLITE_OK)
+      {
+        db_error(ppdb, query);
+      }
+      
+      sqlite3_bind_text(ppstmt, 1, syn.c_str(), 1, SQLITE_STATIC);
+      sqlite3_bind_int(ppstmt, 2, wn[synset_id][wnum]);
+      
+      if (sqlite3_step(ppstmt) != SQLITE_DONE)
+      {
+        db_error(ppdb, query);
+      }
+      
+      sqlite3_finalize(ppstmt);
+    }
   }
   
   sqlite3_close_v2(ppdb);
   
   std::cout << "Done." << std::endl;
-}
\ No newline at end of file
+}
@@ -0,0 +1,50 @@
+#ifndef PROGRESS_H_A34EF856
+#define PROGRESS_H_A34EF856
+
+#include <string>
+
+class progress {
+  private:
+    std::string message;
+    int total;
+    int cur = 0;
+    int lprint = 0;
+    
+  public:
+    progress(std::string message, int total) : message(message), total(total)
+    {
+      std::cout << message << "   0%" << std::flush;
+    }
+    
+    void update(int val)
+    {
+      if (val <= total)
+      {
+        cur = val;
+      } else {
+        cur = total;
+      }
+      
+      int pp = cur * 100 / total;
+      if (pp != lprint)
+      {
+        lprint = pp;
+      
+        std::cout << "\b\b\b\b" << std::right;
+        std::cout.width(3);
+        std::cout << pp << "%" << std::flush;
+      }
+    }
+    
+    void update()
+    {
+      update(cur+1);
+    }
+    
+    ~progress()
+    {
+      std::cout << "\b\b\b\b100%" << std::endl;
+    }
+};
+
+#endif /* end of include guard: PROGRESS_H_A34EF856 */
@@ -34,20 +34,25 @@ CREATE TABLE `verb_groups` (
 DROP TABLE IF EXISTS `adjectives`;
 CREATE TABLE `adjectives` (
   `adjective_id` INTEGER PRIMARY KEY,
-  `form` VARCHAR(32) NOT NULL,
+  `base_form` VARCHAR(32) NOT NULL,
+  `comparative` VARCHAR(32),
+  `superlative` VARCHAR(32),
   `position` CHAR(1)
 );
 
 DROP TABLE IF EXISTS `adverbs`;
 CREATE TABLE `adverbs` (
   `adverb_id` INTEGER PRIMARY KEY,
-  `form` VARCHAR(32) NOT NULL
+  `base_form` VARCHAR(32) NOT NULL,
+  `comparative` VARCHAR(32),
+  `superlative` VARCHAR(32)
 );
 
 DROP TABLE IF EXISTS `nouns`;
 CREATE TABLE `nouns` (
   `noun_id` INTEGER PRIMARY KEY,
-  `form` VARCHAR(32) NOT NULL
+  `singular` VARCHAR(32) NOT NULL,
+  `plural` VARCHAR(32)
 );
 
 DROP TABLE IF EXISTS `hypernymy`;
@@ -146,10 +151,54 @@ CREATE TABLE `mannernymy` (
   FOREIGN KEY (`mannernym_id`) REFERENCES `adverbs`(`adverb_id`)
 );
 
-DROP TABLE IF EXISTS `synonymy`;
-CREATE TABLE `synonymy` (
+DROP TABLE IF EXISTS `noun_synonymy`;
+CREATE TABLE `noun_synonymy` (
+  `noun_1_id` INTEGER NOT NULL,
+  `noun_2_id` INTEGER NOT NULL,
+  FOREIGN KEY (`noun_1_id`) REFERENCES `nouns`(`nouns_id`),
+  FOREIGN KEY (`noun_2_id`) REFERENCES `nouns`(`nouns_id`)
+);
+
+DROP TABLE IF EXISTS `adjective_synonymy`;
+CREATE TABLE `adjective_synonymy` (
   `adjective_1_id` INTEGER NOT NULL,
   `adjective_2_id` INTEGER NOT NULL,
   FOREIGN KEY (`adjective_1_id`) REFERENCES `adjectives`(`adjective_id`),
   FOREIGN KEY (`adjective_2_id`) REFERENCES `adjectives`(`adjective_id`)
 );
+
+DROP TABLE IF EXISTS `adverb_synonymy`;
+CREATE TABLE `adverb_synonymy` (
+  `adverb_1_id` INTEGER NOT NULL,
+  `adverb_2_id` INTEGER NOT NULL,
+  FOREIGN KEY (`adverb_1_id`) REFERENCES `adverbs`(`adverb_id`),
+  FOREIGN KEY (`adverb_2_id`) REFERENCES `adverbs`(`adverb_id`)
+);
+
+DROP TABLE IF EXISTS `noun_pronunciations`;
+CREATE TABLE `noun_pronunciations` (
+  `noun_id` INTEGER NOT NULL,
+  `pronunciation` VARCHAR(64) NOT NULL,
+  FOREIGN KEY (`noun_id`) REFERENCES `nouns`(`noun_id`)
+);
+
+DROP TABLE IF EXISTS `verb_pronunciations`;
+CREATE TABLE `verb_pronunciations` (
+  `verb_id` INTEGER NOT NULL,
+  `pronunciation` VARCHAR(64) NOT NULL,
+  FOREIGN KEY (`verb_id`) REFERENCES `verbs`(`verb_id`)
+);
+
+DROP TABLE IF EXISTS `adjective_pronunciations`;
+CREATE TABLE `adjective_pronunciations` (
+  `adjective_id` INTEGER NOT NULL,
+  `pronunciation` VARCHAR(64) NOT NULL,
+  FOREIGN KEY (`adjective_id`) REFERENCES `adjectives`(`adjective_id`)
+);
+
+DROP TABLE IF EXISTS `adverb_pronunciations`;
+CREATE TABLE `adverb_pronunciations` (
+  `adverb_id` INTEGER NOT NULL,
+  `pronunciation` VARCHAR(64) NOT NULL,
+  FOREIGN KEY (`adverb_id`) REFERENCES `adverbs`(`adverb_id`)
+);
@@ -0,0 +1,586 @@
+#include "verbly.h"
+
+namespace verbly {
+  
+  adjective::adjective(const data& _data, int _id) : word(_data, _id)
+  {
+    
+  }
+  
+  std::string adjective::base_form() const
+  {
+    return _base_form;
+  }
+  
+  std::string adjective::comparative_form() const
+  {
+    return _comparative_form;
+  }
+  
+  std::string adjective::superlative_form() const
+  {
+    return _superlative_form;
+  }
+  
+  adjective::positioning adjective::position() const
+  {
+    return _position;
+  }
+  
+  bool adjective::has_comparative_form() const
+  {
+    return !_comparative_form.empty();
+  }
+  
+  bool adjective::has_superlative_form() const
+  {
+    return !_superlative_form.empty();
+  }
+  
+  bool adjective::has_position() const
+  {
+    return _position != adjective::positioning::undefined;
+  }
+  
+  adjective_query adjective::antonyms() const
+  {
+    return _data.adjectives().antonym_of(*this);
+  }
+  
+  adjective_query adjective::synonyms() const
+  {
+    return _data.adjectives().synonym_of(*this);
+  }
+  
+  adjective_query adjective::generalizations() const
+  {
+    return _data.adjectives().generalization_of(*this);
+  }
+  
+  adjective_query adjective::specifications() const
+  {
+    return _data.adjectives().specification_of(*this);
+  }
+  
+  noun_query adjective::anti_pertainyms() const
+  {
+    return _data.nouns().anti_pertainym_of(*this);
+  }
+  
+  adverb_query adjective::mannernyms() const
+  {
+    return _data.adverbs().mannernym_of(*this);
+  }
+  
+  noun_query adjective::attributes() const
+  {
+    return _data.nouns().attribute_of(*this);
+  }
+  
+  adjective_query::adjective_query(const data& _data) : _data(_data)
+  {
+
+  }
+  
+  adjective_query& adjective_query::limit(int _limit)
+  {
+    if ((_limit > 0) || (_limit == unlimited))
+    {
+      this->_limit = _limit;
+    }
+  
+    return *this;
+  }
+
+  adjective_query& adjective_query::random(bool _random)
+  {
+    this->_random = _random;
+  
+    return *this;
+  }
+  
+  adjective_query& adjective_query::except(const adjective& _word)
+  {
+    _except.push_back(_word);
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::rhymes_with(const word& _word)
+  {
+    for (auto rhyme : _word.rhyme_phonemes())
+    {
+      _rhymes.push_back(rhyme);
+    }
+    
+    if (dynamic_cast<const adjective*>(&_word) != nullptr)
+    {
+      _except.push_back(dynamic_cast<const adjective&>(_word));
+    }
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::has_pronunciation(bool _has_prn)
+  {
+    this->_has_prn = _has_prn;
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::is_variant(bool _is_variant)
+  {
+    this->_is_variant = _is_variant;
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::variant_of(const noun& _noun)
+  {
+    _variant_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::not_variant_of(const noun& _noun)
+  {
+    _not_variant_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::has_antonyms(bool _is_antonymic)
+  {
+    this->_is_antonymic = _is_antonymic;
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::antonym_of(const adjective& _adj)
+  {
+    _antonym_of.push_back(_adj);
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::not_antonym_of(const adjective& _adj)
+  {
+    _not_antonym_of.push_back(_adj);
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::has_synonyms(bool _is_synonymic)
+  {
+    this->_is_synonymic = _is_synonymic;
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::synonym_of(const adjective& _adj)
+  {
+    _synonym_of.push_back(_adj);
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::not_synonym_of(const adjective& _adj)
+  {
+    _not_synonym_of.push_back(_adj);
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::is_generalization(bool _is_generalization)
+  {
+    this->_is_generalization = _is_generalization;
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::generalization_of(const adjective& _adj)
+  {
+    _generalization_of.push_back(_adj);
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::not_generalization_of(const adjective& _adj)
+  {
+    _not_generalization_of.push_back(_adj);
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::is_specification(bool _is_specification)
+  {
+    this->_is_specification = _is_specification;
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::specification_of(const adjective& _adj)
+  {
+    _specification_of.push_back(_adj);
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::not_specification_of(const adjective& _adj)
+  {
+    _not_specification_of.push_back(_adj);
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::is_pertainymic(bool _is_pertainymic)
+  {
+    this->_is_pertainymic = _is_pertainymic;
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::pertainym_of(const noun& _noun)
+  {
+    _pertainym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::is_mannernymic(bool _is_mannernymic)
+  {
+    this->_is_mannernymic = _is_mannernymic;
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::anti_mannernym_of(const adverb& _adv)
+  {
+    _anti_mannernym_of.push_back(_adv);
+    
+    return *this;
+  }
+  
+  std::list<adjective> adjective_query::run() const
+  {
+    std::stringstream construct;
+    construct << "SELECT adjective_id, base_form, comparative, superlative, position FROM adjectives";
+    std::list<std::string> conditions;
+    
+    if (_has_prn)
+    {
+      conditions.push_back("adjective_id IN (SELECT adjective_id FROM adjective_pronunciations)");
+    }
+    
+    if (!_rhymes.empty())
+    {
+      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE @RHMPRN");
+      std::string cond = "adjective_id IN (SELECT adjective_id FROM adjective_pronunciations WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    for (auto except : _except)
+    {
+      conditions.push_back("adjective_id != @EXCID");
+    }
+    
+    if (_requires_comparative_form)
+    {
+      conditions.push_back("comparative IS NOT NULL");
+    }
+    
+    if (_requires_superlative_form)
+    {
+      conditions.push_back("superlative IS NOT NULL");
+    }
+    
+    if (_position != adjective::positioning::undefined)
+    {
+      switch (_position)
+      {
+        case adjective::positioning::predicate: conditions.push_back("position = 'p'"); break;
+        case adjective::positioning::attributive: conditions.push_back("position = 'a'"); break;
+        case adjective::positioning::postnominal: conditions.push_back("position = 'i'"); break;
+      }
+    }
+    
+    if (_is_variant)
+    {
+      conditions.push_back("adjective_id IN (SELECT adjective_id FROM variation)");
+    }
+    
+    if (!_variant_of.empty())
+    {
+      std::list<std::string> clauses(_variant_of.size(), "noun_id = @ATTRID");
+      std::string cond = "adjective_id IN (SELECT adjective_id FROM variation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_variant_of.empty())
+    {
+      std::list<std::string> clauses(_not_variant_of.size(), "noun_id = @NATTRID");
+      std::string cond = "adjective_id NOT IN (SELECT adjective_id FROM variation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_antonymic)
+    {
+      conditions.push_back("adjective_id IN (SELECT adjective_2_id FROM adjective_antonymy)");
+    }
+    
+    if (!_antonym_of.empty())
+    {
+      std::list<std::string> clauses(_antonym_of.size(), "adjective_1_id = @ANTID");
+      std::string cond = "adjective_id IN (SELECT adjective_2_id FROM adjective_antonymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_antonym_of.empty())
+    {
+      std::list<std::string> clauses(_not_antonym_of.size(), "adjective_1_id = @NANTID");
+      std::string cond = "adjective_id NOT IN (SELECT adjective_2_id FROM adjective_antonymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_synonymic)
+    {
+      conditions.push_back("adjective_id IN (SELECT adjective_2_id FROM adjective_synonymy)");
+    }
+    
+    if (!_synonym_of.empty())
+    {
+      std::list<std::string> clauses(_synonym_of.size(), "adjective_1_id = @SYNID");
+      std::string cond = "adjective_id IN (SELECT adjective_2_id FROM adjective_synonymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_synonym_of.empty())
+    {
+      std::list<std::string> clauses(_not_synonym_of.size(), "adjective_1_id = @NSYNID");
+      std::string cond = "adjective_id NOT IN (SELECT adjective_2_id FROM adjective_synonymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_generalization)
+    {
+      conditions.push_back("adjective_id IN (SELECT general_id FROM specification)");
+    }
+    
+    if (!_generalization_of.empty())
+    {
+      std::list<std::string> clauses(_generalization_of.size(), "specific_id = @SPECID");
+      std::string cond = "adjective_id IN (SELECT general_id FROM specification WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_generalization_of.empty())
+    {
+      std::list<std::string> clauses(_not_generalization_of.size(), "specific_id = @NSPECID");
+      std::string cond = "adjective_id NOT IN (SELECT general_id FROM specification WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_specification)
+    {
+      conditions.push_back("adjective_id IN (SELECT specific_id FROM specification)");
+    }
+    
+    if (!_specification_of.empty())
+    {
+      std::list<std::string> clauses(_specification_of.size(), "general_id = @GENID");
+      std::string cond = "adjective_id IN (SELECT specific_id FROM specification WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_specification_of.empty())
+    {
+      std::list<std::string> clauses(_not_specification_of.size(), "general_id = @NGENID");
+      std::string cond = "adjective_id NOT IN (SELECT specific_id FROM specification WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_pertainymic)
+    {
+      conditions.push_back("adjective_id IN (SELECT pertainym_id FROM pertainymy)");
+    }
+    
+    if (!_pertainym_of.empty())
+    {
+      std::list<std::string> clauses(_pertainym_of.size(), "noun_id = @APERID");
+      std::string cond = "adjective_id IN (SELECT pertainym_id FROM pertainymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_mannernymic)
+    {
+      conditions.push_back("adjective_id IN (SELECT adjective_id FROM mannernymy)");
+    }
+    
+    if (!_anti_mannernym_of.empty())
+    {
+      std::list<std::string> clauses(_anti_mannernym_of.size(), "mannernym_id = @MANID");
+      std::string cond = "adjective_id IN (SELECT adjective_id FROM mannernymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!conditions.empty())
+    {
+      construct << " WHERE ";
+      construct << verbly::implode(std::begin(conditions), std::end(conditions), " AND ");
+    }
+
+    if (_random)
+    {
+      construct << " ORDER BY RANDOM()";
+    }
+
+    if (_limit != unlimited)
+    {
+      construct << " LIMIT " << _limit;
+    }
+    
+    sqlite3_stmt* ppstmt;
+    std::string query = construct.str();
+    if (sqlite3_prepare_v2(_data.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+    {
+      throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
+    }
+    
+    if (!_rhymes.empty())
+    {
+      int i = 0;
+      for (auto rhyme : _rhymes)
+      {
+        std::string rhymer = "%" + rhyme;
+        sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@RHMPRN"), rhymer.c_str(), rhymer.length(), SQLITE_STATIC);
+        
+        i++;
+      }
+    }
+    
+    for (auto except : _except)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@EXCID"), except._id);
+    }
+    
+    for (auto attribute : _variant_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@ATTRID"), attribute._id);
+    }
+    
+    for (auto attribute : _not_variant_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NATTRID"), attribute._id);
+    }
+    
+    for (auto antonym : _antonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@ANTID"), antonym._id);
+    }
+    
+    for (auto antonym : _not_antonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NANTID"), antonym._id);
+    }
+    
+    for (auto synonym : _synonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SYNID"), synonym._id);
+    }
+    
+    for (auto synonym : _not_synonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NSYNID"), synonym._id);
+    }
+    
+    for (auto specific : _generalization_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SPECID"), specific._id);
+    }
+    
+    for (auto specific : _not_generalization_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NSPECID"), specific._id);
+    }
+    
+    for (auto general : _specification_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@GENID"), general._id);
+    }
+    
+    for (auto general : _not_specification_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NGENID"), general._id);
+    }
+    
+    for (auto n : _pertainym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@APERID"), n._id);
+    }
+    
+    for (auto mannernym : _anti_mannernym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@MANID"), mannernym._id);
+    }
+
+    std::list<adjective> output;
+    while (sqlite3_step(ppstmt) == SQLITE_ROW)
+    {
+      adjective tnc {_data, sqlite3_column_int(ppstmt, 0)};
+      tnc._base_form = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
+      
+      if (sqlite3_column_type(ppstmt, 2) != SQLITE_NULL)
+      {
+        tnc._comparative_form = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 2)));
+      }
+      
+      if (sqlite3_column_type(ppstmt, 3) != SQLITE_NULL)
+      {
+        tnc._superlative_form = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 3)));
+      }
+      
+      if (sqlite3_column_type(ppstmt, 4) != SQLITE_NULL)
+      {
+        std::string adjpos(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 4)));
+        if (adjpos == "p")
+        {
+          tnc._position = adjective::positioning::predicate;
+        } else if (adjpos == "a")
+        {
+          tnc._position = adjective::positioning::attributive;
+        } else if (adjpos == "i")
+        {
+          tnc._position = adjective::positioning::postnominal;
+        }
+      }
+  
+      output.push_back(tnc);
+    }
+
+    sqlite3_finalize(ppstmt);
+    
+    for (auto& adjective : output)
+    {
+      query = "SELECT pronunciation FROM adjective_pronunciations WHERE adjective_id = ?";
+      if (sqlite3_prepare_v2(_data.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+      {
+        throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
+      }
+      
+      sqlite3_bind_int(ppstmt, 1, adjective._id);
+      
+      while (sqlite3_step(ppstmt) == SQLITE_ROW)
+      {
+        std::string pronunciation(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 0)));
+        auto phonemes = verbly::split<std::list<std::string>>(pronunciation, " ");
+        
+        adjective.pronunciations.push_back(phonemes);
+      }
+      
+      sqlite3_finalize(ppstmt);
+    }
+
+    return output;
+  }
+
+};
@@ -3,17 +3,129 @@
 
 namespace verbly {
   
-  class adjective {
+  class adjective_query;
+  class adverb_query;
+  class noun_query;
+  
+  class adjective : public word {
+    public:
+      enum class positioning {
+        undefined,
+        predicate,
+        attributive,
+        postnominal
+      };
+    
     private:
-      int id;
+      std::string _base_form;
+      std::string _comparative_form;
+      std::string _superlative_form;
+      positioning _position = positioning::undefined;
+      
+      friend class adjective_query;
+      
+    public:
+      adjective(const data& _data, int _id);
+      
+      std::string base_form() const;
+      std::string comparative_form() const;
+      std::string superlative_form() const;
+      positioning position() const;
+      
+      bool has_comparative_form() const;
+      bool has_superlative_form() const;
+      bool has_position() const;
       
+      adjective_query antonyms() const;
+      adjective_query synonyms() const;
+      adjective_query generalizations() const;
+      adjective_query specifications() const;
+      noun_query anti_pertainyms() const;
+      adverb_query mannernyms() const;
+      noun_query attributes() const;
+  };
+  
+  class adjective_query {
     public:
-      std::string form;
+      adjective_query(const data& _data);
+      
+      adjective_query& limit(int _limit);
+      adjective_query& random(bool _random);
+      adjective_query& except(const adjective& _word);
+      adjective_query& rhymes_with(const word& _word);
+      adjective_query& has_pronunciation(bool _has_prn);
+      
+      adjective_query& requires_comparative_form(bool req);
+      adjective_query& requires_superlative_form(bool req);
+      adjective_query& position(adjective::positioning pos);
+      
+      adjective_query& is_variant(bool _is_variant);
+      adjective_query& variant_of(const noun& _noun);
+      adjective_query& not_variant_of(const noun& _noun);
+      
+      adjective_query& has_antonyms(bool _is_antonymic);
+      adjective_query& antonym_of(const adjective& _adj);
+      adjective_query& not_antonym_of(const adjective& _adj);
+      
+      adjective_query& has_synonyms(bool _is_synonymic);
+      adjective_query& synonym_of(const adjective& _adj);
+      adjective_query& not_synonym_of(const adjective& _adj);
+      
+      adjective_query& is_generalization(bool _is_generalization);
+      adjective_query& generalization_of(const adjective& _adj);
+      adjective_query& not_generalization_of(const adjective& _adj);
+      
+      adjective_query& is_specification(bool _is_specification);
+      adjective_query& specification_of(const adjective& _adj);
+      adjective_query& not_specification_of(const adjective& _adj);
+      
+      adjective_query& is_pertainymic(bool _is_pertainymic);
+      adjective_query& pertainym_of(const noun& _noun);
+      
+      adjective_query& is_mannernymic(bool _is_mannernymic);
+      adjective_query& anti_mannernym_of(const adverb& _adv);
+      
+      std::list<adjective> run() const;
+      
+      const static int unlimited = -1;
+
+    protected:
+      const data& _data;
+      int _limit = unlimited;
+      bool _random = false;
+      std::list<std::string> _rhymes;
+      std::list<adjective> _except;
+      bool _has_prn = false;
+      
+      bool _requires_comparative_form = false;
+      bool _requires_superlative_form = false;
+      adjective::positioning _position = adjective::positioning::undefined;
+      
+      bool _is_variant = false;
+      std::list<noun> _variant_of;
+      std::list<noun> _not_variant_of;
+      
+      bool _is_antonymic = false;
+      std::list<adjective> _antonym_of;
+      std::list<adjective> _not_antonym_of;
+      
+      bool _is_synonymic = false;
+      std::list<adjective> _synonym_of;
+      std::list<adjective> _not_synonym_of;
+      
+      bool _is_generalization = false;
+      std::list<adjective> _generalization_of;
+      std::list<adjective> _not_generalization_of;
+      
+      bool _is_specification = false;
+      std::list<adjective> _specification_of;
+      std::list<adjective> _not_specification_of;
+      
+      bool _is_pertainymic = false;
+      std::list<noun> _pertainym_of;
       
-      adjective(int id) : id(id)
-      {
-        
-      }
+      bool _is_mannernymic = false;
+      std::list<adverb> _anti_mannernym_of;
   };
   
 };
@@ -0,0 +1,364 @@
+#include "verbly.h"
+
+namespace verbly {
+  
+  adverb::adverb(const data& _data, int _id) : word(_data, _id)
+  {
+    
+  }
+  
+  std::string adverb::base_form() const
+  {
+    return _base_form;
+  }
+  
+  std::string adverb::comparative_form() const
+  {
+    return _comparative_form;
+  }
+  
+  std::string adverb::superlative_form() const
+  {
+    return _superlative_form;
+  }
+    
+  bool adverb::has_comparative_form() const
+  {
+    return !_comparative_form.empty();
+  }
+  
+  bool adverb::has_superlative_form() const
+  {
+    return !_superlative_form.empty();
+  }
+  
+  adverb_query adverb::antonyms() const
+  {
+    return _data.adverbs().antonym_of(*this);
+  }
+  
+  adverb_query adverb::synonyms() const
+  {
+    return _data.adverbs().synonym_of(*this);
+  }
+  
+  adjective_query adverb::anti_mannernyms() const
+  {
+    return _data.adjectives().anti_mannernym_of(*this);
+  }
+  
+  adverb_query::adverb_query(const data& _data) : _data(_data)
+  {
+
+  }
+  
+  adverb_query& adverb_query::limit(int _limit)
+  {
+    if ((_limit > 0) || (_limit == unlimited))
+    {
+      this->_limit = _limit;
+    }
+  
+    return *this;
+  }
+
+  adverb_query& adverb_query::random(bool _random)
+  {
+    this->_random = _random;
+  
+    return *this;
+  }
+  
+  adverb_query& adverb_query::except(const adverb& _word)
+  {
+    _except.push_back(_word);
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::rhymes_with(const word& _word)
+  {
+    for (auto rhyme : _word.rhyme_phonemes())
+    {
+      _rhymes.push_back(rhyme);
+    }
+    
+    if (dynamic_cast<const adverb*>(&_word) != nullptr)
+    {
+      _except.push_back(dynamic_cast<const adverb&>(_word));
+    }
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::has_pronunciation(bool _has_prn)
+  {
+    this->_has_prn = _has_prn;
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::requires_comparative_form(bool _arg)
+  {
+    _requires_comparative_form = _arg;
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::requires_superlative_form(bool _arg)
+  {
+    _requires_superlative_form = _arg;
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::has_antonyms(bool _arg)
+  {
+    _has_antonyms = _arg;
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::antonym_of(const adverb& _adv)
+  {
+    _antonym_of.push_back(_adv);
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::not_antonym_of(const adverb& _adv)
+  {
+    _not_antonym_of.push_back(_adv);
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::has_synonyms(bool _arg)
+  {
+    _has_synonyms = _arg;
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::synonym_of(const adverb& _adv)
+  {
+    _synonym_of.push_back(_adv);
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::not_synonym_of(const adverb& _adv)
+  {
+    _not_synonym_of.push_back(_adv);
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::is_mannernymic(bool _arg)
+  {
+    _is_mannernymic = _arg;
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::mannernym_of(const adjective& _adj)
+  {
+    _mannernym_of.push_back(_adj);
+    
+    return *this;
+  }
+  
+  std::list<adverb> adverb_query::run() const
+  {
+    std::stringstream construct;
+    construct << "SELECT adverb_id, base_form, comparative, superlative FROM adverbs";
+    std::list<std::string> conditions;
+    
+    if (_has_prn)
+    {
+      conditions.push_back("adverb_id IN (SELECT adverb_id FROM adverb_pronunciations)");
+    }
+    
+    if (!_rhymes.empty())
+    {
+      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE @RHMPRN");
+      std::string cond = "adverb_id IN (SELECT adverb_id FROM adverb_pronunciations WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    for (auto except : _except)
+    {
+      conditions.push_back("adverb_id != @EXCID");
+    }
+    
+    if (_requires_comparative_form)
+    {
+      conditions.push_back("comparative IS NOT NULL");
+    }
+    
+    if (_requires_superlative_form)
+    {
+      conditions.push_back("superlative IS NOT NULL");
+    }
+    
+    if (_has_antonyms)
+    {
+      conditions.push_back("adverb_id IN (SELECT adverb_2_id FROM adverb_antonymy)");
+    }
+    
+    if (!_antonym_of.empty())
+    {
+      std::list<std::string> clauses(_antonym_of.size(), "adverb_1_id = @ANTID");
+      std::string cond = "adverb_id IN (SELECT adverb_2_id FROM adverb_antonymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_antonym_of.empty())
+    {
+      std::list<std::string> clauses(_not_antonym_of.size(), "adverb_1_id = @NANTID");
+      std::string cond = "adverb_id NOT IN (SELECT adverb_2_id FROM adverb_antonymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_has_synonyms)
+    {
+      conditions.push_back("adverb_id IN (SELECT adverb_2_id FROM adverb_synonymy)");
+    }
+    
+    if (!_synonym_of.empty())
+    {
+      std::list<std::string> clauses(_synonym_of.size(), "adverb_1_id = @SYNID");
+      std::string cond = "adverb_id IN (SELECT adverb_2_id FROM adverb_synonymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_synonym_of.empty())
+    {
+      std::list<std::string> clauses(_not_synonym_of.size(), "adverb_1_id = @NSYNID");
+      std::string cond = "adverb_id NOT IN (SELECT adverb_2_id FROM adverb_synonymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_mannernymic)
+    {
+      conditions.push_back("adverb_id IN (SELECT mannernym_id FROM mannernymy)");
+    }
+    
+    if (!_mannernym_of.empty())
+    {
+      std::list<std::string> clauses(_mannernym_of.size(), "adjective_id = @AMANID");
+      std::string cond = "adverb_id IN (SELECT mannernym_id FROM mannernymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!conditions.empty())
+    {
+      construct << " WHERE ";
+      construct << verbly::implode(std::begin(conditions), std::end(conditions), " AND ");
+    }
+
+    if (_random)
+    {
+      construct << " ORDER BY RANDOM()";
+    }
+
+    if (_limit != unlimited)
+    {
+      construct << " LIMIT " << _limit;
+    }
+    
+    sqlite3_stmt* ppstmt;
+    std::string query = construct.str();
+    if (sqlite3_prepare_v2(_data.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+    {
+      throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
+    }
+    
+    if (!_rhymes.empty())
+    {
+      int i = 0;
+      for (auto rhyme : _rhymes)
+      {
+        std::string rhymer = "%" + rhyme;
+        sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@RHMPRN"), rhymer.c_str(), rhymer.length(), SQLITE_STATIC);
+        
+        i++;
+      }
+    }
+    
+    for (auto except : _except)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@EXCID"), except._id);
+    }
+    
+    for (auto antonym : _antonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@ANTID"), antonym._id);
+    }
+    
+    for (auto antonym : _not_antonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NANTID"), antonym._id);
+    }
+    
+    for (auto synonym : _synonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SYNID"), synonym._id);
+    }
+    
+    for (auto synonym : _not_synonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NSYNID"), synonym._id);
+    }
+    
+    for (auto adj : _mannernym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@AMANID"), adj._id);
+    }
+
+    std::list<adverb> output;
+    while (sqlite3_step(ppstmt) == SQLITE_ROW)
+    {
+      adverb tnc {_data, sqlite3_column_int(ppstmt, 0)};
+      tnc._base_form = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
+      
+      if (sqlite3_column_type(ppstmt, 2) != SQLITE_NULL)
+      {
+        tnc._comparative_form = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 2)));
+      }
+      
+      if (sqlite3_column_type(ppstmt, 3) != SQLITE_NULL)
+      {
+        tnc._superlative_form = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 3)));
+      }
+  
+      output.push_back(tnc);
+    }
+
+    sqlite3_finalize(ppstmt);
+    
+    for (auto& adverb : output)
+    {
+      query = "SELECT pronunciation FROM adverb_pronunciations WHERE adverb_id = ?";
+      if (sqlite3_prepare_v2(_data.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+      {
+        throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
+      }
+      
+      sqlite3_bind_int(ppstmt, 1, adverb._id);
+      
+      while (sqlite3_step(ppstmt) == SQLITE_ROW)
+      {
+        std::string pronunciation(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 0)));
+        auto phonemes = verbly::split<std::list<std::string>>(pronunciation, " ");
+        
+        adverb.pronunciations.push_back(phonemes);
+      }
+      
+      sqlite3_finalize(ppstmt);
+    }
+
+    return output;
+  }
+  
+};
@@ -3,17 +3,78 @@
 
 namespace verbly {
   
-  class adverb {
+  class adverb : public word {
     private:
-      int id;
+      std::string _base_form;
+      std::string _comparative_form;
+      std::string _superlative_form;
       
+      friend class adverb_query;
+      
+    public:
+      adverb(const data& _data, int _id);
+      
+      std::string base_form() const;
+      std::string comparative_form() const;
+      std::string superlative_form() const;
+      
+      bool has_comparative_form() const;
+      bool has_superlative_form() const;
+      
+      adverb_query antonyms() const;
+      adverb_query synonyms() const;
+      adjective_query anti_mannernyms() const;
+  };
+  
+  class adverb_query {
     public:
-      std::string form;
+      adverb_query(const data& _data);
+      
+      adverb_query& limit(int _limit);
+      adverb_query& random(bool _random);
+      adverb_query& except(const adverb& _word);
+      adverb_query& rhymes_with(const word& _word);
+      adverb_query& has_pronunciation(bool _has_prn);
+      
+      adverb_query& requires_comparative_form(bool _arg);
+      adverb_query& requires_superlative_form(bool _arg);
+      
+      adverb_query& has_antonyms(bool _arg);
+      adverb_query& antonym_of(const adverb& _adv);
+      adverb_query& not_antonym_of(const adverb& _adv);
+      
+      adverb_query& has_synonyms(bool _arg);
+      adverb_query& synonym_of(const adverb& _adv);
+      adverb_query& not_synonym_of(const adverb& _adv);
+      
+      adverb_query& is_mannernymic(bool _arg);
+      adverb_query& mannernym_of(const adjective& _adj);
+      
+      std::list<adverb> run() const;
+      
+      const static int unlimited = -1;
+      
+    private:
+      const data& _data;
+      int _limit = unlimited;
+      bool _random = false;
+      std::list<std::string> _rhymes;
+      std::list<adverb> _except;
+      bool _has_prn = false;
+      
+      bool _requires_comparative_form = false;
+      bool _requires_superlative_form = false;
+      
+      bool _has_antonyms = false;
+      std::list<adverb> _antonym_of;
+      std::list<adverb> _not_antonym_of;
+      
+      bool _has_synonyms = false;
+      std::list<adverb> _synonym_of;
+      std::list<adverb> _not_synonym_of;
       
-      adverb(int id) : id(id)
-      {
-        
-      }
+      bool _is_mannernymic = false;
+      std::list<adjective> _mannernym_of;
   };
   
 };
@@ -0,0 +1,50 @@
+#include "verbly.h"
+
+namespace verbly {
+
+  data::data(std::string datafile)
+  {
+    if (sqlite3_open_v2(datafile.c_str(), &ppdb, SQLITE_OPEN_READONLY, NULL) != SQLITE_OK)
+    {
+      throw std::invalid_argument(sqlite3_errmsg(ppdb));
+    }
+  }
+
+  data::data(data&& other)
+  {
+    ppdb = other.ppdb;
+  }
+
+  data& data::operator=(data&& other)
+  {
+    ppdb = other.ppdb;
+  
+    return *this;
+  }
+
+  data::~data()
+  {
+    sqlite3_close_v2(ppdb);
+  }
+
+  verb_query data::verbs() const
+  {
+    return verb_query(*this);
+  }
+
+  adjective_query data::adjectives() const
+  {
+    return adjective_query(*this);
+  }
+
+  adverb_query data::adverbs() const
+  {
+    return adverb_query(*this);
+  }
+
+  noun_query data::nouns() const
+  {
+    return noun_query(*this);
+  }
+
+};
@@ -1,273 +1,46 @@
 #ifndef DATA_H_C4AEC3DD
 #define DATA_H_C4AEC3DD
 
-#include "verb.h"
 #include <sqlite3.h>
 #include <stdexcept>
 
 namespace verbly {
   
+  class data;
+  class word;
+  class adjective;
+  class noun;
+  class verb;
+  class adverb;
+  class adjective_query;
+  class adverb_query;
+  class noun_query;
+  class verb_query;
+  
   class data {
     private:
       sqlite3* ppdb;
       
-    public:
-      class verb_query {
-        public:
-          const static int unlimited = -1;
-          
-        private:
-          const data& database;
-          int m_limit = unlimited;
-          bool m_random = false;
-          
-        public:
-          verb_query(const data& database) : database(database)
-          {
-            
-          }
-          
-          verb_query& limit(int m_limit)
-          {
-            if ((m_limit > 0) || (m_limit == unlimited))
-            {
-              this->m_limit = m_limit;
-            }
-            
-            return *this;
-          }
-          
-          verb_query& random(bool m_random)
-          {
-            this->m_random = m_random;
-            
-            return *this;
-          }
-          
-          std::list<verb> run() const
-          {
-            std::stringstream construct;
-            construct << "SELECT verb_id, infinitive, past_tense, past_participle, ing_form, s_form FROM verbs";
-            
-            if (m_random)
-            {
-              construct << " ORDER BY RANDOM()";
-            }
-            
-            if (m_limit != unlimited)
-            {
-              construct << " LIMIT " << m_limit;
-            }
-            
-            sqlite3_stmt* ppstmt;
-            std::string query = construct.str();
-            if (sqlite3_prepare_v2(database.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
-            {
-              throw std::runtime_error(sqlite3_errmsg(database.ppdb));
-            }
-            
-            std::list<verb> output;
-            while (sqlite3_step(ppstmt) == SQLITE_ROW)
-            {
-              verb tnc {sqlite3_column_int(ppstmt, 0)};
-              tnc.infinitive = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
-              tnc.past_tense = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 2)));
-              tnc.past_participle = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 3)));
-              tnc.ing_form = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 4)));
-              tnc.s_form = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 5)));
-              
-              output.push_back(tnc);
-            }
-            
-            sqlite3_finalize(ppstmt);
-            
-            return output;
-          }
-          
-      };
-      
-      class adjective_query {
-        public:
-          const static int unlimited = -1;
-          
-        private:
-          const data& database;
-          int m_limit = unlimited;
-          bool m_random = false;
-          
-        public:
-          adjective_query(const data& database) : database(database)
-          {
-            
-          }
-          
-          adjective_query& limit(int m_limit)
-          {
-            if ((m_limit > 0) || (m_limit == unlimited))
-            {
-              this->m_limit = m_limit;
-            }
-            
-            return *this;
-          }
-          
-          adjective_query& random(bool m_random)
-          {
-            this->m_random = m_random;
-            
-            return *this;
-          }
-          
-          std::list<adjective> run() const
-          {
-            std::stringstream construct;
-            construct << "SELECT adjective_id, form FROM adjectives";
-            
-            if (m_random)
-            {
-              construct << " ORDER BY RANDOM()";
-            }
-            
-            if (m_limit != unlimited)
-            {
-              construct << " LIMIT " << m_limit;
-            }
-            
-            sqlite3_stmt* ppstmt;
-            std::string query = construct.str();
-            if (sqlite3_prepare_v2(database.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
-            {
-              throw std::runtime_error(sqlite3_errmsg(database.ppdb));
-            }
-            
-            std::list<adjective> output;
-            while (sqlite3_step(ppstmt) == SQLITE_ROW)
-            {
-              adjective tnc {sqlite3_column_int(ppstmt, 0)};
-              tnc.form = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
-              
-              output.push_back(tnc);
-            }
-            
-            sqlite3_finalize(ppstmt);
-            
-            return output;
-          }
-          
-      };
-      
-      class adverb_query {
-        public:
-          const static int unlimited = -1;
-          
-        private:
-          const data& database;
-          int m_limit = unlimited;
-          bool m_random = false;
-          
-        public:
-          adverb_query(const data& database) : database(database)
-          {
-            
-          }
-          
-          adverb_query& limit(int m_limit)
-          {
-            if ((m_limit > 0) || (m_limit == unlimited))
-            {
-              this->m_limit = m_limit;
-            }
-            
-            return *this;
-          }
-          
-          adverb_query& random(bool m_random)
-          {
-            this->m_random = m_random;
-            
-            return *this;
-          }
-          
-          std::list<adverb> run() const
-          {
-            std::stringstream construct;
-            construct << "SELECT adverb_id, form FROM adverbs";
-            
-            if (m_random)
-            {
-              construct << " ORDER BY RANDOM()";
-            }
-            
-            if (m_limit != unlimited)
-            {
-              construct << " LIMIT " << m_limit;
-            }
-            
-            sqlite3_stmt* ppstmt;
-            std::string query = construct.str();
-            if (sqlite3_prepare_v2(database.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
-            {
-              throw std::runtime_error(sqlite3_errmsg(database.ppdb));
-            }
-            
-            std::list<adverb> output;
-            while (sqlite3_step(ppstmt) == SQLITE_ROW)
-            {
-              adverb tnc {sqlite3_column_int(ppstmt, 0)};
-              tnc.form = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
-              
-              output.push_back(tnc);
-            }
-            
-            sqlite3_finalize(ppstmt);
-            
-            return output;
-          }
-          
-      };
+      friend class adjective_query;
+      friend class noun_query;
+      friend class verb_query;
+      friend class adverb_query;
       
-      data(std::string datafile)
-      {
-        if (sqlite3_open_v2(datafile.c_str(), &ppdb, SQLITE_OPEN_READONLY, NULL) != SQLITE_OK)
-        {
-          throw std::invalid_argument(sqlite3_errmsg(ppdb));
-        }
-      }
+    public:
+      data(std::string datafile);
       
       data(const data& other) = delete;
       data& operator=(const data& other) = delete;
       
-      data(data&& other)
-      {
-        ppdb = other.ppdb;
-      }
-      
-      data& operator=(data&& other)
-      {
-        ppdb = other.ppdb;
-        
-        return *this;
-      }
-      
-      ~data()
-      {
-        sqlite3_close_v2(ppdb);
-      }
-      
-      verb_query verbs() const
-      {
-        return verb_query(*this);
-      }
+      data(data&& other);
+      data& operator=(data&& other);
       
-      adjective_query adjectives() const
-      {
-        return adjective_query(*this);
-      }
+      ~data();
       
-      adverb_query adverbs() const
-      {
-        return adverb_query(*this);
-      }
+      verb_query verbs() const;
+      adjective_query adjectives() const;
+      adverb_query adverbs() const;
+      noun_query nouns() const;
       
   };
   
@@ -0,0 +1,916 @@
+#include "verbly.h"
+
+namespace verbly {
+  
+  noun::noun(const data& _data, int _id) : word(_data, _id)
+  {
+    
+  }
+  
+  std::string noun::base_form() const
+  {
+    return _singular;
+  }
+
+  std::string noun::singular_form() const
+  {
+    return _singular;
+  }
+  
+  std::string noun::plural_form() const
+  {
+    return _plural;
+  }
+
+  bool noun::has_plural_form() const
+  {
+    return !_plural.empty();
+  }
+  
+  noun_query noun::hypernyms() const
+  {
+    return _data.nouns().hypernym_of(*this);
+  }
+  
+  noun_query noun::hyponyms() const
+  {
+    return _data.nouns().hyponym_of(*this);
+  }
+  
+  noun_query noun::part_meronyms() const
+  {
+    return _data.nouns().part_meronym_of(*this);
+  }
+  
+  noun_query noun::part_holonyms() const
+  {
+    return _data.nouns().part_holonym_of(*this);
+  }
+  
+  noun_query noun::substance_meronyms() const
+  {
+    return _data.nouns().substance_meronym_of(*this);
+  }
+  
+  noun_query noun::substance_holonyms() const
+  {
+    return _data.nouns().substance_holonym_of(*this);
+  }
+  
+  noun_query noun::member_meronyms() const
+  {
+    return _data.nouns().member_meronym_of(*this);
+  }
+  
+  noun_query noun::member_holonyms() const
+  {
+    return _data.nouns().member_holonym_of(*this);
+  }
+  
+  noun_query noun::classes() const
+  {
+    return _data.nouns().class_of(*this);
+  }
+  
+  noun_query noun::instances() const
+  {
+    return _data.nouns().instance_of(*this);
+  }
+  
+  noun_query noun::synonyms() const
+  {
+    return _data.nouns().synonym_of(*this);
+  }
+  
+  noun_query noun::antonyms() const
+  {
+    return _data.nouns().antonym_of(*this);
+  }
+  
+  adjective_query noun::pertainyms() const
+  {
+    return _data.adjectives().pertainym_of(*this);
+  }
+  
+  adjective_query noun::variations() const
+  {
+    return _data.adjectives().variant_of(*this);
+  }
+  
+  noun_query::noun_query(const data& _data) : _data(_data)
+  {
+    
+  }
+  
+  noun_query& noun_query::limit(int _limit)
+  {
+    if ((_limit > 0) || (_limit == unlimited))
+    {
+      this->_limit = _limit;
+    }
+  
+    return *this;
+  }
+
+  noun_query& noun_query::random(bool _random)
+  {
+    this->_random = _random;
+  
+    return *this;
+  }
+  
+  noun_query& noun_query::except(const noun& _word)
+  {
+    _except.push_back(_word);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::rhymes_with(const word& _word)
+  {
+    for (auto rhyme : _word.rhyme_phonemes())
+    {
+      _rhymes.push_back(rhyme);
+    }
+    
+    if (dynamic_cast<const noun*>(&_word) != nullptr)
+    {
+      _except.push_back(dynamic_cast<const noun&>(_word));
+    }
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::has_pronunciation(bool _has_prn)
+  {
+    this->_has_prn = _has_prn;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::is_hypernym(bool _arg)
+  {
+    _is_hypernym = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::hypernym_of(const noun& _noun)
+  {
+    _hypernym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::not_hypernym_of(const noun& _noun)
+  {
+    _not_hypernym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::is_hyponym(bool _arg)
+  {
+    _is_hyponym = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::hyponym_of(const noun& _noun)
+  {
+    _hyponym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::not_hyponym_of(const noun& _noun)
+  {
+    _not_hyponym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::is_part_meronym(bool _arg)
+  {
+    _is_part_meronym = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::part_meronym_of(const noun& _noun)
+  {
+    _part_meronym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::not_part_meronym_of(const noun& _noun)
+  {
+    _not_part_meronym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::is_part_holonym(bool _arg)
+  {
+    _is_part_holonym = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::part_holonym_of(const noun& _noun)
+  {
+    _part_holonym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::not_part_holonym_of(const noun& _noun)
+  {
+    _not_part_holonym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::is_substance_meronym(bool _arg)
+  {
+    _is_substance_meronym = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::substance_meronym_of(const noun& _noun)
+  {
+    _substance_meronym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::not_substance_meronym_of(const noun& _noun)
+  {
+    _not_substance_meronym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::is_substance_holonym(bool _arg)
+  {
+    _is_substance_holonym = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::substance_holonym_of(const noun& _noun)
+  {
+    _substance_holonym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::not_substance_holonym_of(const noun& _noun)
+  {
+    _not_substance_holonym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::is_member_meronym(bool _arg)
+  {
+    _is_member_meronym = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::member_meronym_of(const noun& _noun)
+  {
+    _member_meronym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::not_member_meronym_of(const noun& _noun)
+  {
+    _not_member_meronym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::is_member_holonym(bool _arg)
+  {
+    _is_member_holonym = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::member_holonym_of(const noun& _noun)
+  {
+    _member_holonym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::not_member_holonym_of(const noun& _noun)
+  {
+    _not_member_holonym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::is_proper(bool _arg)
+  {
+    _is_proper = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::instance_of(const noun& _noun)
+  {
+    _instance_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::not_instance_of(const noun& _noun)
+  {
+    _not_instance_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::is_class(bool _arg)
+  {
+    _is_class = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::class_of(const noun& _noun)
+  {
+    _class_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::not_class_of(const noun& _noun)
+  {
+    _not_class_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::has_synonyms(bool _arg)
+  {
+    _has_synonyms = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::synonym_of(const noun& _noun)
+  {
+    _synonym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::not_synonym_of(const noun& _noun)
+  {
+    _not_synonym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::has_antonyms(bool _arg)
+  {
+    _has_antonyms = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::antonym_of(const noun& _noun)
+  {
+    _antonym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::not_antonym_of(const noun& _noun)
+  {
+    _not_antonym_of.push_back(_noun);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::has_pertainym(bool _arg)
+  {
+    _has_pertainym = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::anti_pertainym_of(const adjective& _adj)
+  {
+    _anti_pertainym_of.push_back(_adj);
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::is_attribute(bool _arg)
+  {
+    _is_attribute = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::attribute_of(const adjective& _adj)
+  {
+    _attribute_of.push_back(_adj);
+    
+    return *this;
+  }
+  
+  std::list<noun> noun_query::run() const
+  {
+    std::stringstream construct;
+    construct << "SELECT noun_id, singular, plural FROM nouns";
+    std::list<std::string> conditions;
+    
+    if (_has_prn)
+    {
+      conditions.push_back("noun_id IN (SELECT noun_id FROM noun_pronunciations)");
+    }
+    
+    if (!_rhymes.empty())
+    {
+      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE @RHMPRN");
+      std::string cond = "noun_id IN (SELECT noun_id FROM noun_pronunciations WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    for (auto except : _except)
+    {
+      conditions.push_back("noun_id != @EXCID");
+    }
+    
+    if (_is_hypernym)
+    {
+      conditions.push_back("noun_id IN (SELECT hypernym_id FROM hypernymy)");
+    }
+    
+    if (!_hypernym_of.empty())
+    {
+      std::list<std::string> clauses(_hypernym_of.size(), "hyponym_id = @HYPO");
+      std::string cond = "noun_id IN (SELECT hypernym_id FROM hypernymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_hypernym_of.empty())
+    {
+      std::list<std::string> clauses(_not_hypernym_of.size(), "hyponym_id = @NHYPO");
+      std::string cond = "noun_id NOT IN (SELECT hypernym_id FROM hypernymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_hyponym)
+    {
+      conditions.push_back("noun_id IN (SELECT hyponym_id FROM hypernymy)");
+    }
+    
+    if (!_hyponym_of.empty())
+    {
+      std::list<std::string> clauses(_hyponym_of.size(), "hypernym_id = @HYPER");
+      std::string cond = "noun_id IN (SELECT hyponym_id FROM hypernymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_hyponym_of.empty())
+    {
+      std::list<std::string> clauses(_not_hyponym_of.size(), "hypernym_id = @NHYPER");
+      std::string cond = "noun_id NOT IN (SELECT hyponym_id FROM hypernymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_part_meronym)
+    {
+      conditions.push_back("noun_id IN (SELECT meronym_id FROM part_meronymy)");
+    }
+    
+    if (!_part_meronym_of.empty())
+    {
+      std::list<std::string> clauses(_part_meronym_of.size(), "holonym_id = @PHOLO");
+      std::string cond = "noun_id IN (SELECT meronym_id FROM part_meronymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_part_meronym_of.empty())
+    {
+      std::list<std::string> clauses(_not_part_meronym_of.size(), "holonym_id = @NPHOLO");
+      std::string cond = "noun_id NOT IN (SELECT meronym_id FROM part_meronymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_part_holonym)
+    {
+      conditions.push_back("noun_id IN (SELECT holonym_id FROM part_meronymy)");
+    }
+    
+    if (!_part_holonym_of.empty())
+    {
+      std::list<std::string> clauses(_part_holonym_of.size(), "meronym_id = @PMERO");
+      std::string cond = "noun_id IN (SELECT holonym_id FROM part_meronymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_part_holonym_of.empty())
+    {
+      std::list<std::string> clauses(_not_part_holonym_of.size(), "meronym_id = @NPMERO");
+      std::string cond = "noun_id NOT IN (SELECT holonym_id FROM part_meronymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_substance_meronym)
+    {
+      conditions.push_back("noun_id IN (SELECT meronym_id FROM substance_meronymy)");
+    }
+    
+    if (!_substance_meronym_of.empty())
+    {
+      std::list<std::string> clauses(_substance_meronym_of.size(), "holonym_id = @SHOLO");
+      std::string cond = "noun_id IN (SELECT meronym_id FROM substance_meronymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_substance_meronym_of.empty())
+    {
+      std::list<std::string> clauses(_not_substance_meronym_of.size(), "holonym_id = @NSHOLO");
+      std::string cond = "noun_id NOT IN (SELECT meronym_id FROM substance_meronymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_substance_holonym)
+    {
+      conditions.push_back("noun_id IN (SELECT holonym_id FROM substance_meronymy)");
+    }
+    
+    if (!_substance_holonym_of.empty())
+    {
+      std::list<std::string> clauses(_substance_holonym_of.size(), "meronym_id = @SMERO");
+      std::string cond = "noun_id IN (SELECT holonym_id FROM substance_meronymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_substance_holonym_of.empty())
+    {
+      std::list<std::string> clauses(_not_substance_holonym_of.size(), "meronym_id = @NSMERO");
+      std::string cond = "noun_id NOT IN (SELECT holonym_id FROM substance_meronymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_member_meronym)
+    {
+      conditions.push_back("noun_id IN (SELECT meronym_id FROM member_meronymy)");
+    }
+    
+    if (!_member_meronym_of.empty())
+    {
+      std::list<std::string> clauses(_member_meronym_of.size(), "holonym_id = @MHOLO");
+      std::string cond = "noun_id IN (SELECT meronym_id FROM member_meronymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_member_meronym_of.empty())
+    {
+      std::list<std::string> clauses(_not_member_meronym_of.size(), "holonym_id = @NMHOLO");
+      std::string cond = "noun_id NOT IN (SELECT meronym_id FROM member_meronymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_member_holonym)
+    {
+      conditions.push_back("noun_id IN (SELECT holonym_id FROM member_meronym)");
+    }
+    
+    if (!_member_holonym_of.empty())
+    {
+      std::list<std::string> clauses(_member_holonym_of.size(), "meronym_id = @MMERO");
+      std::string cond = "noun_id IN (SELECT holonym_id FROM member_meronymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_member_holonym_of.empty())
+    {
+      std::list<std::string> clauses(_not_member_holonym_of.size(), "meronym_id = @NMMERO");
+      std::string cond = "noun_id NOT IN (SELECT holonym_id FROM member_meronymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_proper)
+    {
+      conditions.push_back("noun_id IN (SELECT instance_id FROM instantiation)");
+    }
+    
+    if (!_instance_of.empty())
+    {
+      std::list<std::string> clauses(_instance_of.size(), "class_id = @CLSID");
+      std::string cond = "noun_id IN (SELECT instance_id FROM instantiation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_instance_of.empty())
+    {
+      std::list<std::string> clauses(_not_instance_of.size(), "class_id = @NCLSID");
+      std::string cond = "noun_id NOT IN (SELECT instance_id FROM instantiation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_class)
+    {
+      conditions.push_back("noun_id IN (SELECT class_id FROM instantiation)");
+    }
+    
+    if (!_class_of.empty())
+    {
+      std::list<std::string> clauses(_class_of.size(), "instance_id = @INSID");
+      std::string cond = "noun_id IN (SELECT class_id FROM instantiation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_class_of.empty())
+    {
+      std::list<std::string> clauses(_not_class_of.size(), "instance_id = @NINSID");
+      std::string cond = "noun_id NOT IN (SELECT class_id FROM instantiation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_has_synonyms)
+    {
+      conditions.push_back("noun_id IN (SELECT adjective_2_id FROM adjective_synonymy)");
+    }
+    
+    if (!_synonym_of.empty())
+    {
+      std::list<std::string> clauses(_synonym_of.size(), "adjective_1_id = @SYNID");
+      std::string cond = "noun_id IN (SELECT adjective_2_id FROM adjective_synonymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_synonym_of.empty())
+    {
+      std::list<std::string> clauses(_not_synonym_of.size(), "adjective_1_id = @NSYNID");
+      std::string cond = "noun_id NOT IN (SELECT adjective_2_id FROM adjective_synonymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_has_antonyms)
+    {
+      conditions.push_back("noun_id IN (SELECT adjective_2_id FROM adjective_antonymy)");
+    }
+    
+    if (!_antonym_of.empty())
+    {
+      std::list<std::string> clauses(_antonym_of.size(), "adjective_1_id = @ANTID");
+      std::string cond = "noun_id IN (SELECT adjective_2_id FROM adjective_antonymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_antonym_of.empty())
+    {
+      std::list<std::string> clauses(_not_antonym_of.size(), "adjective_1_id = @NANTID");
+      std::string cond = "noun_id NOT IN (SELECT adjective_2_id FROM adjective_antonymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_has_pertainym)
+    {
+      conditions.push_back("noun_id IN (SELECT noun_id FROM pertainymy)");
+    }
+    
+    if (!_anti_pertainym_of.empty())
+    {
+      std::list<std::string> clauses(_anti_pertainym_of.size(), "pertainym_id = @PERID");
+      std::string cond = "noun_id IN (SELECT noun_id FROM pertainymy WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (_is_attribute)
+    {
+      conditions.push_back("noun_id IN (SELECT noun_id FROM variation)");
+    }
+    
+    if (!_attribute_of.empty())
+    {
+      std::list<std::string> clauses(_attribute_of.size(), "adjective_id = @VALID");
+      std::string cond = "noun_id IN (SELECT noun_id FROM variation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!conditions.empty())
+    {
+      construct << " WHERE ";
+      construct << verbly::implode(std::begin(conditions), std::end(conditions), " AND ");
+    }
+
+    if (_random)
+    {
+      construct << " ORDER BY RANDOM()";
+    }
+
+    if (_limit != unlimited)
+    {
+      construct << " LIMIT " << _limit;
+    }
+    
+    sqlite3_stmt* ppstmt;
+    std::string query = construct.str();
+    if (sqlite3_prepare_v2(_data.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+    {
+      throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
+    }
+    
+    if (!_rhymes.empty())
+    {
+      int i = 0;
+      for (auto rhyme : _rhymes)
+      {
+        std::string rhymer = "%" + rhyme;
+        sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@RHMPRN"), rhymer.c_str(), rhymer.length(), SQLITE_STATIC);
+        
+        i++;
+      }
+    }
+    
+    for (auto except : _except)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@EXCID"), except._id);
+    }
+    
+    for (auto hyponym : _hypernym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@HYPO"), hyponym._id);
+    }
+    
+    for (auto hyponym : _not_hypernym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NHYPO"), hyponym._id);
+    }
+    
+    for (auto hypernym : _hyponym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@HYPER"), hypernym._id);
+    }
+    
+    for (auto hypernym : _not_hyponym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NHYPER"), hypernym._id);
+    }
+    
+    for (auto holonym : _part_meronym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@PHOLO"), holonym._id);
+    }
+    
+    for (auto holonym : _not_part_meronym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NPHOLO"), holonym._id);
+    }
+    
+    for (auto meronym : _part_holonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@PMERO"), meronym._id);
+    }
+    
+    for (auto meronym : _not_part_holonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NPMERO"), meronym._id);
+    }
+    
+    for (auto holonym : _substance_meronym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SHOLO"), holonym._id);
+    }
+    
+    for (auto holonym : _not_substance_meronym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NSHOLO"), holonym._id);
+    }
+    
+    for (auto meronym : _substance_holonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SMERO"), meronym._id);
+    }
+    
+    for (auto meronym : _not_substance_holonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NSMERO"), meronym._id);
+    }
+    
+    for (auto holonym : _member_meronym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@MHOLO"), holonym._id);
+    }
+    
+    for (auto holonym : _not_member_meronym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NMHOLO"), holonym._id);
+    }
+    
+    for (auto meronym : _member_holonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@MMERO"), meronym._id);
+    }
+    
+    for (auto meronym : _not_member_holonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NMMERO"), meronym._id);
+    }
+    
+    for (auto cls : _instance_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@CLSID"), cls._id);
+    }
+    
+    for (auto cls : _not_instance_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NCLSID"), cls._id);
+    }
+    
+    for (auto inst : _class_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@INSID"), inst._id);
+    }
+    
+    for (auto inst : _not_class_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NINSID"), inst._id);
+    }
+    
+    for (auto synonym : _synonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SYNID"), synonym._id);
+    }
+    
+    for (auto synonym : _not_synonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NSYNID"), synonym._id);
+    }
+    
+    for (auto antonym : _antonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@ANTID"), antonym._id);
+    }
+    
+    for (auto antonym : _not_antonym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NANTID"), antonym._id);
+    }
+    
+    for (auto pertainym : _anti_pertainym_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@PERID"), pertainym._id);
+    }
+    
+    for (auto value : _attribute_of)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@VALID"), value._id);
+    }
+
+    std::list<noun> output;
+    while (sqlite3_step(ppstmt) == SQLITE_ROW)
+    {
+      noun tnc {_data, sqlite3_column_int(ppstmt, 0)};
+      tnc._singular = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
+      
+      if (sqlite3_column_type(ppstmt, 2) != SQLITE_NULL)
+      {
+        tnc._plural = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 2)));
+      }
+  
+      output.push_back(tnc);
+    }
+
+    sqlite3_finalize(ppstmt);
+    
+    for (auto& noun : output)
+    {
+      query = "SELECT pronunciation FROM noun_pronunciations WHERE noun_id = ?";
+      if (sqlite3_prepare_v2(_data.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+      {
+        throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
+      }
+      
+      sqlite3_bind_int(ppstmt, 1, noun._id);
+      
+      while (sqlite3_step(ppstmt) == SQLITE_ROW)
+      {
+        std::string pronunciation(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 0)));
+        auto phonemes = verbly::split<std::list<std::string>>(pronunciation, " ");
+        
+        noun.pronunciations.push_back(phonemes);
+      }
+      
+      sqlite3_finalize(ppstmt);
+    }
+
+    return output;
+  }
+
+};
@@ -0,0 +1,171 @@
+#ifndef NOUN_H_24A03C83
+#define NOUN_H_24A03C83
+
+namespace verbly {
+  
+  class noun : public word {
+    private:
+      std::string _singular;
+      std::string _plural;
+      
+      friend class noun_query;
+      
+    public:
+      noun(const data& _data, int _id);
+      
+      std::string base_form() const;
+      std::string singular_form() const;
+      std::string plural_form() const;
+      
+      bool has_plural_form() const;
+      
+      noun_query hypernyms() const;
+      noun_query hyponyms() const;
+      noun_query part_meronyms() const;
+      noun_query part_holonyms() const;
+      noun_query substance_meronyms() const;
+      noun_query substance_holonyms() const;
+      noun_query member_meronyms() const;
+      noun_query member_holonyms() const;
+      noun_query classes() const;
+      noun_query instances() const;
+      noun_query synonyms() const;
+      noun_query antonyms() const;
+      adjective_query pertainyms() const;
+      adjective_query variations() const;
+  };
+  
+  class noun_query {
+    public:
+      noun_query(const data& _data);
+      
+      noun_query& limit(int _limit);
+      noun_query& random(bool _random);
+      noun_query& except(const noun& _word);
+      noun_query& rhymes_with(const word& _word);
+      noun_query& has_pronunciation(bool _has_prn);
+      
+      noun_query& is_hypernym(bool _arg);
+      noun_query& hypernym_of(const noun& _noun);
+      noun_query& not_hypernym_of(const noun& _noun);
+      
+      noun_query& is_hyponym(bool _arg);
+      noun_query& hyponym_of(const noun& _noun);
+      noun_query& not_hyponym_of(const noun& _noun);
+      
+      noun_query& is_part_meronym(bool _arg);
+      noun_query& part_meronym_of(const noun& _noun);
+      noun_query& not_part_meronym_of(const noun& _noun);
+      
+      noun_query& is_part_holonym(bool _arg);
+      noun_query& part_holonym_of(const noun& _noun);
+      noun_query& not_part_holonym_of(const noun& _noun);
+      
+      noun_query& is_substance_meronym(bool _arg);
+      noun_query& substance_meronym_of(const noun& _noun);
+      noun_query& not_substance_meronym_of(const noun& _noun);
+      
+      noun_query& is_substance_holonym(bool _arg);
+      noun_query& substance_holonym_of(const noun& _noun);
+      noun_query& not_substance_holonym_of(const noun& _noun);
+      
+      noun_query& is_member_meronym(bool _arg);
+      noun_query& member_meronym_of(const noun& _noun);
+      noun_query& not_member_meronym_of(const noun& _noun);
+      
+      noun_query& is_member_holonym(bool _arg);
+      noun_query& member_holonym_of(const noun& _noun);
+      noun_query& not_member_holonym_of(const noun& _noun);
+      
+      noun_query& is_proper(bool _arg);
+      noun_query& instance_of(const noun& _noun);
+      noun_query& not_instance_of(const noun& _noun);
+      
+      noun_query& is_class(bool _arg);
+      noun_query& class_of(const noun& _noun);
+      noun_query& not_class_of(const noun& _noun);
+      
+      noun_query& has_synonyms(bool _arg);
+      noun_query& synonym_of(const noun& _noun);
+      noun_query& not_synonym_of(const noun& _noun);
+      
+      noun_query& has_antonyms(bool _arg);
+      noun_query& antonym_of(const noun& _noun);
+      noun_query& not_antonym_of(const noun& _noun);
+      
+      noun_query& has_pertainym(bool _arg);
+      noun_query& anti_pertainym_of(const adjective& _adj);
+      
+      noun_query& is_attribute(bool _arg);
+      noun_query& attribute_of(const adjective& _adj);
+      
+      std::list<noun> run() const;
+      
+      const static int unlimited = -1;
+      
+    private:
+      const data& _data;
+      int _limit = unlimited;
+      bool _random = false;
+      std::list<std::string> _rhymes;
+      std::list<noun> _except;
+      bool _has_prn = false;
+      
+      bool _is_hypernym = false;
+      std::list<noun> _hypernym_of;
+      std::list<noun> _not_hypernym_of;
+      
+      bool _is_hyponym = false;
+      std::list<noun> _hyponym_of;
+      std::list<noun> _not_hyponym_of;
+      
+      bool _is_part_meronym = false;
+      std::list<noun> _part_meronym_of;
+      std::list<noun> _not_part_meronym_of;
+      
+      bool _is_substance_meronym = false;
+      std::list<noun> _substance_meronym_of;
+      std::list<noun> _not_substance_meronym_of;
+      
+      bool _is_member_meronym = false;
+      std::list<noun> _member_meronym_of;
+      std::list<noun> _not_member_meronym_of;
+      
+      bool _is_part_holonym = false;
+      std::list<noun> _part_holonym_of;
+      std::list<noun> _not_part_holonym_of;
+      
+      bool _is_substance_holonym = false;
+      std::list<noun> _substance_holonym_of;
+      std::list<noun> _not_substance_holonym_of;
+      
+      bool _is_member_holonym = false;
+      std::list<noun> _member_holonym_of;
+      std::list<noun> _not_member_holonym_of;
+      
+      bool _is_proper = false;
+      std::list<noun> _instance_of;
+      std::list<noun> _not_instance_of;
+      
+      bool _is_class = false;
+      std::list<noun> _class_of;
+      std::list<noun> _not_class_of;
+      
+      bool _has_synonyms = false;
+      std::list<noun> _synonym_of;
+      std::list<noun> _not_synonym_of;
+      
+      bool _has_antonyms = false;
+      std::list<noun> _antonym_of;
+      std::list<noun> _not_antonym_of;
+      
+      bool _has_pertainym = false;
+      std::list<adjective> _anti_pertainym_of;
+      
+      bool _is_attribute = false;
+      std::list<adjective> _attribute_of;
+  };
+  
+};
+
+#endif /* end of include guard: NOUN_H_24A03C83 */
@@ -0,0 +1,53 @@
+#include "verbly.h"
+
+namespace verbly {
+  
+  token::token(token::type _type) : _type(_type)
+  {
+    
+  }
+  
+  token::type token::token_type() const
+  {
+    return _type;
+  }
+  
+  verb_token::verb_token(const class verb& _verb) : token(token::type::verb), _verb(&_verb)
+  {
+    
+  }
+  
+  const class verb& verb_token::verb() const
+  {
+    return *_verb;
+  }
+  
+  verb_token& verb_token::inflect(verb_token::inflection infl)
+  {
+    _inflection = infl;
+    return *this;
+  }
+  
+  bool verb_token::complete() const
+  {
+    return true;
+  }
+  
+  std::string verb_token::compile() const
+  {
+    switch (_inflection)
+    {
+      case inflection::infinitive: return _verb->infinitive_form();
+      case inflection::past_tense: return _verb->past_tense_form();
+      case inflection::past_participle: return _verb->past_participle_form();
+      case inflection::ing_form: return _verb->ing_form();
+      case inflection::s_form: return _verb->s_form();
+    }
+  }
+  
+  token* verb_token::copy() const
+  {
+    return new verb_token(*this);
+  }
+  
+};
@@ -4,16 +4,10 @@
 #include <string>
 #include <list>
 #include <sstream>
-#include "verb.h"
 
 namespace verbly {
   
-  enum class type {
-    verb,
-    fillin,
-    string,
-    utterance
-  };
+  class verb;
   
   class selrestr {
   };
@@ -29,20 +23,22 @@ namespace verbly {
   };
   
   class token {
+    public:
+      enum class type {
+        verb,
+        fillin,
+        string,
+        utterance
+      };
+      
     protected:
       // General
-      type type;
+      type _type;
       
-      token(enum type type) : type(type)
-      {
-        
-      }
+      token(type _type);
       
     public:
-      enum type token_type() const
-      {
-        return type;
-      }
+      enum type token_type() const;
       
       virtual bool complete() const = 0;
       virtual std::string compile() const = 0;
@@ -50,42 +46,32 @@ namespace verbly {
   };
   
   class verb_token : public token {
+    public:
+      enum class inflection {
+        infinitive,
+        past_tense,
+        past_participle,
+        ing_form,
+        s_form
+      };
+      
     private:
       // Verb
-      const verb* m_verb;
-      conjugation verb_infl = conjugation::infinitive;
+      const verb* _verb;
+      inflection _inflection = inflection::infinitive;
     
     public:
-      verb_token(const class verb& verb) : token(type::verb), m_verb(&verb)
-      {
-
-      }
+      verb_token(const class verb& _verb);
       
-      const class verb& verb() const
-      {
-        return *m_verb;
-      }
+      const class verb& verb() const;
       
-      verb_token& conjugate(conjugation infl)
-      {
-        verb_infl = infl;
-        return *this;
-      }
+      verb_token& inflect(inflection infl);
       
-      bool complete() const
-      {
-        return true;
-      }
+      bool complete() const;
       
-      std::string compile() const
-      {
-        return m_verb->conjugate(verb_infl);
-      }
+      std::string compile() const;
       
-      token* copy() const
-      {
-        return new verb_token(*this);
-      }
+      token* copy() const;
   };
   
   class utterance_token : public token {
@@ -140,7 +126,7 @@ namespace verbly {
           }
       };*/
       
-      utterance_token(std::initializer_list<token*> tkns) : token(type::utterance)
+      utterance_token(std::initializer_list<token*> tkns) : token(token::type::utterance)
       {
         for (auto tkn : tkns)
         {
@@ -148,7 +134,7 @@ namespace verbly {
         }
       }
       
-      utterance_token(const utterance_token& other) : token(type::utterance)
+      utterance_token(const utterance_token& other) : token(token::type::utterance)
       {
         for (auto& tkn : other.utterance)
         {
@@ -156,7 +142,7 @@ namespace verbly {
         }
       }
       
-      utterance_token(utterance_token&& other) : token(type::utterance), utterance(std::move(other.utterance))
+      utterance_token(utterance_token&& other) : token(token::type::utterance), utterance(std::move(other.utterance))
       {
         
       }
@@ -237,7 +223,7 @@ namespace verbly {
       fillin_type m_fillin_type;
       
     public:
-      fillin_token(fillin_type ft) : token(type::fillin), m_fillin_type(ft)
+      fillin_token(fillin_type ft) : token(token::type::fillin), m_fillin_type(ft)
       {
 
       }
@@ -301,7 +287,7 @@ namespace verbly {
       std::string str;
       
     public:
-      string_token(std::string str) : token(type::string), str(str)
+      string_token(std::string str) : token(token::type::string), str(str)
       {
         
       }
@@ -0,0 +1,53 @@
+#ifndef UTIL_H_15DDCA2D
+#define UTIL_H_15DDCA2D
+
+#include <string>
+#include <iterator>
+#include <sstream>
+
+namespace verbly {
+  
+  template <class InputIterator>
+  std::string implode(InputIterator first, InputIterator last, std::string delimiter)
+  {
+    std::stringstream result;
+    
+    for (InputIterator it = first; it != last; it++)
+    {
+      if (it != first)
+      {
+        result << delimiter;
+      }
+      
+      result << *it;
+    }
+    
+    return result.str();
+  }
+  
+  template <class Container>
+  Container split(std::string input, std::string delimiter)
+  {
+    Container result;
+    
+    while (!input.empty())
+    {
+      int divider = input.find(" ");
+      if (divider == std::string::npos)
+      {
+        result.push_back(input);
+        
+        input = "";
+      } else {
+        result.push_back(input.substr(0, divider));
+        
+        input = input.substr(divider+1);
+      }
+    }
+    
+    return result;
+  }
+  
+};
+
+#endif /* end of include guard: UTIL_H_15DDCA2D */
@@ -0,0 +1,193 @@
+#include "verbly.h"
+
+namespace verbly {
+  
+  verb::verb(const data& _data, int _id) : word(_data, _id)
+  {
+    
+  }
+  
+  std::string verb::base_form() const
+  {
+    return _infinitive;
+  }
+  
+  std::string verb::infinitive_form() const
+  {
+    return _infinitive;
+  }
+  
+  std::string verb::past_tense_form() const
+  {
+    return _past_tense;
+  }
+  
+  std::string verb::past_participle_form() const
+  {
+    return _past_participle;
+  }
+  
+  std::string verb::ing_form() const
+  {
+    return _ing_form;
+  }
+  
+  std::string verb::s_form() const
+  {
+    return _s_form;
+  }
+  
+  verb_query::verb_query(const data& _data) : _data(_data)
+  {
+
+  }
+  
+  verb_query& verb_query::limit(int _limit)
+  {
+    if ((_limit > 0) || (_limit == unlimited))
+    {
+      this->_limit = _limit;
+    }
+  
+    return *this;
+  }
+
+  verb_query& verb_query::random(bool _random)
+  {
+    this->_random = _random;
+  
+    return *this;
+  }
+  
+  verb_query& verb_query::except(const verb& _word)
+  {
+    _except.push_back(_word);
+    
+    return *this;
+  }
+  
+  verb_query& verb_query::rhymes_with(const word& _word)
+  {
+    for (auto rhyme : _word.rhyme_phonemes())
+    {
+      _rhymes.push_back(rhyme);
+    }
+    
+    if (dynamic_cast<const verb*>(&_word) != nullptr)
+    {
+      _except.push_back(dynamic_cast<const verb&>(_word));
+    }
+    
+    return *this;
+  }
+  
+  verb_query& verb_query::has_pronunciation(bool _has_prn)
+  {
+    this->_has_prn = _has_prn;
+    
+    return *this;
+  }
+  
+  std::list<verb> verb_query::run() const
+  {
+    std::stringstream construct;
+    construct << "SELECT verb_id, infinitive, past_tense, past_participle, ing_form, s_form FROM verbs";
+    std::list<std::string> conditions;
+    
+    if (_has_prn)
+    {
+      conditions.push_back("verb_id IN (SELECT verb_id FROM verb_pronunciations)");
+    }
+    
+    if (!_rhymes.empty())
+    {
+      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE @RHMPRN");
+      std::string cond = "verb_id IN (SELECT verb_id FROM verb_pronunciations WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    for (auto except : _except)
+    {
+      conditions.push_back("verb_id != @EXCID");
+    }
+    
+    if (!conditions.empty())
+    {
+      construct << " WHERE ";
+      construct << verbly::implode(std::begin(conditions), std::end(conditions), " AND ");
+    }
+    
+    if (_random)
+    {
+      construct << " ORDER BY RANDOM()";
+    }
+    
+    if (_limit != unlimited)
+    {
+      construct << " LIMIT " << _limit;
+    }
+    
+    sqlite3_stmt* ppstmt;
+    std::string query = construct.str();
+    if (sqlite3_prepare_v2(_data.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+    {
+      throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
+    }
+    
+    if (!_rhymes.empty())
+    {
+      int i = 0;
+      for (auto rhyme : _rhymes)
+      {
+        std::string rhymer = "%" + rhyme;
+        sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@RHMPRN"), rhymer.c_str(), rhymer.length(), SQLITE_STATIC);
+        
+        i++;
+      }
+    }
+    
+    for (auto except : _except)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@EXCID"), except._id);
+    }
+    
+    std::list<verb> output;
+    while (sqlite3_step(ppstmt) == SQLITE_ROW)
+    {
+      verb tnc {_data, sqlite3_column_int(ppstmt, 0)};
+      tnc._infinitive = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
+      tnc._past_tense = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 2)));
+      tnc._past_participle = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 3)));
+      tnc._ing_form = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 4)));
+      tnc._s_form = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 5)));
+      
+      output.push_back(tnc);
+    }
+    
+    sqlite3_finalize(ppstmt);
+    
+    for (auto& verb : output)
+    {
+      query = "SELECT pronunciation FROM verb_pronunciations WHERE verb_id = ?";
+      if (sqlite3_prepare_v2(_data.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+      {
+        throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
+      }
+      
+      sqlite3_bind_int(ppstmt, 1, verb._id);
+      
+      while (sqlite3_step(ppstmt) == SQLITE_ROW)
+      {
+        std::string pronunciation(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 0)));
+        auto phonemes = verbly::split<std::list<std::string>>(pronunciation, " ");
+        
+        verb.pronunciations.push_back(phonemes);
+      }
+      
+      sqlite3_finalize(ppstmt);
+    }
+    
+    return output;
+  }
+  
+};
@@ -1,8 +1,6 @@
 #ifndef VERB_H_BCC929AD
 #define VERB_H_BCC929AD
 
-#include <vector>
-
 namespace verbly {
   
   /*class frame_part {
@@ -26,42 +24,50 @@ namespace verbly {
       }
   };*/
   
-  enum class conjugation {
-    present_participle,
-    past_participle,
-    infinitive
-  };
-  
-  class verb {
+  class verb : public word {
     private:
-      int id;
+      std::string _infinitive;
+      std::string _past_tense;
+      std::string _past_participle;
+      std::string _ing_form;
+      std::string _s_form;
+      
+      friend class verb_query;
       
     public:
-      verb(int id) : id(id)
-      {
-        
-      }
+      verb(const data& _data, int _id);
       
-      std::string infinitive;
-      std::string past_tense;
-      std::string past_participle;
-      std::string ing_form;
-      std::string s_form;
-      //std::vector<frame> frames;
+      std::string base_form() const;
+      std::string infinitive_form() const;
+      std::string past_tense_form() const;
+      std::string past_participle_form() const;
+      std::string ing_form() const;
+      std::string s_form() const;
+  };
+  
+  class verb_query {
+    public:
+      verb_query(const data& _data);
       
-      std::string conjugate(conjugation infl) const
-      {
-        switch (infl)
-        {
-          case conjugation::infinitive: return infinitive;
-          case conjugation::past_participle: return past_participle;
-          case conjugation::present_participle: return ing_form;
-        }
-      }
+      verb_query& limit(int _limit);
+      verb_query& random(bool _random);
+      verb_query& except(const verb& _word);
+      verb_query& rhymes_with(const word& _word);
+      verb_query& has_pronunciation(bool _has_prn);
+      
+      std::list<verb> run() const;
+      
+      const static int unlimited = -1;
+      
+    private:
+      const data& _data;
+      int _limit = unlimited;
+      bool _random = false;
+      std::list<std::string> _rhymes;
+      std::list<verb> _except;
+      bool _has_prn = false;
   };
   
 };
 
-#include "token.h"
-
 #endif /* end of include guard: VERB_H_BCC929AD */
@@ -2,10 +2,13 @@
 #define VERBLY_H_5B39CE50
 
 #include "c++14.h"
+#include "util.h"
 #include "token.h"
+#include "data.h"
+#include "word.h"
 #include "verb.h"
-#include "adjective.h"
 #include "adverb.h"
-#include "data.h"
+#include "adjective.h"
+#include "noun.h"
 
 #endif /* end of include guard: VERBLY_H_5B39CE50 */
@@ -0,0 +1,32 @@
+#include "verbly.h"
+
+namespace verbly {
+  
+  word::word(const data& _data, int _id) : _data(_data), _id(_id)
+  {
+    
+  }
+  
+  std::list<std::string> word::rhyme_phonemes() const
+  {
+    std::list<std::string> result;
+    
+    for (auto pronunciation : pronunciations)
+    {
+      auto phemstrt = std::find_if(std::begin(pronunciation), std::end(pronunciation), [] (std::string phoneme) {
+        return phoneme.find("1") != std::string::npos;
+      });
+      
+      std::stringstream rhymer;
+      for (auto it = phemstrt; it != std::end(pronunciation); it++)
+      {
+        rhymer << " " << *it;
+      }
+      
+      result.push_back(rhymer.str());
+    }
+    
+    return result;
+  }
+  
+};
@@ -0,0 +1,35 @@
+#ifndef WORD_H_8FC89498
+#define WORD_H_8FC89498
+
+namespace verbly {
+  
+  class adjective_query;
+  class verb_query;
+  class adverb_query;
+  
+  template <class T>
+  class query;
+  
+  class word {
+    protected:
+      const data& _data;
+      int _id;
+      
+      std::list<std::list<std::string>> pronunciations;
+      
+      word(const data& _data, int _id);
+      
+      friend class adjective_query;
+      friend class verb_query;
+      friend class noun_query;
+      friend class adverb_query;
+    
+    public:
+      virtual std::string base_form() const = 0;
+      
+      std::list<std::string> rhyme_phonemes() const;
+  };
+  
+};
+
+#endif /* end of include guard: WORD_H_8FC89498 */