Started structural rewrite

The new object structure was designed to build on the existing WordNet
structure, while also adding in all of the data that we get from other sources.
More information about this can be found on the project wiki.

The generator has already been completely rewritten to generate a
datafile that uses the new structure. In addition, a number of indexes
are created, which does double the size of the datafile, but also allows
for much faster lookups. Finally, the new generator is written modularly
and is a lot more readable than the old one.

The verbly interface to the new object structure has mostly been
completed, but has not been tested fully. There is a completely new
search API which utilizes a lot of operator overloading; documentation
on how to use it should go up at some point.

Token processing and verb frames are currently unimplemented. Source for
these have been left in the repository for now.

78 files changed, 8971 insertions, 8696 deletions

@@ -4,8 +4,10 @@ project (verbly)
 find_package(PkgConfig)
 pkg_check_modules(sqlite3 sqlite3>=3.8.3 REQUIRED)
 
+set(CMAKE_BUILD_TYPE Debug)
+
 include_directories(vendor/json)
-add_library(verbly lib/data.cpp lib/adjective.cpp lib/noun.cpp lib/verb.cpp lib/adverb.cpp lib/token.cpp lib/word.cpp lib/frame.cpp lib/preposition.cpp lib/adjective_query.cpp lib/adverb_query.cpp lib/noun_query.cpp lib/verb_query.cpp lib/frame_query.cpp)
+add_library(verbly lib/filter.cpp lib/field.cpp lib/notion.cpp lib/word.cpp lib/group.cpp lib/frame.cpp lib/lemma.cpp lib/form.cpp lib/pronunciation.cpp lib/statement.cpp lib/binding.cpp lib/database.cpp)
 set_property(TARGET verbly PROPERTY CXX_STANDARD 11)
 set_property(TARGET verbly PROPERTY CXX_STANDARD_REQUIRED ON)
 target_link_libraries(verbly ${sqlite3_LIBRARIES})
@@ -1,12 +1,12 @@
-cmake_minimum_required (VERSION 2.6)
+cmake_minimum_required (VERSION 3.1)
 project (generator)
 
 find_package(PkgConfig)
 pkg_check_modules(sqlite3 sqlite3 REQUIRED)
 find_package(libxml2 REQUIRED)
 
-include_directories(${sqlite3_INCLUDE_DIR} ${LIBXML2_INCLUDE_DIR} ../vendor/json/src)
-add_executable(generator generator.cpp)
+include_directories(${sqlite3_INCLUDE_DIR} ${LIBXML2_INCLUDE_DIR} ../vendor/json)
+add_executable(generator notion.cpp word.cpp lemma.cpp form.cpp pronunciation.cpp group.cpp frame.cpp part.cpp selrestr.cpp database.cpp field.cpp generator.cpp main.cpp)
 set_property(TARGET generator PROPERTY CXX_STANDARD 11)
 set_property(TARGET generator PROPERTY CXX_STANDARD_REQUIRED ON)
 target_link_libraries(generator ${sqlite3_LIBRARIES} ${LIBXML2_LIBRARIES})
@@ -0,0 +1,173 @@
+#include "database.h"
+#include <sqlite3.h>
+#include <cassert>
+#include <fstream>
+#include <stdexcept>
+#include <cstdio>
+#include <sstream>
+#include "field.h"
+#include "../lib/util.h"
+
+namespace verbly {
+  namespace generator {
+
+    sqlite3_error::sqlite3_error(
+      const std::string& what,
+      const std::string& db_err) :
+        what_(what + " (" + db_err + ")"),
+        db_err_(db_err)
+    {
+    }
+
+    const char* sqlite3_error::what() const noexcept
+    {
+      return what_.c_str();
+    }
+
+    const char* sqlite3_error::db_err() const noexcept
+    {
+      return db_err_.c_str();
+    }
+
+    database::database(std::string path)
+    {
+      // If there is already a file at this path, overwrite it.
+      if (std::ifstream(path))
+      {
+        if (std::remove(path.c_str()))
+        {
+          throw std::logic_error("Could not overwrite file at path");
+        }
+      }
+
+      if (sqlite3_open_v2(path.c_str(), &ppdb_, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL) != SQLITE_OK)
+      {
+        // We still have to free the resources allocated. In the event that
+        // allocation failed, ppdb will be null and sqlite3_close_v2 will just
+        // ignore it.
+        std::string errmsg(sqlite3_errmsg(ppdb_));
+        sqlite3_close_v2(ppdb_);
+
+        throw sqlite3_error("Could not create output datafile", errmsg);
+      }
+    }
+
+    database::database(database&& other) : database()
+    {
+      swap(*this, other);
+    }
+
+    database& database::operator=(database&& other)
+    {
+      swap(*this, other);
+
+      return *this;
+    }
+
+    void swap(database& first, database& second)
+    {
+      std::swap(first.ppdb_, second.ppdb_);
+    }
+
+    database::~database()
+    {
+      sqlite3_close_v2(ppdb_);
+    }
+    
+    void database::runQuery(std::string query)
+    {
+      // This can only happen when doing bad things with move semantics.
+      assert(ppdb_ != nullptr);
+      
+      sqlite3_stmt* ppstmt;
+
+      if (sqlite3_prepare_v2(ppdb_, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+      {
+        throw sqlite3_error("Error writing to database", sqlite3_errmsg(ppdb_));
+      }
+      
+      int result = sqlite3_step(ppstmt);
+      sqlite3_finalize(ppstmt);
+
+      if (result != SQLITE_DONE)
+      {
+        throw sqlite3_error("Error writing to database", sqlite3_errmsg(ppdb_));
+      }
+    }
+
+    void database::insertIntoTable(std::string table, std::list<field> fields)
+    {
+      // This can only happen when doing bad things with move semantics.
+      assert(ppdb_ != nullptr);
+      
+      // This shouldn't happen.
+      assert(!fields.empty());
+      
+      std::list<std::string> fieldNames;
+      std::list<std::string> qs;
+      for (field& f : fields)
+      {
+        fieldNames.push_back(f.getName());
+        qs.push_back("?");
+      }
+      
+      std::ostringstream query;
+      query << "INSERT INTO ";
+      query << table;
+      query << " (";
+      query << implode(std::begin(fieldNames), std::end(fieldNames), ", ");
+      query << ") VALUES (";
+      query << implode(std::begin(qs), std::end(qs), ", ");
+      query << ")";
+      
+      std::string query_str = query.str();
+
+      sqlite3_stmt* ppstmt;
+
+      if (sqlite3_prepare_v2(ppdb_, query_str.c_str(), query_str.length(), &ppstmt, NULL) != SQLITE_OK)
+      {
+        throw sqlite3_error("Error writing to database", sqlite3_errmsg(ppdb_));
+      }
+
+      int i = 1;
+      for (field& f : fields)
+      {
+        switch (f.getType())
+        {
+          case field::type::integer:
+          {
+            sqlite3_bind_int(ppstmt, i, f.getInteger());
+
+            break;
+          }
+
+          case field::type::string:
+          {
+            sqlite3_bind_text(ppstmt, i, f.getString().c_str(), f.getString().length(), SQLITE_TRANSIENT);
+
+            break;
+          }
+
+          case field::type::invalid:
+          {
+            // Fields can only be invalid when doing bad things with move semantics.
+            assert(false);
+
+            break;
+          }
+        }
+
+        i++;
+      }
+
+      int result = sqlite3_step(ppstmt);
+      sqlite3_finalize(ppstmt);
+
+      if (result != SQLITE_DONE)
+      {
+        throw sqlite3_error("Error writing to database", sqlite3_errmsg(ppdb_));
+      }
+    }
+
+  };
+};
@@ -0,0 +1,73 @@
+#ifndef DATABASE_H_0B0A47D2
+#define DATABASE_H_0B0A47D2
+
+#include <string>
+#include <exception>
+#include <list>
+
+struct sqlite3;
+
+namespace verbly {
+  namespace generator {
+
+    class field;
+
+    class sqlite3_error : public std::exception {
+    public:
+
+      sqlite3_error(const std::string& what, const std::string& db_err);
+
+      const char* what() const noexcept override;
+      const char* db_err() const noexcept;
+
+    private:
+      std::string what_;
+      std::string db_err_;
+
+    };
+
+    class database {
+    public:
+
+      // Constructor
+
+      explicit database(std::string path);
+
+      // Disable copying
+
+      database(const database& other) = delete;
+      database& operator=(const database& other) = delete;
+
+      // Move constructor and move assignment
+
+      database(database&& other);
+      database& operator=(database&& other);
+
+      // Swap
+
+      friend void swap(database& first, database& second);
+
+      // Destructor
+
+      ~database();
+
+      // Actions
+      
+      void runQuery(std::string query);
+
+      void insertIntoTable(std::string table, std::list<field> fields);
+
+    private:
+
+      database()
+      {
+      }
+
+      sqlite3* ppdb_ = nullptr;
+
+    };
+
+  };
+};
+
+#endif /* end of include guard: DATABASE_H_0B0A47D2 */
@@ -0,0 +1,193 @@
+#include "field.h"
+#include <stdexcept>
+#include <utility>
+
+namespace verbly {
+  namespace generator {
+
+    field::field(const field& other)
+    {
+      type_ = other.type_;
+      name_ = other.name_;
+
+      switch (type_)
+      {
+        case type::integer:
+        {
+          integer_ = other.integer_;
+
+          break;
+        }
+
+        case type::string:
+        {
+          new(&string_) std::string(other.string_);
+
+          break;
+        }
+
+        case type::invalid:
+        {
+          break;
+        }
+      }
+    }
+
+    field::field(field&& other) : field()
+    {
+      swap(*this, other);
+    }
+
+    field& field::operator=(field other)
+    {
+      swap(*this, other);
+
+      return *this;
+    }
+
+    void swap(field& first, field& second)
+    {
+      using type = field::type;
+
+      type tempType = first.type_;
+      std::string tempName = std::move(first.name_);
+      int tempInteger;
+      std::string tempString;
+
+      switch (first.type_)
+      {
+        case type::integer:
+        {
+          tempInteger = first.integer_;
+
+          break;
+        }
+
+        case type::string:
+        {
+          tempString = std::move(tempString);
+
+          break;
+        }
+
+        case type::invalid:
+        {
+          break;
+        }
+      }
+
+      first.~field();
+
+      first.type_ = second.type_;
+      first.name_ = std::move(second.name_);
+
+      switch (second.type_)
+      {
+        case type::integer:
+        {
+          first.integer_ = second.integer_;
+
+          break;
+        }
+
+        case type::string:
+        {
+          new(&first.string_) std::string(std::move(second.string_));
+
+          break;
+        }
+
+        case type::invalid:
+        {
+          break;
+        }
+      }
+
+      second.~field();
+
+      second.type_ = tempType;
+      second.name_ = std::move(tempName);
+
+      switch (tempType)
+      {
+        case type::integer:
+        {
+          second.integer_ = tempInteger;
+
+          break;
+        }
+
+        case type::string:
+        {
+          new(&second.string_) std::string(std::move(tempString));
+
+          break;
+        }
+
+        case type::invalid:
+        {
+          break;
+        }
+      }
+    }
+
+    field::~field()
+    {
+      switch (type_)
+      {
+        case type::string:
+        {
+          using string_type = std::string;
+          string_.~string_type();
+
+          break;
+        }
+
+        case type::integer:
+        case type::invalid:
+        {
+          break;
+        }
+      }
+    }
+
+    field::field(
+      std::string name,
+      int arg) :
+        type_(type::integer),
+        name_(name),
+        integer_(arg)
+    {
+    }
+
+    int field::getInteger() const
+    {
+      if (type_ != type::integer)
+      {
+        throw std::domain_error("field::getInteger called on non-integer field");
+      }
+
+      return integer_;
+    }
+
+    field::field(
+      std::string name,
+      std::string arg) :
+        type_(type::string),
+        name_(name)
+    {
+      new(&string_) std::string(arg);
+    }
+
+    std::string field::getString() const
+    {
+      if (type_ != type::string)
+      {
+        throw std::domain_error("field::getString called on non-string field");
+      }
+
+      return string_;
+    }
+
+  };
+};
@@ -0,0 +1,76 @@
+#ifndef BINDING_H_CAE0B18E
+#define BINDING_H_CAE0B18E
+
+#include <string>
+
+namespace verbly {
+  namespace generator {
+
+    class field {
+      public:
+        enum class type {
+          invalid,
+          integer,
+          string
+        };
+
+        // Copy and move constructors
+
+        field(const field& other);
+        field(field&& other);
+
+        // Assignment
+
+        field& operator=(field other);
+
+        // Swap
+
+        friend void swap(field& first, field& second);
+
+        // Destructor
+
+        ~field();
+
+        // Generic accessors
+        
+        type getType() const
+        {
+          return type_;
+        }
+        
+        std::string getName() const
+        {
+          return name_;
+        }
+
+        // Integer
+        
+        field(std::string name, int arg);
+        
+        int getInteger() const;
+
+        // String
+        
+        field(std::string name, std::string arg);
+        
+        std::string getString() const;
+
+      private:
+
+        field()
+        {
+        }
+
+        union {
+          int integer_;
+          std::string string_;
+        };
+
+        type type_ = type::invalid;
+        std::string name_;
+    };
+
+  };
+};
+
+#endif /* end of include guard: BINDING_H_CAE0B18E */
@@ -0,0 +1,53 @@
+#include "form.h"
+#include <algorithm>
+#include <list>
+#include "database.h"
+#include "field.h"
+#include "pronunciation.h"
+
+namespace verbly {
+  namespace generator {
+
+    int form::nextId_ = 0;
+
+    form::form(std::string text) :
+      id_(nextId_++),
+      text_(text),
+      complexity_(std::count(std::begin(text), std::end(text), ' ') + 1),
+      proper_(std::any_of(std::begin(text), std::end(text), std::isupper))
+    {
+    }
+
+    void form::addPronunciation(const pronunciation& p)
+    {
+      pronunciations_.insert(&p);
+    }
+
+    database& operator<<(database& db, const form& arg)
+    {
+      // Serialize the form first.
+      {
+        std::list<field> fields;
+        fields.emplace_back("form_id", arg.getId());
+        fields.emplace_back("form", arg.getText());
+        fields.emplace_back("complexity", arg.getComplexity());
+        fields.emplace_back("proper", arg.isProper());
+
+        db.insertIntoTable("forms", std::move(fields));
+      }
+
+      // Then, serialize the form/pronunciation relationship.
+      for (const pronunciation* p : arg.getPronunciations())
+      {
+        std::list<field> fields;
+        fields.emplace_back("form_id", arg.getId());
+        fields.emplace_back("pronunciation_id", p->getId());
+
+        db.insertIntoTable("forms_pronunciations", std::move(fields));
+      }
+
+      return db;
+    }
+
+  };
+};
@@ -0,0 +1,71 @@
+#ifndef FORM_H_7EFBC970
+#define FORM_H_7EFBC970
+
+#include <string>
+#include <set>
+
+namespace verbly {
+  namespace generator {
+
+    class pronunciation;
+    class database;
+
+    class form {
+    public:
+
+      // Constructor
+
+      explicit form(std::string text);
+
+      // Mutators
+
+      void addPronunciation(const pronunciation& p);
+
+      // Accessors
+
+      int getId() const
+      {
+        return id_;
+      }
+
+      std::string getText() const
+      {
+        return text_;
+      }
+
+      int getComplexity() const
+      {
+        return complexity_;
+      }
+
+      bool isProper() const
+      {
+        return proper_;
+      }
+
+      std::set<const pronunciation*> getPronunciations() const
+      {
+        return pronunciations_;
+      }
+
+    private:
+
+      static int nextId_;
+
+      const int id_;
+      const std::string text_;
+      const int complexity_;
+      const bool proper_;
+
+      std::set<const pronunciation*> pronunciations_;
+
+    };
+
+    // Serializer
+
+    database& operator<<(database& db, const form& arg);
+
+  };
+};
+
+#endif /* end of include guard: FORM_H_7EFBC970 */
@@ -0,0 +1,83 @@
+#include "frame.h"
+#include "database.h"
+#include "field.h"
+
+namespace verbly {
+  namespace generator {
+    
+    int frame::nextId_ = 0;
+    
+    frame::frame() : id_(nextId_++)
+    {
+    }
+    
+    void frame::push_back(part fp)
+    {
+      parts_.push_back(std::move(fp));
+    }
+    
+    database& operator<<(database& db, const frame& arg)
+    {
+      std::list<field> fields;
+      fields.emplace_back("frame_id", arg.getId());
+      
+      nlohmann::json jsonParts;
+      for (const part& p : arg)
+      {
+        nlohmann::json jsonPart;
+        jsonPart["type"] = static_cast<int>(p.getType());
+        
+        switch (p.getType())
+        {
+          case part::type::noun_phrase:
+          {
+            jsonPart["role"] = p.getNounRole();
+            jsonPart["selrestrs"] = p.getNounSelrestrs().toJson();
+            jsonPart["synrestrs"] = p.getNounSynrestrs();
+            
+            break;
+          }
+          
+          case part::type::preposition:
+          {
+            jsonPart["choices"] = p.getPrepositionChoices();
+            jsonPart["literal"] = p.isPrepositionLiteral();
+            
+            break;
+          }
+          
+          case part::type::literal:
+          {
+            jsonPart["value"] = p.getLiteralValue();
+            
+            break;
+          }
+          
+          case part::type::verb:
+          case part::type::adjective:
+          case part::type::adverb:
+          {
+            break;
+          }
+          
+          case part::type::invalid:
+          {
+            // Invalid parts should not be serialized.
+            assert(false);
+            
+            break;
+          }
+        }
+        
+        jsonParts.emplace_back(std::move(jsonPart));
+      }
+
+      fields.emplace_back("data", jsonParts.dump());
+      
+      db.insertIntoTable("frames", std::move(fields));
+      
+      return db;
+    }
+    
+  };
+};
@@ -0,0 +1,59 @@
+#ifndef FRAME_H_26770FF1
+#define FRAME_H_26770FF1
+
+#include <list>
+#include "part.h"
+
+namespace verbly {
+  namespace generator {
+    
+    class database;
+    
+    class frame {
+    public:
+      
+      // Aliases
+      
+      using const_iterator = std::list<part>::const_iterator;
+      
+      // Constructor
+      
+      frame();
+      
+      // Mutators
+      
+      void push_back(part fp);
+      
+      // Accessors
+      
+      int getId() const
+      {
+        return id_;
+      }
+      
+      const_iterator begin() const
+      {
+        return std::begin(parts_);
+      }
+      
+      const_iterator end() const
+      {
+        return std::end(parts_);
+      }
+      
+    private:
+      
+      static int nextId_;
+      
+      const int id_;
+      
+      std::list<part> parts_;
+      
+    };
+    
+    database& operator<<(database& db, const frame& arg);
+    
+  };
+};
+
+#endif /* end of include guard: FRAME_H_26770FF1 */
@@ -1,2320 +1,1477 @@
-#include <libxml/parser.h>
+#include "generator.h"
+#include <cassert>
+#include <stdexcept>
 #include <iostream>
+#include <regex>
 #include <dirent.h>
-#include <set>
-#include <map>
-#include <string>
-#include <vector>
 #include <fstream>
-#include <sqlite3.h>
-#include <sstream>
-#include <regex>
-#include <list>
-#include <algorithm>
-#include <json.hpp>
+#include "enums.h"
 #include "progress.h"
+#include "selrestr.h"
+#include "role.h"
+#include "part.h"
+#include "field.h"
 #include "../lib/util.h"
 
-using json = nlohmann::json;
-
-struct verb_t {
-  std::string infinitive;
-  std::string past_tense;
-  std::string past_participle;
-  std::string ing_form;
-  std::string s_form;
-  int id;
-};
-
-struct adjective_t {
-  std::string base;
-  std::string comparative;
-  std::string superlative;
-};
-
-struct noun_t {
-  std::string singular;
-  std::string plural;
-};
-
-struct selrestr_t {
-  enum class type_t {
-    singleton,
-    andlogic,
-    orlogic,
-    empty
-  };
-  type_t type;
-  std::string restriction;
-  bool pos;
-  std::list<selrestr_t> subordinates;
-};
-
-struct framepart_t {
-  enum class type_t {
-    np,
-    v,
-    pp,
-    adj,
-    adv,
-    lex
-  };
-  type_t type;
-  std::string role;
-  selrestr_t selrestrs;
-  std::set<std::string> preprestrs;
-  std::set<std::string> synrestrs;
-  std::list<std::string> choices;
-  std::string lexval;
-};
-
-struct group_t {
-  std::string id;
-  std::string parent;
-  std::set<std::string> members;
-  std::map<std::string, selrestr_t> roles;
-  std::list<std::list<framepart_t>> frames;
-};
-
-struct pronunciation_t {
-  std::string phonemes;
-  std::string prerhyme;
-  std::string rhyme;
-  int syllables = 0;
-  std::string stress;
-  
-  bool operator<(const pronunciation_t& other) const
-  {
-    return phonemes < other.phonemes;
-  }
-};
-
-std::map<std::string, group_t> groups;
-std::map<std::string, verb_t> verbs;
-std::map<std::string, adjective_t> adjectives;
-std::map<std::string, noun_t> nouns;
-std::map<int, std::map<int, int>> wn;
-std::map<int, int> images;
-std::map<std::string, std::set<pronunciation_t>> pronunciations;
-
-void print_usage()
-{
-  std::cout << "Verbly Datafile Generator" << std::endl;
-  std::cout << "-------------------------" << 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 an AGID infl.txt file." << std::endl;
-  std::cout << "3. The path to a WordNet prolog data directory." << std::endl;
-  std::cout << "4. The path to a CMUDICT pronunciation file." << std::endl;
-  std::cout << "5. The path to an ImageNet urls.txt file." << std::endl;
-  std::cout << "6. Datafile output path." << std::endl;
-  
-  exit(1);
-}
-
-void db_error(sqlite3* ppdb, std::string query)
-{
-  std::cout << "Error writing to output database: " << sqlite3_errmsg(ppdb) << std::endl;
-  std::cout << query << std::endl;
-  sqlite3_close_v2(ppdb);
-  print_usage();
-}
-
-json export_selrestrs(selrestr_t r)
-{
-  if (r.type == selrestr_t::type_t::empty)
-  {
-    return {};
-  } else if (r.type == selrestr_t::type_t::singleton)
-  {
-    json result;
-    result["type"] = r.restriction;
-    result["pos"] = r.pos;
-    return result;
-  } else {
-    json result;
-    if (r.type == selrestr_t::type_t::andlogic)
-    {
-      result["logic"] = "and";
-    } else {
-      result["logic"] = "or";
-    }
-    
-    std::list<json> outlist;
-    std::transform(std::begin(r.subordinates), std::end(r.subordinates), std::back_inserter(outlist), &export_selrestrs);
-    result["children"] = outlist;
+namespace verbly {
+  namespace generator {
     
-    return result;
-  }
-}
-
-selrestr_t parse_selrestrs(xmlNodePtr top, std::string filename)
-{
-  selrestr_t r;
-  xmlChar* key;
-  
-  if (!xmlStrcmp(top->name, (const xmlChar*) "SELRESTRS"))
-  {
-    if (xmlChildElementCount(top) == 0)
+    generator::generator(
+      std::string verbNetPath,
+      std::string agidPath,
+      std::string wordNetPath,
+      std::string cmudictPath,
+      std::string imageNetPath,
+      std::string outputPath) :
+        verbNetPath_(verbNetPath),
+        agidPath_(agidPath),
+        wordNetPath_(wordNetPath),
+        cmudictPath_(cmudictPath),
+        imageNetPath_(imageNetPath),
+        db_(outputPath)
     {
-      r.type = selrestr_t::type_t::empty;
-    } else if (xmlChildElementCount(top) == 1)
-    {
-      r = parse_selrestrs(xmlFirstElementChild(top), filename);
-    } else {
-      r.type = selrestr_t::type_t::andlogic;
-      
-      if (xmlHasProp(top, (const xmlChar*) "logic"))
+      // Ensure VerbNet directory exists
+      DIR* dir;
+      if ((dir = opendir(verbNetPath_.c_str())) == nullptr)
       {
-        key = xmlGetProp(top, (const xmlChar*) "logic");
-        if (!xmlStrcmp(key, (const xmlChar*) "or"))
-        {
-          r.type = selrestr_t::type_t::orlogic;
-        }
-        xmlFree(key);
+        throw std::invalid_argument("Invalid VerbNet data directory");
       }
-  
-      for (xmlNodePtr selrestr = top->xmlChildrenNode; selrestr != nullptr; selrestr = selrestr->next)
+      
+      closedir(dir);
+      
+      // Ensure AGID infl.txt exists
+      if (!std::ifstream(agidPath_))
       {
-        if (!xmlStrcmp(selrestr->name, (const xmlChar*) "SELRESTRS") || !xmlStrcmp(selrestr->name, (const xmlChar*) "SELRESTR"))
-        {
-          r.subordinates.push_back(parse_selrestrs(selrestr, filename));
-        }
+        throw std::invalid_argument("AGID infl.txt file not found");
       }
-    }
-  } else if (!xmlStrcmp(top->name, (const xmlChar*) "SELRESTR"))
-  {
-    r.type = selrestr_t::type_t::singleton;
-    
-    key = xmlGetProp(top, (xmlChar*) "Value");
-    r.pos = (std::string((const char*)key) == "+");
-    xmlFree(key);
-
-    key = xmlGetProp(top, (xmlChar*) "type");
-    r.restriction = (const char*) key;
-    xmlFree(key);
-  } else {
-    // Invalid
-    std::cout << "Bad VerbNet file format: " << filename << std::endl;
-    print_usage();
-  }
-  
-  return r;
-}
-
-group_t& parse_group(xmlNodePtr top, std::string filename)
-{
-  xmlChar* key = xmlGetProp(top, (xmlChar*) "ID");
-  if (key == 0)
-  {
-    std::cout << "Bad VerbNet file format: " << filename << std::endl;
-    print_usage();
-  }
-  std::string vnid = (const char*)key;
-  vnid = vnid.substr(vnid.find_first_of("-")+1);
-  xmlFree(key);
-  
-  group_t g;
-  g.id = vnid;
-  
-  for (xmlNodePtr node = top->xmlChildrenNode; node != nullptr; node = node->next)
-  {
-    if (!xmlStrcmp(node->name, (const xmlChar*) "SUBCLASSES"))
-    {
-      for (xmlNodePtr subclass = node->xmlChildrenNode; subclass != nullptr; subclass = subclass->next)
+      
+      // Add directory separator to WordNet path
+      if ((wordNetPath_.back() != '/') && (wordNetPath_.back() != '\\'))
       {
-        if (!xmlStrcmp(subclass->name, (const xmlChar*) "VNSUBCLASS"))
-        {
-          auto& sg = parse_group(subclass, filename);
-          sg.parent = vnid;
-          
-          for (auto member : sg.members)
-          {
-            g.members.insert(member);
-          }
-          
-          // The schema requires that subclasses appear after role definitions, so we can do this now
-          for (auto role : g.roles)
-          {
-            if (sg.roles.count(role.first) == 0)
-            {
-              sg.roles[role.first] = role.second;
-            }
-          }
-        }
+        wordNetPath_ += '/';
       }
-    } else if (!xmlStrcmp(node->name, (const xmlChar*) "MEMBERS"))
-    {
-      for (xmlNodePtr member = node->xmlChildrenNode; member != nullptr; member = member->next)
+      
+      // Ensure WordNet tables exist
+      for (std::string table : {
+        "s", "sk", "ant", "at", "cls", "hyp", "ins", "mm", "mp", "ms", "per", "sa", "sim", "syntax"
+      })
       {
-        if (!xmlStrcmp(member->name, (const xmlChar*) "MEMBER"))
+        if (!std::ifstream(wordNetPath_ + "wn_" + table + ".pl"))
         {
-          key = xmlGetProp(member, (xmlChar*) "name");
-          g.members.insert((const char*)key);
-          xmlFree(key);
+          throw std::invalid_argument("WordNet " + table + " table not found");
         }
       }
-    } else if (!xmlStrcmp(node->name, (const xmlChar*) "THEMROLES"))
-    {
-      for (xmlNodePtr role = node->xmlChildrenNode; role != nullptr; role = role->next)
+      
+      // Ensure CMUDICT file exists
+      if (!std::ifstream(cmudictPath_))
       {
-        if (!xmlStrcmp(role->name, (const xmlChar*) "THEMROLE"))
-        {
-          selrestr_t r;
-          r.type = selrestr_t::type_t::empty;
-          
-          key = xmlGetProp(role, (const xmlChar*) "type");
-          std::string type = (const char*)key;
-          xmlFree(key);
-          
-          for (xmlNodePtr rolenode = role->xmlChildrenNode; rolenode != nullptr; rolenode = rolenode->next)
-          {
-            if (!xmlStrcmp(rolenode->name, (const xmlChar*) "SELRESTRS"))
-            {
-              r = parse_selrestrs(rolenode, filename);
-            }
-          }
-          
-          g.roles[type] = r;
-        }
+        throw std::invalid_argument("CMUDICT file not found");
       }
-    } else if (!xmlStrcmp(node->name, (const xmlChar*) "FRAMES"))
-    {
-      for (xmlNodePtr frame = node->xmlChildrenNode; frame != nullptr; frame = frame->next)
+      
+      // Ensure ImageNet urls.txt exists
+      if (!std::ifstream(imageNetPath_))
       {
-        if (!xmlStrcmp(frame->name, (const xmlChar*) "FRAME"))
-        {
-          std::list<framepart_t> f;
-          
-          for (xmlNodePtr framenode = frame->xmlChildrenNode; framenode != nullptr; framenode = framenode->next)
-          {
-            if (!xmlStrcmp(framenode->name, (const xmlChar*) "SYNTAX"))
-            {
-              for (xmlNodePtr syntaxnode = framenode->xmlChildrenNode; syntaxnode != nullptr; syntaxnode = syntaxnode->next)
-              {
-                framepart_t fp;
-                
-                if (!xmlStrcmp(syntaxnode->name, (const xmlChar*) "NP"))
-                {
-                  fp.type = framepart_t::type_t::np;
-                  
-                  key = xmlGetProp(syntaxnode, (xmlChar*) "value");
-                  fp.role = (const char*)key;
-                  xmlFree(key);
-                  
-                  fp.selrestrs.type = selrestr_t::type_t::empty;
-                  
-                  for (xmlNodePtr npnode = syntaxnode->xmlChildrenNode; npnode != nullptr; npnode = npnode->next)
-                  {
-                    if (!xmlStrcmp(npnode->name, (const xmlChar*) "SYNRESTRS"))
-                    {
-                      for (xmlNodePtr synrestr = npnode->xmlChildrenNode; synrestr != nullptr; synrestr = synrestr->next)
-                      {
-                        if (!xmlStrcmp(synrestr->name, (const xmlChar*) "SYNRESTR"))
-                        {
-                          key = xmlGetProp(synrestr, (xmlChar*) "type");
-                          fp.synrestrs.insert(std::string((const char*)key));
-                          xmlFree(key);
-                        }
-                      }
-                    }
-                  
-                    if (!xmlStrcmp(npnode->name, (const xmlChar*) "SELRESTRS"))
-                    {
-                      fp.selrestrs = parse_selrestrs(npnode, filename);
-                    }
-                  }
-                } else if (!xmlStrcmp(syntaxnode->name, (xmlChar*) "VERB"))
-                {
-                  fp.type = framepart_t::type_t::v;
-                } else if (!xmlStrcmp(syntaxnode->name, (xmlChar*) "PREP"))
-                {
-                  fp.type = framepart_t::type_t::pp;
-                  
-                  if (xmlHasProp(syntaxnode, (xmlChar*) "value"))
-                  {
-                    key = xmlGetProp(syntaxnode, (xmlChar*) "value");
-                    std::string choices = (const char*)key;
-                    xmlFree(key);
-                  
-                    fp.choices = verbly::split<std::list<std::string>>(choices, " ");
-                  }
-                  
-                  for (xmlNodePtr npnode = syntaxnode->xmlChildrenNode; npnode != nullptr; npnode = npnode->next)
-                  {
-                    if (!xmlStrcmp(npnode->name, (const xmlChar*) "SELRESTRS"))
-                    {
-                      for (xmlNodePtr synrestr = npnode->xmlChildrenNode; synrestr != nullptr; synrestr = synrestr->next)
-                      {
-                        if (!xmlStrcmp(synrestr->name, (const xmlChar*) "SELRESTR"))
-                        {
-                          key = xmlGetProp(synrestr, (xmlChar*) "type");
-                          fp.preprestrs.insert(std::string((const char*)key));
-                          xmlFree(key);
-                        }
-                      }
-                    }
-                  }
-                } else if (!xmlStrcmp(syntaxnode->name, (xmlChar*) "ADJ"))
-                {
-                  fp.type = framepart_t::type_t::adj;
-                } else if (!xmlStrcmp(syntaxnode->name, (xmlChar*) "ADV"))
-                {
-                  fp.type = framepart_t::type_t::adv;
-                } else if (!xmlStrcmp(syntaxnode->name, (xmlChar*) "LEX"))
-                {
-                  fp.type = framepart_t::type_t::lex;
-                  
-                  key = xmlGetProp(syntaxnode, (xmlChar*) "value");
-                  fp.lexval = (const char*)key;
-                  xmlFree(key);
-                } else {
-                  continue;
-                }
-                
-                f.push_back(fp);
-              }
-              
-              g.frames.push_back(f);
-            }
-          }
-        }
+        throw std::invalid_argument("ImageNet urls.txt file not found");
       }
     }
-  }
-  
-  groups[vnid] = g;
-  
-  return groups[vnid];
-}
-
-int main(int argc, char** argv)
-{
-  if (argc != 7)
-  {
-    print_usage();
-  }
-  
-  // VerbNet data
-  std::cout << "Reading verb frames..." << std::endl;
-  
-  DIR* dir;
-  if ((dir = opendir(argv[1])) == nullptr)
-  {
-    std::cout << "Invalid VerbNet data directory." << std::endl;
-    
-    print_usage();
-  }
-  
-  struct dirent* ent;
-  while ((ent = readdir(dir)) != nullptr)
-  {
-    std::string filename(argv[1]);
-    if (filename.back() != '/')
-    {
-      filename += '/';
-    }
     
-    filename += ent->d_name;
-    //std::cout << ent->d_name << std::endl;
-    
-    if (filename.rfind(".xml") != filename.size() - 4)
-    {
-      continue;
-    }
-    
-    xmlDocPtr doc = xmlParseFile(filename.c_str());
-    if (doc == nullptr)
-    {
-      std::cout << "Error opening " << filename << std::endl;
-      print_usage();
-    }
-    
-    xmlNodePtr top = xmlDocGetRootElement(doc);
-    if ((top == nullptr) || (xmlStrcmp(top->name, (xmlChar*) "VNCLASS")))
-    {
-      std::cout << "Bad VerbNet file format: " << filename << std::endl;
-      print_usage();
-    }
-    
-    parse_group(top, filename);
-  }
-  
-  closedir(dir);
-  
-  // Get verbs from AGID
-  std::cout << "Reading inflections..." << std::endl;
-  
-  std::ifstream agidfile(argv[2]);
-  if (!agidfile.is_open())
-  {
-    std::cout << "Could not open AGID file: " << argv[2] << std::endl;
-    print_usage();
-  }
-  
-  for (;;)
-  {
-    std::string line;
-    if (!getline(agidfile, line))
-    {
-      break;
-    }
-    
-    if (line.back() == '\r')
+    void generator::run()
     {
-      line.pop_back();
-    }
-    
-    int divider = line.find_first_of(" ");
-    std::string word = line.substr(0, divider);
-    line = line.substr(divider+1);
-    char type = line[0];
-    
-    if (line[1] == '?')
-    {
-      line.erase(0, 4);
-    } else {
-      line.erase(0, 3);
-    }
-
-    std::vector<std::string> forms;
-    while (!line.empty())
-    {
-      std::string inflection;
-      if ((divider = line.find(" | ")) != std::string::npos)
-      {
-        inflection = line.substr(0, divider);
-        line = line.substr(divider + 3);
-      } else {
-        inflection = line;
-        line = "";
-      }
-  
-      if ((divider = inflection.find_first_of(",?")) != std::string::npos)
-      {
-        inflection = inflection.substr(0, divider);
-      }
-  
-      forms.push_back(inflection);
+      // Create notions, words, lemmas, and forms from WordNet synsets
+      readWordNetSynsets();
+      
+      // Reads adjective positioning WordNet data
+      readAdjectivePositioning();
+      
+      // Counts the number of URLs ImageNet has per notion 
+      readImageNetUrls();
+      
+      // Creates a word by WordNet sense key lookup table
+      readWordNetSenseKeys();
+      
+      // Creates groups and frames from VerbNet data
+      readVerbNet();
+      
+      // Creates forms and inflections from AGID. To reduce the amount of forms
+      // created, we do this after most lemmas that need inflecting have been
+      // created through other means, and then only generate forms for
+      // inflections of already-existing lemmas. The exception to this regards
+      // verb lemmas. If a verb lemma in AGID either does not exist yet, or does
+      // exist but is not related to any words that are related to verb notions,
+      // then a notion and a word is generated and the form generation proceeds
+      // as usual.
+      readAgidInflections();
+      
+      // Reads in prepositions and the is_a relationship
+      readPrepositions();
+      
+      // Creates pronunciations from CMUDICT. To reduce the amount of
+      // pronunciations created, we do this after all forms have been created,
+      // and then only generate pronunciations for already-exisiting forms.
+      readCmudictPronunciations();
+      
+      // Writes the database schema
+      writeSchema();
+      
+      // Dumps data to the database
+      dumpObjects();
+      
+      // Populates the antonymy relationship from WordNet
+      readWordNetAntonymy();
+      
+      // Populates the variation relationship from WordNet
+      readWordNetVariation();
+      
+      // Populates the usage, topicality, and regionality relationships from
+      // WordNet
+      readWordNetClasses();
+      
+      // Populates the causality relationship from WordNet
+      readWordNetCausality();
+      
+      // Populates the entailment relationship from WordNet
+      readWordNetEntailment();
+      
+      // Populates the hypernymy relationship from WordNet
+      readWordNetHypernymy();
+      
+      // Populates the instantiation relationship from WordNet
+      readWordNetInstantiation();
+      
+      // Populates the member meronymy relationship from WordNet
+      readWordNetMemberMeronymy();
+      
+      // Populates the part meronymy relationship from WordNet
+      readWordNetPartMeronymy();
+      
+      // Populates the substance meronymy relationship from WordNet
+      readWordNetSubstanceMeronymy();
+      
+      // Populates the pertainymy and mannernymy relationships from WordNet
+      readWordNetPertainymy();
+      
+      // Populates the specification relationship from WordNet
+      readWordNetSpecification();
+      
+      // Populates the adjective similarity relationship from WordNet
+      readWordNetSimilarity();
+      
+      
+      
+      
+      
+      
+      
+      
     }
     
-    switch (type)
+    void generator::readWordNetSynsets()
     {
-      case 'V':
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_s.pl"));
+      progress ppgs("Reading synsets from WordNet...", lines.size());
+      
+      for (std::string line : lines)
       {
-        verb_t 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;
+        ppgs.update();
+        
+        std::regex relation("^s\\(([1234]\\d{8}),(\\d+),'(.+)',\\w,\\d+,(\\d+)\\)\\.$");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
+        {
+          continue;
         }
     
-        verbs[word] = v;
-        
-        break;
-      }
-      
-      case 'A':
-      {
-        adjective_t adj;
-        adj.base = word;
-        if (forms.size() == 2)
+        int synset_id = std::stoi(relation_data[1]);
+        int wnum = std::stoi(relation_data[2]);
+        std::string text = relation_data[3];
+        int tag_count = std::stoi(relation_data[4]);
+        size_t word_it;
+        while ((word_it = text.find("''")) != std::string::npos)
         {
-          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;
+          text.erase(word_it, 1);
         }
         
-        adjectives[word] = adj;
-        
-        break;
-      }
-      
-      case 'N':
-      {
-        noun_t n;
-        n.singular = word;
-        if (forms.size() == 1)
+        // The WordNet data does contain duplicates, so we need to check that we
+        // haven't already created this word.
+        std::pair<int, int> lookup(synset_id, wnum);
+        if (!wordByWnidAndWnum_.count(lookup))
         {
-          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;
+          notion& synset = lookupOrCreateNotion(synset_id);
+          lemma& lex = lookupOrCreateLemma(text);
+          word& entry = createWord(synset, lex, tag_count);
+
+          wordByWnidAndWnum_[lookup] = &entry;
         }
-        
-        nouns[word] = n;
-        
-        break;
       }
     }
-  }
-  
-  // Pronounciations
-  std::cout << "Reading pronunciations..." << std::endl;
-  
-  std::ifstream pronfile(argv[4]);
-  if (!pronfile.is_open())
-  {
-    std::cout << "Could not open CMUDICT file: " << argv[4] << std::endl;
-    print_usage();
-  }
-  
-  for (;;)
-  {
-    std::string line;
-    if (!getline(pronfile, line))
-    {
-      break;
-    }
-    
-    if (line.back() == '\r')
-    {
-      line.pop_back();
-    }
     
-    std::regex phoneme("([A-Z][^ \\(]*)(?:\\(\\d+\\))?  ([A-Z 0-9]+)");
-    std::smatch phoneme_data;
-    if (std::regex_search(line, phoneme_data, phoneme))
+    void generator::readAdjectivePositioning()
     {
-      std::string canonical(phoneme_data[1]);
-      std::transform(std::begin(canonical), std::end(canonical), std::begin(canonical), ::tolower);
-      
-      std::string phonemes = phoneme_data[2];
-      auto phoneme_set = verbly::split<std::list<std::string>>(phonemes, " ");
-      auto phemstrt = std::find_if(std::begin(phoneme_set), std::end(phoneme_set), [] (std::string phoneme) {
-        return phoneme.find("1") != std::string::npos;
-      });
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_syntax.pl"));
+      progress ppgs("Reading adjective positionings from WordNet...", lines.size());
       
-      pronunciation_t p;
-      p.phonemes = phonemes;
-      
-      // Rhyme detection
-      if (phemstrt != std::end(phoneme_set))
+      for (std::string line : lines)
       {
-        std::stringstream rhymer;
-        for (auto it = phemstrt; it != std::end(phoneme_set); it++)
-        {
-          std::string naked;
-          std::remove_copy_if(std::begin(*it), std::end(*it), std::back_inserter(naked), [] (char ch) {
-            return isdigit(ch);
-          });
-          
-          if (it != phemstrt)
-          {
-            rhymer << " ";
-          }
-          
-          rhymer << naked;
-        }
+        ppgs.update();
         
-        p.rhyme = rhymer.str();
-        
-        if (phemstrt != std::begin(phoneme_set))
+        std::regex relation("^syntax\\((3\\d{8}),(\\d+),([ipa])p?\\)\\.");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
         {
-          phemstrt--;
-          p.prerhyme = *phemstrt;
-        } else {
-          p.prerhyme = "";
+          continue;
         }
-      } else {
-        p.prerhyme = "";
-        p.rhyme = "";
-      }
       
-      // Syllable/stress
-      for (auto phm : phoneme_set)
-      {
-        if (isdigit(phm.back()))
-        {
-          // It's a vowel!
-          p.syllables++;
+        int synset_id = stoi(relation_data[1]);
+        int wnum = stoi(relation_data[2]);
+        std::string adjpos_str = relation_data[3];
         
-          if (phm.back() == '1')
+        std::pair<int, int> lookup(synset_id, wnum);
+        if (wordByWnidAndWnum_.count(lookup))
+        {
+          word& adj = *wordByWnidAndWnum_.at(lookup);
+          
+          if (adjpos_str == "p")
+          {
+            adj.setAdjectivePosition(positioning::predicate);
+          } else if (adjpos_str == "a")
+          {
+            adj.setAdjectivePosition(positioning::attributive);
+          } else if (adjpos_str == "i")
           {
-            p.stress.push_back('1');
+            adj.setAdjectivePosition(positioning::postnominal);
           } else {
-            p.stress.push_back('0');
+            // Can't happen because of how we specified the regex.
+            assert(false);
           }
         }
       }
-      
-      pronunciations[canonical].insert(p);
-    }
-  }
-  
-  // Images
-  std::cout << "Reading images..." << std::endl;
-  
-  std::ifstream imagefile(argv[5]);
-  if (!imagefile.is_open())
-  {
-    std::cout << "Could not open ImageNet file: " << argv[5] << std::endl;
-    print_usage();
-  }
-  
-  for (;;)
-  {
-    std::string line;
-    if (!getline(imagefile, line))
-    {
-      break;
-    }
-    
-    if (line.back() == '\r')
-    {
-      line.pop_back();
-    }
-    
-    std::string wnid_s = line.substr(1, 8);
-    int wnid = stoi(wnid_s) + 100000000;
-    images[wnid]++;
-  }
-  
-  imagefile.close();
-  
-  // Start writing output
-  std::cout << "Writing schema..." << std::endl;
-  
-  sqlite3* ppdb;
-  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();
-  }
-  
-  std::ifstream schemafile("schema.sql");
-  if (!schemafile.is_open())
-  {
-    std::cout << "Could not find schema file" << std::endl;
-    print_usage();
-  }
-  
-  std::stringstream schemabuilder;
-  for (;;)
-  {
-    std::string line;
-    if (!getline(schemafile, line))
-    {
-      break;
-    }
-    
-    if (line.back() == '\r')
-    {
-      line.pop_back();
-    }
-    
-    schemabuilder << line << std::endl;
-  }
-  
-  std::string schema = schemabuilder.str();
-  while (!schema.empty())
-  {
-    std::string query;
-    int divider = schema.find(";");
-    if (divider != std::string::npos)
-    {
-      query = schema.substr(0, divider+1);
-      schema = schema.substr(divider+2);
-    } else {
-      break;
     }
     
-    sqlite3_stmt* schmstmt;
-    if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &schmstmt, NULL) != SQLITE_OK)
+    void generator::readImageNetUrls()
     {
-      db_error(ppdb, query);
-    }
-  
-    if (sqlite3_step(schmstmt) != SQLITE_DONE)
-    {
-      db_error(ppdb, query);
-    }
-  
-    sqlite3_finalize(schmstmt);
-  }
-  
-  std::cout << "Writing prepositions..." << std::endl;
-  std::ifstream prepfile("prepositions.txt");
-  if (!prepfile.is_open())
-  {
-    std::cout << "Could not find prepositions file" << std::endl;
-    print_usage();
-  }
-  
-  for (;;)
-  {
-    std::string line;
-    if (!getline(prepfile, line))
-    {
-      break;
-    }
-    
-    if (line.back() == '\r')
-    {
-      line.pop_back();
-    }
-    
-    std::regex relation("^([^:]+): (.+)");
-    std::smatch relation_data;
-    std::regex_search(line, relation_data, relation);
-    std::string prep = relation_data[1];
-    std::list<std::string> groups = verbly::split<std::list<std::string>>(relation_data[2], ", ");
-    
-    std::string query("INSERT INTO prepositions (form) VALUES (?)");
-    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, prep.c_str(), prep.length(), SQLITE_TRANSIENT);
-    
-    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);
-    sqlite3_finalize(ppstmt);
-    
-    for (auto group : groups)
-    {
-      query = "INSERT INTO preposition_groups (preposition_id, groupname) VALUES (?, ?)";
-      if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
-      {
-        db_error(ppdb, query);
-      }
+      // The ImageNet datafile is so large that it is unreasonable and
+      // unnecessary to read it into memory; instead, we will parse each line as
+      // we read it. This has the caveat that we cannot display a progress bar.
+      std::cout << "Reading image counts from ImageNet..." << std::endl;
       
-      sqlite3_bind_int(ppstmt, 1, rowid);
-      sqlite3_bind_text(ppstmt, 2, group.c_str(), group.length(), SQLITE_TRANSIENT);
-      
-      if (sqlite3_step(ppstmt) != SQLITE_DONE)
+      std::ifstream file(imageNetPath_);
+      if (!file)
       {
-        db_error(ppdb, query);
+        throw std::invalid_argument("Could not find file " + imageNetPath_);
       }
-      
-      sqlite3_finalize(ppstmt);
-    }
-  }
-  
   
-  {
-    progress ppgs("Writing verbs...", verbs.size());
-    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)
-      {
-        db_error(ppdb, query);
-      }
-    
-      sqlite3_bind_text(ppstmt, 1, mapping.second.infinitive.c_str(), mapping.second.infinitive.length(), SQLITE_TRANSIENT);
-      sqlite3_bind_text(ppstmt, 2, mapping.second.past_tense.c_str(), mapping.second.past_tense.length(), SQLITE_TRANSIENT);
-      sqlite3_bind_text(ppstmt, 3, mapping.second.past_participle.c_str(), mapping.second.past_participle.length(), SQLITE_TRANSIENT);
-      sqlite3_bind_text(ppstmt, 4, mapping.second.ing_form.c_str(), mapping.second.ing_form.length(), SQLITE_TRANSIENT);
-      sqlite3_bind_text(ppstmt, 5, mapping.second.s_form.c_str(), mapping.second.s_form.length(), SQLITE_TRANSIENT);
-    
-      if (sqlite3_step(ppstmt) != SQLITE_DONE)
-      {
-        db_error(ppdb, query);
-      }
-    
-      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)
+      std::string line;
+      while (std::getline(file, line))
       {
-        query = "SELECT last_insert_rowid()";
-        if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+        if (line.back() == '\r')
         {
-          db_error(ppdb, query);
+          line.pop_back();
         }
-    
-        if (sqlite3_step(ppstmt) != SQLITE_ROW)
+      
+        std::string wnid_s = line.substr(1, 8);
+        int wnid = stoi(wnid_s) + 100000000;
+        if (notionByWnid_.count(wnid))
         {
-          db_error(ppdb, query);
-        }
-    
-        int rowid = sqlite3_column_int(ppstmt, 0);
-    
-        sqlite3_finalize(ppstmt);
-        
-        mapping.second.id = rowid;
-        
-        for (auto pronunciation : pronunciations[canonical])
-        {
-          if (!pronunciation.rhyme.empty())
-          {
-            query = "INSERT INTO verb_pronunciations (verb_id, pronunciation, syllables, stress, prerhyme, rhyme) VALUES (?, ?, ?, ?, ?, ?)";
-          } else {
-            query = "INSERT INTO verb_pronunciations (verb_id, pronunciation, syllables, stress) 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.phonemes.c_str(), pronunciation.phonemes.length(), SQLITE_TRANSIENT);
-          sqlite3_bind_int(ppstmt, 3, pronunciation.syllables);
-          sqlite3_bind_text(ppstmt, 4, pronunciation.stress.c_str(), pronunciation.stress.length(), SQLITE_TRANSIENT);
-          
-          if (!pronunciation.rhyme.empty())
-          {
-            sqlite3_bind_text(ppstmt, 5, pronunciation.prerhyme.c_str(), pronunciation.prerhyme.length(), SQLITE_TRANSIENT);
-            sqlite3_bind_text(ppstmt, 6, pronunciation.rhyme.c_str(), pronunciation.rhyme.length(), SQLITE_TRANSIENT);
-          }
-          
-          if (sqlite3_step(ppstmt) != SQLITE_DONE)
-          {
-            db_error(ppdb, query);
-          }
-          
-          sqlite3_finalize(ppstmt);
+          // We know that this notion has a wnid and is a noun.
+          notionByWnid_.at(wnid)->incrementNumOfImages();
         }
       }
-      
-      ppgs.update();
     }
-  }
-  
-  {
-    progress ppgs("Writing verb frames...", groups.size());
-    for (auto& mapping : groups)
+    
+    void generator::readWordNetSenseKeys()
     {
-      std::list<json> roledatal;
-      std::transform(std::begin(mapping.second.roles), std::end(mapping.second.roles), std::back_inserter(roledatal), [] (std::pair<std::string, selrestr_t> r) {
-        json role;
-        role["type"] = r.first;
-        role["selrestrs"] = export_selrestrs(r.second);
-        
-        return role;
-      });
-      
-      json roledata(roledatal);
-      std::string rdm = roledata.dump();
-      
-      sqlite3_stmt* ppstmt;
-      std::string query("INSERT INTO groups (data) VALUES (?)");
-      if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
-      {
-        db_error(ppdb, query);
-      }
-      
-      sqlite3_bind_blob(ppstmt, 1, rdm.c_str(), rdm.size(), SQLITE_TRANSIENT);
-      
-      if (sqlite3_step(ppstmt) != SQLITE_DONE)
-      {
-        db_error(ppdb, query);
-      }
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_sk.pl"));
+      progress ppgs("Reading sense keys from WordNet...", lines.size());
       
-      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 gid = sqlite3_column_int(ppstmt, 0);
-      sqlite3_finalize(ppstmt);
-      
-      for (auto frame : mapping.second.frames)
+      for (std::string line : lines)
       {
-        std::list<json> fdatap;
-        std::transform(std::begin(frame), std::end(frame), std::back_inserter(fdatap), [] (framepart_t& fp) {
-          json part;
-          
-          switch (fp.type)
-          {
-            case framepart_t::type_t::np:
-            {
-              part["type"] = "np";
-              part["role"] = fp.role;
-              part["selrestrs"] = export_selrestrs(fp.selrestrs);
-              part["synrestrs"] = fp.synrestrs;
-              
-              break;
-            }
-            
-            case framepart_t::type_t::pp:
-            {
-              part["type"] = "pp";
-              part["values"] = fp.choices;
-              part["preprestrs"] = fp.preprestrs;
-              
-              break;
-            }
-            
-            case framepart_t::type_t::v:
-            {
-              part["type"] = "v";
-              
-              break;
-            }
-            
-            case framepart_t::type_t::adj:
-            {
-              part["type"] = "adj";
-              
-              break;
-            }
-            
-            case framepart_t::type_t::adv:
-            {
-              part["type"] = "adv";
-              
-              break;
-            }
-            
-            case framepart_t::type_t::lex:
-            {
-              part["type"] = "lex";
-              part["value"] = fp.lexval;
-              
-              break;
-            }
-          }
-          
-          return part;
-        });
-        
-        json fdata(fdatap);
-        std::string marshall = fdata.dump();
-        
-        query = "INSERT INTO frames (group_id, data) VALUES (?, ?)";
-        if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
-        {
-          db_error(ppdb, query);
-        }
-        
-        sqlite3_bind_int(ppstmt, 1, gid);
-        sqlite3_bind_blob(ppstmt, 2, marshall.c_str(), marshall.length(), SQLITE_TRANSIENT);
+        ppgs.update();
         
-        if (sqlite3_step(ppstmt) != SQLITE_DONE)
+        // We only actually need to lookup verbs by sense key so we'll just
+        // ignore everything that isn't a verb.
+        std::regex relation("^sk\\((2\\d{8}),(\\d+),'(.+)'\\)\\.$");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
         {
-          db_error(ppdb, query);
+          continue;
         }
+    
+        int synset_id = stoi(relation_data[1]);
+        int wnum = stoi(relation_data[2]);
+        std::string sense_key = relation_data[3];
         
-        sqlite3_finalize(ppstmt);
-      }
-      
-      for (auto member : mapping.second.members)
-      {
-        if (verbs.count(member) == 1)
+        // We are treating this mapping as injective, which is not entirely
+        // accurate. First, the WordNet table contains duplicate rows, so those
+        // need to be ignored. More importantly, a small number of sense keys
+        // (one for each letter of the Latin alphabet, plus 9 other words) each
+        // map to two different words in the same synset which differ only by
+        // capitalization. Luckily, none of these exceptions are verbs, so we
+        // can pretend that the mapping is injective.
+        if (!wnSenseKeys_.count(sense_key))
         {
-          auto& v = verbs[member];
-          
-          query = "INSERT INTO verb_groups (verb_id, group_id) VALUES (?, ?)";
-          if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
-          {
-            db_error(ppdb, query);
-          }
-          
-          sqlite3_bind_int(ppstmt, 1, v.id);
-          sqlite3_bind_int(ppstmt, 2, gid);
-          
-          if (sqlite3_step(ppstmt) != SQLITE_DONE)
+          std::pair<int, int> lookup(synset_id, wnum);
+          if (wordByWnidAndWnum_.count(lookup))
           {
-            db_error(ppdb, query);
+            wnSenseKeys_[sense_key] = wordByWnidAndWnum_.at(lookup);
           }
-          
-          sqlite3_finalize(ppstmt);
         }
       }
-      
-      ppgs.update();
     }
-  }
-  
-  // Get nouns/adjectives/adverbs from WordNet
-  // Useful relations:
-  // - s: master list
-  // - ant: antonymy (e.g. happy/sad, sad/happy, happiness/sadness)
-  // - at: variation (e.g. a measurement can be standard or nonstandard)
-  // - der: derivation (e.g. happy/happily, happily/happy)
-  // - hyp: hypernymy/hyponymy (e.g. color/red, color/blue)
-  // - ins: instantiation (do we need this? let's see)
-  // - mm: member meronymy/holonymy (e.g. family/mother, family/child)
-  // - mp: part meronymy/holonymy (e.g. wheel/spoke, wheel/tire)
-  // - ms: substance meronymy/holonymy (e.g. tire/rubber, doorstop/rubber)
-  // - per: pertainymy (e.g. something that is Alaskan pertains to Alaska)
-  //        mannernymy (e.g. something done quickly is done in a manner that is quick)
-  // - sa: specification (e.g. inaccurate (general) can mean imprecise or incorrect (specific))
-  // - sim: synonymy (e.g. cheerful/happy, happy/cheerful)
-  // - syntax: positioning flags for some adjectives
-  std::string wnpref {argv[3]};
-  if (wnpref.back() != '/')
-  {
-    wnpref += '/';
-  }
-  
-  // s table
-  {
-    std::ifstream wnsfile(wnpref + "wn_s.pl");
-    if (!wnsfile.is_open())
+    
+    void generator::readVerbNet()
     {
-      std::cout << "Invalid WordNet data directory." << std::endl;
-      print_usage();
-    }
+      std::cout << "Reading frames from VerbNet..." << std::endl;
   
-    std::list<std::string> lines;
-    for (;;)
-    {
-      std::string line;
-      if (!getline(wnsfile, line))
+      DIR* dir;
+      if ((dir = opendir(verbNetPath_.c_str())) == nullptr)
       {
-        break;
+        throw std::invalid_argument("Invalid VerbNet data directory");
       }
-    
-      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,\\d+,\\d+\\)\\.$");
-      std::smatch relation_data;
-      if (!std::regex_search(line, relation_data, relation))
+  
+      struct dirent* ent;
+      while ((ent = readdir(dir)) != nullptr)
       {
-        continue;
-      }
+        std::string filename(verbNetPath_);
+
+        if (filename.back() != '/')
+        {
+          filename += '/';
+        }
     
-      int synset_id = stoi(relation_data[1]);
-      int wnum = stoi(relation_data[2]);
-      std::string word = relation_data[3];
-      size_t word_it;
-      while ((word_it = word.find("''")) != std::string::npos)
-      {
-        word.erase(word_it, 1);
-      }
+        filename += ent->d_name;
     
-      std::string query;
-      switch (synset_id / 100000000)
-      {
-        case 1: // Noun
+        if (filename.rfind(".xml") != filename.size() - 4)
         {
-          if (nouns.count(word) == 1)
-          {
-            query = "INSERT INTO nouns (singular, proper, complexity, images, wnid, plural) VALUES (?, ?, ?, ?, ?, ?)";
-          } else {
-            query = "INSERT INTO nouns (singular, proper, complexity, images, wnid) VALUES (?, ?, ?, ?, ?)";
-          }
-        
-          break;
+          continue;
         }
-      
-        case 2: // Verb
+    
+        xmlDocPtr doc = xmlParseFile(filename.c_str());
+        if (doc == nullptr)
         {
-          // Ignore
-        
-          break;
+          throw std::logic_error("Error opening " + filename);
         }
-      
-        case 3: // Adjective
+    
+        xmlNodePtr top = xmlDocGetRootElement(doc);
+        if ((top == nullptr) || (xmlStrcmp(top->name, reinterpret_cast<const xmlChar*>("VNCLASS"))))
         {
-          if (adjectives.count(word) == 1)
-          {
-            query = "INSERT INTO adjectives (base_form, complexity, comparative, superlative) VALUES (?, ?, ?, ?)";
-          } else {
-            query = "INSERT INTO adjectives (base_form, complexity) VALUES (?, ?)";
-          }
-        
-          break;
+          throw std::logic_error("Bad VerbNet file format: " + filename);
         }
-      
-        case 4: // Adverb
+
+        try
         {
-          if (adjectives.count(word) == 1)
-          {
-            query = "INSERT INTO adverbs (base_form, complexity, comparative, superlative) VALUES (?, ?, ?, ?)";
-          } else {
-            query = "INSERT INTO adverbs (base_form, complexity) VALUES (?, ?)";
-          }
-        
-          break;
+          createGroup(top);
+        } catch (const std::exception& e)
+        {
+          std::throw_with_nested(std::logic_error("Error parsing VerbNet file: " + filename));
         }
       }
+  
+      closedir(dir);
+    }
     
-      sqlite3_stmt* ppstmt;
-      if (sqlite3_prepare_v2(ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+    void generator::readAgidInflections()
+    {
+      std::list<std::string> lines(readFile(agidPath_));
+      progress ppgs("Reading inflections from AGID...", lines.size());
+      
+      for (std::string line : lines)
       {
-        db_error(ppdb, query);
-      }
+        ppgs.update();
+        
+        int divider = line.find_first_of(" ");
+        std::string infinitive = line.substr(0, divider);
+        line = line.substr(divider+1);
+        char type = line[0];
     
-      sqlite3_bind_text(ppstmt, 1, word.c_str(), word.length(), SQLITE_TRANSIENT);
-      switch (synset_id / 100000000)
-      {
-        case 1: // Noun
+        if (line[1] == '?')
         {
-          sqlite3_bind_int(ppstmt, 2, (std::any_of(std::begin(word), std::end(word), [] (char ch) {
-            return isupper(ch);
-          }) ? 1 : 0));
-          
-          sqlite3_bind_int(ppstmt, 3, verbly::split<std::list<std::string>>(word, " ").size());
-          sqlite3_bind_int(ppstmt, 4, images[synset_id]);
-          sqlite3_bind_int(ppstmt, 5, synset_id);
-          
-          if (nouns.count(word) == 1)
-          {
-            sqlite3_bind_text(ppstmt, 6, nouns[word].plural.c_str(), nouns[word].plural.length(), SQLITE_TRANSIENT);
-          }
-          
-          break;
+          line.erase(0, 4);
+        } else {
+          line.erase(0, 3);
         }
         
-        case 3: // Adjective
-        case 4: // Adverb
+        if (!lemmaByBaseForm_.count(infinitive) && (type != 'V'))
         {
-          sqlite3_bind_int(ppstmt, 2, verbly::split<std::list<std::string>>(word, " ").size());
-          
-          if (adjectives.count(word) == 1)
+          continue;
+        }
+        
+        lemma& curLemma = lookupOrCreateLemma(infinitive);
+
+        auto forms = split<std::vector<std::string>>(line, " | ");
+        for (std::string& inflForm : forms)
+        {
+          int sympos = inflForm.find_first_of(",?");
+          if (sympos != std::string::npos)
           {
-            sqlite3_bind_text(ppstmt, 3, adjectives[word].comparative.c_str(), adjectives[word].comparative.length(), SQLITE_TRANSIENT);
-            sqlite3_bind_text(ppstmt, 4, adjectives[word].superlative.c_str(), adjectives[word].superlative.length(), SQLITE_TRANSIENT);
+            inflForm = inflForm.substr(0, sympos);
           }
-          
-          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 (type)
         {
-          switch (synset_id / 100000000)
+          case 'V':
           {
-            case 1: // Noun
+            if (forms.size() == 4)
             {
-              if (!pronunciation.rhyme.empty())
-              {
-                query = "INSERT INTO noun_pronunciations (noun_id, pronunciation, syllables, stress, prerhyme, rhyme) VALUES (?, ?, ?, ?, ?, ?)";
-              } else {
-                query = "INSERT INTO noun_pronunciations (noun_id, pronunciation, syllables, stress) VALUES (?, ?, ?, ?)";
-              }
-              
-              break;
-            }
-            
-            case 3: // Adjective
+              curLemma.addInflection(inflection::past_tense, lookupOrCreateForm(forms[0]));
+              curLemma.addInflection(inflection::past_participle, lookupOrCreateForm(forms[1]));
+              curLemma.addInflection(inflection::ing_form, lookupOrCreateForm(forms[2]));
+              curLemma.addInflection(inflection::s_form, lookupOrCreateForm(forms[3]));
+            } else if (forms.size() == 3)
             {
-              if (!pronunciation.rhyme.empty())
-              {
-                query = "INSERT INTO adjective_pronunciations (adjective_id, pronunciation, syllables, stress, prerhyme, rhyme) VALUES (?, ?, ?, ?, ?, ?)";
-              } else {
-                query = "INSERT INTO adjective_pronunciations (adjective_id, pronunciation, syllables, stress) VALUES (?, ?, ?, ?)";
-              }
-              
-              break;
+              curLemma.addInflection(inflection::past_tense, lookupOrCreateForm(forms[0]));
+              curLemma.addInflection(inflection::past_participle, lookupOrCreateForm(forms[0]));
+              curLemma.addInflection(inflection::ing_form, lookupOrCreateForm(forms[1]));
+              curLemma.addInflection(inflection::s_form, lookupOrCreateForm(forms[2]));
+            } else if (forms.size() == 8)
+            {
+              // As of AGID 2014.08.11, this is only "to be"
+              curLemma.addInflection(inflection::past_tense, lookupOrCreateForm(forms[0]));
+              curLemma.addInflection(inflection::past_participle, lookupOrCreateForm(forms[2]));
+              curLemma.addInflection(inflection::ing_form, lookupOrCreateForm(forms[3]));
+              curLemma.addInflection(inflection::s_form, lookupOrCreateForm(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 \"" << infinitive << "\" due to non-standard number of forms." << std::endl;
             }
-            
-            case 4: // Adverb
+    
+            // For verbs in particular, we sometimes create a notion and a word
+            // from inflection data. Specifically, if there are not yet any
+            // verbs existing that have the same infinitive form. "Yet" means
+            // that this verb appears in the AGID data but not in either WordNet
+            // or VerbNet.
+            if (!wordsByBaseForm_.count(infinitive)
+              || !std::any_of(std::begin(wordsByBaseForm_.at(infinitive)), std::end(wordsByBaseForm_.at(infinitive)), [] (word* w) {
+                return w->getNotion().getPartOfSpeech() == part_of_speech::verb;
+              }))
             {
-              if (!pronunciation.rhyme.empty())
-              {
-                query = "INSERT INTO adverb_pronunciations (adverb_id, pronunciation, syllables, stress, prerhyme, rhyme) VALUES (?, ?, ?, ?, ?, ?)";
-              } else {
-                query = "INSERT INTO adverb_pronunciations (adverb_id, pronunciation, syllables, stress) VALUES (?, ?, ?, ?)";
-              }
-              
-              break;
+              notion& n = createNotion(part_of_speech::verb);
+              createWord(n, curLemma);
             }
-          }
-
-          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.phonemes.c_str(), pronunciation.phonemes.length(), SQLITE_TRANSIENT);
-          sqlite3_bind_int(ppstmt, 3, pronunciation.syllables);
-          sqlite3_bind_text(ppstmt, 4, pronunciation.stress.c_str(), pronunciation.stress.length(), SQLITE_TRANSIENT);
-          
-          if (!pronunciation.rhyme.empty())
-          {
-            sqlite3_bind_text(ppstmt, 5, pronunciation.prerhyme.c_str(), pronunciation.prerhyme.length(), SQLITE_TRANSIENT);
-            sqlite3_bind_text(ppstmt, 6, pronunciation.rhyme.c_str(), pronunciation.rhyme.length(), SQLITE_TRANSIENT);
-          }
         
-          if (sqlite3_step(ppstmt) != SQLITE_DONE)
-          {
-            db_error(ppdb, query);
+            break;
           }
-        
-          sqlite3_finalize(ppstmt);
-        }
-      }
-    }
-  }
-  
-  // While we're working on s
-  {
-    progress ppgs("Writing word synonyms...", wn.size());
-    for (auto sense : wn)
-    {
-      ppgs.update();
       
-      for (auto word1 : sense.second)
-      {
-        for (auto word2 : sense.second)
-        {
-          if (word1 != word2)
+          case 'A':
           {
-            std::string query;
-            switch (sense.first / 100000000)
+            if (forms.size() == 2)
             {
-              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 (?, ?)";
+              curLemma.addInflection(inflection::comparative, lookupOrCreateForm(forms[0]));
+              curLemma.addInflection(inflection::superlative, lookupOrCreateForm(forms[1]));
+            } else {
+              // As of AGID 2014.08.11, this is only "only", which has only the form "onliest"
+              std::cout << " Ignoring adjective/adverb \"" << infinitive << "\" due to non-standard number of forms." << std::endl;
+            }
         
-                break;
-              }
+            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)
+          case 'N':
+          {
+            if (forms.size() == 1)
             {
-              db_error(ppdb, query);
+              curLemma.addInflection(inflection::plural, lookupOrCreateForm(forms[0]));
+            } else {
+              // As of AGID 2014.08.11, this is non-existent.
+              std::cout << " Ignoring noun \"" << infinitive << "\" due to non-standard number of forms." << std::endl;
             }
-    
-            sqlite3_finalize(ppstmt);
+        
+            break;
           }
         }
       }
     }
-  }
-  
-  // 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')
-      {
-        line.pop_back();
-      }
-      
-      lines.push_back(line);
-    }
-    
-    progress ppgs("Writing antonyms...", lines.size());
-    for (auto line : lines)
+    void generator::readPrepositions()
     {
-      ppgs.update();
+      std::list<std::string> lines(readFile("prepositions.txt"));
+      progress ppgs("Reading prepositions...", lines.size());
       
-      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)
+      for (std::string line : lines)
       {
-        case 1: // Noun
-        {
-          query = "INSERT INTO noun_antonymy (noun_1_id, noun_2_id) VALUES (?, ?)";
+        ppgs.update();
         
-          break;
-        }
-      
-        case 2: // Verb
-        {
-          // Ignore
+        std::regex relation("^([^:]+): (.+)");
+        std::smatch relation_data;
+        std::regex_search(line, relation_data, relation);
+        std::string prep = relation_data[1];
+        auto groups = split<std::list<std::string>>(relation_data[2], ", ");
         
-          break;
-        }
-      
-        case 3: // Adjective
-        {
-          query = "INSERT INTO adjective_antonymy (adjective_1_id, adjective_2_id) VALUES (?, ?)";
+        notion& n = createNotion(part_of_speech::preposition);
+        lemma& l = lookupOrCreateLemma(prep);
+        word& w = createWord(n, l);
         
-          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;
+        n.setPrepositionGroups(groups);
       }
-    
-      if (line.back() == '\r')
-      {
-        line.pop_back();
-      }
-      
-      lines.push_back(line);
     }
     
-    progress ppgs("Writing variations...", lines.size());
-    for (auto line : lines)
+    void generator::readCmudictPronunciations()
     {
-      ppgs.update();
+      std::list<std::string> lines(readFile(cmudictPath_));
+      progress ppgs("Reading pronunciations from CMUDICT...", lines.size());
       
-      std::regex relation("^at\\((1\\d{8}),(3\\d{8})\\)\\.");
-      std::smatch relation_data;
-      if (!std::regex_search(line, relation_data, relation))
+      for (std::string line : lines)
       {
-        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])
+        ppgs.update();
+        
+        std::regex phoneme("([A-Z][^ \\(]*)(?:\\(\\d+\\))?  ([A-Z 0-9]+)");
+        std::smatch phoneme_data;
+        if (std::regex_search(line, phoneme_data, phoneme))
         {
-          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);
+          std::string canonical(phoneme_data[1]);
+          std::transform(std::begin(canonical), std::end(canonical), std::begin(canonical), ::tolower);
           
-          if (sqlite3_step(ppstmt) != SQLITE_DONE)
+          if (!formByText_.count(canonical))
           {
-            db_error(ppdb, query);
+            continue;
           }
           
-          sqlite3_finalize(ppstmt);
+          std::string phonemes = phoneme_data[2];
+          pronunciations_.emplace_back(phonemes);
+          pronunciation& p = pronunciations_.back();
+          formByText_.at(canonical)->addPronunciation(p);
         }
       }
     }
-  }
-  
-  // der table
-  {
-    std::ifstream wnderfile(wnpref + "wn_der.pl");
-    if (!wnderfile.is_open())
-    {
-      std::cout << "Invalid WordNet data directory." << std::endl;
-      print_usage();
-    }
     
-    std::list<std::string> lines;
-    for (;;)
+    void generator::writeSchema()
     {
-      std::string line;
-      if (!getline(wnderfile, line))
+      std::ifstream file("schema.sql");
+      if (!file)
       {
-        break;
+        throw std::invalid_argument("Could not find database schema");
       }
-    
-      if (line.back() == '\r')
+  
+      std::ostringstream schemaBuilder;
+      std::string line;
+      while (std::getline(file, line))
       {
-        line.pop_back();
+        if (line.back() == '\r')
+        {
+          line.pop_back();
+        }
+      
+        schemaBuilder << line;
       }
       
-      lines.push_back(line);
+      std::string schema = schemaBuilder.str();
+      auto queries = split<std::list<std::string>>(schema, ";");
+      progress ppgs("Writing database schema...", queries.size());
+      for (std::string query : queries)
+      {
+        if (!queries.empty())
+        {
+          db_.runQuery(query);
+        }
+        
+        ppgs.update();
+      }
     }
     
-    progress ppgs("Writing morphological derivation...", lines.size());
-    for (auto line : lines)
+    void generator::dumpObjects()
     {
-      ppgs.update();
-      
-      std::regex relation("^der\\(([134]\\d{8}),(\\d+),([134]\\d{8}),(\\d+)\\)\\.");
-      std::smatch relation_data;
-      if (!std::regex_search(line, relation_data, relation))
       {
-        continue;
+        progress ppgs("Writing notions...", notions_.size());
+        
+        for (notion& n : notions_)
+        {
+          db_ << n;
+          
+          ppgs.update();
+        }
       }
       
-      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
+        progress ppgs("Writing words...", words_.size());
+        
+        for (word& w : words_)
         {
-          switch (synset_id_2 / 100000000)
-          {
-            case 1: // Noun
-            {
-              query = "INSERT INTO noun_noun_derivation (noun_1_id, noun_2_id) VALUES (?, ?)";
-              break;
-            }
-            
-            case 3: // Adjective
-            {
-              query = "INSERT INTO noun_adjective_derivation (noun_id, adjective_id) VALUES (?, ?)";
-              break;
-            }
-            
-            case 4: // Adverb
-            {
-              query = "INSERT INTO noun_adverb_derivation (noun_id, adverb_id) VALUES (?, ?)";
-              break;
-            }
-          }
+          db_ << w;
           
-          break;
+          ppgs.update();
         }
+      }
+      
+      {
+        progress ppgs("Writing lemmas...", lemmas_.size());
         
-        case 3: // Adjective
+        for (lemma& l : lemmas_)
         {
-          switch (synset_id_2 / 100000000)
-          {
-            case 1: // Noun
-            {
-              query = "INSERT INTO noun_adjective_derivation (adjective_id, noun_id) VALUES (?, ?)";
-              break;
-            }
-            
-            case 3: // Adjective
-            {
-              query = "INSERT INTO adjective_adjective_derivation (adjective_id, adjective_id) VALUES (?, ?)";
-              break;
-            }
-            
-            case 4: // Adverb
-            {
-              query = "INSERT INTO adjective_adverb_derivation (adjective_id, adverb_id) VALUES (?, ?)";
-              break;
-            }
-          }
+          db_ << l;
           
-          break;
+          ppgs.update();
         }
+      }
+      
+      {
+        progress ppgs("Writing forms...", forms_.size());
         
-        case 4: // Adverb
+        for (form& f : forms_)
         {
-          switch (synset_id_2 / 100000000)
-          {
-            case 1: // Noun
-            {
-              query = "INSERT INTO noun_adverb_derivation (adverb_id, noun_id) VALUES (?, ?)";
-              break;
-            }
-            
-            case 3: // Adjective
-            {
-              query = "INSERT INTO adjective_adverb_derivation (adverb_id, adjective_id) VALUES (?, ?)";
-              break;
-            }
-            
-            case 4: // Adverb
-            {
-              query = "INSERT INTO adverb_adverb_derivation (adverb_1_id, adverb_2_id) VALUES (?, ?)";
-              break;
-            }
-          }
+          db_ << f;
           
-          break;
+          ppgs.update();
         }
       }
       
-      sqlite3_stmt* ppstmt;
-      if (sqlite3_prepare_v2(ppdb, query.c_str(), query.size(), &ppstmt, NULL) != SQLITE_OK)
       {
-        db_error(ppdb, query);
+        progress ppgs("Writing pronunciations...", pronunciations_.size());
+        
+        for (pronunciation& p : pronunciations_)
+        {
+          db_ << p;
+          
+          ppgs.update();
+        }
       }
       
-      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);
+        progress ppgs("Writing verb groups...", groups_.size());
+        
+        for (group& g : groups_)
+        {
+          db_ << g;
+          
+          ppgs.update();
+        }
       }
       
-      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;
-      }
-    
-      if (line.back() == '\r')
       {
-        line.pop_back();
+        progress ppgs("Writing verb frames...", frames_.size());
+        
+        for (frame& f : frames_)
+        {
+          db_ << f;
+          
+          ppgs.update();
+        }
       }
-      
-      lines.push_back(line);
     }
     
-    progress ppgs("Writing hypernyms...", lines.size());
-    for (auto line : lines)
+    void generator::readWordNetAntonymy()
     {
-      ppgs.update();
-      
-      std::regex relation("^hyp\\((1\\d{8}),(1\\d{8})\\)\\.");
-      std::smatch relation_data;
-      if (!std::regex_search(line, relation_data, relation))
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_ant.pl"));
+      progress ppgs("Writing antonyms...", lines.size());
+      for (auto line : lines)
       {
-        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 (?, ?)");
+        ppgs.update();
       
-      for (auto mapping1 : wn[synset_id_1])
-      {
-        for (auto mapping2 : wn[synset_id_2])
+        std::regex relation("^ant\\(([134]\\d{8}),(\\d+),([134]\\d{8}),(\\d+)\\)\\.");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
         {
-          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);
+          continue;
+        }
+
+        std::pair<int, int> lookup1(std::stoi(relation_data[1]), std::stoi(relation_data[2]));
+        std::pair<int, int> lookup2(std::stoi(relation_data[3]), std::stoi(relation_data[4]));
+        
+        if (wordByWnidAndWnum_.count(lookup1) && wordByWnidAndWnum_.count(lookup2))
+        {
+          word& word1 = *wordByWnidAndWnum_.at(lookup1);
+          word& word2 = *wordByWnidAndWnum_.at(lookup2);
           
-          if (sqlite3_step(ppstmt) != SQLITE_DONE)
-          {
-            db_error(ppdb, query);
-          }
+          std::list<field> fields;
+          fields.emplace_back("antonym_1_id", word1.getId());
+          fields.emplace_back("antonym_2_id", word2.getId());
           
-          sqlite3_finalize(ppstmt);
+          db_.insertIntoTable("antonymy", std::move(fields));
         }
       }
     }
-  }
-  
-  // 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))
-      {
-        break;
-      }
     
-      if (line.back() == '\r')
+    void generator::readWordNetVariation()
+    {
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_at.pl"));
+      progress ppgs("Writing variation...", lines.size());
+      for (auto line : lines)
       {
-        line.pop_back();
-      }
+        ppgs.update();
       
-      lines.push_back(line);
+        std::regex relation("^at\\((1\\d{8}),(3\\d{8})\\)\\.");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
+        {
+          continue;
+        }
+
+        int lookup1 = std::stoi(relation_data[1]);
+        int lookup2 = std::stoi(relation_data[2]);
+        
+        if (notionByWnid_.count(lookup1) && notionByWnid_.count(lookup2))
+        {
+          notion& notion1 = *notionByWnid_.at(lookup1);
+          notion& notion2 = *notionByWnid_.at(lookup2);
+          
+          std::list<field> fields;
+          fields.emplace_back("noun_id", notion1.getId());
+          fields.emplace_back("adjective_id", notion2.getId());
+          
+          db_.insertIntoTable("variation", std::move(fields));
+        }
+      }
     }
     
-    progress ppgs("Writing instantiations...", lines.size());
-    for (auto line : lines)
+    void generator::readWordNetClasses()
     {
-      ppgs.update();
-      
-      std::regex relation("^ins\\((1\\d{8}),(1\\d{8})\\)\\.");
-      std::smatch relation_data;
-      if (!std::regex_search(line, relation_data, relation))
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_cls.pl"));
+      progress ppgs("Writing usage, topicality, and regionality...", lines.size());
+      for (auto line : lines)
       {
-        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 (?, ?)");
+        ppgs.update();
       
-      for (auto mapping1 : wn[synset_id_1])
-      {
-        for (auto mapping2 : wn[synset_id_2])
+        std::regex relation("^cls\\(([134]\\d{8}),(\\d+),(1\\d{8}),(\\d+),([tur])\\)\\.");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
+        {
+          continue;
+        }
+
+        std::pair<int, int> lookup1(std::stoi(relation_data[1]), std::stoi(relation_data[2]));
+        std::pair<int, int> lookup2(std::stoi(relation_data[3]), std::stoi(relation_data[4]));
+        std::string class_type = relation_data[5];
+        
+        std::string table_name;
+        if (class_type == "t")
+        {
+          table_name += "topicality";
+        } else if (class_type == "u")
+        {
+          table_name += "usage";
+        } else if (class_type == "r")
+        {
+          table_name += "regionality";
+        }
+        
+        std::list<int> leftJoin;
+        std::list<int> rightJoin;
+        
+        if ((lookup1.second == 0) && (wordsByWnid_.count(lookup1.first)))
         {
-          sqlite3_stmt* ppstmt;
-          if (sqlite3_prepare_v2(ppdb, query.c_str(), query.size(), &ppstmt, NULL) != SQLITE_OK)
+          std::transform(std::begin(wordsByWnid_.at(lookup1.first)), std::end(wordsByWnid_.at(lookup1.first)), std::back_inserter(leftJoin), [] (word* w) {
+            return w->getId();
+          });
+        } else if (wordByWnidAndWnum_.count(lookup1)) {
+          leftJoin.push_back(wordByWnidAndWnum_.at(lookup1)->getId());
+        }
+        
+        if ((lookup2.second == 0) && (wordsByWnid_.count(lookup2.first)))
+        {
+          std::transform(std::begin(wordsByWnid_.at(lookup2.first)), std::end(wordsByWnid_.at(lookup2.first)), std::back_inserter(rightJoin), [] (word* w) {
+            return w->getId();
+          });
+        } else if (wordByWnidAndWnum_.count(lookup2)) {
+          rightJoin.push_back(wordByWnidAndWnum_.at(lookup2)->getId());
+        }
+        
+        for (int word1 : leftJoin)
+        {
+          for (int word2 : rightJoin)
           {
-            db_error(ppdb, query);
-          }
+            std::list<field> fields;
+            fields.emplace_back("term_id", word1);
+            fields.emplace_back("domain_id", word2);
           
-          sqlite3_bind_int(ppstmt, 1, mapping1.second);
-          sqlite3_bind_int(ppstmt, 2, mapping2.second);
-          
-          if (sqlite3_step(ppstmt) != SQLITE_DONE)
-          {
-            db_error(ppdb, query);
+            db_.insertIntoTable(table_name, std::move(fields));
           }
-          
-          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))
-      {
-        break;
-      }
     
-      if (line.back() == '\r')
+    void generator::readWordNetCausality()
+    {
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_cs.pl"));
+      progress ppgs("Writing causality...", lines.size());
+      for (auto line : lines)
       {
-        line.pop_back();
-      }
+        ppgs.update();
       
-      lines.push_back(line);
+        std::regex relation("^cs\\((2\\d{8}),(2\\d{8})\\)\\.");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
+        {
+          continue;
+        }
+
+        int lookup1 = std::stoi(relation_data[1]);
+        int lookup2 = std::stoi(relation_data[2]);
+        
+        if (notionByWnid_.count(lookup1) && notionByWnid_.count(lookup2))
+        {
+          notion& notion1 = *notionByWnid_.at(lookup1);
+          notion& notion2 = *notionByWnid_.at(lookup2);
+          
+          std::list<field> fields;
+          fields.emplace_back("effect_id", notion1.getId());
+          fields.emplace_back("cause_id", notion2.getId());
+          
+          db_.insertIntoTable("causality", std::move(fields));
+        }
+      }
     }
     
-    progress ppgs("Writing member meronyms...", lines.size());
-    for (auto line : lines)
+    void generator::readWordNetEntailment()
     {
-      ppgs.update();
-      
-      std::regex relation("^mm\\((1\\d{8}),(1\\d{8})\\)\\.");
-      std::smatch relation_data;
-      if (!std::regex_search(line, relation_data, relation))
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_ent.pl"));
+      progress ppgs("Writing entailment...", lines.size());
+      for (auto line : lines)
       {
-        continue;
-      }
+        ppgs.update();
       
-      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])
+        std::regex relation("^ent\\((2\\d{8}),(2\\d{8})\\)\\.");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
         {
-          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);
+          continue;
+        }
+
+        int lookup1 = std::stoi(relation_data[1]);
+        int lookup2 = std::stoi(relation_data[2]);
+        
+        if (notionByWnid_.count(lookup1) && notionByWnid_.count(lookup2))
+        {
+          notion& notion1 = *notionByWnid_.at(lookup1);
+          notion& notion2 = *notionByWnid_.at(lookup2);
           
-          if (sqlite3_step(ppstmt) != SQLITE_DONE)
-          {
-            db_error(ppdb, query);
-          }
+          std::list<field> fields;
+          fields.emplace_back("given_id", notion1.getId());
+          fields.emplace_back("entailment_id", notion2.getId());
           
-          sqlite3_finalize(ppstmt);
+          db_.insertIntoTable("entailment", std::move(fields));
         }
       }
     }
-  }
-  
-  // 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 (;;)
+    
+    void generator::readWordNetHypernymy()
     {
-      std::string line;
-      if (!getline(wnmsfile, line))
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_hyp.pl"));
+      progress ppgs("Writing hypernymy...", lines.size());
+      for (auto line : lines)
       {
-        break;
+        ppgs.update();
+      
+        std::regex relation("^hyp\\(([12]\\d{8}),([12]\\d{8})\\)\\.");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
+        {
+          continue;
+        }
+
+        int lookup1 = std::stoi(relation_data[1]);
+        int lookup2 = std::stoi(relation_data[2]);
+        
+        if (notionByWnid_.count(lookup1) && notionByWnid_.count(lookup2))
+        {
+          notion& notion1 = *notionByWnid_.at(lookup1);
+          notion& notion2 = *notionByWnid_.at(lookup2);
+          
+          std::list<field> fields;
+          fields.emplace_back("hyponym_id", notion1.getId());
+          fields.emplace_back("hypernym_id", notion2.getId());
+          
+          db_.insertIntoTable("hypernymy", std::move(fields));
+        }
       }
+    }
     
-      if (line.back() == '\r')
+    void generator::readWordNetInstantiation()
+    {
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_ins.pl"));
+      progress ppgs("Writing instantiation...", lines.size());
+      for (auto line : lines)
       {
-        line.pop_back();
-      }
+        ppgs.update();
       
-      lines.push_back(line);
+        std::regex relation("^ins\\((1\\d{8}),(1\\d{8})\\)\\.");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
+        {
+          continue;
+        }
+
+        int lookup1 = std::stoi(relation_data[1]);
+        int lookup2 = std::stoi(relation_data[2]);
+        
+        if (notionByWnid_.count(lookup1) && notionByWnid_.count(lookup2))
+        {
+          notion& notion1 = *notionByWnid_.at(lookup1);
+          notion& notion2 = *notionByWnid_.at(lookup2);
+          
+          std::list<field> fields;
+          fields.emplace_back("instance_id", notion1.getId());
+          fields.emplace_back("class_id", notion2.getId());
+          
+          db_.insertIntoTable("instantiation", std::move(fields));
+        }
+      }
     }
     
-    progress ppgs("Writing substance meronyms...", lines.size());
-    for (auto line : lines)
+    void generator::readWordNetMemberMeronymy()
     {
-      ppgs.update();
-      
-      std::regex relation("^ms\\((1\\d{8}),(1\\d{8})\\)\\.");
-      std::smatch relation_data;
-      if (!std::regex_search(line, relation_data, relation))
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_mm.pl"));
+      progress ppgs("Writing member meronymy...", lines.size());
+      for (auto line : lines)
       {
-        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 (?, ?)");
+        ppgs.update();
       
-      for (auto mapping1 : wn[synset_id_1])
-      {
-        for (auto mapping2 : wn[synset_id_2])
+        std::regex relation("^mm\\((1\\d{8}),(1\\d{8})\\)\\.");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
         {
-          sqlite3_stmt* ppstmt;
-          if (sqlite3_prepare_v2(ppdb, query.c_str(), query.size(), &ppstmt, NULL) != SQLITE_OK)
-          {
-            db_error(ppdb, query);
-          }
+          continue;
+        }
+
+        int lookup1 = std::stoi(relation_data[1]);
+        int lookup2 = std::stoi(relation_data[2]);
+        
+        if (notionByWnid_.count(lookup1) && notionByWnid_.count(lookup2))
+        {
+          notion& notion1 = *notionByWnid_.at(lookup1);
+          notion& notion2 = *notionByWnid_.at(lookup2);
           
-          sqlite3_bind_int(ppstmt, 1, mapping1.second);
-          sqlite3_bind_int(ppstmt, 2, mapping2.second);
+          std::list<field> fields;
+          fields.emplace_back("holonym_id", notion1.getId());
+          fields.emplace_back("meronym_id", notion2.getId());
           
-          if (sqlite3_step(ppstmt) != SQLITE_DONE)
-          {
-            db_error(ppdb, query);
-          }
-          
-          sqlite3_finalize(ppstmt);
+          db_.insertIntoTable("member_meronymy", std::move(fields));
         }
       }
     }
-  }
-  
-  // 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 (;;)
+    
+    void generator::readWordNetPartMeronymy()
     {
-      std::string line;
-      if (!getline(wnmpfile, line))
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_mp.pl"));
+      progress ppgs("Writing part meronymy...", lines.size());
+      for (auto line : lines)
       {
-        break;
+        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 lookup1 = std::stoi(relation_data[1]);
+        int lookup2 = std::stoi(relation_data[2]);
+        
+        if (notionByWnid_.count(lookup1) && notionByWnid_.count(lookup2))
+        {
+          notion& notion1 = *notionByWnid_.at(lookup1);
+          notion& notion2 = *notionByWnid_.at(lookup2);
+          
+          std::list<field> fields;
+          fields.emplace_back("holonym_id", notion1.getId());
+          fields.emplace_back("meronym_id", notion2.getId());
+          
+          db_.insertIntoTable("part_meronymy", std::move(fields));
+        }
       }
+    }
     
-      if (line.back() == '\r')
+    void generator::readWordNetSubstanceMeronymy()
+    {
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_ms.pl"));
+      progress ppgs("Writing substance meronymy...", lines.size());
+      for (auto line : lines)
       {
-        line.pop_back();
-      }
+        ppgs.update();
       
-      lines.push_back(line);
+        std::regex relation("^ms\\((1\\d{8}),(1\\d{8})\\)\\.");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
+        {
+          continue;
+        }
+
+        int lookup1 = std::stoi(relation_data[1]);
+        int lookup2 = std::stoi(relation_data[2]);
+        
+        if (notionByWnid_.count(lookup1) && notionByWnid_.count(lookup2))
+        {
+          notion& notion1 = *notionByWnid_.at(lookup1);
+          notion& notion2 = *notionByWnid_.at(lookup2);
+          
+          std::list<field> fields;
+          fields.emplace_back("holonym_id", notion1.getId());
+          fields.emplace_back("meronym_id", notion2.getId());
+          
+          db_.insertIntoTable("substance_meronymy", std::move(fields));
+        }
+      }
     }
     
-    progress ppgs("Writing part meronyms...", lines.size());
-    for (auto line : lines)
+    void generator::readWordNetPertainymy()
     {
-      ppgs.update();
-      
-      std::regex relation("^mp\\((1\\d{8}),(1\\d{8})\\)\\.");
-      std::smatch relation_data;
-      if (!std::regex_search(line, relation_data, relation))
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_per.pl"));
+      progress ppgs("Writing pertainymy and mannernymy...", lines.size());
+      for (auto line : lines)
       {
-        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 (?, ?)");
+        ppgs.update();
       
-      for (auto mapping1 : wn[synset_id_1])
-      {
-        for (auto mapping2 : wn[synset_id_2])
+        std::regex relation("^per\\(([34]\\d{8}),(\\d+),([13]\\d{8}),(\\d+)\\)\\.");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
         {
-          sqlite3_stmt* ppstmt;
-          if (sqlite3_prepare_v2(ppdb, query.c_str(), query.size(), &ppstmt, NULL) != SQLITE_OK)
-          {
-            db_error(ppdb, query);
-          }
+          continue;
+        }
+
+        std::pair<int, int> lookup1(std::stoi(relation_data[1]), std::stoi(relation_data[2]));
+        std::pair<int, int> lookup2(std::stoi(relation_data[3]), std::stoi(relation_data[4]));
+        
+        if (wordByWnidAndWnum_.count(lookup1) && wordByWnidAndWnum_.count(lookup2))
+        {
+          word& word1 = *wordByWnidAndWnum_.at(lookup1);
+          word& word2 = *wordByWnidAndWnum_.at(lookup2);
           
-          sqlite3_bind_int(ppstmt, 1, mapping1.second);
-          sqlite3_bind_int(ppstmt, 2, mapping2.second);
+          if (word1.getNotion().getPartOfSpeech() == part_of_speech::adjective)
+          {
+            std::list<field> fields;
+            fields.emplace_back("pertainym_id", word1.getId());
+            fields.emplace_back("noun_id", word2.getId());
           
-          if (sqlite3_step(ppstmt) != SQLITE_DONE)
+            db_.insertIntoTable("pertainymy", std::move(fields));
+          } else if (word1.getNotion().getPartOfSpeech() == part_of_speech::adverb)
           {
-            db_error(ppdb, query);
-          }
+            std::list<field> fields;
+            fields.emplace_back("mannernym_id", word1.getId());
+            fields.emplace_back("adjective_id", word2.getId());
           
-          sqlite3_finalize(ppstmt);
+            db_.insertIntoTable("mannernymy", std::move(fields));
+          }
         }
       }
     }
-  }
-  
-  // per table
-  {
-    std::ifstream wnperfile(wnpref + "wn_per.pl");
-    if (!wnperfile.is_open())
-    {
-      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')
+    void generator::readWordNetSpecification()
+    {
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_sa.pl"));
+      progress ppgs("Writing specifications...", lines.size());
+      for (auto line : lines)
       {
-        line.pop_back();
+        ppgs.update();
+
+        std::regex relation("^sa\\((23\\d{8}),(\\d+),(23\\d{8}),(\\d+)\\)\\.");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
+        {
+          continue;
+        }
+
+        std::pair<int, int> lookup1(std::stoi(relation_data[1]), std::stoi(relation_data[2]));
+        std::pair<int, int> lookup2(std::stoi(relation_data[3]), std::stoi(relation_data[4]));
+        
+        if (wordByWnidAndWnum_.count(lookup1) && wordByWnidAndWnum_.count(lookup2))
+        {
+          word& word1 = *wordByWnidAndWnum_.at(lookup1);
+          word& word2 = *wordByWnidAndWnum_.at(lookup2);
+          
+          std::list<field> fields;
+          fields.emplace_back("general_id", word1.getId());
+          fields.emplace_back("specific_id", word2.getId());
+          
+          db_.insertIntoTable("specification", std::move(fields));
+        }
       }
-      
-      lines.push_back(line);
     }
     
-    progress ppgs("Writing pertainyms and mannernyms...", lines.size());
-    for (auto line : lines)
+    void generator::readWordNetSimilarity()
     {
-      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))
+      std::list<std::string> lines(readFile(wordNetPath_ + "wn_sim.pl"));
+      progress ppgs("Writing adjective similarity...", lines.size());
+      for (auto line : lines)
       {
-        continue;
-      }
+        ppgs.update();
       
-      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
+        std::regex relation("^sim\\((3\\d{8}),(3\\d{8})\\)\\.");
+        std::smatch relation_data;
+        if (!std::regex_search(line, relation_data, relation))
         {
-          // 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;
+          continue;
         }
+
+        int lookup1 = std::stoi(relation_data[1]);
+        int lookup2 = std::stoi(relation_data[2]);
         
-        case 4: // Adverb
+        if (notionByWnid_.count(lookup1) && notionByWnid_.count(lookup2))
         {
-          // This is a mannernym, the second word should be an adjective
-          if (synset_id_2 / 100000000 != 3)
-          {
-            continue;
-          }
+          notion& notion1 = *notionByWnid_.at(lookup1);
+          notion& notion2 = *notionByWnid_.at(lookup2);
           
-          query = "INSERT INTO mannernymy (mannernym_id, adjective_id) VALUES (?, ?)";
+          std::list<field> fields;
+          fields.emplace_back("adjective_1_id", notion1.getId());
+          fields.emplace_back("adjective_2_id", notion2.getId());
           
-          break;
+          db_.insertIntoTable("similarity", std::move(fields));
         }
       }
-      
-      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)
+    std::list<std::string> generator::readFile(std::string path)
+    {
+      std::ifstream file(path);
+      if (!file)
       {
-        db_error(ppdb, query);
+        throw std::invalid_argument("Could not find file " + path);
       }
-    
-      sqlite3_finalize(ppstmt);
-    }
-  }
   
-  // sa table
-  {
-    std::ifstream wnsafile(wnpref + "wn_sa.pl");
-    if (!wnsafile.is_open())
-    {
-      std::cout << "Invalid WordNet data directory." << std::endl;
-      print_usage();
-    }
-
-    std::list<std::string> lines;
-    for (;;)
-    {
+      std::list<std::string> lines;
       std::string line;
-      if (!getline(wnsafile, line))
-      {
-        break;
-      }
-    
-      if (line.back() == '\r')
+      while (std::getline(file, line))
       {
-        line.pop_back();
+        if (line.back() == '\r')
+        {
+          line.pop_back();
+        }
+      
+        lines.push_back(line);
       }
       
-      lines.push_back(line);
+      return lines;
     }
     
-    progress ppgs("Writing specifications...", lines.size());
-    for (auto line : lines)
+    part_of_speech generator::partOfSpeechByWnid(int wnid)
     {
-      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)
+      switch (wnid / 100000000)
       {
-        db_error(ppdb, query);
+        case 1: return part_of_speech::noun;
+        case 2: return part_of_speech::verb;
+        case 3: return part_of_speech::adjective;
+        case 4: return part_of_speech::adverb;
+        default: throw std::domain_error("Invalid WordNet synset ID: " + std::to_string(wnid));
       }
+    }
     
-      sqlite3_bind_int(ppstmt, 1, wn[synset_id_1][wnum_1]);
-      sqlite3_bind_int(ppstmt, 2, wn[synset_id_2][wnum_2]);
+    notion& generator::createNotion(part_of_speech partOfSpeech)
+    {
+      notions_.emplace_back(partOfSpeech);
+      
+      return notions_.back();
+    }
     
-      if (sqlite3_step(ppstmt) != SQLITE_DONE)
+    notion& generator::lookupOrCreateNotion(int wnid)
+    {
+      if (!notionByWnid_.count(wnid))
       {
-        db_error(ppdb, query);
+        notions_.emplace_back(partOfSpeechByWnid(wnid), wnid);
+        notionByWnid_[wnid] = &notions_.back();
       }
-    
-      sqlite3_finalize(ppstmt);
-    }
-  }
-
-  // sim table
-  {
-    std::ifstream wnsimfile(wnpref + "wn_sim.pl");
-    if (!wnsimfile.is_open())
-    {
-      std::cout << "Invalid WordNet data directory." << std::endl;
-      print_usage();
+      
+      return *notionByWnid_.at(wnid);
     }
-
-    std::list<std::string> lines;
-    for (;;)
+    
+    lemma& generator::lookupOrCreateLemma(std::string base_form)
     {
-      std::string line;
-      if (!getline(wnsimfile, line))
+      if (!lemmaByBaseForm_.count(base_form))
       {
-        break;
+        lemmas_.emplace_back(lookupOrCreateForm(base_form));
+        lemmaByBaseForm_[base_form] = &lemmas_.back();
       }
+      
+      return *lemmaByBaseForm_.at(base_form);
+    }
     
-      if (line.back() == '\r')
+    form& generator::lookupOrCreateForm(std::string text)
+    {
+      if (!formByText_.count(text))
       {
-        line.pop_back();
+        forms_.emplace_back(text);
+        formByText_[text] = &forms_.back();
       }
       
-      lines.push_back(line);
+      return *formByText_[text];
     }
     
-    progress ppgs("Writing sense synonyms...", lines.size());
-    for (auto line : lines)
+    template <typename... Args> word& generator::createWord(Args&&... args)
     {
-      ppgs.update();
+      words_.emplace_back(std::forward<Args>(args)...);
+      word& w = words_.back();
       
-      std::regex relation("^sim\\((3\\d{8}),(3\\d{8})\\)\\.");
-      std::smatch relation_data;
-      if (!std::regex_search(line, relation_data, relation))
+      wordsByBaseForm_[w.getLemma().getBaseForm().getText()].insert(&w);
+      
+      if (w.getNotion().hasWnid())
       {
-        continue;
+        wordsByWnid_[w.getNotion().getWnid()].insert(&w);
       }
       
-      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 (?, ?)");
+      return w;
+    }
+    
+    group& generator::createGroup(xmlNodePtr top)
+    {
+      groups_.emplace_back();
+      group& grp = groups_.back();
       
-      for (auto mapping1 : wn[synset_id_1])
+      xmlChar* key;
+  
+      for (xmlNodePtr node = top->xmlChildrenNode; node != nullptr; node = node->next)
       {
-        for (auto mapping2 : wn[synset_id_2])
+        if (!xmlStrcmp(node->name, reinterpret_cast<const xmlChar*>("SUBCLASSES")))
         {
-          sqlite3_stmt* ppstmt;
-          if (sqlite3_prepare_v2(ppdb, query.c_str(), query.size(), &ppstmt, NULL) != SQLITE_OK)
+          for (xmlNodePtr subclass = node->xmlChildrenNode; subclass != nullptr; subclass = subclass->next)
           {
-            db_error(ppdb, query);
+            if (!xmlStrcmp(subclass->name, reinterpret_cast<const xmlChar*>("VNSUBCLASS")))
+            {
+              try
+              {
+                group& subgrp = createGroup(subclass);
+                subgrp.setParent(grp);
+              } catch (const std::exception& e)
+              {
+                key = xmlGetProp(subclass, reinterpret_cast<const xmlChar*>("ID"));
+                
+                if (key == nullptr)
+                {
+                  std::throw_with_nested(std::logic_error("Error parsing IDless subgroup"));
+                } else {
+                  std::string subgroupId(reinterpret_cast<const char*>(key));
+                  xmlFree(key);
+                  
+                  std::throw_with_nested(std::logic_error("Error parsing subgroup " + subgroupId));
+                }
+              }
+            }
           }
-          
-          sqlite3_bind_int(ppstmt, 1, mapping1.second);
-          sqlite3_bind_int(ppstmt, 2, mapping2.second);
-          
-          if (sqlite3_step(ppstmt) != SQLITE_DONE)
+        } else if (!xmlStrcmp(node->name, reinterpret_cast<const xmlChar*>("MEMBERS")))
+        {
+          for (xmlNodePtr member = node->xmlChildrenNode; member != nullptr; member = member->next)
           {
-            db_error(ppdb, query);
+            if (!xmlStrcmp(member->name, reinterpret_cast<const xmlChar*>("MEMBER")))
+            {
+              key = xmlGetProp(member, reinterpret_cast<const xmlChar*>("wn"));
+              std::string wnSenses(reinterpret_cast<const char*>(key));
+              xmlFree(key);
+              
+              auto wnSenseKeys = split<std::list<std::string>>(wnSenses, " ");
+              if (!wnSenseKeys.empty())
+              {
+                std::list<std::string> tempKeys;
+                
+                std::transform(std::begin(wnSenseKeys), std::end(wnSenseKeys), std::back_inserter(tempKeys), [] (std::string sense) {
+                  return sense + "::";
+                });
+                
+                std::list<std::string> filteredKeys;
+                
+                std::remove_copy_if(std::begin(tempKeys), std::end(tempKeys), std::back_inserter(filteredKeys), [&] (std::string sense) {
+                  return !wnSenseKeys_.count(sense);
+                });
+                
+                wnSenseKeys = std::move(filteredKeys);
+              }
+              
+              if (!wnSenseKeys.empty())
+              {
+                for (std::string sense : wnSenseKeys)
+                {
+                  word& wordSense = *wnSenseKeys_[sense];
+                  wordSense.setVerbGroup(grp);
+                }
+              } else {
+                key = xmlGetProp(member, reinterpret_cast<const xmlChar*>("name"));
+                std::string memberName(reinterpret_cast<const char*>(key));
+                xmlFree(key);
+                
+                notion& n = createNotion(part_of_speech::verb);
+                lemma& l = lookupOrCreateLemma(memberName);
+                word& w = createWord(n, l);
+                
+                w.setVerbGroup(grp);
+              }
+            }
           }
-          
-          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)
+        } else if (!xmlStrcmp(node->name, reinterpret_cast<const xmlChar*>("THEMROLES")))
+        {
+          for (xmlNodePtr roletopnode = node->xmlChildrenNode; roletopnode != nullptr; roletopnode = roletopnode->next)
           {
-            db_error(ppdb, query);
+            if (!xmlStrcmp(roletopnode->name, reinterpret_cast<const xmlChar*>("THEMROLE")))
+            {
+              role r;
+              
+              key = xmlGetProp(roletopnode, reinterpret_cast<const xmlChar*>("type"));
+              std::string roleName = reinterpret_cast<const char*>(key);
+              xmlFree(key);
+              
+              for (xmlNodePtr rolenode = roletopnode->xmlChildrenNode; rolenode != nullptr; rolenode = rolenode->next)
+              {
+                if (!xmlStrcmp(rolenode->name, reinterpret_cast<const xmlChar*>("SELRESTRS")))
+                {
+                  r.setSelrestrs(parseSelrestr(rolenode));
+                }
+              }
+
+              grp.addRole(roleName, std::move(r));
+            }
           }
+        } else if (!xmlStrcmp(node->name, reinterpret_cast<const xmlChar*>("FRAMES")))
+        {
+          for (xmlNodePtr frametopnode = node->xmlChildrenNode; frametopnode != nullptr; frametopnode = frametopnode->next)
+          {
+            if (!xmlStrcmp(frametopnode->name, reinterpret_cast<const xmlChar*>("FRAME")))
+            {
+              frames_.emplace_back();
+              frame& fr = frames_.back();
           
-          sqlite3_finalize(ppstmt);
+              for (xmlNodePtr framenode = frametopnode->xmlChildrenNode; framenode != nullptr; framenode = framenode->next)
+              {
+                if (!xmlStrcmp(framenode->name, reinterpret_cast<const xmlChar*>("SYNTAX")))
+                {
+                  for (xmlNodePtr syntaxnode = framenode->xmlChildrenNode; syntaxnode != nullptr; syntaxnode = syntaxnode->next)
+                  {                
+                    if (!xmlStrcmp(syntaxnode->name, reinterpret_cast<const xmlChar*>("NP")))
+                    {
+                      key = xmlGetProp(syntaxnode, reinterpret_cast<const xmlChar*>("value"));
+                      std::string partRole = reinterpret_cast<const char*>(key);
+                      xmlFree(key);
+                  
+                      selrestr partSelrestrs;
+                      std::set<std::string> partSynrestrs;
+
+                      for (xmlNodePtr npnode = syntaxnode->xmlChildrenNode; npnode != nullptr; npnode = npnode->next)
+                      {
+                        if (!xmlStrcmp(npnode->name, reinterpret_cast<const xmlChar*>("SYNRESTRS")))
+                        {
+                          for (xmlNodePtr synrestr = npnode->xmlChildrenNode; synrestr != nullptr; synrestr = synrestr->next)
+                          {
+                            if (!xmlStrcmp(synrestr->name, reinterpret_cast<const xmlChar*>("SYNRESTR")))
+                            {
+                              key = xmlGetProp(synrestr, reinterpret_cast<const xmlChar*>("type"));
+                              partSynrestrs.insert(reinterpret_cast<const char*>(key));
+                              xmlFree(key);
+                            }
+                          }
+                        }
+                  
+                        if (!xmlStrcmp(npnode->name, reinterpret_cast<const xmlChar*>("SELRESTRS")))
+                        {
+                          partSelrestrs = parseSelrestr(npnode);
+                        }
+                      }
+                      
+                      fr.push_back(part::createNounPhrase(std::move(partRole), std::move(partSelrestrs), std::move(partSynrestrs)));
+                    } else if (!xmlStrcmp(syntaxnode->name, reinterpret_cast<const xmlChar*>("VERB")))
+                    {
+                      fr.push_back(part::createVerb());
+                    } else if (!xmlStrcmp(syntaxnode->name, reinterpret_cast<const xmlChar*>("PREP")))
+                    {
+                      std::set<std::string> partChoices;
+                      bool partLiteral;
+                      
+                      if (xmlHasProp(syntaxnode, reinterpret_cast<const xmlChar*>("value")))
+                      {
+                        partLiteral = true;
+                        
+                        key = xmlGetProp(syntaxnode, reinterpret_cast<const xmlChar*>("value"));
+                        std::string choicesStr = reinterpret_cast<const char*>(key);
+                        xmlFree(key);
+                        
+                        split(choicesStr, " ", std::inserter(partChoices, std::end(partChoices)));
+                      } else {
+                        partLiteral = false;
+                        
+                        for (xmlNodePtr npnode = syntaxnode->xmlChildrenNode; npnode != nullptr; npnode = npnode->next)
+                        {
+                          if (!xmlStrcmp(npnode->name, reinterpret_cast<const xmlChar*>("SELRESTRS")))
+                          {
+                            for (xmlNodePtr synrestr = npnode->xmlChildrenNode; synrestr != nullptr; synrestr = synrestr->next)
+                            {
+                              if (!xmlStrcmp(synrestr->name, reinterpret_cast<const xmlChar*>("SELRESTR")))
+                              {
+                                key = xmlGetProp(synrestr, reinterpret_cast<const xmlChar*>("type"));
+                                partChoices.insert(reinterpret_cast<const char*>(key));
+                                xmlFree(key);
+                              }
+                            }
+                          }
+                        }
+                      }
+                  
+                      fr.push_back(part::createPreposition(std::move(partChoices), partLiteral));
+                    } else if (!xmlStrcmp(syntaxnode->name, reinterpret_cast<const xmlChar*>("ADJ")))
+                    {
+                      fr.push_back(part::createAdjective());
+                    } else if (!xmlStrcmp(syntaxnode->name, reinterpret_cast<const xmlChar*>("ADV")))
+                    {
+                      fr.push_back(part::createAdverb());
+                    } else if (!xmlStrcmp(syntaxnode->name, reinterpret_cast<const xmlChar*>("LEX")))
+                    {
+                      key = xmlGetProp(syntaxnode, reinterpret_cast<const xmlChar*>("value"));
+                      std::string literalValue = reinterpret_cast<const char*>(key);
+                      xmlFree(key);
+                      
+                      fr.push_back(part::createLiteral(literalValue));
+                    } else {
+                      continue;
+                    }
+                  }
+
+                  grp.addFrame(fr);
+                }
+              }
+            }
+          }
         }
       }
-    }
-  }
-  
-  // syntax table
-  {
-    std::ifstream wnsyntaxfile(wnpref + "wn_syntax.pl");
-    if (!wnsyntaxfile.is_open())
-    {
-      std::cout << "Invalid WordNet data directory." << std::endl;
-      print_usage();
-    }
 
-    std::list<std::string> lines;
-    for (;;)
-    {
-      std::string line;
-      if (!getline(wnsyntaxfile, line))
-      {
-        break;
-      }
-    
-      if (line.back() == '\r')
-      {
-        line.pop_back();
-      }
-      
-      lines.push_back(line);
+      return grp;
     }
     
-    progress ppgs("Writing adjective syntax markers...", lines.size());
-    for (auto line : lines)
+    selrestr generator::parseSelrestr(xmlNodePtr top)
     {
-      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)
+      xmlChar* key;
+  
+      if (!xmlStrcmp(top->name, reinterpret_cast<const xmlChar*>("SELRESTRS")))
       {
-        db_error(ppdb, query);
-      }
-      
-      sqlite3_bind_text(ppstmt, 1, syn.c_str(), 1, SQLITE_TRANSIENT);
-      sqlite3_bind_int(ppstmt, 2, wn[synset_id][wnum]);
-      
-      if (sqlite3_step(ppstmt) != SQLITE_DONE)
+        if (xmlChildElementCount(top) == 0)
+        {
+          return {};
+        } else if (xmlChildElementCount(top) == 1)
+        {
+          return parseSelrestr(xmlFirstElementChild(top));
+        } else {
+          bool orlogic = false;
+          if (xmlHasProp(top, reinterpret_cast<const xmlChar*>("logic")))
+          {
+            key = xmlGetProp(top, reinterpret_cast<const xmlChar*>("logic"));
+            if (!xmlStrcmp(key, reinterpret_cast<const xmlChar*>("or")))
+            {
+              orlogic = true;
+            }
+            
+            xmlFree(key);
+          }
+  
+          std::list<selrestr> children;
+          for (xmlNodePtr selrestr = top->xmlChildrenNode; selrestr != nullptr; selrestr = selrestr->next)
+          {
+            if (!xmlStrcmp(selrestr->name, reinterpret_cast<const xmlChar*>("SELRESTRS"))
+              || !xmlStrcmp(selrestr->name, reinterpret_cast<const xmlChar*>("SELRESTR")))
+            {
+              children.push_back(parseSelrestr(selrestr));
+            }
+          }
+          
+          return selrestr(children, orlogic);
+        }
+      } else if (!xmlStrcmp(top->name, reinterpret_cast<const xmlChar*>("SELRESTR")))
       {
-        db_error(ppdb, query);
+        key = xmlGetProp(top, reinterpret_cast<const xmlChar*>("Value"));
+        bool selPos = (std::string(reinterpret_cast<const char*>(key)) == "+");
+        xmlFree(key);
+
+        key = xmlGetProp(top, reinterpret_cast<const xmlChar*>("type"));
+        std::string selRestriction = reinterpret_cast<const char*>(key);
+        xmlFree(key);
+        
+        return selrestr(selRestriction, selPos);
+      } else {
+        throw std::logic_error("Badly formatted selrestr");
       }
-      
-      sqlite3_finalize(ppstmt);
     }
-  }
-  
-  sqlite3_close_v2(ppdb);
-  
-  std::cout << "Done." << std::endl;
-}
+    
+  };
+};
@@ -0,0 +1,151 @@
+#ifndef GENERATOR_H_5B61CBC5
+#define GENERATOR_H_5B61CBC5
+
+#include <string>
+#include <map>
+#include <list>
+#include <set>
+#include <libxml/parser.h>
+#include "database.h"
+#include "notion.h"
+#include "word.h"
+#include "lemma.h"
+#include "form.h"
+#include "pronunciation.h"
+#include "group.h"
+#include "frame.h"
+
+namespace verbly {
+  namespace generator {
+
+    enum class part_of_speech;
+    class selrestr;
+    
+    class generator {
+    public:
+      
+      // Constructor
+      
+      generator(
+        std::string verbNetPath,
+        std::string agidPath,
+        std::string wordNetPath,
+        std::string cmudictPath,
+        std::string imageNetPath,
+        std::string outputPath);
+      
+      // Action
+      
+      void run();
+      
+    private:
+      
+      // Subroutines
+      
+      void readWordNetSynsets();
+      
+      void readAdjectivePositioning();
+      
+      void readImageNetUrls();
+      
+      void readWordNetSenseKeys();
+      
+      void readVerbNet();
+      
+      void readAgidInflections();
+      
+      void readPrepositions();
+      
+      void readCmudictPronunciations();
+      
+      void writeSchema();
+      
+      void dumpObjects();
+      
+      void readWordNetAntonymy();
+      
+      void readWordNetVariation();
+      
+      void readWordNetClasses();
+      
+      void readWordNetCausality();
+      
+      void readWordNetEntailment();
+      
+      void readWordNetHypernymy();
+      
+      void readWordNetInstantiation();
+      
+      void readWordNetMemberMeronymy();
+      
+      void readWordNetPartMeronymy();
+      
+      void readWordNetSubstanceMeronymy();
+      
+      void readWordNetPertainymy();
+      
+      void readWordNetSpecification();
+      
+      void readWordNetSimilarity();
+      
+      // Helpers
+      
+      std::list<std::string> readFile(std::string path);
+      
+      inline part_of_speech partOfSpeechByWnid(int wnid);
+      
+      notion& createNotion(part_of_speech partOfSpeech);
+      
+      notion& lookupOrCreateNotion(int wnid);
+      
+      lemma& lookupOrCreateLemma(std::string base_form);
+      
+      form& lookupOrCreateForm(std::string text);
+      
+      template <typename... Args> word& createWord(Args&&... args);
+      
+      group& createGroup(xmlNodePtr top);
+      
+      selrestr parseSelrestr(xmlNodePtr top);
+      
+      // Input
+      
+      std::string verbNetPath_;
+      std::string agidPath_;
+      std::string wordNetPath_;
+      std::string cmudictPath_;
+      std::string imageNetPath_;
+      
+      // Output
+      
+      database db_;
+      
+      // Data
+      
+      std::list<notion> notions_;
+      std::list<word> words_;
+      std::list<lemma> lemmas_;
+      std::list<form> forms_;
+      std::list<pronunciation> pronunciations_;
+      std::list<frame> frames_;
+      std::list<group> groups_;
+      
+      // Indexes
+      
+      std::map<int, notion*> notionByWnid_;
+      std::map<int, std::set<word*>> wordsByWnid_;
+      std::map<std::pair<int, int>, word*> wordByWnidAndWnum_;
+      std::map<std::string, std::set<word*>> wordsByBaseForm_;
+      std::map<std::string, lemma*> lemmaByBaseForm_;
+      std::map<std::string, form*> formByText_;
+      
+      // Caches
+      
+      std::map<std::string, word*> wnSenseKeys_;
+      
+    };
+    
+  };
+};
+
+#endif /* end of include guard: GENERATOR_H_5B61CBC5 */
@@ -0,0 +1,119 @@
+#include "group.h"
+#include <stdexcept>
+#include <list>
+#include <json.hpp>
+#include "database.h"
+#include "field.h"
+#include "frame.h"
+
+namespace verbly {
+  namespace generator {
+    
+    int group::nextId_ = 0;
+    
+    group::group() : id_(nextId_++)
+    {
+    }
+    
+    void group::setParent(const group& parent)
+    {
+      // Adding a group to itself is nonsensical.
+      assert(&parent != this);
+      
+      parent_ = &parent;
+    }
+    
+    void group::addRole(std::string name, role r)
+    {
+      roleNames_.insert(name);
+      roles_[name] = std::move(r);
+    }
+    
+    void group::addFrame(const frame& f)
+    {
+      frames_.insert(&f);
+    }
+    
+    std::set<std::string> group::getRoles() const
+    {
+      std::set<std::string> fullRoles = roleNames_;
+      
+      if (hasParent())
+      {
+        for (std::string name : getParent().getRoles())
+        {
+          fullRoles.insert(name);
+        }
+      }
+      
+      return fullRoles;
+    }
+    
+    const role& group::getRole(std::string name) const
+    {
+      if (roles_.count(name))
+      {
+        return roles_.at(name);
+      } else if (hasParent())
+      {
+        return getParent().getRole(name);
+      } else {
+        throw std::invalid_argument("Specified role not found in verb group");
+      }
+    }
+    
+    std::set<const frame*> group::getFrames() const
+    {
+      std::set<const frame*> fullFrames = frames_;
+      
+      if (hasParent())
+      {
+        for (const frame* f : getParent().getFrames())
+        {
+          fullFrames.insert(f);
+        }
+      }
+      
+      return fullFrames;
+    }
+    
+    database& operator<<(database& db, const group& arg)
+    {
+      // Serialize the group first
+      {
+        std::list<field> fields;
+        fields.emplace_back("group_id", arg.getId());
+        
+        nlohmann::json jsonRoles;
+        for (std::string name : arg.getRoles())
+        {
+          const role& r = arg.getRole(name);
+          
+          nlohmann::json jsonRole;
+          jsonRole["type"] = name;
+          jsonRole["selrestrs"] = r.getSelrestrs().toJson();
+          
+          jsonRoles.emplace_back(std::move(jsonRole));
+        }
+
+        fields.emplace_back("data", jsonRoles.dump());
+        
+        db.insertIntoTable("groups", std::move(fields));
+      }
+      
+      // Then, serialize the group/frame relationship
+      for (const frame* f : arg.getFrames())
+      {
+        std::list<field> fields;
+        
+        fields.emplace_back("group_id", arg.getId());
+        fields.emplace_back("frame_id", f->getId());
+        
+        db.insertIntoTable("groups_frames", std::move(fields));
+      }
+      
+      return db;
+    }
+    
+  };
+};
@@ -0,0 +1,80 @@
+#ifndef GROUP_H_EDAFB5DC
+#define GROUP_H_EDAFB5DC
+
+#include <map>
+#include <set>
+#include <string>
+#include <cassert>
+#include "role.h"
+
+namespace verbly {
+  namespace generator {
+    
+    class frame;
+    class database;
+    
+    class group {
+    public:
+      
+      // Constructor
+      
+      group();
+      
+      // Mutators
+      
+      void setParent(const group& parent);
+      
+      void addRole(std::string name, role r);
+      
+      void addFrame(const frame& f);
+      
+      // Accessors
+      
+      int getId() const
+      {
+        return id_;
+      }
+      
+      bool hasParent() const
+      {
+        return (parent_ != nullptr);
+      }
+      
+      const group& getParent() const
+      {
+        // Calling code should always call hasParent first
+        assert(parent_ != nullptr);
+        
+        return *parent_;
+      }
+      
+      std::set<std::string> getRoles() const;
+      
+      const role& getRole(std::string name) const;
+      
+      std::set<const frame*> getFrames() const;
+      
+    private:
+      
+      static int nextId_;
+      
+      const int id_;
+      
+      const group* parent_ = nullptr;
+      std::map<std::string, role> roles_;
+      std::set<const frame*> frames_;
+      
+      // Caches
+      
+      std::set<std::string> roleNames_;
+      
+    };
+    
+    // Serializer
+    
+    database& operator<<(database& db, const group& arg);
+    
+  };
+};
+
+#endif /* end of include guard: GROUP_H_EDAFB5DC */
@@ -0,0 +1,65 @@
+#include "lemma.h"
+#include <list>
+#include <cassert>
+#include "field.h"
+#include "database.h"
+#include "form.h"
+
+namespace verbly {
+  namespace generator {
+
+    int lemma::nextId_ = 0;
+
+    lemma::lemma(const form& baseForm) :
+      id_(nextId_++),
+      baseForm_(baseForm)
+    {
+      inflections_[inflection::base] = {&baseForm};
+    }
+
+    void lemma::addInflection(inflection type, const form& f)
+    {
+      // There can only be one base form.
+      assert(type != inflection::base);
+
+      inflections_[type].insert(&f);
+    }
+
+    std::set<const form*> lemma::getInflections(inflection type) const
+    {
+      if (inflections_.count(type))
+      {
+        return inflections_.at(type);
+      } else {
+        return {};
+      }
+    }
+
+    database& operator<<(database& db, const lemma& arg)
+    {
+      for (inflection type : {
+        inflection::base,
+        inflection::plural,
+        inflection::comparative,
+        inflection::superlative,
+        inflection::past_tense,
+        inflection::past_participle,
+        inflection::ing_form,
+        inflection::s_form})
+      {
+        for (const form* f : arg.getInflections(type))
+        {
+          std::list<field> fields;
+          fields.emplace_back("lemma_id", arg.getId());
+          fields.emplace_back("form_id", f->getId());
+          fields.emplace_back("category", static_cast<int>(type));
+
+          db.insertIntoTable("lemmas_forms", std::move(fields));
+        }
+      }
+
+      return db;
+    }
+
+  };
+};
@@ -0,0 +1,58 @@
+#ifndef LEMMA_H_D73105A7
+#define LEMMA_H_D73105A7
+
+#include <string>
+#include <map>
+#include <set>
+#include "enums.h"
+
+namespace verbly {
+  namespace generator {
+
+    class database;
+    class form;
+
+    class lemma {
+    public:
+
+      // Constructors
+
+      explicit lemma(const form& baseForm);
+
+      // Mutators
+
+      void addInflection(inflection type, const form& f);
+
+      // Accessors
+
+      int getId() const
+      {
+        return id_;
+      }
+
+      const form& getBaseForm() const
+      {
+        return baseForm_;
+      }
+
+      std::set<const form*> getInflections(inflection type) const;
+
+    private:
+
+      static int nextId_;
+
+      const int id_;
+      const form& baseForm_;
+
+      std::map<inflection, std::set<const form*>> inflections_;
+
+    };
+
+    // Serializer
+
+    database& operator<<(database& db, const lemma& arg);
+
+  };
+};
+
+#endif /* end of include guard: LEMMA_H_D73105A7 */
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <exception>
+#include "generator.h"
+
+void printUsage()
+{
+  std::cout << "usage: generator verbnet agid wordnet cmudict imagenet output" << std::endl;
+  std::cout << "verbnet  :: path to a VerbNet data directory" << std::endl;
+  std::cout << "agid     :: path to an AGID infl.txt file" << std::endl;
+  std::cout << "wordnet  :: path to a WordNet prolog data directory" << std::endl;
+  std::cout << "cmudict  :: path to a CMUDICT pronunciation file" << std::endl;
+  std::cout << "imagenet :: path to an ImageNet urls.txt file" << std::endl;
+  std::cout << "output   :: datafile output path" << std::endl;
+}
+
+int main(int argc, char** argv)
+{
+  if (argc == 7)
+  {
+    try
+    {
+      verbly::generator::generator app(argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]);
+      
+      try
+      {
+        app.run();
+      } catch (const std::exception& e)
+      {
+        std::cout << e.what() << std::endl;
+      }
+    } catch (const std::exception& e)
+    {
+      std::cout << e.what() << std::endl;
+      printUsage();
+    }
+  } else {
+    std::cout << "verbly datafile generator" << std::endl;
+    printUsage();
+  }
+}
@@ -0,0 +1,85 @@
+#include "notion.h"
+#include <string>
+#include <list>
+#include "database.h"
+#include "field.h"
+
+namespace verbly {
+  namespace generator {
+
+    int notion::nextId_ = 0;
+
+    notion::notion(
+      part_of_speech partOfSpeech) :
+        id_(nextId_++),
+        partOfSpeech_(partOfSpeech)
+    {
+    }
+
+    notion::notion(
+      part_of_speech partOfSpeech,
+      int wnid) :
+        id_(nextId_++),
+        partOfSpeech_(partOfSpeech),
+        wnid_(wnid),
+        hasWnid_(true)
+    {
+    }
+
+    void notion::incrementNumOfImages()
+    {
+      // Calling code should always call hasWnid and check that the notion is a noun first.
+      assert(hasWnid_ && (partOfSpeech_ == part_of_speech::noun));
+      
+      numOfImages_++;
+    }
+    
+    void notion::setPrepositionGroups(std::list<std::string> groups)
+    {
+      // Calling code should always check that the notion is a preposition first.
+      assert(partOfSpeech_ == part_of_speech::preposition);
+      
+      prepositionGroups_ = groups;
+    }
+
+    database& operator<<(database& db, const notion& arg)
+    {
+      // First, serialize the notion
+      {
+        std::list<field> fields;
+
+        fields.emplace_back("notion_id", arg.getId());
+        fields.emplace_back("part_of_speech", static_cast<int>(arg.getPartOfSpeech()));
+
+        if (arg.hasWnid())
+        {
+          fields.emplace_back("wnid", arg.getWnid());
+        
+          if (arg.getPartOfSpeech() == part_of_speech::noun)
+          {
+            fields.emplace_back("images", arg.getNumOfImages());
+          }
+        }
+
+        db.insertIntoTable("notions", std::move(fields));
+      }
+      
+      // Next, serialize the is_a relationship if this is a preposition
+      if (arg.getPartOfSpeech() == part_of_speech::preposition)
+      {
+        for (std::string group : arg.getPrepositionGroups())
+        {
+          std::list<field> fields;
+          
+          fields.emplace_back("notion_id", arg.getId());
+          fields.emplace_back("groupname", group);
+          
+          db.insertIntoTable("is_a", std::move(fields));
+        }
+      }
+
+      return db;
+    }
+
+  };
+};
@@ -0,0 +1,91 @@
+#ifndef NOTION_H_221DE2BC
+#define NOTION_H_221DE2BC
+
+#include <cassert>
+#include <list>
+#include <string>
+#include "enums.h"
+
+namespace verbly {
+  namespace generator {
+
+    class database;
+
+    class notion {
+    public:
+
+      // Constructors
+
+      explicit notion(part_of_speech partOfSpeech);
+
+      notion(part_of_speech partOfSpeech, int wnid);
+
+      // Mutators
+
+      void incrementNumOfImages();
+      
+      void setPrepositionGroups(std::list<std::string> groups);
+
+      // Accessors
+
+      int getId() const
+      {
+        return id_;
+      }
+
+      part_of_speech getPartOfSpeech() const
+      {
+        return partOfSpeech_;
+      }
+      
+      bool hasWnid() const
+      {
+        return hasWnid_;
+      }
+
+      int getWnid() const
+      {
+        // Calling code should always call hasWnid first.
+        assert(hasWnid_);
+
+        return wnid_;
+      }
+
+      int getNumOfImages() const
+      {
+        // Calling code should always call hasWnid and check that the notion is a noun first.
+        assert(hasWnid_ && (partOfSpeech_ == part_of_speech::noun));
+
+        return numOfImages_;
+      }
+      
+      std::list<std::string> getPrepositionGroups() const
+      {
+        // Calling code should always check that the notion is a preposition first.
+        assert(partOfSpeech_ == part_of_speech::preposition);
+        
+        return prepositionGroups_;
+      }
+
+    private:
+
+      static int nextId_;
+
+      const int id_;
+      const part_of_speech partOfSpeech_;
+      const int wnid_ = 0;
+      const bool hasWnid_ = false;
+
+      int numOfImages_ = 0;
+      std::list<std::string> prepositionGroups_;
+
+    };
+
+    // Serializer
+
+    database& operator<<(database& db, const notion& arg);
+
+  };
+};
+
+#endif /* end of include guard: NOTION_H_221DE2BC */
@@ -0,0 +1,336 @@
+#include "part.h"
+#include <stdexcept>
+#include "selrestr.h"
+
+namespace verbly {
+  namespace generator {
+    
+    part part::createNounPhrase(std::string role, selrestr selrestrs, std::set<std::string> synrestrs)
+    {
+      part p(type::noun_phrase);
+      
+      new(&p.noun_phrase_.role) std::string(std::move(role));
+      new(&p.noun_phrase_.selrestrs) selrestr(std::move(selrestrs));
+      new(&p.noun_phrase_.synrestrs) std::set<std::string>(std::move(synrestrs));
+      
+      return p;
+    }
+    
+    part part::createVerb()
+    {
+      return part(type::verb);
+    }
+    
+    part part::createPreposition(std::set<std::string> choices, bool literal)
+    {
+      part p(type::preposition);
+      
+      new(&p.preposition_.choices) std::set<std::string>(std::move(choices));
+      p.preposition_.literal = literal;
+      
+      return p;
+    }
+    
+    part part::createAdjective()
+    {
+      return part(type::adjective);
+    }
+    
+    part part::createAdverb()
+    {
+      return part(type::adverb);
+    }
+    
+    part part::createLiteral(std::string value)
+    {
+      part p(type::literal);
+      
+      new(&p.literal_) std::string(std::move(value));
+      
+      return p;
+    }
+    
+    part::part(const part& other)
+    {
+      type_ = other.type_;
+      
+      switch (type_)
+      {
+        case type::noun_phrase:
+        {
+          new(&noun_phrase_.role) std::string(other.noun_phrase_.role);
+          new(&noun_phrase_.selrestrs) selrestr(other.noun_phrase_.selrestrs);
+          new(&noun_phrase_.synrestrs) std::set<std::string>(other.noun_phrase_.synrestrs);
+          
+          break;
+        }
+        
+        case type::preposition:
+        {
+          new(&preposition_.choices) std::set<std::string>(other.preposition_.choices);
+          preposition_.literal = other.preposition_.literal;
+          
+          break;
+        }
+        
+        case type::literal:
+        {
+          new(&literal_) std::string(other.literal_);
+          
+          break;
+        }
+        
+        case type::verb:
+        case type::adjective:
+        case type::adverb:
+        case type::invalid:
+        {
+          break;
+        }
+      }
+    }
+    
+    part::part(part&& other) : part()
+    {
+      swap(*this, other);
+    }
+    
+    part& part::operator=(part other)
+    {
+      swap(*this, other);
+      
+      return *this;
+    }
+    
+    void swap(part& first, part& second)
+    {
+      using type = part::type;
+      
+      type tempType = first.type_;
+      std::string tempRole;
+      selrestr tempSelrestrs;
+      std::set<std::string> tempSynrestrs;
+      std::set<std::string> tempChoices;
+      bool tempPrepLiteral;
+      std::string tempLiteralValue;
+      
+      switch (tempType)
+      {
+        case type::noun_phrase:
+        {
+          tempRole = std::move(first.noun_phrase_.role);
+          tempSelrestrs = std::move(first.noun_phrase_.selrestrs);
+          tempSynrestrs = std::move(first.noun_phrase_.synrestrs);
+          
+          break;
+        }
+        
+        case type::preposition:
+        {
+          tempChoices = std::move(first.preposition_.choices);
+          tempPrepLiteral = first.preposition_.literal;
+          
+          break;
+        }
+        
+        case type::literal:
+        {
+          tempLiteralValue = std::move(first.literal_);
+          
+          break;
+        }
+        
+        case type::verb:
+        case type::adjective:
+        case type::adverb:
+        case type::invalid:
+        {
+          break;
+        }
+      }
+      
+      first.~part();
+      
+      first.type_ = second.type_;
+      
+      switch (first.type_)
+      {
+        case type::noun_phrase:
+        {
+          new(&first.noun_phrase_.role) std::string(std::move(second.noun_phrase_.role));
+          new(&first.noun_phrase_.selrestrs) selrestr(std::move(second.noun_phrase_.selrestrs));
+          new(&first.noun_phrase_.synrestrs) std::set<std::string>(std::move(second.noun_phrase_.synrestrs));
+          
+          break;
+        }
+        
+        case type::preposition:
+        {
+          new(&first.preposition_.choices) std::set<std::string>(std::move(second.preposition_.choices));
+          first.preposition_.literal = second.preposition_.literal;
+          
+          break;
+        }
+        
+        case type::literal:
+        {
+          new(&first.literal_) std::string(std::move(second.literal_));
+          
+          break;
+        }
+        
+        case type::verb:
+        case type::adjective:
+        case type::adverb:
+        case type::invalid:
+        {
+          break;
+        }
+      }
+      
+      second.~part();
+      
+      second.type_ = tempType;
+      
+      switch (second.type_)
+      {
+        case type::noun_phrase:
+        {
+          new(&second.noun_phrase_.role) std::string(std::move(tempRole));
+          new(&second.noun_phrase_.selrestrs) selrestr(std::move(tempSelrestrs));
+          new(&second.noun_phrase_.synrestrs) std::set<std::string>(std::move(tempSynrestrs));
+          
+          break;
+        }
+        
+        case type::preposition:
+        {
+          new(&second.preposition_.choices) std::set<std::string>(std::move(tempChoices));
+          second.preposition_.literal = tempPrepLiteral;
+          
+          break;
+        }
+        
+        case type::literal:
+        {
+          new(&second.literal_) std::string(std::move(tempLiteralValue));
+          
+          break;
+        }
+        
+        case type::verb:
+        case type::adjective:
+        case type::adverb:
+        case type::invalid:
+        {
+          break;
+        }
+      }
+    }
+    
+    part::~part()
+    {
+      switch (type_)
+      {
+        case type::noun_phrase:
+        {
+          using string_type = std::string;
+          using set_type = std::set<std::string>;
+          
+          noun_phrase_.role.~string_type();
+          noun_phrase_.selrestrs.~selrestr();
+          noun_phrase_.synrestrs.~set_type();
+          
+          break;
+        }
+        
+        case type::preposition:
+        {
+          using set_type = std::set<std::string>;
+          
+          preposition_.choices.~set_type();
+          
+          break;
+        }
+        
+        case type::literal:
+        {
+          using string_type = std::string;
+          
+          literal_.~string_type();
+          
+          break;
+        }
+        
+        case type::verb:
+        case type::adjective:
+        case type::adverb:
+        case type::invalid:
+        {
+          break;
+        }
+      }
+    }
+    
+    std::string part::getNounRole() const
+    {
+      if (type_ == type::noun_phrase)
+      {
+        return noun_phrase_.role;
+      } else {
+        throw std::domain_error("part::getNounRole is only valid for noun phrase parts");
+      }
+    }
+    
+    selrestr part::getNounSelrestrs() const
+    {
+      if (type_ == type::noun_phrase)
+      {
+        return noun_phrase_.selrestrs;
+      } else {
+        throw std::domain_error("part::getNounSelrestrs is only valid for noun phrase parts");
+      }
+    }
+    
+    std::set<std::string> part::getNounSynrestrs() const
+    {
+      if (type_ == type::noun_phrase)
+      {
+        return noun_phrase_.synrestrs;
+      } else {
+        throw std::domain_error("part::getNounSynrestrs is only valid for noun phrase parts");
+      }
+    }
+    
+    std::set<std::string> part::getPrepositionChoices() const
+    {
+      if (type_ == type::preposition)
+      {
+        return preposition_.choices;
+      } else {
+        throw std::domain_error("part::getPrepositionChoices is only valid for preposition parts");
+      }
+    }
+    
+    bool part::isPrepositionLiteral() const
+    {
+      if (type_ == type::preposition)
+      {
+        return preposition_.literal;
+      } else {
+        throw std::domain_error("part::isPrepositionLiteral is only valid for preposition parts");
+      }
+    }
+    
+    std::string part::getLiteralValue() const
+    {
+      if (type_ == type::literal)
+      {
+        return literal_;
+      } else {
+        throw std::domain_error("part::getLiteralValue is only valid for literal parts");
+      }
+    }
+    
+  };
+};
@@ -0,0 +1,114 @@
+#ifndef PART_H_FB54F361
+#define PART_H_FB54F361
+
+#include <string>
+#include <set>
+#include "selrestr.h"
+
+namespace verbly {
+  namespace generator {
+    
+    class part {
+    public:
+      enum class type {
+        invalid = -1,
+        noun_phrase = 0,
+        verb = 1,
+        preposition = 2,
+        adjective = 3,
+        adverb = 4,
+        literal = 5
+      };
+      
+      // Static factories
+      
+      static part createNounPhrase(std::string role, selrestr selrestrs, std::set<std::string> synrestrs);
+      
+      static part createVerb();
+      
+      static part createPreposition(std::set<std::string> choices, bool literal);
+      
+      static part createAdjective();
+      
+      static part createAdverb();
+      
+      static part createLiteral(std::string value);
+      
+      // Copy and move constructors
+      
+      part(const part& other);
+      
+      part(part&& other);
+      
+      // Assignment
+      
+      part& operator=(part other);
+      
+      // Swap
+      
+      friend void swap(part& first, part& second);
+      
+      // Destructor
+      
+      ~part();
+      
+      // General accessors
+      
+      type getType() const
+      {
+        return type_;
+      }
+      
+      // Noun phrase accessors
+      
+      std::string getNounRole() const;
+      
+      selrestr getNounSelrestrs() const;
+      
+      std::set<std::string> getNounSynrestrs() const;
+      
+      // Preposition accessors
+      
+      std::set<std::string> getPrepositionChoices() const;
+      
+      bool isPrepositionLiteral() const;
+      
+      // Literal accessors
+      
+      std::string getLiteralValue() const;
+      
+    private:
+      
+      // Private constructors
+      
+      part()
+      {
+      }
+      
+      part(type t) : type_(t)
+      {
+      }
+      
+      // Data
+      
+      union {
+        struct {
+          std::string role;
+          selrestr selrestrs;
+          std::set<std::string> synrestrs;
+        } noun_phrase_;
+        struct {
+          std::set<std::string> choices;
+          bool literal;
+        } preposition_;
+        std::string literal_;
+      };
+      
+      type type_ = type::invalid;
+      
+    };
+    
+  };
+};
+
+#endif /* end of include guard: PART_H_FB54F361 */
@@ -3,48 +3,54 @@
 
 #include <string>
 
-class progress {
-  private:
-    std::string message;
-    int total;
-    int cur = 0;
-    int lprint = 0;
+namespace verbly {
+  namespace generator {
     
-  public:
-    progress(std::string message, int total) : message(message), total(total)
-    {
-      std::cout << message << "   0%" << std::flush;
-    }
+    class progress {
+      private:
+        std::string message;
+        int total;
+        int cur = 0;
+        int lprint = 0;
     
-    void update(int val)
-    {
-      if (val <= total)
-      {
-        cur = val;
-      } else {
-        cur = total;
-      }
+      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;
+          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;
-      }
-    }
+            std::cout << "\b\b\b\b" << std::right;
+            std::cout.width(3);
+            std::cout << pp << "%" << std::flush;
+          }
+        }
+    
+        void update()
+        {
+          update(cur+1);
+        }
     
-    void update()
-    {
-      update(cur+1);
-    }
+        ~progress()
+        {
+          std::cout << "\b\b\b\b100%" << std::endl;
+        }
+    };
     
-    ~progress()
-    {
-      std::cout << "\b\b\b\b100%" << std::endl;
-    }
+  };
 };
 
 #endif /* end of include guard: PROGRESS_H_A34EF856 */
@@ -0,0 +1,87 @@
+#include "pronunciation.h"
+#include <list>
+#include <algorithm>
+#include <cctype>
+#include <iterator>
+#include "database.h"
+#include "field.h"
+#include "../lib/util.h"
+
+namespace verbly {
+  namespace generator {
+
+    int pronunciation::nextId_ = 0;
+
+    pronunciation::pronunciation(std::string phonemes) :
+      id_(nextId_++),
+      phonemes_(phonemes)
+    {
+      auto phonemeList = split<std::list<std::string>>(phonemes, " ");
+
+      auto rhymeStart = std::find_if(std::begin(phonemeList), std::end(phonemeList), [] (std::string phoneme) {
+        return phoneme.find("1") != std::string::npos;
+      });
+
+      // Rhyme detection
+      if (rhymeStart != std::end(phonemeList))
+      {
+        std::list<std::string> rhymePhonemes;
+
+        std::transform(rhymeStart, std::end(phonemeList), std::back_inserter(rhymePhonemes), [] (std::string phoneme) {
+          std::string naked;
+
+          std::remove_copy_if(std::begin(phoneme), std::end(phoneme), std::back_inserter(naked), [] (char ch) {
+            return std::isdigit(ch);
+          });
+
+          return naked;
+        });
+
+        rhyme_ = implode(std::begin(rhymePhonemes), std::end(rhymePhonemes), " ");
+
+        if (rhymeStart != std::begin(phonemeList))
+        {
+          prerhyme_ = *std::prev(rhymeStart);
+        }
+      }
+
+      // Syllable/stress
+      for (std::string phoneme : phonemeList)
+      {
+        if (std::isdigit(phoneme.back()))
+        {
+          // It's a vowel!
+          syllables_++;
+
+          if (phoneme.back() == '1')
+          {
+            stress_.push_back('1');
+          } else {
+            stress_.push_back('0');
+          }
+        }
+      }
+    }
+
+    database& operator<<(database& db, const pronunciation& arg)
+    {
+      std::list<field> fields;
+
+      fields.emplace_back("pronunciation_id", arg.getId());
+      fields.emplace_back("phonemes", arg.getPhonemes());
+      fields.emplace_back("syllables", arg.getSyllables());
+      fields.emplace_back("stress", arg.getStress());
+
+      if (arg.hasRhyme())
+      {
+        fields.emplace_back("rhyme", arg.getRhymePhonemes());
+        fields.emplace_back("prerhyme", arg.getPrerhyme());
+      }
+
+      db.insertIntoTable("pronunciations", std::move(fields));
+
+      return db;
+    }
+
+  };
+};
@@ -0,0 +1,82 @@
+#ifndef PRONUNCIATION_H_584A08DD
+#define PRONUNCIATION_H_584A08DD
+
+#include <string>
+#include <cassert>
+
+namespace verbly {
+  namespace generator {
+
+    class database;
+
+    class pronunciation {
+    public:
+
+      // Constructor
+
+      explicit pronunciation(std::string phonemes);
+
+      // Accessors
+
+      int getId() const
+      {
+        return id_;
+      }
+
+      std::string getPhonemes() const
+      {
+        return phonemes_;
+      }
+
+      bool hasRhyme() const
+      {
+        return !rhyme_.empty();
+      }
+
+      std::string getRhymePhonemes() const
+      {
+        // Calling code should always call hasRhyme first.
+        assert(!rhyme_.empty());
+
+        return rhyme_;
+      }
+
+      std::string getPrerhyme() const
+      {
+        // Calling code should always call hasRhyme first.
+        assert(!rhyme_.empty());
+
+        return prerhyme_;
+      }
+
+      int getSyllables() const
+      {
+        return syllables_;
+      }
+
+      std::string getStress() const
+      {
+        return stress_;
+      }
+
+    private:
+
+      static int nextId_;
+
+      const int id_;
+      const std::string phonemes_;
+      std::string rhyme_;
+      std::string prerhyme_;
+      int syllables_ = 0;
+      std::string stress_;
+
+    };
+
+    // Serializer
+
+    database& operator<<(database& db, const pronunciation& arg);
+
+  };
+};
+
+#endif /* end of include guard: PRONUNCIATION_H_584A08DD */
@@ -0,0 +1,35 @@
+#ifndef ROLE_H_249F9A9C
+#define ROLE_H_249F9A9C
+
+#include "selrestr.h"
+
+namespace verbly {
+  namespace generator {
+    
+    class role {
+    public:
+      
+      // Mutators
+      
+      void setSelrestrs(selrestr selrestrs)
+      {
+        selrestrs_ = selrestrs;
+      }
+      
+      // Accessors
+      
+      const selrestr& getSelrestrs() const
+      {
+        return selrestrs_;
+      }
+      
+    private:
+      
+      selrestr selrestrs_;
+      
+    };
+    
+  };
+};
+
+#endif /* end of include guard: ROLE_H_249F9A9C */
@@ -1,286 +1,204 @@
-DROP TABLE IF EXISTS `verbs`;
-CREATE TABLE `verbs` (
-  `verb_id` INTEGER PRIMARY KEY,
-  `infinitive` VARCHAR(32) NOT NULL,
-  `past_tense` VARCHAR(32) NOT NULL,
-  `past_participle` VARCHAR(32) NOT NULL,
-  `ing_form` VARCHAR(32) NOT NULL,
-  `s_form` VARCHAR(32) NOT NULL
+CREATE TABLE `notions` (
+  `notion_id` INTEGER PRIMARY KEY,
+  `part_of_speech` SMALLINT NOT NULL,
+  `wnid` INTEGER,
+  `images` INTEGER
 );
 
-DROP TABLE IF EXISTS `groups`;
-CREATE TABLE `groups` (
-  `group_id` INTEGER PRIMARY KEY,
-  `data` BLOB NOT NULL
-);
-
-DROP TABLE IF EXISTS `frames`;
-CREATE TABLE `frames` (
-  `frame_id` INTEGER PRIMARY KEY,
-  `group_id` INTEGER NOT NULL,
-  `data` BLOB NOT NULL,
-  FOREIGN KEY (`group_id`) REFERENCES `groups`(`group_id`)
-);
+CREATE UNIQUE INDEX `notion_by_wnid` ON `notions`(`wnid`);
 
-DROP TABLE IF EXISTS `verb_groups`;
-CREATE TABLE `verb_groups` (
-  `verb_id` INTEGER NOT NULL,
-  `group_id` INTEGER NOT NULL,
-  FOREIGN KEY (`verb_id`) REFERENCES `verbs`(`verb_id`),
-  FOREIGN KEY (`group_id`) REFERENCES `groups`(`group_id`)
-);
-
-DROP TABLE IF EXISTS `adjectives`;
-CREATE TABLE `adjectives` (
-  `adjective_id` INTEGER PRIMARY KEY,
-  `base_form` VARCHAR(32) NOT NULL,
-  `comparative` VARCHAR(32),
-  `superlative` VARCHAR(32),
-  `position` CHAR(1),
-  `complexity` INTEGER NOT NULL
-);
-
-DROP TABLE IF EXISTS `adverbs`;
-CREATE TABLE `adverbs` (
-  `adverb_id` INTEGER PRIMARY KEY,
-  `base_form` VARCHAR(32) NOT NULL,
-  `comparative` VARCHAR(32),
-  `superlative` VARCHAR(32),
-  `complexity` INTEGER NOT NULL
-);
-
-DROP TABLE IF EXISTS `nouns`;
-CREATE TABLE `nouns` (
-  `noun_id` INTEGER PRIMARY KEY,
-  `singular` VARCHAR(32) NOT NULL,
-  `plural` VARCHAR(32),
-  `proper` INTEGER(1) NOT NULL,
-  `complexity` INTEGER NOT NULL,
-  `images` INTEGER NOT NULL,
-  `wnid` INTEGER NOT NULL
-);
-
-DROP TABLE IF EXISTS `hypernymy`;
 CREATE TABLE `hypernymy` (
   `hypernym_id` INTEGER NOT NULL,
-  `hyponym_id` INTEGER NOT NULL,
-  FOREIGN KEY (`hypernym_id`) REFERENCES `nouns`(`noun_id`),
-  FOREIGN KEY (`hyponym_id`) REFERENCES `nouns`(`noun_id`)
+  `hyponym_id` INTEGER NOT NULL
 );
 
-DROP TABLE IF EXISTS `instantiation`;
+CREATE INDEX `hyponym_of` ON `hypernymy`(`hypernym_id`);
+CREATE INDEX `hypernym_of` ON `hypernymy`(`hyponym_id`);
+
 CREATE TABLE `instantiation` (
   `class_id` INTEGER NOT NULL,
-  `instance_id` INTEGER NOT NULL,
-  FOREIGN KEY (`class_id`) REFERENCES `nouns`(`noun_id`),
-  FOREIGN KEY (`instance_id`) REFERENCES `nouns`(`noun_id`)
+  `instance_id` INTEGER NOT NULL
 );
 
-DROP TABLE IF EXISTS `member_meronymy`;
+CREATE INDEX `instance_of` ON `instantiation`(`class_id`);
+CREATE INDEX `class_of` ON `instantiation`(`instance_id`);
+
 CREATE TABLE `member_meronymy` (
   `meronym_id` INTEGER NOT NULL,
-  `holonym_id` INTEGER NOT NULL,
-  FOREIGN KEY (`meronym_id`) REFERENCES `nouns`(`noun_id`),
-  FOREIGN KEY (`holonym_id`) REFERENCES `nouns`(`noun_id`)
+  `holonym_id` INTEGER NOT NULL
 );
 
-DROP TABLE IF EXISTS `part_meronymy`;
+CREATE INDEX `member_holonym_of` ON `member_meronymy`(`meronym_id`);
+CREATE INDEX `member_meronym_of` ON `member_meronymy`(`holonym_id`);
+
 CREATE TABLE `part_meronymy` (
   `meronym_id` INTEGER NOT NULL,
-  `holonym_id` INTEGER NOT NULL,
-  FOREIGN KEY (`meronym_id`) REFERENCES `nouns`(`noun_id`),
-  FOREIGN KEY (`holonym_id`) REFERENCES `nouns`(`noun_id`)
+  `holonym_id` INTEGER NOT NULL
 );
 
-DROP TABLE IF EXISTS `substance_meronymy`;
+CREATE INDEX `part_holonym_of` ON `part_meronymy`(`meronym_id`);
+CREATE INDEX `part_meronym_of` ON `part_meronymy`(`holonym_id`);
+
 CREATE TABLE `substance_meronymy` (
   `meronym_id` INTEGER NOT NULL,
-  `holonym_id` INTEGER NOT NULL,
-  FOREIGN KEY (`meronym_id`) REFERENCES `nouns`(`noun_id`),
-  FOREIGN KEY (`holonym_id`) REFERENCES `nouns`(`noun_id`)
+  `holonym_id` INTEGER NOT NULL
 );
 
-DROP TABLE IF EXISTS `variation`;
+CREATE INDEX `substance_holonym_of` ON `substance_meronymy`(`meronym_id`);
+CREATE INDEX `substance_meronym_of` ON `substance_meronymy`(`holonym_id`);
+
 CREATE TABLE `variation` (
   `noun_id` INTEGER NOT NULL,
-  `adjective_id` INTEGER NOT NULL,
-  FOREIGN KEY (`noun_id`) REFERENCES `nouns`(`noun_id`),
-  FOREIGN KEY (`adjective_id`) REFERENCES `adjectives`(`adjective_id`)
+  `adjective_id` INTEGER NOT NULL
 );
 
-DROP TABLE IF EXISTS `noun_antonymy`;
-CREATE TABLE `noun_antonymy` (
-  `noun_1_id` INTEGER NOT NULL,
-  `noun_2_id` INTEGER NOT NULL,
-  FOREIGN KEY (`noun_1_id`) REFERENCES `nouns`(`noun_id`),
-  FOREIGN KEY (`noun_2_id`) REFERENCES `nouns`(`noun_id`)
-);
+CREATE INDEX `variant_of` ON `variation`(`noun_id`);
+CREATE INDEX `attribute_of` ON `variation`(`adjective_id`);
 
-DROP TABLE IF EXISTS `adjective_antonymy`;
-CREATE TABLE `adjective_antonymy` (
+CREATE TABLE `similarity` (
   `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`)
+  `adjective_2_id` INTEGER NOT NULL
+);
+
+CREATE INDEX `similar_to` ON `similarity`(`adjective_1_id`);
+
+CREATE TABLE `is_a` (
+  `notion_id` INTEGER NOT NULL,
+  `groupname` VARCHAR(32) NOT NULL
 );
 
-DROP TABLE IF EXISTS `adverb_antonymy`;
-CREATE TABLE `adverb_antonymy` (
-  `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`)
+CREATE TABLE `entailment` (
+  `given_id` INTEGER NOT NULL,
+  `entailment_id` INTEGER NOT NULL
+);
+
+CREATE INDEX `entailment_of` ON `entailment`(`given_id`);
+CREATE INDEX `entailed_by` ON `entailment`(`entailment_id`);
+
+CREATE TABLE `causality` (
+  `cause_id` INTEGER NOT NULL,
+  `effect_id` INTEGER NOT NULL
+);
+
+CREATE INDEX `effect_of` ON `causality`(`cause_id`);
+CREATE INDEX `cause_of` ON `causality`(`effect_id`);
+
+CREATE TABLE `words` (
+  `word_id` INTEGER PRIMARY KEY,
+  `notion_id` INTEGER NOT NULL,
+  `lemma_id` INTEGER NOT NULL,
+  `tag_count` INTEGER,
+  `position` SMALLINT,
+  `group_id` INTEGER
+);
+
+CREATE INDEX `notion_words` ON `words`(`notion_id`);
+CREATE INDEX `lemma_words` ON `words`(`lemma_id`);
+CREATE INDEX `group_words` ON `words`(`group_id`);
+
+CREATE TABLE `antonymy` (
+  `antonym_1_id` INTEGER NOT NULL,
+  `antonym_2_id` INTEGER NOT NULL
 );
 
-DROP TABLE IF EXISTS `specification`;
+CREATE INDEX `antonym_of` ON `antonymy`(`antonym_1_id`);
+
 CREATE TABLE `specification` (
   `general_id` INTEGER NOT NULL,
-  `specific_id` INTEGER NOT NULL,
-  FOREIGN KEY (`general_id`) REFERENCES `adjectives`(`adjective_id`),
-  FOREIGN KEY (`specific_id`) REFERENCES `adjectives`(`adjective_id`)
+  `specific_id` INTEGER NOT NULL
 );
 
-DROP TABLE IF EXISTS `pertainymy`;
+CREATE INDEX `specification_of` ON `specification`(`general_id`);
+CREATE INDEX `generalization_of` ON `specification`(`specific_id`);
+
 CREATE TABLE `pertainymy` (
   `noun_id` INTEGER NOT NULL,
-  `pertainym_id` INTEGER NOT NULL,
-  FOREIGN KEY (`noun_id`) REFERENCES `nouns`(`noun_id`),
-  FOREIGN KEY (`pertainym_id`) REFERENCES `adjectives`(`adjective_id`)
+  `pertainym_id` INTEGER NOT NULL
 );
 
-DROP TABLE IF EXISTS `mannernymy`;
+CREATE INDEX `pertainym_of` ON `pertainymy`(`noun_id`);
+CREATE INDEX `anti_pertainym_of` ON `pertainymy`(`pertainym_id`);
+
 CREATE TABLE `mannernymy` (
   `adjective_id` INTEGER NOT NULL,
-  `mannernym_id` INTEGER NOT NULL,
-  FOREIGN KEY (`adjective_id`) REFERENCES `adjectives`(`adjective_id`),
-  FOREIGN KEY (`mannernym_id`) REFERENCES `adverbs`(`adverb_id`)
+  `mannernym_id` INTEGER NOT NULL
 );
 
-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`)
-);
+CREATE INDEX `mannernym_of` ON `mannernymy`(`adjective_id`);
+CREATE INDEX `anti_mannernym_of` ON `mannernymy`(`mannernym_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`)
+CREATE TABLE `usage` (
+  `domain_id` INTEGER NOT NULL,
+  `term_id` INTEGER NOT NULL
 );
 
-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`)
-);
+CREATE INDEX `usage_term_of` ON `usage`(`domain_id`);
+CREATE INDEX `usage_domain_of` ON `usage`(`term_id`);
 
-DROP TABLE IF EXISTS `noun_pronunciations`;
-CREATE TABLE `noun_pronunciations` (
-  `noun_id` INTEGER NOT NULL,
-  `pronunciation` VARCHAR(64) NOT NULL,
-  `prerhyme` VARCHAR(8),
-  `rhyme` VARCHAR(64),
-  `syllables` INT NOT NULL,
-  `stress` VARCHAR(64) NOT NULL,
-  FOREIGN KEY (`noun_id`) REFERENCES `nouns`(`noun_id`)
+CREATE TABLE `topicality` (
+  `domain_id` INTEGER NOT NULL,
+  `term_id` INTEGER NOT NULL
 );
 
-DROP TABLE IF EXISTS `verb_pronunciations`;
-CREATE TABLE `verb_pronunciations` (
-  `verb_id` INTEGER NOT NULL,
-  `pronunciation` VARCHAR(64) NOT NULL,
-  `prerhyme` VARCHAR(8),
-  `rhyme` VARCHAR(64),
-  `syllables` INT NOT NULL,
-  `stress` VARCHAR(64) NOT NULL,
-  FOREIGN KEY (`verb_id`) REFERENCES `verbs`(`verb_id`)
-);
+CREATE INDEX `topical_term_of` ON `topicality`(`domain_id`);
+CREATE INDEX `topical_domain_of` ON `topicality`(`term_id`);
 
-DROP TABLE IF EXISTS `adjective_pronunciations`;
-CREATE TABLE `adjective_pronunciations` (
-  `adjective_id` INTEGER NOT NULL,
-  `pronunciation` VARCHAR(64) NOT NULL,
-  `prerhyme` VARCHAR(8),
-  `rhyme` VARCHAR(64),
-  `syllables` INT NOT NULL,
-  `stress` VARCHAR(64) NOT NULL,
-  FOREIGN KEY (`adjective_id`) REFERENCES `adjectives`(`adjective_id`)
+CREATE TABLE `regionality` (
+  `domain_id` INTEGER NOT NULL,
+  `term_id` INTEGER NOT NULL
 );
 
-DROP TABLE IF EXISTS `adverb_pronunciations`;
-CREATE TABLE `adverb_pronunciations` (
-  `adverb_id` INTEGER NOT NULL,
-  `pronunciation` VARCHAR(64) NOT NULL,
-  `prerhyme` VARCHAR(8),
-  `rhyme` VARCHAR(64),
-  `syllables` INT NOT NULL,
-  `stress` VARCHAR(64) NOT NULL,
-  FOREIGN KEY (`adverb_id`) REFERENCES `adverbs`(`adverb_id`)
-);
+CREATE INDEX `regional_term_of` ON `regionality`(`domain_id`);
+CREATE INDEX `regional_domain_of` ON `regionality`(`term_id`);
 
-DROP TABLE IF EXISTS `noun_noun_derivation`;
-CREATE TABLE `noun_noun_derivation` (
-  `noun_1_id` INTEGER NOT NULL,
-  `noun_2_id` INTEGER NOT NULL,
-  FOREIGN KEY (`noun_1_id`) REFERENCES `nouns`(`noun_id`),
-  FOREIGN KEY (`noun_2_id`) REFERENCES `nouns`(`noun_id`)
+CREATE TABLE `forms` (
+  `form_id` INTEGER PRIMARY KEY,
+  `form` VARCHAR(32) NOT NULL,
+  `complexity` SMALLINT NOT NULL,
+  `proper` SMALLINT NOT NULL
 );
 
-DROP TABLE IF EXISTS `noun_adjective_derivation`;
-CREATE TABLE `noun_adjective_derivation` (
-  `noun_id` INTEGER NOT NULL,
-  `adjective_id` INTEGER NOT NULL,
-  FOREIGN KEY (`noun_id`) REFERENCES `nouns`(`noun_id`),
-  FOREIGN KEY (`adjective_id`) REFERENCES `adjectives`(`adjective_id`)
-);
+CREATE UNIQUE INDEX `form_by_string` ON `forms`(`form`);
 
-DROP TABLE IF EXISTS `noun_adverb_derivation`;
-CREATE TABLE `noun_adverb_derivation` (
-  `noun_id` INTEGER NOT NULL,
-  `adverb_id` INTEGER NOT NULL,
-  FOREIGN KEY (`noun_id`) REFERENCES `nouns`(`noun_id`),
-  FOREIGN KEY (`adverb_id`) REFERENCES `adverbs`(`adverb_id`)
+CREATE TABLE `lemmas_forms` (
+  `lemma_id` INTEGER NOT NULL,
+  `form_id` INTEGER NOT NULL,
+  `category` SMALLINT NOT NULL
 );
 
-DROP TABLE IF EXISTS `adjective_adjective_derivation`;
-CREATE TABLE `adjective_adjective_derivation` (
-  `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`)
+CREATE INDEX `form_of` ON `lemmas_forms`(`lemma_id`);
+CREATE INDEX `lemma_of` ON `lemmas_forms`(`form_id`);
+
+CREATE TABLE `pronunciations` (
+  `pronunciation_id` INTEGER PRIMARY KEY,
+  `phonemes` VARCHAR(64) NOT NULL,
+  `prerhyme` VARCHAR(8),
+  `rhyme` VARCHAR(64),
+  `syllables` INTEGER NOT NULL,
+  `stress` VARCHAR(64) NOT NULL
 );
 
-DROP TABLE IF EXISTS `adjective_adverb_derivation`;
-CREATE TABLE `adjective_adverb_derivation` (
-  `adjective_id` INTEGER NOT NULL,
-  `adverb_id` INTEGER NOT NULL,
-  FOREIGN KEY (`adjective_id`) REFERENCES `adjectives`(`adjective_id`),
-  FOREIGN KEY (`adverb_id`) REFERENCES `adverbs`(`adjective_id`)
+CREATE TABLE `forms_pronunciations` (
+  `form_id` INTEGER NOT NULL,
+  `pronunciation_id` INTEGER NOT NULL
 );
 
-DROP TABLE IF EXISTS `adverb_adverb_derivation`;
-CREATE TABLE `adverb_adverb_derivation` (
-  `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`)
+CREATE INDEX `pronunciation_of` ON `forms_pronunciations`(`form_id`);
+CREATE INDEX `spelling_of` ON `forms_pronunciations`(`pronunciation_id`);
+
+CREATE TABLE `groups` (
+  `group_id` INTEGER PRIMARY KEY,
+  `data` BLOB NOT NULL
 );
 
-DROP TABLE IF EXISTS `prepositions`;
-CREATE TABLE `prepositions` (
-  `preposition_id` INTEGER PRIMARY KEY,
-  `form` VARCHAR(32) NOT NULL
+CREATE TABLE `frames` (
+  `frame_id` INTEGER PRIMARY KEY,
+  `data` BLOB NOT NULL
 );
 
-DROP TABLE IF EXISTS `preposition_groups`;
-CREATE TABLE `preposition_groups` (
-  `preposition_id` INTEGER NOT NULL,
-  `groupname` VARCHAR(32) NOT NULL,
-  FOREIGN KEY (`preposition_id`) REFERENCES `prepositions`(`preposition_id`)
+CREATE TABLE `groups_frames` (
+  `group_id` INTEGER NOT NULL,
+  `frame_id` INTEGER NOT NULL
 );
+
+CREATE INDEX `frames_in` ON `groups_frames`(`group_id`);
@@ -0,0 +1,288 @@
+#include "selrestr.h"
+
+namespace verbly {
+  namespace generator {
+    
+    selrestr::selrestr(const selrestr& other)
+    {
+      type_ = other.type_;
+      
+      switch (type_)
+      {
+        case type::singleton:
+        {
+          singleton_.pos = other.singleton_.pos;
+          new(&singleton_.restriction) std::string(other.singleton_.restriction);
+          
+          break;
+        }
+        
+        case type::group:
+        {
+          new(&group_.children) std::list<selrestr>(other.group_.children);
+          group_.orlogic = other.group_.orlogic;
+          
+          break;
+        }
+        
+        case type::empty:
+        {
+          break;
+        }
+      }
+    }
+    
+    selrestr::selrestr(selrestr&& other) : selrestr()
+    {
+      swap(*this, other);
+    }
+    
+    selrestr& selrestr::operator=(selrestr other)
+    {
+      swap(*this, other);
+      
+      return *this;
+    }
+    
+    void swap(selrestr& first, selrestr& second)
+    {
+      using type = selrestr::type;
+      
+      type tempType = first.type_;
+      int tempPos;
+      std::string tempRestriction;
+      std::list<selrestr> tempChildren;
+      bool tempOrlogic;
+      
+      switch (tempType)
+      {
+        case type::singleton:
+        {
+          tempPos = first.singleton_.pos;
+          tempRestriction = std::move(first.singleton_.restriction);
+          
+          break;
+        }
+        
+        case type::group:
+        {
+          tempChildren = std::move(first.group_.children);
+          tempOrlogic = first.group_.orlogic;
+          
+          break;
+        }
+        
+        case type::empty:
+        {
+          break;
+        }
+      }
+      
+      first.~selrestr();
+      
+      first.type_ = second.type_;
+      
+      switch (first.type_)
+      {
+        case type::singleton:
+        {
+          first.singleton_.pos = second.singleton_.pos;
+          new(&first.singleton_.restriction) std::string(std::move(second.singleton_.restriction));
+          
+          break;
+        }
+        
+        case type::group:
+        {
+          new(&first.group_.children) std::list<selrestr>(std::move(second.group_.children));
+          first.group_.orlogic = second.group_.orlogic;
+          
+          break;
+        }
+        
+        case type::empty:
+        {
+          break;
+        }
+      }
+      
+      second.~selrestr();
+      
+      second.type_ = tempType;
+      
+      switch (second.type_)
+      {
+        case type::singleton:
+        {
+          second.singleton_.pos = tempPos;
+          new(&second.singleton_.restriction) std::string(std::move(tempRestriction));
+          
+          break;
+        }
+        
+        case type::group:
+        {
+          new(&second.group_.children) std::list<selrestr>(std::move(tempChildren));
+          second.group_.orlogic = tempOrlogic;
+          
+          break;
+        }
+        
+        case type::empty:
+        {
+          break;
+        }
+      }
+    }
+    
+    selrestr::~selrestr()
+    {
+      switch (type_)
+      {
+        case type::singleton:
+        {
+          using string_type = std::string;
+          singleton_.restriction.~string_type();
+          
+          break;
+        }
+        
+        case type::group:
+        {
+          using list_type = std::list<selrestr>;
+          group_.children.~list_type();
+          
+          break;
+        }
+        
+        case type::empty:
+        {
+          break;
+        }
+      }
+    }
+    
+    selrestr::selrestr() : type_(type::empty)
+    {
+    }
+    
+    selrestr::selrestr(
+      std::string restriction,
+      bool pos) :
+        type_(type::singleton)
+    {
+      new(&singleton_.restriction) std::string(std::move(restriction));
+      singleton_.pos = pos;
+    }
+    
+    std::string selrestr::getRestriction() const
+    {
+      if (type_ == type::singleton)
+      {
+        return singleton_.restriction;
+      } else {
+        throw std::domain_error("Only singleton selrestrs have restrictions");
+      }
+    }
+    
+    bool selrestr::getPos() const
+    {
+      if (type_ == type::singleton)
+      {
+        return singleton_.pos;
+      } else {
+        throw std::domain_error("Only singleton selrestrs have positivity flags");
+      }
+    }
+    
+    selrestr::selrestr(
+      std::list<selrestr> children,
+      bool orlogic) :
+        type_(type::group)
+    {
+      new(&group_.children) std::list<selrestr>(std::move(children));
+      group_.orlogic = orlogic;
+    }
+    
+    std::list<selrestr> selrestr::getChildren() const
+    {
+      if (type_ == type::group)
+      {
+        return group_.children;
+      } else {
+        throw std::domain_error("Only group selrestrs have children");
+      }
+    }
+    
+    std::list<selrestr>::const_iterator selrestr::begin() const
+    {
+      if (type_ == type::group)
+      {
+        return std::begin(group_.children);
+      } else {
+        throw std::domain_error("Only group selrestrs have children");
+      }
+    }
+    
+    std::list<selrestr>::const_iterator selrestr::end() const
+    {
+      if (type_ == type::group)
+      {
+        return std::end(group_.children);
+      } else {
+        throw std::domain_error("Only group selrestrs have children");
+      }
+    }
+    
+    bool selrestr::getOrlogic() const
+    {
+      if (type_ == type::group)
+      {
+        return group_.orlogic;
+      } else {
+        throw std::domain_error("Only group selrestrs have logic");
+      }
+    }
+    
+    nlohmann::json selrestr::toJson() const
+    {
+      switch (type_)
+      {
+        case type::empty:
+        {
+          return {};
+        }
+        
+        case type::singleton:
+        {
+          return {
+            {"type", singleton_.restriction},
+            {"pos", singleton_.pos}
+          };
+        }
+        
+        case type::group:
+        {
+          std::string logic;
+          if (group_.orlogic)
+          {
+            logic = "or";
+          } else {
+            logic = "and";
+          }
+          
+          std::list<nlohmann::json> children;
+          std::transform(std::begin(group_.children), std::end(group_.children), std::back_inserter(children), [] (const selrestr& child) {
+            return child.toJson();
+          });
+          
+          return {
+            {"logic", logic},
+            {"children", children}
+          };
+        }
+      }
+    }
+    
+  };
+};
@@ -0,0 +1,88 @@
+#ifndef SELRESTR_H_50652FB7
+#define SELRESTR_H_50652FB7
+
+#include <list>
+#include <string>
+#include <json.hpp>
+
+namespace verbly {
+  namespace generator {
+    
+    class selrestr {
+    public:
+      enum class type {
+        empty,
+        singleton,
+        group
+      };
+      
+      // Copy and move constructors
+      
+      selrestr(const selrestr& other);
+      selrestr(selrestr&& other);
+      
+      // Assignment
+      
+      selrestr& operator=(selrestr other);
+      
+      // Swap
+      
+      friend void swap(selrestr& first, selrestr& second);
+      
+      // Destructor
+      
+      ~selrestr();
+      
+      // Generic accessors
+      
+      type getType() const
+      {
+        return type_;
+      }
+      
+      // Empty
+      
+      selrestr();
+      
+      // Singleton
+      
+      selrestr(std::string restriction, bool pos);
+      
+      std::string getRestriction() const;
+      
+      bool getPos() const;
+      
+      // Group
+      
+      selrestr(std::list<selrestr> children, bool orlogic);
+      
+      std::list<selrestr> getChildren() const;
+      
+      std::list<selrestr>::const_iterator begin() const;
+      
+      std::list<selrestr>::const_iterator end() const;
+      
+      bool getOrlogic() const;
+      
+      // Helpers
+      
+      nlohmann::json toJson() const;
+      
+    private:
+      union {
+        struct {
+          bool pos;
+          std::string restriction;
+        } singleton_;
+        struct {
+          std::list<selrestr> children;
+          bool orlogic;
+        } group_;
+      };
+      type type_;
+    };
+    
+  };
+};
+
+#endif /* end of include guard: SELRESTR_H_50652FB7 */
@@ -0,0 +1,77 @@
+#include "word.h"
+#include <list>
+#include <string>
+#include "database.h"
+#include "notion.h"
+#include "lemma.h"
+#include "field.h"
+#include "group.h"
+
+namespace verbly {
+  namespace generator {
+
+    int word::nextId_ = 0;
+
+    word::word(
+      notion& n,
+      lemma& l) :
+        id_(nextId_++),
+        notion_(n),
+        lemma_(l)
+    {
+    }
+
+    word::word(
+      notion& n,
+      lemma& l,
+      int tagCount) :
+        id_(nextId_++),
+        notion_(n),
+        lemma_(l),
+        tagCount_(tagCount),
+        hasTagCount_(true)
+    {
+    }
+
+    void word::setAdjectivePosition(positioning adjectivePosition)
+    {
+      adjectivePosition_ = adjectivePosition;
+    }
+    
+    void word::setVerbGroup(const group& verbGroup)
+    {
+      verbGroup_ = &verbGroup;
+    }
+
+    database& operator<<(database& db, const word& arg)
+    {
+      std::list<field> fields;
+      
+      fields.emplace_back("word_id", arg.getId());
+      fields.emplace_back("notion_id", arg.getNotion().getId());
+      fields.emplace_back("lemma_id", arg.getLemma().getId());
+
+      if (arg.hasTagCount())
+      {
+        fields.emplace_back("tag_count", arg.getTagCount());
+      }
+      
+      if ((arg.getNotion().getPartOfSpeech() == part_of_speech::adjective)
+        && (arg.getAdjectivePosition() != positioning::undefined))
+      {
+        fields.emplace_back("position", static_cast<int>(arg.getAdjectivePosition()));
+      }
+      
+      if ((arg.getNotion().getPartOfSpeech() == part_of_speech::verb)
+        && (arg.hasVerbGroup()))
+      {
+        fields.emplace_back("group_id", arg.getVerbGroup().getId());
+      }
+
+      db.insertIntoTable("words", std::move(fields));
+
+      return db;
+    }
+
+  };
+};
@@ -0,0 +1,110 @@
+#ifndef WORD_H_91F99D46
+#define WORD_H_91F99D46
+
+#include <cassert>
+#include "enums.h"
+
+namespace verbly {
+  namespace generator {
+
+    class notion;
+    class lemma;
+    class database;
+    class group;
+
+    class word {
+    public:
+
+      // Constructors
+
+      word(notion& n, lemma& l);
+
+      word(notion& n, lemma& l, int tagCount);
+
+      // Mutators
+
+      void setAdjectivePosition(positioning adjectivePosition);
+      
+      void setVerbGroup(const group& verbGroup);
+
+      // Accessors
+
+      int getId() const
+      {
+        return id_;
+      }
+
+      notion& getNotion()
+      {
+        return notion_;
+      }
+
+      const notion& getNotion() const
+      {
+        return notion_;
+      }
+
+      lemma& getLemma()
+      {
+        return lemma_;
+      }
+
+      const lemma& getLemma() const
+      {
+        return lemma_;
+      }
+
+      bool hasTagCount() const
+      {
+        return hasTagCount_;
+      }
+      
+      int getTagCount() const
+      {
+        // Calling code should always call hasTagCount first.
+        assert(hasTagCount_);
+
+        return tagCount_;
+      }
+
+      positioning getAdjectivePosition() const
+      {
+        return adjectivePosition_;
+      }
+      
+      bool hasVerbGroup() const
+      {
+        return (verbGroup_ != nullptr);
+      }
+      
+      const group& getVerbGroup() const
+      {
+        // Calling code should always call hasVerbGroup first.
+        assert(verbGroup_ != nullptr);
+        
+        return *verbGroup_;
+      }
+
+    private:
+
+      static int nextId_;
+
+      const int id_;
+      notion& notion_;
+      lemma& lemma_;
+      const int tagCount_ = 0;
+      const bool hasTagCount_ = false;
+
+      positioning adjectivePosition_ = positioning::undefined;
+      const group* verbGroup_ = nullptr;
+
+    };
+
+    // Serializer
+
+    database& operator<<(database& db, const word& arg);
+
+  };
+};
+
+#endif /* end of include guard: WORD_H_91F99D46 */
@@ -1,113 +0,0 @@
-#include "verbly.h"
-
-namespace verbly {
-  
-  adjective::adjective()
-  {
-    
-  }
-  
-  adjective::adjective(const data& _data, int _id) : word(_data, _id)
-  {
-    
-  }
-  
-  std::string adjective::base_form() const
-  {
-    assert(_valid == true);
-    
-    return _base_form;
-  }
-  
-  std::string adjective::comparative_form() const
-  {
-    assert(_valid == true);
-    
-    return _comparative_form;
-  }
-  
-  std::string adjective::superlative_form() const
-  {
-    assert(_valid == true);
-    
-    return _superlative_form;
-  }
-  
-  adjective::positioning adjective::position() const
-  {
-    assert(_valid == true);
-    
-    return _position;
-  }
-  
-  bool adjective::has_comparative_form() const
-  {
-    assert(_valid == true);
-    
-    return !_comparative_form.empty();
-  }
-  
-  bool adjective::has_superlative_form() const
-  {
-    assert(_valid == true);
-    
-    return !_superlative_form.empty();
-  }
-  
-  bool adjective::has_position() const
-  {
-    assert(_valid == true);
-    
-    return _position != adjective::positioning::undefined;
-  }
-  
-  adjective_query adjective::antonyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->adjectives().antonym_of(*this);
-  }
-  
-  adjective_query adjective::synonyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->adjectives().synonym_of(*this);
-  }
-  
-  adjective_query adjective::generalizations() const
-  {
-    assert(_valid == true);
-    
-    return _data->adjectives().generalization_of(*this);
-  }
-  
-  adjective_query adjective::specifications() const
-  {
-    assert(_valid == true);
-    
-    return _data->adjectives().specification_of(*this);
-  }
-  
-  noun_query adjective::anti_pertainyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().anti_pertainym_of(*this);
-  }
-  
-  adverb_query adjective::mannernyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->adverbs().mannernym_of(*this);
-  }
-  
-  noun_query adjective::attributes() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().attribute_of(*this);
-  }
-
-};
@@ -1,51 +0,0 @@
-#ifndef ADJECTIVE_H_87B3FB75
-#define ADJECTIVE_H_87B3FB75
-
-namespace verbly {
-  
-  class adjective_query;
-  class adverb_query;
-  class noun_query;
-  
-  class adjective : public word {
-    public:
-      enum class positioning {
-        undefined,
-        predicate,
-        attributive,
-        postnominal
-      };
-    
-    private:
-      std::string _base_form;
-      std::string _comparative_form;
-      std::string _superlative_form;
-      positioning _position = positioning::undefined;
-      
-      friend class adjective_query;
-      
-    public:
-      adjective();
-      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;
-  };
-  
-};
-
-#endif /* end of include guard: ADJECTIVE_H_87B3FB75 */
@@ -1,1072 +0,0 @@
-#include "verbly.h"
-
-namespace verbly {
-
-  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()
-  {
-    this->_random = true;
-  
-    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.get_rhymes())
-    {
-      _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::rhymes_with(rhyme _r)
-  {
-    _rhymes.push_back(_r);
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::has_pronunciation()
-  {
-    this->_has_prn = true;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::has_rhyming_noun()
-  {
-    _has_rhyming_noun = true;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::has_rhyming_adjective()
-  {
-    _has_rhyming_adjective = true;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::has_rhyming_adverb()
-  {
-    _has_rhyming_adverb = true;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::has_rhyming_verb()
-  {
-    _has_rhyming_verb = true;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::with_stress(filter<std::vector<bool>> _arg)
-  {
-    _stress = _arg;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::with_prefix(filter<std::string> _f)
-  {
-    _f.clean();
-    _with_prefix = _f;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::with_suffix(filter<std::string> _f)
-  {
-    _f.clean();
-    _with_suffix = _f;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::with_complexity(int _arg)
-  {
-    _with_complexity = _arg;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::requires_comparative_form()
-  {
-    _requires_comparative_form = true;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::requires_superlative_form()
-  {
-    _requires_superlative_form = true;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::position(adjective::positioning pos)
-  {
-    _position = pos;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::is_variant()
-  {
-    this->_is_variant = true;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::variant_of(filter<noun> _f)
-  {
-    _f.clean();
-    _variant_of = _f;
-    
-    return *this;
-  }
-    
-  adjective_query& adjective_query::has_antonyms()
-  {
-    this->_is_antonymic = true;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::antonym_of(filter<adjective> _f)
-  {
-    _f.clean();
-    _antonym_of = _f;
-    
-    return *this;
-  }
-    
-  adjective_query& adjective_query::has_synonyms()
-  {
-    this->_is_synonymic = true;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::synonym_of(filter<adjective> _f)
-  {
-    _f.clean();
-    _synonym_of = _f;
-    
-    return *this;
-  }
-
-  adjective_query& adjective_query::is_generalization()
-  {
-    this->_is_generalization = true;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::generalization_of(filter<adjective> _f)
-  {
-    _f.clean();
-    _generalization_of = _f;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::is_specification()
-  {
-    this->_is_specification = true;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::specification_of(filter<adjective> _f)
-  {
-    _f.clean();
-    _specification_of = _f;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::is_pertainymic()
-  {
-    this->_is_pertainymic = true;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::pertainym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _pertainym_of = _f;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::is_mannernymic()
-  {
-    this->_is_mannernymic = true;
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::anti_mannernym_of(filter<adverb> _f)
-  {
-    _f.clean();
-    _anti_mannernym_of = _f;
-    
-    return *this;
-  }
-  /*
-  adjective_query& adjective_query::derived_from(const word& _w)
-  {
-    if (dynamic_cast<const adjective*>(&_w) != nullptr)
-    {
-      _derived_from_adjective.push_back(dynamic_cast<const adjective&>(_w));
-    } else if (dynamic_cast<const adverb*>(&_w) != nullptr)
-    {
-      _derived_from_adverb.push_back(dynamic_cast<const adverb&>(_w));
-    } else if (dynamic_cast<const noun*>(&_w) != nullptr)
-    {
-      _derived_from_noun.push_back(dynamic_cast<const noun&>(_w));
-    }
-    
-    return *this;
-  }
-  
-  adjective_query& adjective_query::not_derived_from(const word& _w)
-  {
-    if (dynamic_cast<const adjective*>(&_w) != nullptr)
-    {
-      _not_derived_from_adjective.push_back(dynamic_cast<const adjective&>(_w));
-    } else if (dynamic_cast<const adverb*>(&_w) != nullptr)
-    {
-      _not_derived_from_adverb.push_back(dynamic_cast<const adverb&>(_w));
-    } else if (dynamic_cast<const noun*>(&_w) != nullptr)
-    {
-      _not_derived_from_noun.push_back(dynamic_cast<const noun&>(_w));
-    }
-    
-    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;
-    std::list<binding> bindings;
-    
-    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(), "(prerhyme != ? AND rhyme = ?)");
-      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 rhy : _rhymes)
-      {
-        bindings.emplace_back(rhy.get_prerhyme());
-        bindings.emplace_back(rhy.get_rhyme());
-      }
-    }
-    
-    if (_has_rhyming_noun)
-    {
-      conditions.push_back("adjective_id IN (SELECT a.adjective_id FROM adjectives AS a INNER JOIN adjective_pronunciations AS curp ON curp.adjective_id = a.adjective_id INNER JOIN noun_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
-    }
-    
-    if (_has_rhyming_adjective)
-    {
-      conditions.push_back("adjective_id IN (SELECT a.adjective_id FROM adjectives AS a INNER JOIN adjective_pronunciations AS curp ON curp.adjective_id = a.adjective_id INNER JOIN adjective_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme AND rhmp.adjective_id != curp.adjective_id)");
-    }
-    
-    if (_has_rhyming_adverb)
-    {
-      conditions.push_back("adjective_id IN (SELECT a.adjective_id FROM adjectives AS a INNER JOIN adjective_pronunciations AS curp ON curp.adjective_id = a.adjective_id INNER JOIN adverb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
-    }
-    
-    if (_has_rhyming_verb)
-    {
-      conditions.push_back("adjective_id IN (SELECT a.adjective_id FROM adjectives AS a INNER JOIN adjective_pronunciations AS curp ON curp.adjective_id = a.adjective_id INNER JOIN verb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
-    }
-    
-    for (auto except : _except)
-    {
-      conditions.push_back("adjective_id != ?");
-      bindings.emplace_back(except._id);
-    }
-    
-    if (_requires_comparative_form)
-    {
-      conditions.push_back("comparative IS NOT NULL");
-    }
-    
-    if (_requires_superlative_form)
-    {
-      conditions.push_back("superlative IS NOT NULL");
-    }
-    
-    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;
-      case adjective::positioning::undefined: break;
-    }
-    
-    if (!_stress.empty())
-    {
-      std::stringstream cond;
-      if (_stress.get_notlogic())
-      {
-        cond << "adjective_id NOT IN";
-      } else {
-        cond << "adjective_id IN";
-      }
-      
-      cond << "(SELECT adjective_id FROM adjective_pronunciations WHERE ";
-      
-      std::function<std::string (filter<std::vector<bool>>, bool)> recur = [&] (filter<std::vector<bool>> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<std::vector<bool>>::type::singleton:
-          {
-            std::ostringstream _val;
-            for (auto syl : f.get_elem())
-            {
-              if (syl)
-              {
-                _val << "1";
-              } else {
-                _val << "0";
-              }
-            }
-            
-            bindings.emplace_back(_val.str());
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "stress = ?";
-            } else {
-              return "stress != ?";
-            }
-          }
-          
-          case filter<std::vector<bool>>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<std::vector<bool>> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_stress, _stress.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (!_with_prefix.empty())
-    {
-      std::function<std::string (filter<std::string>, bool)> recur = [&] (filter<std::string> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<std::string>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem() + "%");
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "base_form LIKE ?";
-            } else {
-              return "base_form NOT LIKE ?";
-            }
-          }
-          
-          case filter<std::string>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<std::string> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      conditions.push_back(recur(_with_prefix, false));
-    }
-    
-    if (!_with_suffix.empty())
-    {
-      std::function<std::string (filter<std::string>, bool)> recur = [&] (filter<std::string> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<std::string>::type::singleton:
-          {
-            bindings.emplace_back("%" + f.get_elem());
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "base_form LIKE ?";
-            } else {
-              return "base_form NOT LIKE ?";
-            }
-          }
-          
-          case filter<std::string>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<std::string> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      conditions.push_back(recur(_with_suffix, false));
-    }
-    
-    if (_with_complexity != unlimited)
-    {
-      conditions.push_back("complexity = ?");
-      bindings.emplace_back(_with_complexity);
-    }
-    
-    if (_is_variant)
-    {
-      conditions.push_back("adjective_id IN (SELECT adjective_id FROM variation)");
-    }
-    
-    if (!_variant_of.empty())
-    {
-      std::stringstream cond;
-      if (_variant_of.get_notlogic())
-      {
-        cond << "adjective_id NOT IN";
-      } else {
-        cond << "adjective_id IN";
-      }
-      
-      cond << "(SELECT adjective_id FROM variation WHERE ";
-      
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "noun_id = ?";
-            } else {
-              return "noun_id != ?";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_variant_of, _variant_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_is_antonymic)
-    {
-      conditions.push_back("adjective_id IN (SELECT adjective_2_id FROM adjective_antonymy)");
-    }
-    
-    if (!_antonym_of.empty())
-    {
-      std::stringstream cond;
-      if (_antonym_of.get_notlogic())
-      {
-        cond << "adjective_id NOT IN";
-      } else {
-        cond << "adjective_id IN";
-      }
-      
-      cond << "(SELECT adjective_2_id FROM adjective_antonymy WHERE ";
-      
-      std::function<std::string (filter<adjective>, bool)> recur = [&] (filter<adjective> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<adjective>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "adjective_1_id = ?";
-            } else {
-              return "adjective_1_id != ?";
-            }
-          }
-          
-          case filter<adjective>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<adjective> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_antonym_of, _antonym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_is_synonymic)
-    {
-      conditions.push_back("adjective_id IN (SELECT adjective_2_id FROM adjective_synonymy)");
-    }
-    
-    if (!_synonym_of.empty())
-    {
-      std::stringstream cond;
-      if (_synonym_of.get_notlogic())
-      {
-        cond << "adjective_id NOT IN";
-      } else {
-        cond << "adjective_id IN";
-      }
-      
-      cond << "(SELECT adjective_2_id FROM adjective_synonymy WHERE ";
-      
-      std::function<std::string (filter<adjective>, bool)> recur = [&] (filter<adjective> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<adjective>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "adjective_1_id = ?";
-            } else {
-              return "adjective_1_id != ?";
-            }
-          }
-          
-          case filter<adjective>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<adjective> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_synonym_of, _synonym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_is_generalization)
-    {
-      conditions.push_back("adjective_id IN (SELECT general_id FROM specification)");
-    }
-    
-    if (!_generalization_of.empty())
-    {
-      std::stringstream cond;
-      if (_generalization_of.get_notlogic())
-      {
-        cond << "adjective_id NOT IN";
-      } else {
-        cond << "adjective_id IN";
-      }
-      
-      cond << "(SELECT general_id FROM specification WHERE ";
-      
-      std::function<std::string (filter<adjective>, bool)> recur = [&] (filter<adjective> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<adjective>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "specific_id = ?";
-            } else {
-              return "specific_id != ?";
-            }
-          }
-          
-          case filter<adjective>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<adjective> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_generalization_of, _generalization_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_is_specification)
-    {
-      conditions.push_back("adjective_id IN (SELECT specific_id FROM specification)");
-    }
-    
-    if (!_specification_of.empty())
-    {
-      std::stringstream cond;
-      if (_specification_of.get_notlogic())
-      {
-        cond << "adjective_id NOT IN";
-      } else {
-        cond << "adjective_id IN";
-      }
-      
-      cond << "(SELECT specific_id FROM specification WHERE ";
-      
-      std::function<std::string (filter<adjective>, bool)> recur = [&] (filter<adjective> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<adjective>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "general_id = ?";
-            } else {
-              return "general_id != ?";
-            }
-          }
-          
-          case filter<adjective>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<adjective> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_specification_of, _specification_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_is_pertainymic)
-    {
-      conditions.push_back("adjective_id IN (SELECT pertainym_id FROM pertainymy)");
-    }
-    
-    if (!_pertainym_of.empty())
-    {
-      std::stringstream cond;
-      if (_pertainym_of.get_notlogic())
-      {
-        cond << "adjective_id NOT IN";
-      } else {
-        cond << "adjective_id IN";
-      }
-      
-      cond << "(SELECT pertainym_id FROM pertainymy WHERE ";
-      
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "noun_id = ?";
-            } else {
-              return "noun_id != ?";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_pertainym_of, _pertainym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_is_mannernymic)
-    {
-      conditions.push_back("adjective_id IN (SELECT adjective_id FROM mannernymy)");
-    }
-    
-    if (!_anti_mannernym_of.empty())
-    {
-      std::stringstream cond;
-      if (_anti_mannernym_of.get_notlogic())
-      {
-        cond << "adjective_id NOT IN";
-      } else {
-        cond << "adjective_id IN";
-      }
-      
-      cond << "(SELECT adjective_id FROM mannernymy WHERE ";
-      
-      std::function<std::string (filter<adverb>, bool)> recur = [&] (filter<adverb> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<adverb>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "mannernym_id = ?";
-            } else {
-              return "mannernym_id != ?";
-            }
-          }
-          
-          case filter<adverb>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<adverb> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_anti_mannernym_of, _anti_mannernym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-/*    
-    if (!_derived_from_adjective.empty())
-    {
-      std::list<std::string> clauses(_derived_from_adjective.size(), "adjective_2_id = @DERADJ");
-      std::string cond = "adjective_id IN (SELECT adjective_1_id FROM adjective_adjective_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_not_derived_from_adjective.empty())
-    {
-      std::list<std::string> clauses(_not_derived_from_adjective.size(), "adjective_2_id = @NDERADJ");
-      std::string cond = "adjective_id NOT IN (SELECT adjective_1_id FROM adjective_adjective_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_derived_from_adverb.empty())
-    {
-      std::list<std::string> clauses(_derived_from_adverb.size(), "adverb_id = @DERADV");
-      std::string cond = "adjective_id IN (SELECT adjective_id FROM adjective_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_not_derived_from_adverb.empty())
-    {
-      std::list<std::string> clauses(_not_derived_from_adverb.size(), "adverb_id = @NDERADV");
-      std::string cond = "adjective_id NOT IN (SELECT adjective_id FROM adjective_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_derived_from_noun.empty())
-    {
-      std::list<std::string> clauses(_derived_from_noun.size(), "noun_id = @DERN");
-      std::string cond = "adjective_id IN (SELECT adjective_id FROM noun_adjective_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_not_derived_from_noun.empty())
-    {
-      std::list<std::string> clauses(_not_derived_from_noun.size(), "noun_id = @NDERN");
-      std::string cond = "adjective_id NOT IN (SELECT adjective_id FROM noun_adjective_derivation 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));
-    }
-    
-    int i = 1;
-    for (auto& binding : bindings)
-    {
-      switch (binding.get_type())
-      {
-        case binding::type::integer:
-        {
-          sqlite3_bind_int(ppstmt, i, binding.get_integer());
-          
-          break;
-        }
-        
-        case binding::type::string:
-        {
-          sqlite3_bind_text(ppstmt, i, binding.get_string().c_str(), binding.get_string().length(), SQLITE_TRANSIENT);
-          
-          break;
-        }
-      }
-      
-      i++;
-    }
-    
-    /*
-    for (auto adj : _derived_from_adjective)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERADJ"), adj._id);
-    }
-    
-    for (auto adj : _not_derived_from_adjective)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERADJ"), adj._id);
-    }
-    
-    for (auto adv : _derived_from_adverb)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERADV"), adv._id);
-    }
-    
-    for (auto adv : _not_derived_from_adverb)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERADV"), adv._id);
-    }
-    
-    for (auto n : _derived_from_noun)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERN"), n._id);
-    }
-    
-    for (auto n : _not_derived_from_noun)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERN"), n._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, prerhyme, rhyme 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);
-        
-        if ((sqlite3_column_type(ppstmt, 1) != SQLITE_NULL) && (sqlite3_column_type(ppstmt, 2) != SQLITE_NULL))
-        {
-          std::string prerhyme(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
-          std::string rhyming(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 2)));
-          adjective.rhymes.emplace_back(prerhyme, rhyming);
-        }
-      }
-      
-      sqlite3_finalize(ppstmt);
-    }
-
-    return output;
-  }
-
-};
@@ -1,112 +0,0 @@
-#ifndef ADJECTIVE_QUERY_H_05E590FD
-#define ADJECTIVE_QUERY_H_05E590FD
-
-namespace verbly {
-  
-  class adjective_query {
-    public:
-      adjective_query(const data& _data);
-      
-      adjective_query& limit(int _limit);
-      adjective_query& random();
-      adjective_query& except(const adjective& _word);
-      adjective_query& rhymes_with(const word& _word);
-      adjective_query& rhymes_with(rhyme _r);
-      adjective_query& has_pronunciation();
-      adjective_query& has_rhyming_noun();
-      adjective_query& has_rhyming_adjective();
-      adjective_query& has_rhyming_adverb();
-      adjective_query& has_rhyming_verb();
-      adjective_query& with_stress(filter<std::vector<bool>> _arg);
-      
-      adjective_query& requires_comparative_form();
-      adjective_query& requires_superlative_form();
-      adjective_query& position(adjective::positioning pos);
-      
-      adjective_query& with_prefix(filter<std::string> _f);
-      adjective_query& with_suffix(filter<std::string> _f);
-      
-      adjective_query& with_complexity(int _arg);
-      
-      adjective_query& is_variant();
-      adjective_query& variant_of(filter<noun> _f);
-      
-      adjective_query& has_antonyms();
-      adjective_query& antonym_of(filter<adjective> _f);
-      
-      adjective_query& has_synonyms();
-      adjective_query& synonym_of(filter<adjective> _f);
-      
-      adjective_query& is_generalization();
-      adjective_query& generalization_of(filter<adjective> _f);
-      
-      adjective_query& is_specification();
-      adjective_query& specification_of(filter<adjective> _f);
-      
-      adjective_query& is_pertainymic();
-      adjective_query& pertainym_of(filter<noun> _f);
-      
-      adjective_query& is_mannernymic();
-      adjective_query& anti_mannernym_of(filter<adverb> _f);
-      
-/*      adjective_query& derived_from(const word& _w);
-      adjective_query& not_derived_from(const word& _w);*/
-      
-      std::list<adjective> run() const;
-      
-      const static int unlimited = -1;
-
-    protected:
-      const data& _data;
-      int _limit = unlimited;
-      bool _random = false;
-      std::list<rhyme> _rhymes;
-      std::list<adjective> _except;
-      bool _has_prn = false;
-      bool _has_rhyming_noun = false;
-      bool _has_rhyming_adjective = false;
-      bool _has_rhyming_adverb = false;
-      bool _has_rhyming_verb = false;
-      filter<std::vector<bool>> _stress;
-      
-      bool _requires_comparative_form = false;
-      bool _requires_superlative_form = false;
-      adjective::positioning _position = adjective::positioning::undefined;
-      
-      filter<std::string> _with_prefix;
-      filter<std::string> _with_suffix;
-      
-      int _with_complexity = unlimited;
-      
-      bool _is_variant = false;
-      filter<noun> _variant_of;
-            
-      bool _is_antonymic = false;
-      filter<adjective> _antonym_of;
-      
-      bool _is_synonymic = false;
-      filter<adjective> _synonym_of;
-      
-      bool _is_generalization = false;
-      filter<adjective> _generalization_of;
-      
-      bool _is_specification = false;
-      filter<adjective> _specification_of;
-      
-      bool _is_pertainymic = false;
-      filter<noun> _pertainym_of;
-      
-      bool _is_mannernymic = false;
-      filter<adverb> _anti_mannernym_of;
-      
-/*      std::list<adjective> _derived_from_adjective;
-      std::list<adjective> _not_derived_from_adjective;
-      std::list<adverb> _derived_from_adverb;
-      std::list<adverb> _not_derived_from_adverb;
-      std::list<noun> _derived_from_noun;
-      std::list<noun> _not_derived_from_noun;*/
-  };
-  
-};
-
-#endif /* end of include guard: ADJECTIVE_QUERY_H_05E590FD */
@@ -1,71 +0,0 @@
-#include "verbly.h"
-
-namespace verbly {
-  
-  adverb::adverb()
-  {
-    
-  }
-  
-  adverb::adverb(const data& _data, int _id) : word(_data, _id)
-  {
-    
-  }
-  
-  std::string adverb::base_form() const
-  {
-    assert(_valid == true);
-    
-    return _base_form;
-  }
-  
-  std::string adverb::comparative_form() const
-  {
-    assert(_valid == true);
-    
-    return _comparative_form;
-  }
-  
-  std::string adverb::superlative_form() const
-  {
-    assert(_valid == true);
-    
-    return _superlative_form;
-  }
-    
-  bool adverb::has_comparative_form() const
-  {
-    assert(_valid == true);
-    
-    return !_comparative_form.empty();
-  }
-  
-  bool adverb::has_superlative_form() const
-  {
-    assert(_valid == true);
-    
-    return !_superlative_form.empty();
-  }
-  
-  adverb_query adverb::antonyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->adverbs().antonym_of(*this);
-  }
-  
-  adverb_query adverb::synonyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->adverbs().synonym_of(*this);
-  }
-  
-  adjective_query adverb::anti_mannernyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->adjectives().anti_mannernym_of(*this);
-  }
-  
-};
@@ -1,35 +0,0 @@
-#ifndef ADVERB_H_86F8302F
-#define ADVERB_H_86F8302F
-
-namespace verbly {
-  
-  class adverb : public word {
-    private:
-      std::string _base_form;
-      std::string _comparative_form;
-      std::string _superlative_form;
-      
-      friend class adverb_query;
-      
-    public:
-      adverb();
-      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;
-      
-      adverb_query& derived_from(const word& _w);
-      adverb_query& not_derived_from(const word& _w);
-  };
-  
-};
-
-#endif /* end of include guard: ADVERB_H_86F8302F */
@@ -1,758 +0,0 @@
-#include "verbly.h"
-
-namespace verbly {
-  
-  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()
-  {
-    this->_random = true;
-  
-    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.get_rhymes())
-    {
-      _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::rhymes_with(rhyme _r)
-  {
-    _rhymes.push_back(_r);
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::has_pronunciation()
-  {
-    this->_has_prn = true;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::has_rhyming_noun()
-  {
-    _has_rhyming_noun = true;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::has_rhyming_adjective()
-  {
-    _has_rhyming_adjective = true;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::has_rhyming_adverb()
-  {
-    _has_rhyming_adverb = true;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::has_rhyming_verb()
-  {
-    _has_rhyming_verb = true;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::requires_comparative_form()
-  {
-    _requires_comparative_form = true;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::requires_superlative_form()
-  {
-    _requires_superlative_form = true;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::with_stress(filter<std::vector<bool>> _arg)
-  {
-    _stress = _arg;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::with_prefix(filter<std::string> _f)
-  {
-    _f.clean();
-    _with_prefix = _f;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::with_suffix(filter<std::string> _f)
-  {
-    _f.clean();
-    _with_suffix = _f;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::with_complexity(int _arg)
-  {
-    _with_complexity = _arg;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::has_antonyms()
-  {
-    _has_antonyms = true;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::antonym_of(filter<adverb> _f)
-  {
-    _f.clean();
-    _antonym_of = _f;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::has_synonyms()
-  {
-    _has_synonyms = true;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::synonym_of(filter<adverb> _f)
-  {
-    _f.clean();
-    _synonym_of = _f;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::is_mannernymic()
-  {
-    _is_mannernymic = true;
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::mannernym_of(filter<adjective> _f)
-  {
-    _f.clean();
-    _mannernym_of = _f;
-    
-    return *this;
-  }
-  /*
-  adverb_query& adverb_query::derived_from(const word& _w)
-  {
-    if (dynamic_cast<const adjective*>(&_w) != nullptr)
-    {
-      _derived_from_adjective.push_back(dynamic_cast<const adjective&>(_w));
-    } else if (dynamic_cast<const adverb*>(&_w) != nullptr)
-    {
-      _derived_from_adverb.push_back(dynamic_cast<const adverb&>(_w));
-    } else if (dynamic_cast<const noun*>(&_w) != nullptr)
-    {
-      _derived_from_noun.push_back(dynamic_cast<const noun&>(_w));
-    }
-    
-    return *this;
-  }
-  
-  adverb_query& adverb_query::not_derived_from(const word& _w)
-  {
-    if (dynamic_cast<const adjective*>(&_w) != nullptr)
-    {
-      _not_derived_from_adjective.push_back(dynamic_cast<const adjective&>(_w));
-    } else if (dynamic_cast<const adverb*>(&_w) != nullptr)
-    {
-      _not_derived_from_adverb.push_back(dynamic_cast<const adverb&>(_w));
-    } else if (dynamic_cast<const noun*>(&_w) != nullptr)
-    {
-      _not_derived_from_noun.push_back(dynamic_cast<const noun&>(_w));
-    }
-    
-    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;
-    std::list<binding> bindings;
-    
-    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(), "(prerhyme != ? AND rhyme = ?)");
-      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 rhy : _rhymes)
-      {
-        bindings.emplace_back(rhy.get_prerhyme());
-        bindings.emplace_back(rhy.get_rhyme());
-      }
-    }
-    
-    if (_has_rhyming_noun)
-    {
-      conditions.push_back("adverb_id IN (SELECT a.adverb_id FROM adverbs AS a INNER JOIN adverb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN noun_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
-    }
-    
-    if (_has_rhyming_adjective)
-    {
-      conditions.push_back("adverb_id IN (SELECT a.adverb_id FROM adverbs AS a INNER JOIN adverb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN adjective_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
-    }
-    
-    if (_has_rhyming_adverb)
-    {
-      conditions.push_back("adverb_id IN (SELECT a.adverb_id FROM adverbs AS a INNER JOIN adverb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN adverb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme AND rhmp.adverb_id != curp.adverb_id)");
-    }
-    
-    if (_has_rhyming_verb)
-    {
-      conditions.push_back("adverb_id IN (SELECT a.adverb_id FROM adverbs AS a INNER JOIN adverb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN verb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
-    }
-    
-    for (auto except : _except)
-    {
-      conditions.push_back("adverb_id != ?");
-      bindings.emplace_back(except._id);
-    }
-    
-    if (_requires_comparative_form)
-    {
-      conditions.push_back("comparative IS NOT NULL");
-    }
-    
-    if (_requires_superlative_form)
-    {
-      conditions.push_back("superlative IS NOT NULL");
-    }
-    
-    if (!_stress.empty())
-    {
-      std::stringstream cond;
-      if (_stress.get_notlogic())
-      {
-        cond << "adverb_id NOT IN";
-      } else {
-        cond << "adverb_id IN";
-      }
-      
-      cond << "(SELECT adverb_id FROM adverb_pronunciations WHERE ";
-      
-      std::function<std::string (filter<std::vector<bool>>, bool)> recur = [&] (filter<std::vector<bool>> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<std::vector<bool>>::type::singleton:
-          {
-            std::ostringstream _val;
-            for (auto syl : f.get_elem())
-            {
-              if (syl)
-              {
-                _val << "1";
-              } else {
-                _val << "0";
-              }
-            }
-            
-            bindings.emplace_back(_val.str());
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "stress = ?";
-            } else {
-              return "stress != ?";
-            }
-          }
-          
-          case filter<std::vector<bool>>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<std::vector<bool>> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_stress, _stress.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (!_with_prefix.empty())
-    {
-      std::function<std::string (filter<std::string>, bool)> recur = [&] (filter<std::string> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<std::string>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem() + "%");
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "base_form LIKE ?";
-            } else {
-              return "base_form NOT LIKE ?";
-            }
-          }
-          
-          case filter<std::string>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<std::string> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      conditions.push_back(recur(_with_prefix, false));
-    }
-    
-    if (!_with_suffix.empty())
-    {
-      std::function<std::string (filter<std::string>, bool)> recur = [&] (filter<std::string> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<std::string>::type::singleton:
-          {
-            bindings.emplace_back("%" + f.get_elem());
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "base_form LIKE ?";
-            } else {
-              return "base_form NOT LIKE ?";
-            }
-          }
-          
-          case filter<std::string>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<std::string> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      conditions.push_back(recur(_with_suffix, false));
-    }
-    
-    if (_with_complexity != unlimited)
-    {
-      conditions.push_back("complexity = ?");
-      bindings.emplace_back(_with_complexity);
-    }
-    
-    if (_has_antonyms)
-    {
-      conditions.push_back("adverb_id IN (SELECT adverb_2_id FROM adverb_antonymy)");
-    }
-    
-    if (!_antonym_of.empty())
-    {
-      std::stringstream cond;
-      if (_antonym_of.get_notlogic())
-      {
-        cond << "adverb_id NOT IN";
-      } else {
-        cond << "adverb_id IN";
-      }
-      
-      cond << "(SELECT adverb_2_id FROM adverb_antonymy WHERE ";
-      
-      std::function<std::string (filter<adverb>, bool)> recur = [&] (filter<adverb> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<adverb>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "adverb_1_id = ?";
-            } else {
-              return "adverb_1_id != ?";
-            }
-          }
-          
-          case filter<adverb>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<adverb> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_antonym_of, _antonym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_has_synonyms)
-    {
-      conditions.push_back("adverb_id IN (SELECT adverb_2_id FROM adverb_synonymy)");
-    }
-    
-    if (!_synonym_of.empty())
-    {
-      std::stringstream cond;
-      if (_antonym_of.get_notlogic())
-      {
-        cond << "adverb_id NOT IN";
-      } else {
-        cond << "adverb_id IN";
-      }
-      
-      cond << "(SELECT adverb_2_id FROM adverb_synonymy WHERE ";
-      
-      std::function<std::string (filter<adverb>, bool)> recur = [&] (filter<adverb> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<adverb>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "adverb_1_id = ?";
-            } else {
-              return "adverb_1_id != ?";
-            }
-          }
-          
-          case filter<adverb>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<adverb> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_synonym_of, _synonym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_is_mannernymic)
-    {
-      conditions.push_back("adverb_id IN (SELECT mannernym_id FROM mannernymy)");
-    }
-    
-    if (!_mannernym_of.empty())
-    {
-      std::stringstream cond;
-      if (_antonym_of.get_notlogic())
-      {
-        cond << "adverb_id NOT IN";
-      } else {
-        cond << "adverb_id IN";
-      }
-      
-      cond << "(SELECT mannernym_id FROM mannernymy WHERE ";
-      
-      std::function<std::string (filter<adjective>, bool)> recur = [&] (filter<adjective> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<adjective>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "adjective_id = ?";
-            } else {
-              return "adjective_id != ?";
-            }
-          }
-          
-          case filter<adjective>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<adjective> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_mannernym_of, _mannernym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-/*    if (!_derived_from_adjective.empty())
-    {
-      std::list<std::string> clauses(_derived_from_adjective.size(), "adjective_id = @DERADJ");
-      std::string cond = "adverb_id IN (SELECT adverb_id FROM adjective_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_not_derived_from_adjective.empty())
-    {
-      std::list<std::string> clauses(_not_derived_from_adjective.size(), "adjective_id = @NDERADJ");
-      std::string cond = "adverb_id NOT IN (SELECT adverb_id FROM adjective_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_derived_from_adverb.empty())
-    {
-      std::list<std::string> clauses(_derived_from_adverb.size(), "adverb_2_id = @DERADV");
-      std::string cond = "adverb_id IN (SELECT adverb_1_id FROM adverb_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_not_derived_from_adverb.empty())
-    {
-      std::list<std::string> clauses(_not_derived_from_adverb.size(), "adverb_2_id = @NDERADV");
-      std::string cond = "adverb_id NOT IN (SELECT adverb_1_id FROM adverb_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_derived_from_noun.empty())
-    {
-      std::list<std::string> clauses(_derived_from_noun.size(), "noun_id = @DERN");
-      std::string cond = "adverb_id IN (SELECT adverb_id FROM noun_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_not_derived_from_noun.empty())
-    {
-      std::list<std::string> clauses(_not_derived_from_noun.size(), "noun_id = @NDERN");
-      std::string cond = "adverb_id NOT IN (SELECT adverb_id FROM noun_adverb_derivation 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));
-    }
-    
-    int i = 1;
-    for (auto& binding : bindings)
-    {
-      switch (binding.get_type())
-      {
-        case binding::type::integer:
-        {
-          sqlite3_bind_int(ppstmt, i, binding.get_integer());
-          
-          break;
-        }
-        
-        case binding::type::string:
-        {
-          sqlite3_bind_text(ppstmt, i, binding.get_string().c_str(), binding.get_string().length(), SQLITE_TRANSIENT);
-          
-          break;
-        }
-      }
-      
-      i++;
-    }
-    
-    /*
-    for (auto adj : _derived_from_adjective)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERADJ"), adj._id);
-    }
-    
-    for (auto adj : _not_derived_from_adjective)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERADJ"), adj._id);
-    }
-    
-    for (auto adv : _derived_from_adverb)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERADV"), adv._id);
-    }
-    
-    for (auto adv : _not_derived_from_adverb)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERADV"), adv._id);
-    }
-    
-    for (auto n : _derived_from_noun)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERN"), n._id);
-    }
-    
-    for (auto n : _not_derived_from_noun)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERN"), n._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, prerhyme, rhyme 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);
-        
-        if ((sqlite3_column_type(ppstmt, 1) != SQLITE_NULL) && (sqlite3_column_type(ppstmt, 2) != SQLITE_NULL))
-        {
-          std::string prerhyme(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
-          std::string rhyming(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 2)));
-          adverb.rhymes.emplace_back(prerhyme, rhyming);
-        }
-      }
-      
-      sqlite3_finalize(ppstmt);
-    }
-
-    return output;
-  }
-
-};
@@ -1,86 +0,0 @@
-#ifndef ADVERB_QUERY_H_CA13CCDD
-#define ADVERB_QUERY_H_CA13CCDD
-
-namespace verbly {
-  
-  class adverb_query {
-    public:
-      adverb_query(const data& _data);
-      
-      adverb_query& limit(int _limit);
-      adverb_query& random();
-      adverb_query& except(const adverb& _word);
-      adverb_query& rhymes_with(const word& _word);
-      adverb_query& rhymes_with(rhyme _r);
-      adverb_query& has_pronunciation();
-      adverb_query& has_rhyming_noun();
-      adverb_query& has_rhyming_adjective();
-      adverb_query& has_rhyming_adverb();
-      adverb_query& has_rhyming_verb();
-      adverb_query& with_stress(filter<std::vector<bool>> _arg);
-      
-      adverb_query& requires_comparative_form();
-      adverb_query& requires_superlative_form();
-      
-      adverb_query& with_prefix(filter<std::string> _f);
-      adverb_query& with_suffix(filter<std::string> _f);
-      
-      adverb_query& with_complexity(int _arg);
-      
-      adverb_query& has_antonyms();
-      adverb_query& antonym_of(filter<adverb> _f);
-      
-      adverb_query& has_synonyms();
-      adverb_query& synonym_of(filter<adverb> _f);
-      
-      adverb_query& is_mannernymic();
-      adverb_query& mannernym_of(filter<adjective> _f);
-      
-/*      adverb_query& derived_from(const word& _w);
-      adverb_query& not_derived_from(const word& _w);*/
-      
-      std::list<adverb> run() const;
-      
-      const static int unlimited = -1;
-      
-    private:
-      const data& _data;
-      int _limit = unlimited;
-      bool _random = false;
-      std::list<rhyme> _rhymes;
-      std::list<adverb> _except;
-      bool _has_prn = false;
-      bool _has_rhyming_noun = false;
-      bool _has_rhyming_adjective = false;
-      bool _has_rhyming_adverb = false;
-      bool _has_rhyming_verb = false;
-      filter<std::vector<bool>> _stress;
-      
-      bool _requires_comparative_form = false;
-      bool _requires_superlative_form = false;
-      
-      filter<std::string> _with_prefix;
-      filter<std::string> _with_suffix;
-      
-      int _with_complexity = unlimited;
-      
-      bool _has_antonyms = false;
-      filter<adverb> _antonym_of;
-      
-      bool _has_synonyms = false;
-      filter<adverb> _synonym_of;
-      
-      bool _is_mannernymic = false;
-      filter<adjective> _mannernym_of;
-      
-/*      std::list<adjective> _derived_from_adjective;
-      std::list<adjective> _not_derived_from_adjective;
-      std::list<adverb> _derived_from_adverb;
-      std::list<adverb> _not_derived_from_adverb;
-      std::list<noun> _derived_from_noun;
-      std::list<noun> _not_derived_from_noun;*/
-  };
-  
-};
-
-#endif /* end of include guard: ADVERB_QUERY_H_CA13CCDD */
@@ -0,0 +1,180 @@
+#include "binding.h"
+#include <stdexcept>
+#include <utility>
+
+namespace verbly {
+
+  binding::binding(const binding& other)
+  {
+    type_ = other.type_;
+
+    switch (type_)
+    {
+      case type::integer:
+      {
+        integer_ = other.integer_;
+
+        break;
+      }
+
+      case type::string:
+      {
+        new(&string_) std::string(other.string_);
+
+        break;
+      }
+
+      case type::invalid:
+      {
+        break;
+      }
+    }
+  }
+
+  binding::binding(binding&& other) : binding()
+  {
+    swap(*this, other);
+  }
+
+  binding& binding::operator=(binding other)
+  {
+    swap(*this, other);
+
+    return *this;
+  }
+
+  void swap(binding& first, binding& second)
+  {
+    using type = binding::type;
+
+    type tempType = first.type_;
+    int tempInteger;
+    std::string tempString;
+
+    switch (first.type_)
+    {
+      case type::integer:
+      {
+        tempInteger = first.integer_;
+
+        break;
+      }
+
+      case type::string:
+      {
+        tempString = std::move(tempString);
+
+        break;
+      }
+
+      case type::invalid:
+      {
+        break;
+      }
+    }
+
+    first.~binding();
+
+    first.type_ = second.type_;
+
+    switch (second.type_)
+    {
+      case type::integer:
+      {
+        first.integer_ = second.integer_;
+
+        break;
+      }
+
+      case type::string:
+      {
+        new(&first.string_) std::string(std::move(second.string_));
+
+        break;
+      }
+
+      case type::invalid:
+      {
+        break;
+      }
+    }
+
+    second.~binding();
+
+    second.type_ = tempType;
+
+    switch (tempType)
+    {
+      case type::integer:
+      {
+        second.integer_ = tempInteger;
+
+        break;
+      }
+
+      case type::string:
+      {
+        new(&second.string_) std::string(std::move(tempString));
+
+        break;
+      }
+
+      case type::invalid:
+      {
+        break;
+      }
+    }
+  }
+
+  binding::~binding()
+  {
+    switch (type_)
+    {
+      case type::string:
+      {
+        using string_type = std::string;
+        string_.~string_type();
+
+        break;
+      }
+
+      case type::integer:
+      case type::invalid:
+      {
+        break;
+      }
+    }
+  }
+
+  binding::binding(int arg) :
+    type_(type::integer),
+    integer_(arg)
+  {
+  }
+
+  int binding::getInteger() const
+  {
+    if (type_ != type::integer)
+    {
+      throw std::domain_error("binding::getInteger called on non-integer binding");
+    }
+
+    return integer_;
+  }
+
+  binding::binding(std::string arg) : type_(type::string)
+  {
+    new(&string_) std::string(arg);
+  }
+
+  std::string binding::getString() const
+  {
+    if (type_ != type::string)
+    {
+      throw std::domain_error("binding::getString called on non-string binding");
+    }
+
+    return string_;
+  }
+
+};
@@ -0,0 +1,70 @@
+#ifndef BINDING_H_CAE0B18E
+#define BINDING_H_CAE0B18E
+
+#include <string>
+
+namespace verbly {
+
+  class binding {
+    public:
+      enum class type {
+        invalid,
+        integer,
+        string
+      };
+      
+      // Default constructor
+      
+      binding()
+      {
+      }
+
+      // Copy and move constructors
+
+      binding(const binding& other);
+      binding(binding&& other);
+
+      // Assignment
+
+      binding& operator=(binding other);
+
+      // Swap
+
+      friend void swap(binding& first, binding& second);
+
+      // Destructor
+
+      ~binding();
+
+      // Generic accessors
+      
+      type getType() const
+      {
+        return type_;
+      }
+
+      // Integer
+      
+      binding(int arg);
+      
+      int getInteger() const;
+
+      // String
+      
+      binding(std::string arg);
+      
+      std::string getString() const;
+
+    private:
+
+      union {
+        int integer_;
+        std::string string_;
+      };
+
+      type type_ = type::invalid;
+  };
+
+};
+
+#endif /* end of include guard: BINDING_H_CAE0B18E */
@@ -1,177 +0,0 @@
-#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);
-  }
-  
-  frame_query data::frames() const
-  {
-    return frame_query(*this);
-  }
-  
-  preposition_query data::prepositions() const
-  {
-    return preposition_query(*this);
-  }
-  
-  binding::type binding::get_type() const
-  {
-    return _type;
-  }
-  
-  binding::binding(const binding& other)
-  {
-    _type = other._type;
-    
-    switch (_type)
-    {
-      case type::integer:
-      {
-        _integer = other._integer;
-        
-        break;
-      }
-      
-      case type::string:
-      {
-        new(&_string) std::string(other._string);
-        
-        break;
-      }
-    }
-  }
-  
-  binding::~binding()
-  {
-    switch (_type)
-    {
-      case type::string:
-      {
-        using string_type = std::string;
-        _string.~string_type();
-        
-        break;
-      }
-    }
-  }
-  
-  binding& binding::operator=(const binding& other)
-  {
-    this->~binding();
-    
-    _type = other._type;
-    
-    switch (_type)
-    {
-      case type::integer:
-      {
-        _integer = other._integer;
-        
-        break;
-      }
-      
-      case type::string:
-      {
-        new(&_string) std::string(other._string);
-        
-        break;
-      }
-    }
-    
-    return *this;
-  }
-  
-  binding::binding(int _arg)
-  {
-    _type = type::integer;
-    _integer = _arg;
-  }
-  
-  int binding::get_integer() const
-  {
-    assert(_type == type::integer);
-    
-    return _integer;
-  }
-  
-  void binding::set_integer(int _arg)
-  {
-    *this = binding(_arg);
-  }
-  
-  binding& binding::operator=(int _arg)
-  {
-    *this = binding(_arg);
-    
-    return *this;
-  }
-  
-  binding::binding(std::string _arg)
-  {
-    _type = type::string;
-    new(&_string) std::string(_arg);
-  }
-  
-  std::string binding::get_string() const
-  {
-    assert(_type == type::string);
-    
-    return _string;
-  }
-  
-  void binding::set_string(std::string _arg)
-  {
-    *this = binding(_arg);
-  }
-  
-  binding& binding::operator=(std::string _arg)
-  {
-    *this = binding(_arg);
-    
-    return *this;
-  }
-  
-};
@@ -1,380 +0,0 @@
-#ifndef DATA_H_C4AEC3DD
-#define DATA_H_C4AEC3DD
-
-#include <sqlite3.h>
-
-namespace verbly {
-  
-  class data;
-  class word;
-  class adjective;
-  class noun;
-  class verb;
-  class adverb;
-  class frame;
-  class adjective_query;
-  class adverb_query;
-  class noun_query;
-  class verb_query;
-  class frame_query;
-  class preposition_query;
-  
-  class data {
-    private:
-      sqlite3* ppdb;
-      
-      friend class adjective_query;
-      friend class noun_query;
-      friend class verb_query;
-      friend class adverb_query;
-      friend class frame_query;
-      friend class preposition_query;
-      
-    public:
-      data(std::string datafile);
-      
-      data(const data& other) = delete;
-      data& operator=(const data& other) = delete;
-      
-      data(data&& other);
-      data& operator=(data&& other);
-      
-      ~data();
-      
-      verb_query verbs() const;
-      adjective_query adjectives() const;
-      adverb_query adverbs() const;
-      noun_query nouns() const;
-      frame_query frames() const;
-      preposition_query prepositions() const;
-      
-  };
-  
-  template <class T>
-  class filter {
-    public:
-      enum class type {
-        singleton,
-        group
-      };
-      
-      typedef filter<T> value_type;
-      
-      type get_type() const
-      {
-        return _type;
-      }
-      
-      filter(const filter<T>& other)
-      {
-        _type = other._type;
-        _notlogic = other._notlogic;
-        
-        switch (_type)
-        {
-          case type::singleton:
-          {
-            new(&_singleton.elem) T(other._singleton.elem);
-            
-            break;
-          }
-          
-          case type::group:
-          {
-            new(&_group.elems) std::list<filter<T>>(other._group.elems);
-            _group.orlogic = other._group.orlogic;
-            
-            break;
-          }
-        }
-      }
-      
-      filter<T>& operator=(const filter<T>& other)
-      {
-        this->~filter();
-        
-        _type = other._type;
-        _notlogic = other._notlogic;
-        
-        switch (_type)
-        {
-          case type::singleton:
-          {
-            new(&_singleton.elem) T(other._singleton.elem);
-            
-            break;
-          }
-          
-          case type::group:
-          {
-            new(&_group.elems) std::list<filter<T>>(other._group.elems);
-            _group.orlogic = other._group.orlogic;
-            
-            break;
-          }
-        }
-        
-        return *this;
-      }
-      
-      ~filter()
-      {
-        switch (_type)
-        {
-          case type::singleton:
-          {
-            _singleton.elem.~T();
-            
-            break;
-          }
-          
-          case type::group:
-          {
-            using list_type = std::list<filter<T>>;
-            _group.elems.~list_type();
-            
-            break;
-          }
-        }
-      }
-      
-      bool get_notlogic() const
-      {
-        return _notlogic;
-      }
-      
-      void set_notlogic(bool _nl)
-      {
-        _notlogic = _nl;
-      }
-      
-      std::list<T> inorder_flatten() const
-      {
-        std::list<T> result;
-        
-        if (_type == type::singleton)
-        {
-          result.push_back(_singleton.elem);
-        } else if (_type == type::group)
-        {
-          for (auto elem : _group.elems)
-          {
-            auto l = elem.inorder_flatten();
-            result.insert(std::end(result), std::begin(l), std::end(l));
-          }
-        }
-        
-        return result;
-      }
-      
-      std::set<T> uniq_flatten() const
-      {
-        std::set<T> result;
-        
-        if (_type == type::singleton)
-        {
-          result.insert(_singleton.elem);
-        } else if (_type == type::group)
-        {
-          for (auto elem : _group.elems)
-          {
-            auto l = elem.uniq_flatten();
-            result.insert(std::begin(l), std::end(l));
-          }
-        }
-        
-        return result;
-      }
-      
-      void clean()
-      {
-        if (_type == type::group)
-        {
-          std::list<typename std::list<filter<T>>::iterator> toremove;
-          for (auto it = _group.elems.begin(); it != _group.elems.end(); it++)
-          {
-            it->clean();
-            
-            if (it->get_type() == type::group)
-            {
-              if (it->_group.elems.size() == 0)
-              {
-                toremove.push_back(it);
-              } else if (it->_group.elems.size() == 1)
-              {
-                bool truelogic = it->_notlogic != it->_group.elems.front()._notlogic;
-                filter<T> e = it->_group.elems.front();
-                *it = e;
-                it->_notlogic = truelogic;
-              }
-            }
-          }
-          
-          for (auto rem : toremove)
-          {
-            _group.elems.erase(rem);
-          }
-          
-          if (_group.elems.size() == 1)
-          {
-            bool truelogic = _notlogic != _group.elems.front()._notlogic;
-            filter<T> e = _group.elems.front();
-            *this = e;
-            _notlogic = truelogic;
-          }
-        }
-      }
-      
-      // Singleton
-      filter(T _elem, bool _notlogic = false) : _type(type::singleton)
-      {
-        new(&_singleton.elem) T(_elem);
-        this->_notlogic = _notlogic;
-      }
-      
-      filter<T>& operator=(T _elem)
-      {
-        *this = filter<T>{_elem};
-        
-        return *this;
-      }
-      
-      T get_elem() const
-      {
-        assert(_type == type::singleton);
-        
-        return _singleton.elem;
-      }
-      
-      void set_elem(T _elem)
-      {
-        assert(_type == type::singleton);
-        
-        _singleton.elem = _elem;
-      }
-      
-      // Group
-      typedef typename std::list<filter<T>>::iterator iterator;
-      
-      filter() : _type(type::group)
-      {
-        new(&_group.elems) std::list<filter<T>>();
-        _group.orlogic = false;
-      }
-      
-      filter(std::initializer_list<filter<T>> _init) : _type(type::group)
-      {
-        new(&_group.elems) std::list<filter<T>>(_init);
-        _group.orlogic = false;
-      }
-      
-      iterator begin()
-      {
-        assert(_type == type::group);
-        
-        return _group.elems.begin();
-      }
-      
-      iterator end()
-      {
-        assert(_type == type::group);
-        
-        return _group.elems.end();
-      }
-      
-      filter<T>& operator<<(filter<T> _elem)
-      {
-        assert(_type == type::group);
-        
-        _group.elems.push_back(_elem);
-        
-        return *this;
-      }
-      
-      void push_back(filter<T> _elem)
-      {
-        assert(_type == type::group);
-        
-        _group.elems.push_back(_elem);
-      }
-      
-      bool get_orlogic() const
-      {
-        assert(_type == type::group);
-        
-        return _group.orlogic;
-      }
-      
-      void set_orlogic(bool _ol)
-      {
-        assert(_type == type::group);
-        
-        _group.orlogic = _ol;
-      }
-      
-      bool empty() const
-      {
-        if (_type == type::group)
-        {
-          return _group.elems.empty();
-        } else {
-          return false;
-        }
-      }
-      
-      int size() const
-      {
-        assert(_type == type::group);
-        
-        return _group.elems.size();
-      }
-      
-    private:
-      type _type;
-      bool _notlogic = false;
-      union {
-        struct {
-          T elem;
-        } _singleton;
-        struct {
-          std::list<filter<T>> elems;
-          bool orlogic;
-        } _group;
-      };
-  };
-  
-  class binding {
-    public:
-      enum class type {
-        integer,
-        string
-      };
-  
-      type get_type() const;
-      binding(const binding& other);
-      ~binding();
-      binding& operator=(const binding& other);
-    
-      // Integer
-      binding(int _arg);
-      int get_integer() const;
-      void set_integer(int _arg);
-      binding& operator=(int _arg);
-    
-      // String
-      binding(std::string _arg);
-      std::string get_string() const;
-      void set_string(std::string _arg);
-      binding& operator=(std::string _arg);
-    
-    private:
-      union {
-        int _integer;
-        std::string _string;
-      };
-      type _type;
-  };
-  
-};
-
-#endif /* end of include guard: DATA_H_C4AEC3DD */
@@ -0,0 +1,79 @@
+#include "database.h"
+#include <sqlite3.h>
+#include <stdexcept>
+#include "query.h"
+
+namespace verbly {
+
+  database::database(std::string path)
+  {
+    if (sqlite3_open_v2(path.c_str(), &ppdb_, SQLITE_OPEN_READONLY, NULL) != SQLITE_OK)
+    {
+      // We still have to free the resources allocated. In the event that
+      // allocation failed, ppdb will be null and sqlite3_close_v2 will just
+      // ignore it.
+      std::string errmsg(sqlite3_errmsg(ppdb_));
+      sqlite3_close_v2(ppdb_);
+
+      throw database_error("Could not open verbly datafile", errmsg);
+    }
+  }
+
+  database::database(database&& other) : database()
+  {
+    swap(*this, other);
+  }
+
+  database& database::operator=(database&& other)
+  {
+    swap(*this, other);
+
+    return *this;
+  }
+
+  void swap(database& first, database& second)
+  {
+    std::swap(first.ppdb_, second.ppdb_);
+  }
+
+  database::~database()
+  {
+    sqlite3_close_v2(ppdb_);
+  }
+  
+  query<notion> database::notions(filter where, bool random, int limit) const
+  {
+    return query<notion>(*this, ppdb_, std::move(where), random, limit);
+  }
+  
+  query<word> database::words(filter where, bool random, int limit) const
+  {
+    return query<word>(*this, ppdb_, std::move(where), random, limit);
+  }
+  
+  query<group> database::groups(filter where, bool random, int limit) const
+  {
+    return query<group>(*this, ppdb_, std::move(where), random, limit);
+  }
+  
+  query<frame> database::frames(filter where, bool random, int limit) const
+  {
+    return query<frame>(*this, ppdb_, std::move(where), random, limit);
+  }
+  
+  query<lemma> database::lemmas(filter where, bool random, int limit) const
+  {
+    return query<lemma>(*this, ppdb_, std::move(where), random, limit);
+  }
+  
+  query<form> database::forms(filter where, bool random, int limit) const
+  {
+    return query<form>(*this, ppdb_, std::move(where), random, limit);
+  }
+  
+  query<pronunciation> database::pronunciations(filter where, bool random, int limit) const
+  {
+    return query<pronunciation>(*this, ppdb_, std::move(where), random, limit);
+  }
+
+};
@@ -0,0 +1,73 @@
+#ifndef DATABASE_H_0B0A47D2
+#define DATABASE_H_0B0A47D2
+
+#include <string>
+#include <exception>
+#include <list>
+#include "notion.h"
+#include "word.h"
+#include "group.h"
+#include "frame.h"
+#include "lemma.h"
+#include "form.h"
+#include "pronunciation.h"
+
+struct sqlite3;
+
+namespace verbly {
+  
+  template <typename Object>
+  class query;
+
+  class database {
+  public:
+
+    // Constructor
+
+    explicit database(std::string path);
+
+    // Disable copying
+
+    database(const database& other) = delete;
+    database& operator=(const database& other) = delete;
+
+    // Move constructor and move assignment
+
+    database(database&& other);
+    database& operator=(database&& other);
+
+    // Swap
+
+    friend void swap(database& first, database& second);
+
+    // Destructor
+
+    ~database();
+    
+    // Queries
+    
+    query<notion> notions(filter where, bool random = true, int limit = 1) const;
+    
+    query<word> words(filter where, bool random = true, int limit = 1) const;
+    
+    query<group> groups(filter where, bool random = true, int limit = 1) const;
+    
+    query<frame> frames(filter where, bool random = true, int limit = 1) const;
+    
+    query<lemma> lemmas(filter where, bool random = true, int limit = 1) const;
+    
+    query<form> forms(filter where, bool random = true, int limit = 1) const;
+    
+    query<pronunciation> pronunciations(filter where, bool random = true, int limit = 1) const;
+
+  private:
+
+    database() = default;
+
+    sqlite3* ppdb_ = nullptr;
+
+  };
+
+};
+
+#endif /* end of include guard: DATABASE_H_0B0A47D2 */
@@ -0,0 +1,45 @@
+#ifndef ENUMS_H_260BA847
+#define ENUMS_H_260BA847
+
+namespace verbly {
+    
+  enum class part_of_speech {
+    noun = 0,
+    adjective = 1,
+    adverb = 2,
+    verb = 3,
+    preposition = 4
+  };
+  
+  enum class positioning {
+    undefined = -1,
+    predicate = 0,
+    attributive = 1,
+    postnominal = 2
+  };
+  
+  enum class inflection {
+    base = 0,
+    plural = 1,
+    comparative = 2,
+    superlative = 3,
+    past_tense = 4,
+    past_participle = 5,
+    ing_form = 6,
+    s_form = 7
+  };
+  
+  enum class object {
+    undefined = -1,
+    notion = 0,
+    word = 1,
+    group = 2,
+    frame = 3,
+    lemma = 4,
+    form = 5,
+    pronunciation = 6
+  };
+  
+};
+
+#endif /* end of include guard: ENUMS_H_260BA847 */
@@ -0,0 +1,91 @@
+#include "field.h"
+#include "filter.h"
+
+namespace verbly {
+  
+  filter field::operator==(int value) const
+  {
+    return filter(*this, filter::comparison::int_equals, value);
+  }
+  
+  filter field::operator!=(int value) const
+  {
+    return filter(*this, filter::comparison::int_does_not_equal, value);
+  }
+  
+  filter field::operator<(int value) const
+  {
+    return filter(*this, filter::comparison::int_is_less_than, value);
+  }
+  
+  filter field::operator<=(int value) const
+  {
+    return filter(*this, filter::comparison::int_is_at_most, value);
+  }
+  
+  filter field::operator>(int value) const
+  {
+    return filter(*this, filter::comparison::int_is_greater_than, value);
+  }
+  
+  filter field::operator>=(int value) const
+  {
+    return filter(*this, filter::comparison::int_is_at_least, value);
+  }
+  
+  filter field::operator==(part_of_speech value) const
+  {
+    return filter(*this, filter::comparison::int_equals, static_cast<int>(value));
+  }
+  
+  filter field::operator==(positioning value) const
+  {
+    return filter(*this, filter::comparison::int_equals, static_cast<int>(value));
+  }
+  
+  filter field::operator==(inflection value) const
+  {
+    return filter(*this, filter::comparison::int_equals, static_cast<int>(value));
+  }
+  
+  filter field::operator==(bool value) const
+  {
+    return filter(*this, filter::comparison::boolean_equals, value);
+  }
+  
+  filter field::operator==(std::string value) const
+  {
+    return filter(*this, filter::comparison::string_equals, std::move(value));
+  }
+  
+  filter field::operator!=(std::string value) const
+  {
+    return filter(*this, filter::comparison::string_does_not_equal, std::move(value));
+  }
+  
+  filter field::operator%=(std::string value) const
+  {
+    return filter(*this, filter::comparison::string_is_like, std::move(value));
+  }
+  
+  field::operator filter() const
+  {
+    return filter(*this, filter::comparison::is_not_null);
+  }
+  
+  filter field::operator!() const
+  {
+    return filter(*this, filter::comparison::is_null);
+  }
+  
+  filter field::operator%=(filter joinCondition) const
+  {
+    if (type_ == type::hierarchal_join)
+    {
+      return filter(*this, filter::comparison::hierarchally_matches, std::move(joinCondition));
+    } else {
+      return filter(*this, filter::comparison::matches, std::move(joinCondition));
+    }
+  }
+  
+};
@@ -0,0 +1,306 @@
+#ifndef FIELD_H_43258321
+#define FIELD_H_43258321
+
+#include "enums.h"
+#include <stdexcept>
+#include <tuple>
+
+namespace verbly {
+  
+  class filter;
+  
+  class field {
+  public:
+    enum class type {
+      undefined,
+      string,
+      integer,
+      boolean,
+      join,
+      join_through,
+      hierarchal_join
+    };
+    
+    // Default constructor
+    
+    field()
+    {
+    }
+    
+    // Static factories
+    
+    static field stringField(
+      object obj,
+      const char* name,
+      bool nullable = false)
+    {
+      return field(obj, type::string, name, nullable);
+    }
+    
+    static field stringField(
+      const char* table,
+      const char* name,
+      bool nullable = false)
+    {
+      return field(object::undefined, type::string, name, nullable, table);
+    }
+    
+    static field integerField(
+      object obj,
+      const char* name,
+      bool nullable = false)
+    {
+      return field(obj, type::integer, name, nullable);
+    }
+    
+    static field integerField(
+      const char* table,
+      const char* name,
+      bool nullable = false)
+    {
+      return field(object::undefined, type::integer, name, nullable, table);
+    }
+    
+    static field booleanField(
+      object obj,
+      const char* name,
+      bool nullable = false)
+    {
+      return field(obj, type::boolean, name, nullable);
+    }
+    
+    static field booleanField(
+      const char* table,
+      const char* name,
+      bool nullable = false)
+    {
+      return field(object::undefined, type::boolean, name, nullable, table);
+    }
+    
+    static field joinField(
+      object obj,
+      const char* name,
+      object joinWith,
+      bool nullable = false)
+    {
+      return field(obj, type::join, name, nullable, 0, joinWith);
+    }
+    
+    static field joinField(
+      object obj,
+      const char* name,
+      const char* table,
+      bool nullable = false)
+    {
+      return field(obj, type::join, name, nullable, table);
+    }
+    
+    static field joinThrough(
+      object obj,
+      const char* name,
+      object joinWith,
+      const char* joinTable,
+      const char* foreignColumn)
+    {
+      return field(obj, type::join_through, name, true, joinTable, joinWith, foreignColumn, name, foreignColumn);
+    }
+    
+    static field joinThrough(
+      object obj,
+      const char* name,
+      object joinWith,
+      const char* joinTable,
+      const char* foreignColumn,
+      const char* joinColumn,
+      const char* foreignJoinColumn)
+    {
+      return field(obj, type::join_through, name, true, joinTable, joinWith, foreignColumn, joinColumn, foreignJoinColumn);
+    }
+    
+    static field selfJoin(
+      object obj,
+      const char* name,
+      const char* joinTable,
+      const char* joinColumn,
+      const char* foreignJoinColumn)
+    {
+      return field(obj, type::join_through, name, true, joinTable, obj, name, joinColumn, foreignJoinColumn);
+    }
+    
+    static field hierarchalSelfJoin(
+      object obj,
+      const char* name,
+      const char* joinTable,
+      const char* joinColumn,
+      const char* foreignJoinColumn)
+    {
+      return field(obj, type::hierarchal_join, name, true, joinTable, obj, name, joinColumn, foreignJoinColumn);
+    }
+    
+    // Accessors
+    
+    object getObject() const
+    {
+      return object_;
+    }
+    
+    type getType() const
+    {
+      return type_;
+    }
+    
+    bool isJoin() const
+    {
+      return ((type_ == type::join) || (type_ == type::join_through) || (type_ == type::hierarchal_join));
+    }
+    
+    const char* getColumn() const
+    {
+      return column_;
+    }
+    
+    bool isNullable() const
+    {
+      return nullable_;
+    }
+    
+    bool hasTable() const
+    {
+      return (table_ != 0);
+    }
+    
+    const char* getTable() const
+    {
+      return table_;
+    }
+    
+    // Joins
+    
+    object getJoinObject() const
+    {
+      // We ignore hierarchal joins because they are always self joins.
+      return ((type_ == type::join) || (type_ == type::join_through))
+        ? joinObject_
+        : throw std::domain_error("Non-join fields don't have join objects");
+    }
+        
+    // Many-to-many joins
+    
+    const char* getForeignColumn() const
+    {
+      // We ignore hierarchal joins because they are always self joins.
+      return (type_ == type::join_through)
+        ? foreignColumn_
+        : throw std::domain_error("Only many-to-many join fields have a foreign column");
+    }
+    
+    const char* getJoinColumn() const
+    {
+      return ((type_ == type::join_through) || (type_ == type::hierarchal_join))
+        ? joinColumn_
+        : throw std::domain_error("Only many-to-many join fields have a join column");
+    }
+    
+    const char* getForeignJoinColumn() const
+    {
+      return ((type_ == type::join_through) || (type_ == type::hierarchal_join))
+        ? foreignJoinColumn_
+        : throw std::domain_error("Only many-to-many join fields have a foreign join column");
+    }
+    
+    // Ordering
+    
+    bool operator<(const field& other) const
+    {
+      // For the most part, (object, column) uniquely identifies fields.
+      // However, there do exist a number of relationships from an object to
+      // itself, such as notion hypernymy/hyponymy. Hypernymy and hyponymy have
+      // the same object (notion), the same column (notion_id), and the same
+      // table (hypernymy); however, they have different join columns.
+      return std::tie(object_, column_, table_, joinColumn_) < std::tie(other.object_, other.column_, other.table_, other.joinColumn_);
+    }
+    
+    // Equality
+    
+    bool operator==(const field& other) const
+    {
+      // For the most part, (object, column) uniquely identifies fields.
+      // However, there do exist a number of relationships from an object to
+      // itself, such as notion hypernymy/hyponymy. Hypernymy and hyponymy have
+      // the same object (notion), the same column (notion_id), and the same
+      // table (hypernymy); however, they have different join columns.
+      return std::tie(object_, column_, table_, joinColumn_) == std::tie(other.object_, other.column_, other.table_, other.joinColumn_);
+    }
+    
+    // Filter construction
+    
+    filter operator==(int value) const; // Integer equality
+    filter operator!=(int value) const; // Integer inequality
+    filter operator<(int value) const; // Integer is less than
+    filter operator<=(int value) const; // Integer is at most
+    filter operator>(int value) const; // Integer is greater than
+    filter operator>=(int value) const; // Integer is at least
+    
+    filter operator==(part_of_speech value) const; // Part of speech equality
+    filter operator==(positioning value) const; // Adjective positioning equality
+    filter operator==(inflection value) const; // Inflection category equality
+    
+    filter operator==(bool value) const; // Boolean equality
+    
+    filter operator==(std::string value) const; // String equality
+    filter operator!=(std::string value) const; // String inequality
+    filter operator%=(std::string value) const; // String matching
+    
+    operator filter() const; // Non-nullity
+    filter operator!() const; // Nullity
+    
+    filter operator%=(filter joinCondition) const; // Join
+    
+  private:
+    
+    // Constructor
+    
+    field(
+      object obj,
+      type datatype,
+      const char* column,
+      bool nullable = false,
+      const char* table = 0,
+      object joinObject = object::undefined,
+      const char* foreignColumn = 0,
+      const char* joinColumn = 0,
+      const char* foreignJoinColumn = 0) :
+        object_(obj),
+        type_(datatype),
+        column_(column),
+        nullable_(nullable),
+        table_(table),
+        joinObject_(joinObject),
+        foreignColumn_(foreignColumn),
+        joinColumn_(joinColumn),
+        foreignJoinColumn_(foreignJoinColumn)
+    {
+    }
+    
+    // General
+    object object_ = object::undefined;
+    type type_ = type::undefined;
+    const char* column_ = 0;
+    const char* table_ = 0;
+    
+    // Non-joins and belongs-to joins
+    bool nullable_ = false;
+    
+    // Joins
+    object joinObject_ = object::undefined;
+    
+    // Many-to-many joins
+    const char* foreignColumn_ = 0;
+    const char* joinColumn_ = 0;
+    const char* foreignJoinColumn_ = 0;
+    
+  };
+  
+};
+
+#endif /* end of include guard: FIELD_H_43258321 */
@@ -0,0 +1,1365 @@
+#include "filter.h"
+#include <stdexcept>
+#include <map>
+#include "notion.h"
+#include "word.h"
+#include "group.h"
+#include "frame.h"
+#include "lemma.h"
+#include "form.h"
+#include "pronunciation.h"
+
+namespace verbly {
+
+  filter::filter(const filter& other)
+  {
+    type_ = other.type_;
+    
+    switch (type_)
+    {
+      case type::empty:
+      {
+        break;
+      }
+      
+      case type::singleton:
+      {
+        new(&singleton_.filterField) field(other.singleton_.filterField);
+        singleton_.filterType = other.singleton_.filterType;
+        
+        switch (singleton_.filterType)
+        {
+          case comparison::int_equals:
+          case comparison::int_does_not_equal:
+          case comparison::int_is_at_least:
+          case comparison::int_is_greater_than:
+          case comparison::int_is_at_most:
+          case comparison::int_is_less_than:
+          {
+            singleton_.intValue = other.singleton_.intValue;
+            
+            break;
+          }
+          
+          case comparison::boolean_equals:
+          {
+            singleton_.boolValue = other.singleton_.boolValue;
+            
+            break;
+          }
+          
+          case comparison::string_equals:
+          case comparison::string_does_not_equal:
+          case comparison::string_is_like:
+          case comparison::string_is_not_like:
+          {
+            new(&singleton_.stringValue) std::string(other.singleton_.stringValue);
+            
+            break;
+          }
+          
+          case comparison::is_null:
+          case comparison::is_not_null:
+          {
+            break;
+          }
+          
+          case comparison::matches:
+          case comparison::does_not_match:
+          case comparison::hierarchally_matches:
+          case comparison::does_not_hierarchally_match:
+          {
+            new(&singleton_.join) std::unique_ptr<filter>(new filter(*other.singleton_.join));
+            
+            break;
+          }
+        }
+        
+        break;
+      }
+      
+      case type::group:
+      {
+        new(&group_.children) std::list<filter>(other.group_.children);
+        group_.orlogic = other.group_.orlogic;
+        
+        break;
+      }
+    }
+  }
+  
+  filter::filter(filter&& other) : filter()
+  {
+    swap(*this, other);
+  }
+  
+  filter& filter::operator=(filter other)
+  {
+    swap(*this, other);
+    
+    return *this;
+  }
+  
+  void swap(filter& first, filter& second)
+  {
+    using type = filter::type;
+    using comparison = filter::comparison;
+    
+    type tempType = first.type_;
+    field tempField;
+    comparison tempComparison;
+    std::unique_ptr<filter> tempJoin;
+    std::string tempStringValue;
+    int tempIntValue;
+    bool tempBoolValue;
+    std::list<filter> tempChildren;
+    bool tempOrlogic;
+    
+    switch (tempType)
+    {
+      case type::empty:
+      {
+        break;
+      }
+      
+      case type::singleton:
+      {
+        tempField = std::move(first.singleton_.filterField);
+        tempComparison = first.singleton_.filterType;
+        
+        switch (tempComparison)
+        {
+          case comparison::int_equals:
+          case comparison::int_does_not_equal:
+          case comparison::int_is_at_least:
+          case comparison::int_is_greater_than:
+          case comparison::int_is_at_most:
+          case comparison::int_is_less_than:
+          {
+            tempIntValue = first.singleton_.intValue;
+            
+            break;
+          }
+          
+          case comparison::boolean_equals:
+          {
+            tempBoolValue = first.singleton_.boolValue;
+            
+            break;
+          }
+          
+          case comparison::string_equals:
+          case comparison::string_does_not_equal:
+          case comparison::string_is_like:
+          case comparison::string_is_not_like:
+          {
+            tempStringValue = std::move(first.singleton_.stringValue);
+            
+            break;
+          }
+          
+          case comparison::is_null:
+          case comparison::is_not_null:
+          {
+            break;
+          }
+          
+          case comparison::matches:
+          case comparison::does_not_match:
+          case comparison::hierarchally_matches:
+          case comparison::does_not_hierarchally_match:
+          {
+            tempJoin = std::move(first.singleton_.join);
+            
+            break;
+          }
+        }
+        
+        break;
+      }
+      
+      case type::group:
+      {
+        tempChildren = std::move(first.group_.children);
+        tempOrlogic = first.group_.orlogic;
+        
+        break;
+      }
+    }
+    
+    first.~filter();
+    
+    first.type_ = second.type_;
+    
+    switch (first.type_)
+    {
+      case type::empty:
+      {
+        break;
+      }
+      
+      case type::singleton:
+      {
+        new(&first.singleton_.filterField) field(std::move(second.singleton_.filterField));
+        first.singleton_.filterType = second.singleton_.filterType;
+        
+        switch (first.singleton_.filterType)
+        {
+          case comparison::int_equals:
+          case comparison::int_does_not_equal:
+          case comparison::int_is_at_least:
+          case comparison::int_is_greater_than:
+          case comparison::int_is_at_most:
+          case comparison::int_is_less_than:
+          {
+            first.singleton_.intValue = second.singleton_.intValue;
+            
+            break;
+          }
+          
+          case comparison::boolean_equals:
+          {
+            first.singleton_.boolValue = second.singleton_.boolValue;
+            
+            break;
+          }
+          
+          case comparison::string_equals:
+          case comparison::string_does_not_equal:
+          case comparison::string_is_like:
+          case comparison::string_is_not_like:
+          {
+            new(&first.singleton_.stringValue) std::string(std::move(second.singleton_.stringValue));
+            
+            break;
+          }
+          
+          case comparison::is_null:
+          case comparison::is_not_null:
+          {
+            break;
+          }
+          
+          case comparison::matches:
+          case comparison::does_not_match:
+          case comparison::hierarchally_matches:
+          case comparison::does_not_hierarchally_match:
+          {
+            new(&first.singleton_.join) std::unique_ptr<filter>(std::move(second.singleton_.join));
+            
+            break;
+          }
+        }
+        
+        break;
+      }
+      
+      case type::group:
+      {
+        new(&first.group_.children) std::list<filter>(std::move(second.group_.children));
+        first.group_.orlogic = second.group_.orlogic;
+        
+        break;
+      }
+    }
+    
+    second.~filter();
+    
+    second.type_ = tempType;
+    
+    switch (second.type_)
+    {
+      case type::empty:
+      {
+        break;
+      }
+      
+      case type::singleton:
+      {
+        new(&second.singleton_.filterField) field(std::move(tempField));
+        second.singleton_.filterType = tempComparison;
+        
+        switch (second.singleton_.filterType)
+        {
+          case comparison::int_equals:
+          case comparison::int_does_not_equal:
+          case comparison::int_is_at_least:
+          case comparison::int_is_greater_than:
+          case comparison::int_is_at_most:
+          case comparison::int_is_less_than:
+          {
+            second.singleton_.intValue = tempIntValue;
+            
+            break;
+          }
+          
+          case comparison::boolean_equals:
+          {
+            second.singleton_.boolValue = tempBoolValue;
+            
+            break;
+          }
+          
+          case comparison::string_equals:
+          case comparison::string_does_not_equal:
+          case comparison::string_is_like:
+          case comparison::string_is_not_like:
+          {
+            new(&second.singleton_.stringValue) std::string(std::move(tempStringValue));
+            
+            break;
+          }
+          
+          case comparison::is_null:
+          case comparison::is_not_null:
+          {
+            break;
+          }
+          
+          case comparison::matches:
+          case comparison::does_not_match:
+          case comparison::hierarchally_matches:
+          case comparison::does_not_hierarchally_match:
+          {
+            new(&second.singleton_.join) std::unique_ptr<filter>(std::move(tempJoin));
+            
+            break;
+          }
+        }
+        
+        break;
+      }
+      
+      case type::group:
+      {
+        new(&second.group_.children) std::list<filter>(std::move(tempChildren));
+        second.group_.orlogic = tempOrlogic;
+        
+        break;
+      }
+    }
+  }
+  
+  filter::~filter()
+  {
+    switch (type_)
+    {
+      case type::empty:
+      {
+        break;
+      }
+      
+      case type::singleton:
+      {
+        singleton_.filterField.~field();
+        
+        switch (singleton_.filterType)
+        {
+          case comparison::int_equals:
+          case comparison::int_does_not_equal:
+          case comparison::int_is_at_least:
+          case comparison::int_is_greater_than:
+          case comparison::int_is_at_most:
+          case comparison::int_is_less_than:
+          case comparison::boolean_equals:
+          case comparison::is_null:
+          case comparison::is_not_null:
+          {
+            break;
+          }
+          
+          case comparison::string_equals:
+          case comparison::string_does_not_equal:
+          case comparison::string_is_like:
+          case comparison::string_is_not_like:
+          {
+            using string_type = std::string;
+            
+            singleton_.stringValue.~string_type();
+            
+            break;
+          }
+          
+          case comparison::matches:
+          case comparison::does_not_match:
+          case comparison::hierarchally_matches:
+          case comparison::does_not_hierarchally_match:
+          {
+            using ptr_type = std::unique_ptr<filter>;
+            
+            singleton_.join.~ptr_type();
+            
+            break;
+          }
+        }
+        
+        break;
+      }
+      
+      case type::group:
+      {
+        using list_type = std::list<filter>;
+        
+        group_.children.~list_type();
+        
+        break;
+      }
+    }
+  }
+  
+  filter::filter()
+  {
+  }
+  
+  filter::filter(
+    field filterField,
+    comparison filterType,
+    int filterValue) :
+      type_(type::singleton)
+  {
+    if (filterField.getType() == field::type::integer)
+    {
+      switch (filterType)
+      {
+        case comparison::int_equals:
+        case comparison::int_does_not_equal:
+        case comparison::int_is_at_least:
+        case comparison::int_is_greater_than:
+        case comparison::int_is_at_most:
+        case comparison::int_is_less_than:
+        {
+          new(&singleton_.filterField) field(std::move(filterField));
+          singleton_.filterType = filterType;
+          singleton_.intValue = filterValue;
+          
+          break;
+        }
+        
+        case comparison::boolean_equals:
+        case comparison::string_equals:
+        case comparison::string_does_not_equal:
+        case comparison::string_is_like:
+        case comparison::string_is_not_like:
+        case comparison::is_null:
+        case comparison::is_not_null:
+        case comparison::matches:
+        case comparison::does_not_match:
+        case comparison::hierarchally_matches:
+        case comparison::does_not_hierarchally_match:
+        {
+          throw std::invalid_argument("Invalid comparison for integer field");
+        }
+      }
+    } else {
+      throw std::domain_error("Cannot match a non-integer field against an integer value");
+    }
+  }
+  
+  filter::filter(
+    field filterField,
+    comparison filterType,
+    std::string filterValue) :
+      type_(type::singleton)
+  {
+    if (filterField.getType() == field::type::string)
+    {
+      switch (filterType)
+      {
+        case comparison::string_equals:
+        case comparison::string_does_not_equal:
+        case comparison::string_is_like:
+        case comparison::string_is_not_like:
+        {
+          new(&singleton_.filterField) field(std::move(filterField));
+          singleton_.filterType = filterType;
+          new(&singleton_.stringValue) std::string(std::move(filterValue));
+          
+          break;
+        }
+        
+        case comparison::int_equals:
+        case comparison::int_does_not_equal:
+        case comparison::int_is_at_least:
+        case comparison::int_is_greater_than:
+        case comparison::int_is_at_most:
+        case comparison::int_is_less_than:
+        case comparison::boolean_equals:
+        case comparison::is_null:
+        case comparison::is_not_null:
+        case comparison::matches:
+        case comparison::does_not_match:
+        case comparison::hierarchally_matches:
+        case comparison::does_not_hierarchally_match:
+        {
+          throw std::invalid_argument("Invalid comparison for string field");
+        }
+      }
+    } else {
+      throw std::domain_error("Cannot match a non-string field against an string value");
+    }
+  }
+  
+  filter::filter(
+    field filterField,
+    comparison filterType,
+    bool filterValue) :
+      type_(type::singleton)
+  {
+    if (filterField.getType() == field::type::boolean)
+    {
+      switch (filterType)
+      {
+        case comparison::boolean_equals:
+        {
+          new(&singleton_.filterField) field(std::move(filterField));
+          singleton_.filterType = filterType;
+          singleton_.boolValue = filterValue;
+          
+          break;
+        }
+        
+        case comparison::string_equals:
+        case comparison::string_does_not_equal:
+        case comparison::string_is_like:
+        case comparison::string_is_not_like:
+        case comparison::int_equals:
+        case comparison::int_does_not_equal:
+        case comparison::int_is_at_least:
+        case comparison::int_is_greater_than:
+        case comparison::int_is_at_most:
+        case comparison::int_is_less_than:
+        case comparison::is_null:
+        case comparison::is_not_null:
+        case comparison::matches:
+        case comparison::does_not_match:
+        case comparison::hierarchally_matches:
+        case comparison::does_not_hierarchally_match:
+        {
+          throw std::invalid_argument("Invalid comparison for boolean field");
+        }
+      }
+    } else {
+      throw std::domain_error("Cannot match a non-boolean field against a boolean value");
+    }
+  }
+  
+  filter::filter(
+    field filterField,
+    comparison filterType) :
+      type_(type::singleton)
+  {
+    if (filterField.isNullable())
+    {
+      switch (filterType)
+      {
+        case comparison::is_null:
+        case comparison::is_not_null:
+        {
+          new(&singleton_.filterField) field(std::move(filterField));
+          singleton_.filterType = filterType;
+      
+          break;
+        }
+    
+        case comparison::string_equals:
+        case comparison::string_does_not_equal:
+        case comparison::string_is_like:
+        case comparison::string_is_not_like:
+        case comparison::int_equals:
+        case comparison::int_does_not_equal:
+        case comparison::int_is_at_least:
+        case comparison::int_is_greater_than:
+        case comparison::int_is_at_most:
+        case comparison::int_is_less_than:
+        case comparison::boolean_equals:
+        case comparison::matches:
+        case comparison::does_not_match:
+        case comparison::hierarchally_matches:
+        case comparison::does_not_hierarchally_match:
+        {
+          throw std::invalid_argument("Incorrect constructor for given comparison");
+        }
+      }
+    } else {
+      throw std::domain_error("Cannot check nullity/non-nullity of non-nullable field");
+    }
+  }
+  
+  filter::filter(
+    field joinOn,
+    comparison filterType,
+    filter joinCondition) :
+      type_(type::singleton)
+  {
+    switch (joinOn.getType())
+    {
+      case field::type::join:
+      case field::type::join_through:
+      {
+        switch (filterType)
+        {
+          case comparison::matches:
+          case comparison::does_not_match:
+          {
+            new(&singleton_.filterField) field(std::move(joinOn));
+            singleton_.filterType = filterType;
+            new(&singleton_.join) std::unique_ptr<filter>(new filter(joinCondition.normalize(singleton_.filterField.getJoinObject())));
+            
+            break;
+          }
+          
+          case comparison::int_equals:
+          case comparison::int_does_not_equal:
+          case comparison::int_is_at_least:
+          case comparison::int_is_greater_than:
+          case comparison::int_is_at_most:
+          case comparison::int_is_less_than:
+          case comparison::boolean_equals:
+          case comparison::string_equals:
+          case comparison::string_does_not_equal:
+          case comparison::string_is_like:
+          case comparison::string_is_not_like:
+          case comparison::is_null:
+          case comparison::is_not_null:
+          case comparison::hierarchally_matches:
+          case comparison::does_not_hierarchally_match:
+          {
+            throw std::invalid_argument("Incorrect constructor for given comparison");
+          }
+        }
+        
+        break;
+      }
+      
+      case field::type::hierarchal_join:
+      {
+        switch (filterType)
+        {
+          case comparison::hierarchally_matches:
+          case comparison::does_not_hierarchally_match:
+          {
+            new(&singleton_.filterField) field(std::move(joinOn));
+            singleton_.filterType = filterType;
+            new(&singleton_.join) std::unique_ptr<filter>(new filter(joinCondition.normalize(singleton_.filterField.getObject())));
+            
+            break;
+          }
+          
+          case comparison::int_equals:
+          case comparison::int_does_not_equal:
+          case comparison::int_is_at_least:
+          case comparison::int_is_greater_than:
+          case comparison::int_is_at_most:
+          case comparison::int_is_less_than:
+          case comparison::boolean_equals:
+          case comparison::string_equals:
+          case comparison::string_does_not_equal:
+          case comparison::string_is_like:
+          case comparison::string_is_not_like:
+          case comparison::is_null:
+          case comparison::is_not_null:
+          case comparison::matches:
+          case comparison::does_not_match:
+          {
+            throw std::invalid_argument("Incorrect constructor for given comparison");
+          }
+        }
+        
+        break;
+      }
+      
+      case field::type::undefined:
+      case field::type::string:
+      case field::type::integer:
+      case field::type::boolean:
+      {
+        throw std::domain_error("Matching field must be a join field");
+      }
+    }
+  }
+  
+  field filter::getField() const
+  {
+    if (type_ == type::singleton)
+    {
+      return singleton_.filterField;
+    } else {
+      throw std::domain_error("This filter does not have a field");
+    }
+  }
+  
+  filter::comparison filter::getComparison() const
+  {
+    if (type_ == type::singleton)
+    {
+      return singleton_.filterType;
+    } else {
+      throw std::domain_error("This filter does not have a comparison");
+    }
+  }
+  
+  filter filter::getJoinCondition() const
+  {
+    if (type_ == type::singleton)
+    {
+      switch (singleton_.filterType)
+      {
+        case comparison::matches:
+        case comparison::does_not_match:
+        case comparison::hierarchally_matches:
+        case comparison::does_not_hierarchally_match:
+        {
+          return *singleton_.join;
+        }
+        
+        case comparison::string_equals:
+        case comparison::string_does_not_equal:
+        case comparison::string_is_like:
+        case comparison::string_is_not_like:
+        case comparison::int_equals:
+        case comparison::int_does_not_equal:
+        case comparison::int_is_at_least:
+        case comparison::int_is_greater_than:
+        case comparison::int_is_at_most:
+        case comparison::int_is_less_than:
+        case comparison::boolean_equals:
+        case comparison::is_null:
+        case comparison::is_not_null:
+        {
+          throw std::domain_error("This filter does not have a join condition");
+        }
+      }
+    } else {
+      throw std::domain_error("This filter does not have a join condition");
+    }
+  }
+  
+  std::string filter::getStringArgument() const
+  {
+    if (type_ == type::singleton)
+    {
+      switch (singleton_.filterType)
+      {
+        case comparison::string_equals:
+        case comparison::string_does_not_equal:
+        case comparison::string_is_like:
+        case comparison::string_is_not_like:
+        {
+          return singleton_.stringValue;
+        }
+        
+        case comparison::int_equals:
+        case comparison::int_does_not_equal:
+        case comparison::int_is_at_least:
+        case comparison::int_is_greater_than:
+        case comparison::int_is_at_most:
+        case comparison::int_is_less_than:
+        case comparison::boolean_equals:
+        case comparison::is_null:
+        case comparison::is_not_null:
+        case comparison::matches:
+        case comparison::does_not_match:
+        case comparison::hierarchally_matches:
+        case comparison::does_not_hierarchally_match:
+        {
+          throw std::domain_error("This filter does not have a string argument");
+        }
+      }
+    } else {
+      throw std::domain_error("This filter does not have a string argument");
+    }
+  }
+  
+  int filter::getIntegerArgument() const
+  {
+    if (type_ == type::singleton)
+    {
+      switch (singleton_.filterType)
+      {
+        case comparison::int_equals:
+        case comparison::int_does_not_equal:
+        case comparison::int_is_at_least:
+        case comparison::int_is_greater_than:
+        case comparison::int_is_at_most:
+        case comparison::int_is_less_than:
+        {
+          return singleton_.intValue;
+        }
+        
+        case comparison::string_equals:
+        case comparison::string_does_not_equal:
+        case comparison::string_is_like:
+        case comparison::string_is_not_like:
+        case comparison::boolean_equals:
+        case comparison::is_null:
+        case comparison::is_not_null:
+        case comparison::matches:
+        case comparison::does_not_match:
+        case comparison::hierarchally_matches:
+        case comparison::does_not_hierarchally_match:
+        {
+          throw std::domain_error("This filter does not have an integer argument");
+        }
+      }
+    } else {
+      throw std::domain_error("This filter does not have an integer argument");
+    }
+  }
+  
+  bool filter::getBooleanArgument() const
+  {
+    if ((type_ == type::singleton) && (singleton_.filterType == comparison::boolean_equals))
+    {
+      return singleton_.boolValue;
+    } else {
+      throw std::domain_error("This filter does not have a boolean argument");
+    }
+  }
+  
+  filter::filter(bool orlogic) : type_(type::group)
+  {
+    new(&group_.children) std::list<filter>();
+    group_.orlogic = orlogic;
+  }
+  
+  bool filter::getOrlogic() const
+  {
+    if (type_ == type::group)
+    {
+      return group_.orlogic;
+    } else {
+      throw std::domain_error("This filter is not a group filter");
+    }
+  }
+  
+  filter filter::operator+(filter condition) const
+  {
+    filter result(*this);
+    result += std::move(condition);
+    
+    return result;
+  }
+  
+  filter& filter::operator+=(filter condition)
+  {
+    if (type_ == type::group)
+    {
+      group_.children.push_back(std::move(condition));
+      
+      return *this;
+    } else {
+      throw std::domain_error("Children can only be added to group filters");
+    }
+  }
+  
+  filter::const_iterator filter::begin() const
+  {
+    if (type_ == type::group)
+    {
+      return std::begin(group_.children);
+    } else {
+      throw std::domain_error("This filter has no children");
+    }
+  }
+  
+  filter::const_iterator filter::end() const
+  {
+    if (type_ == type::group)
+    {
+      return std::end(group_.children);
+    } else {
+      throw std::domain_error("This filter has no children");
+    }
+  }
+  
+  filter filter::operator!() const
+  {
+    switch (type_)
+    {
+      case type::empty:
+      {
+        return {};
+      }
+      
+      case type::singleton:
+      {
+        switch (singleton_.filterType)
+        {
+          case comparison::int_equals:
+          {
+            return filter(singleton_.filterField, comparison::int_does_not_equal, singleton_.intValue);
+          }
+          
+          case comparison::int_does_not_equal:
+          {
+            return filter(singleton_.filterField, comparison::int_equals, singleton_.intValue);
+          }
+          
+          case comparison::int_is_at_least:
+          {
+            return filter(singleton_.filterField, comparison::int_is_less_than, singleton_.intValue);
+          }
+          
+          case comparison::int_is_greater_than:
+          {
+            return filter(singleton_.filterField, comparison::int_is_at_most, singleton_.intValue);
+          }
+          
+          case comparison::int_is_at_most:
+          {
+            return filter(singleton_.filterField, comparison::int_is_greater_than, singleton_.intValue);
+          }
+          
+          case comparison::int_is_less_than:
+          {
+            return filter(singleton_.filterField, comparison::int_is_at_least, singleton_.intValue);
+          }
+          
+          case comparison::boolean_equals:
+          {
+            return filter(singleton_.filterField, comparison::boolean_equals, !singleton_.boolValue);
+          }
+          
+          case comparison::string_equals:
+          {
+            return filter(singleton_.filterField, comparison::string_does_not_equal, singleton_.stringValue);
+          }
+          
+          case comparison::string_does_not_equal:
+          {
+            return filter(singleton_.filterField, comparison::string_equals, singleton_.stringValue);
+          }
+          
+          case comparison::string_is_like:
+          {
+            return filter(singleton_.filterField, comparison::string_is_not_like, singleton_.stringValue);
+          }
+          
+          case comparison::string_is_not_like:
+          {
+            return filter(singleton_.filterField, comparison::string_is_like, singleton_.stringValue);
+          }
+          
+          case comparison::is_null:
+          {
+            return filter(singleton_.filterField, comparison::is_not_null);
+          }
+          
+          case comparison::is_not_null:
+          {
+            return filter(singleton_.filterField, comparison::is_null);
+          }
+          
+          case comparison::matches:
+          {
+            return filter(singleton_.filterField, comparison::does_not_match, *singleton_.join);
+          }
+          
+          case comparison::does_not_match:
+          {
+            return filter(singleton_.filterField, comparison::matches, *singleton_.join);
+          }
+          
+          case comparison::hierarchally_matches:
+          {
+            return filter(singleton_.filterField, comparison::does_not_hierarchally_match, *singleton_.join);
+          }
+          
+          case comparison::does_not_hierarchally_match:
+          {
+            return filter(singleton_.filterField, comparison::hierarchally_matches, *singleton_.join);
+          }
+        }
+      }
+      
+      case type::group:
+      {
+        filter result(!group_.orlogic);
+        
+        for (const filter& child : group_.children)
+        {
+          result += !child;
+        }
+        
+        return result;
+      }
+    }
+  }
+  
+  filter& filter::operator&=(filter condition)
+  {
+    return (*this = (*this && std::move(condition)));
+  }
+  
+  filter& filter::operator|=(filter condition)
+  {
+    return (*this = (*this || std::move(condition)));
+  }
+  
+  filter filter::operator&&(filter condition) const
+  {
+    switch (type_)
+    {
+      case type::empty:
+      {
+        return condition;
+      }
+      
+      case type::singleton:
+      {
+        filter result(false);
+        result.group_.children.push_back(*this);
+        result.group_.children.push_back(std::move(condition));
+        
+        return result;
+      }
+      
+      case type::group:
+      {
+        if (group_.orlogic)
+        {
+          filter result(false);
+          result.group_.children.push_back(*this);
+          result.group_.children.push_back(std::move(condition));
+
+          return result;
+        } else {
+          filter result(*this);
+          result.group_.children.push_back(std::move(condition));
+          
+          return result;
+        }
+      }
+    }
+  }
+  
+  filter filter::operator||(filter condition) const
+  {
+    switch (type_)
+    {
+      case type::empty:
+      {
+        return condition;
+      }
+      
+      case type::singleton:
+      {
+        filter result(true);
+        result.group_.children.push_back(*this);
+        result.group_.children.push_back(std::move(condition));
+        
+        return result;
+      }
+      
+      case type::group:
+      {
+        if (!group_.orlogic)
+        {
+          filter result(true);
+          result.group_.children.push_back(*this);
+          result.group_.children.push_back(std::move(condition));
+
+          return result;
+        } else {
+          filter result(*this);
+          result.group_.children.push_back(std::move(condition));
+          
+          return result;
+        }
+      }
+    }
+  }
+  
+  filter filter::normalize(object context) const
+  {
+    {
+      switch (type_)
+      {
+        case type::empty:
+        {
+          return *this;
+        }
+
+        case type::singleton:
+        {
+          // First, switch on the normalized context, and then switch on the
+          // current context. We recursively recontextualize by using the
+          // current filter as a subquery for a join such that the context of
+          // the subquery is one step closer to the context of the current
+          // filter, and then letting the filter constructor normalize the
+          // subquery.
+          switch (context)
+          {
+            case object::undefined:
+            {
+              // An undefined object indicates no participation in
+              // recontexualization.
+              return *this;
+            }
+            
+            case object::notion:
+            {
+              switch (singleton_.filterField.getObject())
+              {
+                case object::undefined:
+                case object::notion:
+                {
+                  return *this;
+                }
+                
+                case object::word:
+                case object::group:
+                case object::frame:
+                case object::lemma:
+                case object::form:
+                case object::pronunciation:
+                {
+                  return (verbly::notion::word %= *this);
+                }
+              }
+            }
+              
+            case object::word:
+            {
+              switch (singleton_.filterField.getObject())
+              {
+                case object::notion:
+                {
+                  return (verbly::word::notion %= *this);
+                }
+                
+                case object::undefined:
+                case object::word:
+                {
+                  return *this;
+                }
+                
+                case object::group:
+                case object::frame:
+                {
+                  return (verbly::word::group %= *this);
+                }
+                
+                case object::lemma:
+                case object::form:
+                case object::pronunciation:
+                {
+                  return (verbly::word::lemma %= *this);
+                }
+              }
+              
+              case object::group:
+              {
+                switch (singleton_.filterField.getObject())
+                {
+                  case object::undefined:
+                  case object::group:
+                  {
+                    return *this;
+                  }
+                  
+                  case object::notion:
+                  case object::word:
+                  case object::lemma:
+                  case object::form:
+                  case object::pronunciation:
+                  {
+                    return (verbly::group::word %= *this);
+                  }
+                  
+                  case object::frame:
+                  {
+                    return (verbly::group::frame %= *this);
+                  }
+                }
+              }
+              
+              case object::frame:
+              {
+                switch (singleton_.filterField.getObject())
+                {
+                  case object::undefined:
+                  case object::frame:
+                  {
+                    return *this;
+                  }
+                
+                  case object::notion:
+                  case object::word:
+                  case object::group:
+                  case object::lemma:
+                  case object::form:
+                  case object::pronunciation:
+                  {
+                    return (verbly::frame::group %= *this);
+                  }
+                }
+              }
+              
+              case object::lemma:
+              {
+                switch (singleton_.filterField.getObject())
+                {
+                  case object::notion:
+                  case object::word:
+                  case object::group:
+                  case object::frame:
+                  {
+                    return verbly::lemma::word %= *this;
+                  }
+                  
+                  case object::undefined:
+                  case object::lemma:
+                  {
+                    return *this;
+                  }
+
+                  case object::form:
+                  case object::pronunciation:
+                  {
+                    return (verbly::lemma::form(inflection::base) %= *this);
+                  }
+                }
+              }
+              
+              case object::form:
+              {
+                switch (singleton_.filterField.getObject())
+                {
+                  case object::notion:
+                  case object::word:
+                  case object::group:
+                  case object::frame:
+                  case object::lemma:
+                  {
+                    return verbly::form::lemma(inflection::base) %= *this;
+                  }
+                  
+                  case object::undefined:
+                  case object::form:
+                  {
+                    return *this;
+                  }
+
+                  case object::pronunciation:
+                  {
+                    return (verbly::form::pronunciation %= *this);
+                  }
+                }
+              }
+              
+              case object::pronunciation:
+              {
+                switch (singleton_.filterField.getObject())
+                {
+                  case object::notion:
+                  case object::word:
+                  case object::group:
+                  case object::frame:
+                  case object::lemma:
+                  case object::form:
+                  {
+                    return verbly::pronunciation::form %= *this;
+                  }
+                  
+                  case object::undefined:
+                  case object::pronunciation:
+                  {
+                    return *this;
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        case type::group:
+        {
+          filter result(group_.orlogic);
+          std::map<field, filter> joins;
+
+          for (const filter& child : group_.children)
+          {
+            filter normalized = child.normalize(context);
+
+            // Notably, this does not attempt to merge hierarchal matches.
+            switch (normalized.getType())
+            {
+              case type::singleton:
+              {
+                switch (normalized.getComparison())
+                {
+                  case comparison::matches:
+                  {
+                    if (!joins.count(normalized.singleton_.filterField))
+                    {
+                      joins[normalized.getField()] = filter(group_.orlogic);
+                    }
+
+                    joins.at(normalized.getField()) += std::move(*normalized.singleton_.join);
+                    
+                    break;
+                  }
+                  
+                  case comparison::does_not_match:
+                  {
+                    if (!joins.count(normalized.singleton_.filterField))
+                    {
+                      joins[normalized.getField()] = filter(group_.orlogic);
+                    }
+
+                    joins.at(normalized.getField()) += !*normalized.singleton_.join;
+                    
+                    break;
+                  }
+                  
+                  case comparison::int_equals:
+                  case comparison::int_does_not_equal:
+                  case comparison::int_is_at_least:
+                  case comparison::int_is_greater_than:
+                  case comparison::int_is_at_most:
+                  case comparison::int_is_less_than:
+                  case comparison::boolean_equals:
+                  case comparison::string_equals:
+                  case comparison::string_does_not_equal:
+                  case comparison::string_is_like:
+                  case comparison::string_is_not_like:
+                  case comparison::is_null:
+                  case comparison::is_not_null:
+                  case comparison::hierarchally_matches:
+                  case comparison::does_not_hierarchally_match:
+                  {
+                    result += std::move(normalized);
+                    
+                    break;
+                  }
+                }
+                
+                break;
+              }
+              
+              case type::group:
+              case type::empty:
+              {
+                result += std::move(normalized);
+                
+                break;
+              }
+            }
+          }
+
+          for (auto& mapping : joins)
+          {
+            const field& joinOn = mapping.first;
+            filter& joinCondition = mapping.second;
+
+            result += (joinOn %= joinCondition.normalize(joinOn.getJoinObject()));
+          }
+
+          return result;
+        }
+      }
+    }
+  }
+
+};
@@ -0,0 +1,143 @@
+#ifndef FILTER_H_932BA9C6
+#define FILTER_H_932BA9C6
+
+#include <list>
+#include <string>
+#include <memory>
+#include "field.h"
+#include "enums.h"
+
+namespace verbly {
+  
+  class filter {
+  public:
+    enum class type {
+      empty,
+      singleton,
+      group
+    };
+    
+    enum class comparison {
+      int_equals,
+      int_does_not_equal,
+      int_is_at_least,
+      int_is_greater_than,
+      int_is_at_most,
+      int_is_less_than,
+      boolean_equals,
+      string_equals,
+      string_does_not_equal,
+      string_is_like,
+      string_is_not_like,
+      is_null,
+      is_not_null,
+      matches,
+      does_not_match,
+      hierarchally_matches,
+      does_not_hierarchally_match
+    };
+    
+    // Copy and move constructors
+    
+    filter(const filter& other);
+    filter(filter&& other);
+    
+    // Assignment
+    
+    filter& operator=(filter other);
+    
+    // Swap
+    
+    friend void swap(filter& first, filter& second);
+    
+    // Destructor
+    
+    ~filter();
+    
+    // Accessors
+    
+    type getType() const
+    {
+      return type_;
+    }
+    
+    // Empty
+    
+    filter();
+    
+    // Singleton
+    
+    filter(field filterField, comparison filterType, int filterValue);
+    filter(field filterField, comparison filterType, std::string filterValue);
+    filter(field filterField, comparison filterType, bool filterValue);
+    filter(field filterField, comparison filterType);
+    filter(field joinOn, comparison filterType, filter joinCondition);
+    
+    field getField() const;
+    
+    comparison getComparison() const;
+    
+    filter getJoinCondition() const;
+    
+    std::string getStringArgument() const;
+    
+    int getIntegerArgument() const;
+    
+    bool getBooleanArgument() const;
+    
+    // Group
+    
+    explicit filter(bool orlogic);
+    
+    bool getOrlogic() const;
+    
+    filter operator+(filter condition) const;
+    
+    filter& operator+=(filter condition);
+    
+    using const_iterator = std::list<filter>::const_iterator;
+    
+    const_iterator begin() const;
+    
+    const_iterator end() const;
+    
+    // Negation
+    
+    filter operator!() const;
+    
+    // Groupifying
+    
+    filter operator&&(filter condition) const;
+    filter operator||(filter condition) const;
+    
+    filter& operator&=(filter condition);
+    filter& operator|=(filter condition);
+    
+    // Utility
+    
+    filter normalize(object context) const;
+    
+  private:
+    union {
+      struct {
+        field filterField;
+        comparison filterType;
+        union {
+          std::unique_ptr<filter> join;
+          std::string stringValue;
+          int intValue;
+          bool boolValue;
+        };
+      } singleton_;
+      struct {
+        std::list<filter> children;
+        bool orlogic;
+      } group_;
+    };
+    type type_ = type::empty;
+    
+  };
+  
+};
+
+#endif /* end of include guard: FILTER_H_932BA9C6 */
@@ -0,0 +1,53 @@
+#include "form.h"
+#include <sqlite3.h>
+#include "filter.h"
+#include "pronunciation.h"
+#include "database.h"
+#include "query.h"
+
+namespace verbly {
+  
+  const object form::objectType = object::form;
+  
+  const std::list<std::string> form::select = {"form_id", "form", "complexity", "proper"};
+  
+  const field form::id = field::integerField(object::form, "form_id");
+  const field form::text = field::stringField(object::form, "form");
+  const field form::complexity = field::integerField(object::form, "complexity");
+  const field form::proper = field::booleanField(object::form, "proper");
+  
+  const field form::pronunciation = field::joinThrough(object::form, "form_id", object::pronunciation, "forms_pronunciations", "pronunciation_id");
+  
+  const field form::lemmaJoin = field::joinField(object::form, "form_id", object::lemma);
+  const field form::inflectionCategory = field::integerField("lemmas_forms", "category");
+  
+  form::form(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true)
+  {
+    id_ = sqlite3_column_int(row, 0);
+    text_ = std::string(reinterpret_cast<const char*>(sqlite3_column_text(row, 1)));
+    complexity_ = sqlite3_column_int(row, 2);
+    proper_ = (sqlite3_column_int(row, 3) == 1);
+  }
+  
+  filter operator%=(form::inflection_field check, filter joinCondition)
+  {
+    return (form::lemmaJoin %= (joinCondition && (form::inflectionCategory == check.getCategory())));
+  }
+  
+  const std::vector<pronunciation>& form::getPronunciations() const
+  {
+    if (!valid_)
+    {
+      throw std::domain_error("Bad access to uninitialized form");
+    }
+    
+    if (!initializedPronunciations_)
+    {
+      pronunciations_ = db_->pronunciations(pronunciation::form %= *this, false, -1).all();
+      initializedPronunciations_ = true;
+    }
+    
+    return pronunciations_;
+  }
+  
+};
@@ -0,0 +1,149 @@
+#ifndef FORM_H_3A6C962C
+#define FORM_H_3A6C962C
+
+#include <list>
+#include <vector>
+#include <string>
+#include <stdexcept>
+#include "field.h"
+#include "filter.h"
+
+struct sqlite3_stmt;
+
+namespace verbly {
+  
+  class pronunciation;
+  class database;
+  
+  class form {
+  public:
+    
+    // Default constructor
+    
+    form() = default;
+    
+    // Construct from database
+    
+    form(const database& db, sqlite3_stmt* row);
+    
+    // Accessors
+    
+    operator bool() const
+    {
+      return valid_;
+    }
+    
+    int getId() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized form");
+      }
+      
+      return id_;
+    }
+    
+    std::string getText() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized form");
+      }
+      
+      return text_;
+    }
+    
+    int getComplexity() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized form");
+      }
+      
+      return complexity_;
+    }
+    
+    bool isProper() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized form");
+      }
+      
+      return proper_;
+    }
+    
+    const std::vector<pronunciation>& getPronunciations() const;
+    
+    // Type info
+    
+    static const object objectType;
+    
+    static const std::list<std::string> select;
+    
+    // Query fields
+    
+    static const field id;
+    static const field text;
+    static const field complexity;
+    static const field proper;
+    
+    operator filter() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized form");
+      }
+      
+      return (id == id_);
+    }
+    
+    // Relationships to other objects
+    
+    static const field pronunciation;
+    
+    class inflection_field {
+    public:
+      
+      inflection_field(inflection category) : category_(category)
+      {
+      }
+      
+      const inflection getCategory() const
+      {
+        return category_;
+      }
+      
+    private:
+      
+      const inflection category_;
+    };
+    
+    static const inflection_field lemma(inflection category)
+    {
+      return inflection_field(category);
+    }
+    
+    friend filter operator%=(form::inflection_field check, filter joinCondition);
+    
+  private:
+    bool valid_ = false;
+    
+    int id_;
+    std::string text_;
+    int complexity_ ;
+    bool proper_;
+    
+    const database* db_;
+    
+    mutable bool initializedPronunciations_ = false;
+    mutable std::vector<class pronunciation> pronunciations_;
+    
+    static const field lemmaJoin;
+    static const field inflectionCategory;
+    
+  };
+  
+};
+
+#endif /* end of include guard: FORM_H_3A6C962C */
@@ -1,320 +1,21 @@
-#include "verbly.h"
+#include "frame.h"
+#include <sqlite3.h>
 
 namespace verbly {
   
-  frame::selrestr::type frame::selrestr::get_type() const
-  {
-    return _type;
-  }
-  
-  frame::selrestr::selrestr(const selrestr& other)
-  {
-    _type = other._type;
-    
-    switch (_type)
-    {
-      case frame::selrestr::type::singleton:
-      {
-        _singleton.pos = other._singleton.pos;
-        new(&_singleton.restriction) std::string(other._singleton.restriction);
-        
-        break;
-      }
-      
-      case frame::selrestr::type::group:
-      {
-        new(&_group.children) std::list<selrestr>(other._group.children);
-        _group.orlogic = other._group.orlogic;
-        
-        break;
-      }
-      
-      case frame::selrestr::type::empty:
-      {
-        // Nothing!
-        
-        break;
-      }
-    }
-  }
-  
-  frame::selrestr::~selrestr()
-  {
-    switch (_type)
-    {
-      case frame::selrestr::type::singleton:
-      {
-        using string_type = std::string;
-        _singleton.restriction.~string_type();
-        
-        break;
-      }
-      
-      case frame::selrestr::type::group:
-      {
-        using list_type = std::list<selrestr>;
-        _group.children.~list_type();
-        
-        break;
-      }
-      
-      case frame::selrestr::type::empty:
-      {
-        // Nothing!
-        
-        break;
-      }
-    }
-  }
-  
-  frame::selrestr& frame::selrestr::operator=(const selrestr& other)
-  {
-    this->~selrestr();
-    
-    _type = other._type;
-    
-    switch (_type)
-    {
-      case frame::selrestr::type::singleton:
-      {
-        _singleton.pos = other._singleton.pos;
-        new(&_singleton.restriction) std::string(other._singleton.restriction);
-        
-        break;
-      }
-      
-      case frame::selrestr::type::group:
-      {
-        new(&_group.children) std::list<selrestr>(other._group.children);
-        _group.orlogic = other._group.orlogic;
-        
-        break;
-      }
-      
-      case frame::selrestr::type::empty:
-      {
-        // Nothing!
-        
-        break;
-      }
-    }
-    
-    return *this;
-  }
-  
-  frame::selrestr::selrestr() : _type(frame::selrestr::type::empty)
-  {
-    
-  }
-  
-  frame::selrestr::selrestr(std::string restriction, bool pos) : _type(frame::selrestr::type::singleton)
-  {
-    new(&_singleton.restriction) std::string(restriction);
-    _singleton.pos = pos;
-  }
-  
-  std::string frame::selrestr::get_restriction() const
-  {
-    assert(_type == frame::selrestr::type::singleton);
-    
-    return _singleton.restriction;
-  }
-  
-  bool frame::selrestr::get_pos() const
-  {
-    assert(_type == frame::selrestr::type::singleton);
-    
-    return _singleton.pos;
-  }
-  
-  frame::selrestr::selrestr(std::list<selrestr> children, bool orlogic) : _type(frame::selrestr::type::group)
-  {
-    new(&_group.children) std::list<selrestr>(children);
-    _group.orlogic = orlogic;
-  }
-  
-  std::list<frame::selrestr> frame::selrestr::get_children() const
-  {
-    assert(_type == frame::selrestr::type::group);
-    
-    return _group.children;
-  }
-  
-  std::list<frame::selrestr>::const_iterator frame::selrestr::begin() const
-  {
-    assert(_type == frame::selrestr::type::group);
-    
-    return _group.children.begin();
-  }
-  
-  std::list<frame::selrestr>::const_iterator frame::selrestr::end() const
-  {
-    assert(_type == frame::selrestr::type::group);
-    
-    return _group.children.end();
-  }
-  
-  bool frame::selrestr::get_orlogic() const
-  {
-    assert(_type == frame::selrestr::type::group);
-    
-    return _group.orlogic;
-  }
-  
-  frame::part::type frame::part::get_type() const
-  {
-    return _type;
-  }
-  
-  frame::part::part()
-  {
-    
-  }
+  const object frame::objectType = object::frame;
   
-  frame::part::part(const part& other)
-  {
-    _type = other._type;
-    
-    switch (_type)
-    {
-      case frame::part::type::noun_phrase:
-      {
-        new(&_noun_phrase.role) std::string(other._noun_phrase.role);
-        new(&_noun_phrase.selrestrs) selrestr(other._noun_phrase.selrestrs);
-        new(&_noun_phrase.synrestrs) std::set<std::string>(other._noun_phrase.synrestrs);
-        
-        break;
-      }
-      
-      case frame::part::type::literal_preposition:
-      {
-        new(&_literal_preposition.choices) std::vector<std::string>(other._literal_preposition.choices);
-        
-        break;
-      }
-      
-      case frame::part::type::selection_preposition:
-      {
-        new(&_selection_preposition.preprestrs) std::vector<std::string>(other._selection_preposition.preprestrs);
-        
-        break;
-      }
-      
-      case frame::part::type::literal:
-      {
-        new(&_literal.lexval) std::string(other._literal.lexval);
-        
-        break;
-      }
-      
-      default:
-      {
-        // Nothing!
-        
-        break;
-      }
-    }
-  }
+  const std::list<std::string> frame::select = {"frame_id", "data"};
   
-  frame::part::~part()
-  {
-    switch (_type)
-    {
-      case frame::part::type::noun_phrase:
-      {
-        using string_type = std::string;
-        using set_type = std::set<std::string>;
-        
-        _noun_phrase.role.~string_type();
-        _noun_phrase.selrestrs.~selrestr();
-        _noun_phrase.synrestrs.~set_type();
-        
-        break;
-      }
-      
-      case frame::part::type::literal_preposition:
-      {
-        using vector_type = std::vector<std::string>;
-        _literal_preposition.choices.~vector_type();
-        
-        break;
-      }
-      
-      case frame::part::type::selection_preposition:
-      {
-        using vector_type = std::vector<std::string>;
-        _selection_preposition.preprestrs.~vector_type();
-        
-        break;
-      }
-      
-      case frame::part::type::literal:
-      {
-        using string_type = std::string;
-        _literal.lexval.~string_type();
-        
-        break;
-      }
-      
-      default:
-      {
-        // Nothing!
-        
-        break;
-      }
-    }
-  }
+  const field frame::id = field::integerField(object::frame, "frame_id");
   
-  std::string frame::part::get_role() const
-  {
-    assert(_type == frame::part::type::noun_phrase);
-    
-    return _noun_phrase.role;
-  }
+  const field frame::group = field::joinThrough(object::frame, "frame_id", object::group, "groups_frames", "group_id");
   
-  frame::selrestr frame::part::get_selrestrs() const
+  frame::frame(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true)
   {
-    assert(_type == frame::part::type::noun_phrase);
+    id_ = sqlite3_column_int(row, 0);
     
-    return _noun_phrase.selrestrs;
-  }
-  
-  std::set<std::string> frame::part::get_synrestrs() const
-  {
-    assert(_type == frame::part::type::noun_phrase);
-    
-    return _noun_phrase.synrestrs;
-  }
-  
-  std::vector<std::string> frame::part::get_choices() const
-  {
-    assert(_type == frame::part::type::literal_preposition);
-    
-    return _literal_preposition.choices;
-  }
-  
-  std::vector<std::string> frame::part::get_preprestrs() const
-  {
-    assert(_type == frame::part::type::selection_preposition);
-    
-    return _selection_preposition.preprestrs;
-  }
-  
-  std::string frame::part::get_literal() const
-  {
-    assert(_type == frame::part::type::literal);
-    
-    return _literal.lexval;
-  }
-  
-  std::vector<frame::part> frame::parts() const
-  {
-    return _parts;
-  }
-  
-  std::map<std::string, frame::selrestr> frame::roles() const
-  {
-    return _roles;
+    // TODO: Initialize frame data from row.
   }
   
 };
@@ -1,118 +1,78 @@
-#ifndef FRAME_H_9A5D90FE
-#define FRAME_H_9A5D90FE
+#ifndef FRAME_H_EA29065A
+#define FRAME_H_EA29065A
+
+#include <stdexcept>
+#include <list>
+#include "field.h"
+#include "filter.h"
+
+struct sqlite3_stmt;
 
 namespace verbly {
   
-  class frame_query;
-
+  class database;
+  
   class frame {
-    public:
-      class selrestr {
-        public:
-          enum class type {
-            empty,
-            singleton,
-            group
-          };
-          
-          type get_type() const;
-          selrestr(const selrestr& other);
-          ~selrestr();
-          selrestr& operator=(const selrestr& other);
-          
-          // Empty
-          selrestr();
-          
-          // Singleton
-          selrestr(std::string restriction, bool pos);
-          std::string get_restriction() const;
-          bool get_pos() const;
-          
-          // Group
-          selrestr(std::list<selrestr> children, bool orlogic);
-          std::list<selrestr> get_children() const;
-          std::list<selrestr>::const_iterator begin() const;
-          std::list<selrestr>::const_iterator end() const;
-          bool get_orlogic() const;
-          
-        private:
-          union {
-            struct {
-              bool pos;
-              std::string restriction;
-            } _singleton;
-            struct {
-              std::list<selrestr> children;
-              bool orlogic;
-            } _group;
-          };
-          type _type;
-      };
+  public:
+    
+    // Default constructor
+    
+    frame() = default;
+    
+    // Construct from database
+    
+    frame(const database& db, sqlite3_stmt* row);
+    
+    // Accessors
+    
+    operator bool() const
+    {
+      return valid_;
+    }
+    
+    int getId() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized frame");
+      }
       
-      class part {
-        public:
-          enum class type {
-            noun_phrase,
-            verb,
-            literal_preposition,
-            selection_preposition,
-            adjective,
-            adverb,
-            literal
-          };
-          
-          type get_type() const;
-          part(const part& other);
-          ~part();
-          
-          // Noun phrase
-          std::string get_role() const;
-          selrestr get_selrestrs() const;
-          std::set<std::string> get_synrestrs() const;
-          
-          // Literal preposition
-          std::vector<std::string> get_choices() const;
-          
-          // Selection preposition
-          std::vector<std::string> get_preprestrs() const;
-          
-          // Literal
-          std::string get_literal() const;
-          
-        private:
-          friend class frame_query;
-          
-          part();
-          
-          union {
-            struct {
-              std::string role;
-              selrestr selrestrs;
-              std::set<std::string> synrestrs;
-            } _noun_phrase;
-            struct {
-              std::vector<std::string> choices;
-            } _literal_preposition;
-            struct {
-              std::vector<std::string> preprestrs;
-            } _selection_preposition;
-            struct {
-              std::string lexval;
-            } _literal;
-          };
-          type _type;
-      };
+      return id_;
+    }
+    
+    // Type info
+    
+    static const object objectType;
+    
+    static const std::list<std::string> select;
+    
+    // Query fields
+    
+    static const field id;
+    
+    operator filter() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized frame");
+      }
       
-      std::vector<part> parts() const;
-      std::map<std::string, selrestr> roles() const;
-      
-    private:
-      friend class frame_query;
-      
-      std::vector<part> _parts;
-      std::map<std::string, selrestr> _roles;
+      return (id == id_);
+    }
+    
+    // Relationships to other objects
+    
+    static const field group;
+    
+  private:
+    bool valid_ = false;
+    
+    int id_;
+    
+    const database* db_;
+    
   };
-
+  
 };
 
-#endif /* end of include guard: FRAME_H_9A5D90FE */
+#endif /* end of include guard: FRAME_H_EA29065A */
@@ -0,0 +1,43 @@
+#include "group.h"
+#include <sqlite3.h>
+#include "frame.h"
+#include "database.h"
+#include "query.h"
+
+namespace verbly {
+  
+  const object group::objectType = object::group;
+  
+  const std::list<std::string> group::select = {"group_id", "data"};
+  
+  const field group::id = field::integerField(object::group, "group_id");
+  
+  const field group::frame = field::joinThrough(object::group, "group_id", object::frame, "groups_frames", "frame_id");
+  const field group::word = field::joinField(object::group, "group_id", object::word);
+  
+  group::group(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true)
+  {
+    id_ = sqlite3_column_int(row, 0);
+    
+    // TODO: Initialize role data from row.
+  }
+  
+  const std::vector<frame>& group::getFrames() const
+  {
+    if (!valid_)
+    {
+      throw std::domain_error("Bad access to uninitialized group");
+    }
+    
+    if (!initializedFrames_)
+    {
+      frames_ = db_->frames(frame::group %= *this, false, -1).all();
+      
+      initializedFrames_ = true;
+    }
+    
+    return frames_;
+  }
+  
+};
+
@@ -0,0 +1,87 @@
+#ifndef GROUP_H_BD6933C0
+#define GROUP_H_BD6933C0
+
+#include <stdexcept>
+#include <list>
+#include <vector>
+#include "field.h"
+#include "filter.h"
+
+struct sqlite3_stmt;
+
+namespace verbly {
+  
+  class database;
+  class frame;
+  
+  class group {
+  public:
+    
+    // Default constructor
+    
+    group() = default;
+    
+    // Construct from database
+    
+    group(const database& db, sqlite3_stmt* row);
+    
+    // Accessors
+    
+    operator bool() const
+    {
+      return valid_;
+    }
+    
+    int getId() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized group");
+      }
+      
+      return id_;
+    }
+    
+    const std::vector<frame>& getFrames() const;
+    
+    // Type info
+    
+    static const object objectType;
+    
+    static const std::list<std::string> select;
+    
+    // Query fields
+    
+    static const field id;
+    
+    operator filter() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized group");
+      }
+      
+      return (id == id_);
+    }
+    
+    // Relationships to other objects
+    
+    static const field frame;
+    
+    static const field word;
+    
+  private:
+    bool valid_ = false;
+    
+    int id_;
+    
+    const database* db_;
+    
+    mutable bool initializedFrames_ = false;
+    mutable std::vector<class frame> frames_;
+    
+  };
+  
+};
+
+#endif /* end of include guard: GROUP_H_BD6933C0 */
@@ -0,0 +1,69 @@
+#include "lemma.h"
+#include <sqlite3.h>
+#include "database.h"
+#include "query.h"
+
+namespace verbly {
+  
+  const object lemma::objectType = object::lemma;
+  
+  const std::list<std::string> lemma::select = {"lemma_id"};
+  
+  const field lemma::id = field::integerField(object::lemma, "lemma_id");
+  
+  const field lemma::word = field::joinField(object::lemma, "lemma_id", object::word);
+  
+  const field lemma::formJoin = field::joinField(object::lemma, "form_id", object::form);
+  const field lemma::inflectionCategory = field::integerField(object::lemma, "category");
+  
+  filter operator%=(lemma::inflection_field check, filter joinCondition)
+  {
+    return (lemma::formJoin %= joinCondition) && (lemma::inflectionCategory == check.getCategory());
+  }
+  
+  lemma::lemma(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true)
+  {
+    id_ = sqlite3_column_int(row, 0);
+  }
+  
+  const form& lemma::getBaseForm() const
+  {
+    if (!valid_)
+    {
+      throw std::domain_error("Bad access to uninitialized lemma");
+    }
+    
+    if (!forms_.count(inflection::base))
+    {
+      initializeForm(inflection::base);
+    }
+    
+    return forms_.at(inflection::base).front();
+  }
+  
+  bool lemma::hasInflection(inflection category) const
+  {
+    return !getInflections(category).empty();
+  }
+  
+  const std::vector<form>& lemma::getInflections(inflection category) const
+  {
+    if (!valid_)
+    {
+      throw std::domain_error("Bad access to uninitialized lemma");
+    }
+    
+    if (!forms_.count(category))
+    {
+      initializeForm(category);
+    }
+    
+    return forms_.at(category);
+  }
+  
+  void lemma::initializeForm(inflection infl) const
+  {
+    forms_[infl] = db_->forms(form::lemma(infl) %= *this, false, -1).all();
+  }
+  
+};
@@ -0,0 +1,120 @@
+#ifndef LEMMA_H_0A180D30
+#define LEMMA_H_0A180D30
+
+#include <stdexcept>
+#include <vector>
+#include <list>
+#include <map>
+#include "field.h"
+#include "enums.h"
+#include "filter.h"
+
+struct sqlite3_stmt;
+
+namespace verbly {
+  
+  class form;
+  class database;
+  
+  class lemma {
+  public:
+    
+    // Default constructor
+    
+    lemma() = default;
+    
+    // Construct from database
+    
+    lemma(const database& db, sqlite3_stmt* row);
+    
+    // Accessors
+    
+    operator bool() const
+    {
+      return valid_;
+    }
+    
+    int getId() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized lemma");
+      }
+      
+      return id_;
+    }
+    
+    const form& getBaseForm() const;
+    
+    bool hasInflection(inflection category) const;
+    
+    const std::vector<form>& getInflections(inflection category) const;
+    
+    // Type info
+    
+    static const object objectType;
+    
+    static const std::list<std::string> select;
+    
+    // Query fields
+    
+    static const field id;
+    
+    operator filter() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized lemma");
+      }
+      
+      return (id == id_);
+    }
+    
+    // Relationships to other objects
+    
+    static const field word;
+    
+    class inflection_field {
+    public:
+      
+      inflection_field(inflection category) : category_(category)
+      {
+      }
+      
+      const inflection getCategory() const
+      {
+        return category_;
+      }
+      
+    private:
+      
+      const inflection category_;
+    };
+    
+    static const inflection_field form(inflection category)
+    {
+      return inflection_field(category);
+    }
+    
+    friend filter operator%=(lemma::inflection_field check, filter joinCondition);
+    
+  private:
+    
+    void initializeForm(inflection category) const;
+    
+    bool valid_ = false;
+    
+    int id_;
+    
+    mutable std::map<inflection, std::vector<class form>> forms_;
+    
+    const database* db_;
+    
+    static const field formJoin;
+    static const field inflectionCategory;
+    
+  };
+  
+};
+
+#endif /* end of include guard: LEMMA_H_0A180D30 */
@@ -0,0 +1,94 @@
+#include "notion.h"
+#include <sqlite3.h>
+#include <sstream>
+
+namespace verbly {
+  
+  const object notion::objectType = object::notion;
+  
+  const std::list<std::string> notion::select = {"notion_id", "part_of_speech", "wnid", "images"};
+  
+  const field notion::id = field::integerField(object::notion, "notion_id");
+  const field notion::partOfSpeech = field::integerField(object::notion, "part_of_speech");
+  const field notion::wnid = field::integerField(object::notion, "wnid", true);
+  const field notion::numOfImages = field::integerField(object::notion, "images", true);
+  
+  const field notion::word = field::joinField(object::notion, "word_id", object::word);
+
+  const field notion::hypernyms = field::selfJoin(object::notion, "notion_id", "hypernymy", "hyponym_id", "hypernym_id");
+  const field notion::hyponyms = field::selfJoin(object::notion, "notion_id", "hypernymy", "hypernym_id", "hyponym_id");
+
+  const field notion::fullHypernyms = field::hierarchalSelfJoin(object::notion, "notion_id", "hypernymy", "hyponym_id", "hypernym_id");
+  const field notion::fullHyponyms = field::hierarchalSelfJoin(object::notion, "notion_id", "hypernymy", "hypernym_id", "hyponym_id");
+
+  const field notion::instances = field::selfJoin(object::notion, "notion_id", "instantiation", "class_id", "instance_id");
+  const field notion::classes = field::selfJoin(object::notion, "notion_id", "instantiation", "instance_id", "class_id");
+
+  const field notion::memberMeronyms = field::selfJoin(object::notion, "notion_id", "member_meronymy", "holonym_id", "meronym_id");
+  const field notion::memberHolonyms = field::selfJoin(object::notion, "notion_id", "member_meronymy", "meronym_id", "holonym_id");
+
+  const field notion::fullMemberMeronyms = field::hierarchalSelfJoin(object::notion, "notion_id", "member_meronymy", "holonym_id", "meronym_id");
+  const field notion::fullMemberHolonyms = field::hierarchalSelfJoin(object::notion, "notion_id", "member_meronymy", "meronym_id", "holonym_id");
+
+  const field notion::partMeronyms = field::selfJoin(object::notion, "notion_id", "part_meronymy", "holonym_id", "meronym_id");
+  const field notion::partHolonyms = field::selfJoin(object::notion, "notion_id", "part_meronymy", "meronym_id", "holonym_id");
+
+  const field notion::fullPartMeronyms = field::hierarchalSelfJoin(object::notion, "notion_id", "part_meronymy", "holonym_id", "meronym_id");
+  const field notion::fullPartHolonyms = field::hierarchalSelfJoin(object::notion, "notion_id", "part_meronymy", "meronym_id", "holonym_id");
+
+  const field notion::substanceMeronyms = field::selfJoin(object::notion, "notion_id", "substance_meronymy", "holonym_id", "meronym_id");
+  const field notion::substanceHolonyms = field::selfJoin(object::notion, "notion_id", "substance_meronymy", "meronym_id", "holonym_id");
+
+  const field notion::fullSubstanceMeronyms = field::hierarchalSelfJoin(object::notion, "notion_id", "substance_meronymy", "holonym_id", "meronym_id");
+  const field notion::fullSubstanceHolonyms = field::hierarchalSelfJoin(object::notion, "notion_id", "substance_meronymy", "meronym_id", "holonym_id");
+
+  const field notion::variants = field::selfJoin(object::notion, "notion_id", "variation", "noun_id", "adjective_id");
+  const field notion::attributes = field::selfJoin(object::notion, "notion_id", "variation", "adjective_id", "noun_id");
+
+  const field notion::similarAdjectives = field::selfJoin(object::notion, "notion_id", "similarity", "adjective_2_id", "adjective_1_id");
+
+  const field notion::entails = field::selfJoin(object::notion, "notion_id", "entailment", "given_id", "entailment_id");
+  const field notion::entailedBy = field::selfJoin(object::notion, "notion_id", "entailment", "entailment_id", "given_id");
+
+  const field notion::causes = field::selfJoin(object::notion, "notion_id", "causality", "effect_id", "cause_id");
+  const field notion::effects = field::selfJoin(object::notion, "notion_id", "causality", "cause_id", "effect_id");
+  
+  const notion::preposition_group_field prepositionGroup = {};
+  
+  const field notion::preposition_group_field::isA = field::joinField(object::notion, "notion_id", "is_a");
+  const field notion::preposition_group_field::groupNameField = field::stringField("is_a", "groupname");
+  
+  notion::notion(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true)
+  {
+    id_ = sqlite3_column_int(row, 0);
+    partOfSpeech_ = static_cast<part_of_speech>(sqlite3_column_int(row, 1));
+    
+    if (sqlite3_column_type(row, 2) != SQLITE_NULL)
+    {
+      hasWnid_ = true;
+      wnid_ = sqlite3_column_int(row, 2);
+    }
+    
+    if (sqlite3_column_type(row, 3) != SQLITE_NULL)
+    {
+      hasNumOfImages_ = true;
+      numOfImages_ = sqlite3_column_int(row, 3);
+    }
+  }
+  
+  std::string notion::getImageNetUrl() const
+  {
+    std::stringstream url;
+    url << "http://www.image-net.org/api/text/imagenet.synset.geturls?wnid=n";
+    url.width(8);
+    url.fill('0');
+    url << (getWnid() % 100000000);
+    return url.str();
+  }
+  
+  filter notion::preposition_group_field::operator==(std::string groupName) const
+  {
+    return (isA %= (groupNameField == groupName));
+  }
+  
+};
@@ -0,0 +1,200 @@
+#ifndef NOTION_H_FD1C7646
+#define NOTION_H_FD1C7646
+
+#include <stdexcept>
+#include <string>
+#include "field.h"
+#include "filter.h"
+
+struct sqlite3_stmt;
+
+namespace verbly {
+  
+  class database;
+  
+  class notion {
+  public:
+    
+    // Default constructor
+    
+    notion() = default;
+    
+    // Construct from database
+    
+    notion(const database& db, sqlite3_stmt* row);
+    
+    // Accessors
+    
+    operator bool() const
+    {
+      return valid_;
+    }
+    
+    int getId() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized notion");
+      }
+      
+      return id_;
+    }
+    
+    part_of_speech getPartOfSpeech() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized notion");
+      }
+      
+      return partOfSpeech_;
+    }
+    
+    bool hasWnid() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized notion");
+      }
+      
+      return hasWnid_;
+    }
+    
+    int getWnid() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized notion");
+      }
+      
+      if (!hasWnid_)
+      {
+        throw std::domain_error("Notion has no wnid");
+      }
+      
+      return wnid_;
+    }
+    
+    bool hasNumOfImages() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized notion");
+      }
+      
+      return hasNumOfImages_;
+    }
+    
+    int getNumOfImages() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized notion");
+      }
+      
+      if (!hasNumOfImages_)
+      {
+        throw std::domain_error("Notion does not have a number of images");
+      }
+      
+      return numOfImages_;
+    }
+    
+    // Convenience
+    
+    std::string getImageNetUrl() const;
+    
+    // Type info
+    
+    static const object objectType;
+    
+    static const std::list<std::string> select;
+    
+    // Query fields
+    
+    static const field id;
+    static const field partOfSpeech;
+    static const field wnid;
+    static const field numOfImages;
+    
+    operator filter() const
+    {
+      return (id == id_);
+    }
+    
+    // Relationships with other objects
+    
+    static const field word;
+    
+    // Relationships with self
+    
+    static const field hypernyms;
+    static const field hyponyms;
+    
+    static const field fullHypernyms;
+    static const field fullHyponyms;
+    
+    static const field instances;
+    static const field classes;
+    
+    static const field memberMeronyms;
+    static const field memberHolonyms;
+    
+    static const field fullMemberMeronyms;
+    static const field fullMemberHolonyms;
+    
+    static const field partMeronyms;
+    static const field partHolonyms;
+    
+    static const field fullPartMeronyms;
+    static const field fullPartHolonyms;
+    
+    static const field substanceMeronyms;
+    static const field substanceHolonyms;
+    
+    static const field fullSubstanceMeronyms;
+    static const field fullSubstanceHolonyms;
+    
+    static const field variants;
+    static const field attributes;
+    
+    static const field similarAdjectives;
+    
+    static const field entails;
+    static const field entailedBy;
+    
+    static const field causes;
+    static const field effects;
+    
+    // Preposition group relationship
+    
+    class preposition_group_field {
+    public:
+      
+      filter operator==(std::string groupName) const;
+      
+    private:
+      
+      static const field isA;
+      static const field groupNameField;
+    };
+    
+    static const preposition_group_field prepositionGroup;
+    
+  private:
+    bool valid_ = false;
+    
+    int id_;
+    part_of_speech partOfSpeech_;
+    bool hasWnid_ = false;
+    int wnid_;
+    bool hasNumOfImages_ = false;
+    int numOfImages_;
+    
+    const database* db_;
+    
+  };
+  
+};
+
+#endif /* end of include guard: NOTION_H_FD1C7646 */
@@ -1,221 +0,0 @@
-#include "verbly.h"
-#include <set>
-#include <iostream>
-
-namespace verbly {
-  
-  noun::noun()
-  {
-    
-  }
-  
-  noun::noun(const data& _data, int _id) : word(_data, _id)
-  {
-    
-  }
-  
-  std::string noun::base_form() const
-  {
-    assert(_valid == true);
-    
-    return _singular;
-  }
-
-  std::string noun::singular_form() const
-  {
-    assert(_valid == true);
-    
-    return _singular;
-  }
-  
-  std::string noun::plural_form() const
-  {
-    assert(_valid == true);
-    
-    return _plural;
-  }
-  
-  int noun::wnid() const
-  {
-    assert(_valid == true);
-    
-    return _wnid;
-  }
-
-  bool noun::has_plural_form() const
-  {
-    assert(_valid == true);
-    
-    return !_plural.empty();
-  }
-  
-  noun_query noun::hypernyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().hypernym_of(*this);
-  }
-  
-  noun_query noun::full_hypernyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().full_hypernym_of(*this);
-  }
-  
-  noun_query noun::hyponyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().hyponym_of(*this);
-  }
-  
-  noun_query noun::full_hyponyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().full_hyponym_of(*this);
-  }
-  
-  noun_query noun::part_meronyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().part_meronym_of(*this);
-  }
-  
-  noun_query noun::full_part_meronyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().full_part_meronym_of(*this);
-  }
-  
-  noun_query noun::part_holonyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().part_holonym_of(*this);
-  }
-  
-  noun_query noun::full_part_holonyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().full_part_holonym_of(*this);
-  }
-  
-  noun_query noun::substance_meronyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().substance_meronym_of(*this);
-  }
-  
-  noun_query noun::full_substance_meronyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().full_substance_meronym_of(*this);
-  }
-  
-  noun_query noun::substance_holonyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().substance_holonym_of(*this);
-  }
-  
-  noun_query noun::full_substance_holonyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().full_substance_holonym_of(*this);
-  }
-  
-  noun_query noun::member_meronyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().member_meronym_of(*this);
-  }
-  
-  noun_query noun::full_member_meronyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().full_member_meronym_of(*this);
-  }
-  
-  noun_query noun::member_holonyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().member_holonym_of(*this);
-  }
-  
-  noun_query noun::full_member_holonyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().full_member_holonym_of(*this);
-  }
-  
-  noun_query noun::classes() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().class_of(*this);
-  }
-  
-  noun_query noun::instances() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().instance_of(*this);
-  }
-  
-  noun_query noun::synonyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().synonym_of(*this);
-  }
-  
-  noun_query noun::antonyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->nouns().antonym_of(*this);
-  }
-  
-  adjective_query noun::pertainyms() const
-  {
-    assert(_valid == true);
-    
-    return _data->adjectives().pertainym_of(*this);
-  }
-  
-  adjective_query noun::variations() const
-  {
-    assert(_valid == true);
-    
-    return _data->adjectives().variant_of(*this);
-  }
-  
-  std::string noun::imagenet_url() const
-  {
-    std::stringstream url;
-    url << "http://www.image-net.org/api/text/imagenet.synset.geturls?wnid=n";
-    url.width(8);
-    url.fill('0');
-    url << (_wnid % 100000000);
-    return url.str();
-  }
-  
-  bool noun::operator<(const noun& other) const
-  {
-    return _id < other._id;
-  }
-
-};
@@ -1,55 +0,0 @@
-#ifndef NOUN_H_24A03C83
-#define NOUN_H_24A03C83
-
-namespace verbly {
-  
-  class noun : public word {
-    private:
-      std::string _singular;
-      std::string _plural;
-      int _wnid;
-      
-      friend class noun_query;
-      
-    public:
-      noun();
-      noun(const data& _data, int _id);
-      
-      std::string base_form() const;
-      std::string singular_form() const;
-      std::string plural_form() const;
-      int wnid() const;
-      
-      bool has_plural_form() const;
-      
-      noun_query hypernyms() const;
-      noun_query full_hypernyms() const;
-      noun_query hyponyms() const;
-      noun_query full_hyponyms() const;
-      noun_query part_meronyms() const;
-      noun_query full_part_meronyms() const;
-      noun_query part_holonyms() const;
-      noun_query full_part_holonyms() const;
-      noun_query substance_meronyms() const;
-      noun_query full_substance_meronyms() const;
-      noun_query substance_holonyms() const;
-      noun_query full_substance_holonyms() const;
-      noun_query member_meronyms() const;
-      noun_query full_member_meronyms() const;
-      noun_query member_holonyms() const;
-      noun_query full_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;
-      
-      std::string imagenet_url() const;
-      
-      bool operator<(const noun& other) const;
-  };
-  
-};
-
-#endif /* end of include guard: NOUN_H_24A03C83 */
@@ -1,2013 +0,0 @@
-#include "verbly.h"
-
-namespace verbly {
-  
-  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()
-  {
-    this->_random = true;
-  
-    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.get_rhymes())
-    {
-      _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::rhymes_with(rhyme _r)
-  {
-    _rhymes.push_back(_r);
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::has_pronunciation()
-  {
-    this->_has_prn = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::has_rhyming_noun()
-  {
-    _has_rhyming_noun = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::has_rhyming_adjective()
-  {
-    _has_rhyming_adjective = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::has_rhyming_adverb()
-  {
-    _has_rhyming_adverb = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::has_rhyming_verb()
-  {
-    _has_rhyming_verb = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::with_stress(filter<std::vector<bool>> _arg)
-  {
-    _stress = _arg;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::with_singular_form(std::string _arg)
-  {
-    _with_singular_form.push_back(_arg);
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::with_prefix(filter<std::string> _f)
-  {
-    _f.clean();
-    _with_prefix = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::with_suffix(filter<std::string> _f)
-  {
-    _f.clean();
-    _with_suffix = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::requires_plural_form()
-  {
-    _requires_plural_form = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::with_complexity(int _arg)
-  {
-    _with_complexity = _arg;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::is_hypernym()
-  {
-    _is_hypernym = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::hypernym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _hypernym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::full_hypernym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _full_hypernym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::is_hyponym()
-  {
-    _is_hyponym = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::hyponym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _hyponym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::full_hyponym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _full_hyponym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::is_part_meronym()
-  {
-    _is_part_meronym = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::part_meronym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _part_meronym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::full_part_meronym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _full_part_meronym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::is_part_holonym()
-  {
-    _is_part_holonym = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::part_holonym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _part_holonym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::full_part_holonym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _full_part_holonym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::is_substance_meronym()
-  {
-    _is_substance_meronym = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::substance_meronym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _substance_meronym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::full_substance_meronym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _full_substance_meronym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::is_substance_holonym()
-  {
-    _is_substance_holonym = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::substance_holonym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _substance_holonym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::full_substance_holonym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _full_substance_holonym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::is_member_meronym()
-  {
-    _is_member_meronym = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::member_meronym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _member_meronym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::full_member_meronym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _full_member_meronym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::is_member_holonym()
-  {
-    _is_member_holonym = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::member_holonym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _member_holonym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::full_member_holonym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _full_member_holonym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::is_proper()
-  {
-    _is_proper = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::is_not_proper()
-  {
-    _is_not_proper = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::is_instance()
-  {
-    _is_instance = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::instance_of(filter<noun> _f)
-  {
-    _f.clean();
-    _instance_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::is_class()
-  {
-    _is_class = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::class_of(filter<noun> _f)
-  {
-    _f.clean();
-    _class_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::has_synonyms()
-  {
-    _has_synonyms = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::synonym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _synonym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::has_antonyms()
-  {
-    _has_antonyms = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::antonym_of(filter<noun> _f)
-  {
-    _f.clean();
-    _antonym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::has_pertainym()
-  {
-    _has_pertainym = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::anti_pertainym_of(filter<adjective> _f)
-  {
-    _f.clean();
-    _anti_pertainym_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::is_attribute()
-  {
-    _is_attribute = true;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::attribute_of(filter<adjective> _f)
-  {
-    _f.clean();
-    _attribute_of = _f;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::at_least_n_images(int _arg)
-  {
-    _at_least_n_images = _arg;
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::with_wnid(int _arg)
-  {
-    _with_wnid.insert(_arg);
-    
-    return *this;
-  }
-  
-  /*
-  noun_query& noun_query::derived_from(const word& _w)
-  {
-    if (dynamic_cast<const adjective*>(&_w) != nullptr)
-    {
-      _derived_from_adjective.push_back(dynamic_cast<const adjective&>(_w));
-    } else if (dynamic_cast<const adverb*>(&_w) != nullptr)
-    {
-      _derived_from_adverb.push_back(dynamic_cast<const adverb&>(_w));
-    } else if (dynamic_cast<const noun*>(&_w) != nullptr)
-    {
-      _derived_from_noun.push_back(dynamic_cast<const noun&>(_w));
-    }
-    
-    return *this;
-  }
-  
-  noun_query& noun_query::not_derived_from(const word& _w)
-  {
-    if (dynamic_cast<const adjective*>(&_w) != nullptr)
-    {
-      _not_derived_from_adjective.push_back(dynamic_cast<const adjective&>(_w));
-    } else if (dynamic_cast<const adverb*>(&_w) != nullptr)
-    {
-      _not_derived_from_adverb.push_back(dynamic_cast<const adverb&>(_w));
-    } else if (dynamic_cast<const noun*>(&_w) != nullptr)
-    {
-      _not_derived_from_noun.push_back(dynamic_cast<const noun&>(_w));
-    }
-    
-    return *this;
-  }*/
-  
-  std::list<noun> noun_query::run() const
-  {
-    std::stringstream construct;
-    
-    if (!_full_hypernym_of.empty() || !_full_hyponym_of.empty() || !_full_part_meronym_of.empty() || !_full_part_holonym_of.empty() || !_full_substance_meronym_of.empty() || !_full_substance_holonym_of.empty() || !_full_member_meronym_of.empty() || !_full_member_holonym_of.empty())
-    {
-      construct << "WITH RECURSIVE ";
-      
-      std::list<std::string> ctes;
-      
-      for (auto hyponym : _full_hypernym_of.uniq_flatten())
-      {
-        ctes.push_back("hypernym_tree_" + std::to_string(hyponym._id) + " AS (SELECT hypernym_id FROM hypernymy WHERE hyponym_id = " + std::to_string(hyponym._id) + " UNION SELECT h.hypernym_id FROM hypernym_tree_" + std::to_string(hyponym._id) + " AS t INNER JOIN hypernymy AS h ON t.hypernym_id = h.hyponym_id)");
-      }
-      
-      for (auto hypernym : _full_hyponym_of.uniq_flatten())
-      {
-        ctes.push_back("hyponym_tree_" + std::to_string(hypernym._id) + " AS (SELECT hyponym_id FROM hypernymy WHERE hypernym_id = " + std::to_string(hypernym._id) + " UNION SELECT h.hyponym_id FROM hyponym_tree_" + std::to_string(hypernym._id) + " AS t INNER JOIN hypernymy AS h ON t.hyponym_id = h.hypernym_id)");
-      }
-      
-      for (auto holonym : _full_part_meronym_of.uniq_flatten())
-      {
-        ctes.push_back("part_meronym_tree_" + std::to_string(holonym._id) + " AS (SELECT meronym_id FROM part_meronymy WHERE holonym_id = " + std::to_string(holonym._id) + " UNION SELECT h.meronym_id FROM part_meronym_tree_" + std::to_string(holonym._id) + " AS t INNER JOIN part_meronymy AS h ON t.meronym_id = h.holonym_id)");
-      }
-      
-      for (auto meronym : _full_part_holonym_of.uniq_flatten())
-      {
-        ctes.push_back("part_holonym_tree_" + std::to_string(meronym._id) + " AS (SELECT holonym_id FROM part_meronymy WHERE meronym_id = " + std::to_string(meronym._id) + " UNION SELECT h.holonym_id FROM part_holonym_tree_" + std::to_string(meronym._id) + " AS t INNER JOIN part_meronymy AS h ON t.holonym_id = h.meronym_id)");
-      }
-      
-      for (auto holonym : _full_substance_meronym_of.uniq_flatten())
-      {
-        ctes.push_back("substance_meronym_tree_" + std::to_string(holonym._id) + " AS (SELECT meronym_id FROM substance_meronymy WHERE holonym_id = " + std::to_string(holonym._id) + " UNION SELECT h.meronym_id FROM substance_meronym_tree_" + std::to_string(holonym._id) + " AS t INNER JOIN substance_meronymy AS h ON t.meronym_id = h.holonym_id)");
-      }
-      
-      for (auto meronym : _full_substance_holonym_of.uniq_flatten())
-      {
-        ctes.push_back("substance_holonym_tree_" + std::to_string(meronym._id) + " AS (SELECT holonym_id FROM substance_meronymy WHERE meronym_id = " + std::to_string(meronym._id) + " UNION SELECT h.holonym_id FROM substance_holonym_tree_" + std::to_string(meronym._id) + " AS t INNER JOIN substance_meronymy AS h ON t.holonym_id = h.meronym_id)");
-      }
-      
-      for (auto holonym : _full_member_meronym_of.uniq_flatten())
-      {
-        ctes.push_back("member_meronym_tree_" + std::to_string(holonym._id) + " AS (SELECT meronym_id FROM member_meronymy WHERE holonym_id = " + std::to_string(holonym._id) + " UNION SELECT h.meronym_id FROM member_meronym_tree_" + std::to_string(holonym._id) + " AS t INNER JOIN member_meronymy AS h ON t.meronym_id = h.holonym_id)");
-      }
-      
-      for (auto meronym : _full_member_holonym_of.uniq_flatten())
-      {
-        ctes.push_back("member_holonym_tree_" + std::to_string(meronym._id) + " AS (SELECT holonym_id FROM member_meronymy WHERE meronym_id = " + std::to_string(meronym._id) + " UNION SELECT h.holonym_id FROM member_holonym_tree_" + std::to_string(meronym._id) + " AS t INNER JOIN member_meronymy AS h ON t.holonym_id = h.meronym_id)");
-      }
-      
-      construct << verbly::implode(std::begin(ctes), std::end(ctes), ", ");
-      construct << " ";
-    }
-    
-    construct << "SELECT noun_id, singular, plural, wnid FROM nouns";
-    std::list<std::string> conditions;
-    std::list<binding> bindings;
-    
-    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(), "(prerhyme != ? AND rhyme = ?)");
-      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 rhy : _rhymes)
-      {
-        bindings.emplace_back(rhy.get_prerhyme());
-        bindings.emplace_back(rhy.get_rhyme());
-      }
-    }
-    
-    if (_has_rhyming_noun)
-    {
-      conditions.push_back("noun_id IN (SELECT a.noun_id FROM nouns AS a INNER JOIN noun_pronunciations AS curp ON curp.noun_id = a.noun_id INNER JOIN noun_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme AND rhmp.noun_id != curp.noun_id)");
-    }
-    
-    if (_has_rhyming_adjective)
-    {
-      conditions.push_back("noun_id IN (SELECT a.noun_id FROM nouns AS a INNER JOIN noun_pronunciations AS curp ON curp.noun_id = a.noun_id INNER JOIN adjective_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
-    }
-    
-    if (_has_rhyming_adverb)
-    {
-      conditions.push_back("noun_id IN (SELECT a.noun_id FROM nouns AS a INNER JOIN noun_pronunciations AS curp ON curp.noun_id = a.noun_id INNER JOIN adverb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
-    }
-    
-    if (_has_rhyming_verb)
-    {
-      conditions.push_back("noun_id IN (SELECT a.noun_id FROM nouns AS a INNER JOIN noun_pronunciations AS curp ON curp.noun_id = a.noun_id INNER JOIN verb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
-    }
-    
-    if (!_stress.empty())
-    {
-      std::stringstream cond;
-      if (_stress.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT noun_id FROM noun_pronunciations WHERE ";
-      
-      std::function<std::string (filter<std::vector<bool>>, bool)> recur = [&] (filter<std::vector<bool>> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<std::vector<bool>>::type::singleton:
-          {
-            std::ostringstream _val;
-            for (auto syl : f.get_elem())
-            {
-              if (syl)
-              {
-                _val << "1";
-              } else {
-                _val << "0";
-              }
-            }
-            
-            bindings.emplace_back(_val.str());
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "stress = ?";
-            } else {
-              return "stress != ?";
-            }
-          }
-          
-          case filter<std::vector<bool>>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<std::vector<bool>> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_stress, _stress.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-
-    for (auto except : _except)
-    {
-      conditions.push_back("noun_id != ?");
-      bindings.emplace_back(except._id);
-    }
-    
-    if (!_with_singular_form.empty())
-    {
-      std::list<std::string> clauses(_with_singular_form.size(), "singular = ?");
-      std::string cond = "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-      
-      for (auto form : _with_singular_form)
-      {
-        bindings.emplace_back(form);
-      }
-    }
-    
-    if (_requires_plural_form)
-    {
-      conditions.push_back("plural IS NOT NULL");
-    }
-    
-    if (!_with_prefix.empty())
-    {
-      std::function<std::string (filter<std::string>, bool)> recur = [&] (filter<std::string> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<std::string>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem() + "%");
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "singular LIKE ?";
-            } else {
-              return "singular NOT LIKE ?";
-            }
-          }
-          
-          case filter<std::string>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<std::string> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      conditions.push_back(recur(_with_prefix, false));
-    }
-    
-    if (!_with_suffix.empty())
-    {
-      std::function<std::string (filter<std::string>, bool)> recur = [&] (filter<std::string> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<std::string>::type::singleton:
-          {
-            bindings.emplace_back("%" + f.get_elem());
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "singular LIKE ?";
-            } else {
-              return "singular NOT LIKE ?";
-            }
-          }
-          
-          case filter<std::string>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<std::string> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      conditions.push_back(recur(_with_suffix, false));
-    }
-    
-    if (_with_complexity != unlimited)
-    {
-      conditions.push_back("complexity = ?");
-      bindings.emplace_back(_with_complexity);
-    }
-    
-    if (_is_hypernym)
-    {
-      conditions.push_back("noun_id IN (SELECT hypernym_id FROM hypernymy)");
-    }
-    
-    if (!_hypernym_of.empty())
-    {
-      std::stringstream cond;
-      if (_hypernym_of.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT hypernym_id FROM hypernymy WHERE ";
-      
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "hyponym_id = ?";
-            } else {
-              return "hyponym_id != ?";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_hypernym_of, _hypernym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (!_full_hypernym_of.empty())
-    {
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            if (notlogic == f.get_notlogic())
-            {
-              return "noun_id IN (SELECT hypernym_id FROM hypernym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            } else {
-              return "noun_id NOT IN (SELECT hypernym_id FROM hypernym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      conditions.push_back(recur(_full_hypernym_of, false));
-    }
-    
-    if (!_full_hyponym_of.empty())
-    {
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            if (notlogic == f.get_notlogic())
-            {
-              return "noun_id IN (SELECT hyponym_id FROM hyponym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            } else {
-              return "noun_id NOT IN (SELECT hyponym_id FROM hyponym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      conditions.push_back(recur(_full_hyponym_of, false));
-    }
-    
-    if (_is_hyponym)
-    {
-      conditions.push_back("noun_id IN (SELECT hyponym_id FROM hypernymy)");
-    }
-    
-    if (!_hyponym_of.empty())
-    {
-      std::stringstream cond;
-      if (_hyponym_of.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT hyponym_id FROM hypernymy WHERE ";
-      
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "hypernym_id = ?";
-            } else {
-              return "hypernym_id != ?";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_hyponym_of, _hyponym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_is_part_meronym)
-    {
-      conditions.push_back("noun_id IN (SELECT meronym_id FROM part_meronymy)");
-    }
-    
-    if (!_part_meronym_of.empty())
-    {
-      std::stringstream cond;
-      if (_part_meronym_of.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT meronym_id FROM part_meronymy WHERE ";
-      
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "holonym_id = ?";
-            } else {
-              return "holonym_id != ?";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_part_meronym_of, _part_meronym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (!_full_part_meronym_of.empty())
-    {
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            if (notlogic == f.get_notlogic())
-            {
-              return "noun_id IN (SELECT meronym_id FROM part_meronym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            } else {
-              return "noun_id NOT IN (SELECT meronym_id FROM part_meronym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      conditions.push_back(recur(_full_part_meronym_of, false));
-    }
-    
-    if (_is_part_holonym)
-    {
-      conditions.push_back("noun_id IN (SELECT holonym_id FROM part_meronymy)");
-    }
-    
-    if (!_part_holonym_of.empty())
-    {
-      std::stringstream cond;
-      if (_part_holonym_of.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT holonym_id FROM part_meronymy WHERE ";
-      
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "meronym_id = ?";
-            } else {
-              return "meronym_id != ?";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_part_holonym_of, _part_holonym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (!_full_part_holonym_of.empty())
-    {
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            if (notlogic == f.get_notlogic())
-            {
-              return "noun_id IN (SELECT holonym_id FROM part_holonym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            } else {
-              return "noun_id NOT IN (SELECT holonym_id FROM part_holonym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      conditions.push_back(recur(_full_part_holonym_of, false));
-    }
-    
-    if (_is_substance_meronym)
-    {
-      conditions.push_back("noun_id IN (SELECT meronym_id FROM substance_meronymy)");
-    }
-    
-    if (!_substance_meronym_of.empty())
-    {
-      std::stringstream cond;
-      if (_substance_meronym_of.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT meronym_id FROM substance_meronymy WHERE ";
-      
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "holonym_id = ?";
-            } else {
-              return "holonym_id != ?";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_substance_meronym_of, _substance_meronym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (!_full_substance_meronym_of.empty())
-    {
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            if (notlogic == f.get_notlogic())
-            {
-              return "noun_id IN (SELECT meronym_id FROM substance_meronym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            } else {
-              return "noun_id NOT IN (SELECT meronym_id FROM substance_meronym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      conditions.push_back(recur(_full_substance_meronym_of, false));
-    }
-    
-    if (_is_substance_holonym)
-    {
-      conditions.push_back("noun_id IN (SELECT holonym_id FROM substance_meronymy)");
-    }
-    
-    if (!_substance_holonym_of.empty())
-    {
-      std::stringstream cond;
-      if (_substance_holonym_of.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT holonym_id FROM substance_meronymy WHERE ";
-      
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "meronym_id = ?";
-            } else {
-              return "meronym_id != ?";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_substance_holonym_of, _substance_holonym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (!_full_substance_holonym_of.empty())
-    {
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            if (notlogic == f.get_notlogic())
-            {
-              return "noun_id IN (SELECT holonym_id FROM substance_holonym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            } else {
-              return "noun_id NOT IN (SELECT holonym_id FROM substance_holonym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      conditions.push_back(recur(_full_substance_holonym_of, false));
-    }
-    
-    if (_is_member_meronym)
-    {
-      conditions.push_back("noun_id IN (SELECT meronym_id FROM member_meronymy)");
-    }
-    
-    if (!_member_meronym_of.empty())
-    {
-      std::stringstream cond;
-      if (_member_meronym_of.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT meronym_id FROM member_meronymy WHERE ";
-      
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "holonym_id = ?";
-            } else {
-              return "holonym_id != ?";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_member_meronym_of, _member_meronym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (!_full_member_meronym_of.empty())
-    {
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            if (notlogic == f.get_notlogic())
-            {
-              return "noun_id IN (SELECT meronym_id FROM member_meronym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            } else {
-              return "noun_id NOT IN (SELECT meronym_id FROM member_meronym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      conditions.push_back(recur(_full_member_meronym_of, false));
-    }
-    
-    if (_is_member_holonym)
-    {
-      conditions.push_back("noun_id IN (SELECT holonym_id FROM member_meronym)");
-    }
-    
-    if (!_member_holonym_of.empty())
-    {
-      std::stringstream cond;
-      if (_member_holonym_of.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT holonym_id FROM member_meronymy WHERE ";
-      
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "meronym_id = ?";
-            } else {
-              return "meronym_id != ?";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_member_holonym_of, _member_holonym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (!_full_member_holonym_of.empty())
-    {
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            if (notlogic == f.get_notlogic())
-            {
-              return "noun_id IN (SELECT holonym_id FROM member_holonym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            } else {
-              return "noun_id NOT IN (SELECT holonym_id FROM member_holonym_tree_" + std::to_string(f.get_elem()._id) + ")";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      conditions.push_back(recur(_full_member_holonym_of, false));
-    }
-    
-    if (_is_proper)
-    {
-      conditions.push_back("proper = 1");
-    }
-    
-    if (_is_not_proper)
-    {
-      conditions.push_back("proper = 0");
-    }
-    
-    if (_is_instance)
-    {
-      conditions.push_back("noun_id IN (SELECT instance_id FROM instantiation)");
-    }
-    
-    if (!_instance_of.empty())
-    {
-      std::stringstream cond;
-      if (_instance_of.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT instance_id FROM instantiation WHERE ";
-      
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "class_id = ?";
-            } else {
-              return "class_id != ?";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_instance_of, _instance_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_is_class)
-    {
-      conditions.push_back("noun_id IN (SELECT class_id FROM instantiation)");
-    }
-    
-    if (!_class_of.empty())
-    {
-      std::stringstream cond;
-      if (_class_of.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT class_id FROM instantiation WHERE ";
-      
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "instance_id = ?";
-            } else {
-              return "instance_id != ?";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_class_of, _class_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_has_synonyms)
-    {
-      conditions.push_back("noun_id IN (SELECT noun_2_id FROM noun_synonymy)");
-    }
-    
-    if (!_synonym_of.empty())
-    {
-      std::stringstream cond;
-      if (_synonym_of.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT noun_2_id FROM noun_synonymy WHERE ";
-      
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "noun_1_id = ?";
-            } else {
-              return "noun_1_id != ?";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_synonym_of, _synonym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_has_antonyms)
-    {
-      conditions.push_back("noun_id IN (SELECT noun_2_id FROM noun_antonymy)");
-    }
-    
-    if (!_antonym_of.empty())
-    {
-      std::stringstream cond;
-      if (_antonym_of.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT noun_2_id FROM noun_antonymy WHERE ";
-      
-      std::function<std::string (filter<noun>, bool)> recur = [&] (filter<noun> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<noun>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "noun_1_id = ?";
-            } else {
-              return "noun_1_id != ?";
-            }
-          }
-          
-          case filter<noun>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<noun> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_antonym_of, _antonym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_has_pertainym)
-    {
-      conditions.push_back("noun_id IN (SELECT noun_id FROM pertainymy)");
-    }
-    
-    if (!_anti_pertainym_of.empty())
-    {
-      std::stringstream cond;
-      if (_anti_pertainym_of.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT noun_id FROM pertainymy WHERE ";
-      
-      std::function<std::string (filter<adjective>, bool)> recur = [&] (filter<adjective> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<adjective>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "pertainym_id = ?";
-            } else {
-              return "pertainym_id != ?";
-            }
-          }
-          
-          case filter<adjective>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<adjective> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_anti_pertainym_of, _anti_pertainym_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_is_attribute)
-    {
-      conditions.push_back("noun_id IN (SELECT noun_id FROM variation)");
-    }
-    
-    if (!_attribute_of.empty())
-    {
-      std::stringstream cond;
-      if (_attribute_of.get_notlogic())
-      {
-        cond << "noun_id NOT IN";
-      } else {
-        cond << "noun_id IN";
-      }
-      
-      cond << "(SELECT noun_id FROM variation WHERE ";
-      
-      std::function<std::string (filter<adjective>, bool)> recur = [&] (filter<adjective> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<adjective>::type::singleton:
-          {
-            bindings.emplace_back(f.get_elem()._id);
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "adjective_id = ?";
-            } else {
-              return "adjective_id != ?";
-            }
-          }
-          
-          case filter<adjective>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<adjective> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_attribute_of, _attribute_of.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    if (_at_least_n_images != unlimited)
-    {
-      conditions.push_back("images >= ?");
-      bindings.emplace_back(_at_least_n_images);
-    }
-    
-    if (!_with_wnid.empty())
-    {
-      std::vector<std::string> clauses(_with_wnid.size(), "wnid = ?");
-      std::string cond = verbly::implode(std::begin(clauses), std::end(clauses), " OR ");
-      conditions.push_back("(" + cond + ")");
-      
-      for (auto wnid : _with_wnid)
-      {
-        bindings.emplace_back(wnid);
-      }
-    }
-    
-    /*
-    if (!_derived_from_adjective.empty())
-    {
-      std::list<std::string> clauses(_derived_from_adjective.size(), "adjective_id = @DERADJ");
-      std::string cond = "noun_id IN (SELECT noun_id FROM noun_adjective_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_not_derived_from_adjective.empty())
-    {
-      std::list<std::string> clauses(_not_derived_from_adjective.size(), "adjective_id = @NDERADJ");
-      std::string cond = "noun_id NOT IN (SELECT noun_id FROM noun_adjective_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_derived_from_adverb.empty())
-    {
-      std::list<std::string> clauses(_derived_from_adverb.size(), "adverb_id = @DERADV");
-      std::string cond = "noun_id IN (SELECT noun_id FROM noun_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_not_derived_from_adverb.empty())
-    {
-      std::list<std::string> clauses(_not_derived_from_adverb.size(), "adverb_id = @NDERADV");
-      std::string cond = "noun_id NOT IN (SELECT noun_id FROM noun_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_derived_from_noun.empty())
-    {
-      std::list<std::string> clauses(_derived_from_noun.size(), "noun_2_id = @DERN");
-      std::string cond = "noun_id IN (SELECT noun_1_id FROM noun_noun_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-      conditions.push_back(cond);
-    }
-    
-    if (!_not_derived_from_noun.empty())
-    {
-      std::list<std::string> clauses(_not_derived_from_noun.size(), "noun_2_id = @NDERN");
-      std::string cond = "noun_id NOT IN (SELECT noun_1_id FROM noun_noun_derivation 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));
-    }
-
-    int i = 1;
-    for (auto& binding : bindings)
-    {
-      switch (binding.get_type())
-      {
-        case binding::type::integer:
-        {
-          sqlite3_bind_int(ppstmt, i, binding.get_integer());
-          
-          break;
-        }
-        
-        case binding::type::string:
-        {
-          sqlite3_bind_text(ppstmt, i, binding.get_string().c_str(), binding.get_string().length(), SQLITE_TRANSIENT);
-          
-          break;
-        }
-      }
-      
-      i++;
-    }
-
-    /*
-    for (auto adj : _derived_from_adjective)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERADJ"), adj._id);
-    }
-    
-    for (auto adj : _not_derived_from_adjective)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERADJ"), adj._id);
-    }
-    
-    for (auto adv : _derived_from_adverb)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERADV"), adv._id);
-    }
-    
-    for (auto adv : _not_derived_from_adverb)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERADV"), adv._id);
-    }
-    
-    for (auto n : _derived_from_noun)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERN"), n._id);
-    }
-    
-    for (auto n : _not_derived_from_noun)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERN"), n._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)));
-      }
-      
-      tnc._wnid = sqlite3_column_int(ppstmt, 3);
-  
-      output.push_back(tnc);
-    }
-
-    sqlite3_finalize(ppstmt);
-    
-    for (auto& noun : output)
-    {
-      query = "SELECT pronunciation, prerhyme, rhyme 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);
-        
-        if ((sqlite3_column_type(ppstmt, 1) != SQLITE_NULL) && (sqlite3_column_type(ppstmt, 2) != SQLITE_NULL))
-        {
-          std::string prerhyme(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
-          std::string rhyming(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 2)));
-          
-          noun.rhymes.emplace_back(prerhyme, rhyming);
-        }
-      }
-      
-      sqlite3_finalize(ppstmt);
-    }
-
-    return output;
-  }
-
-};
@@ -1,180 +0,0 @@
-#ifndef NOUN_QUERY_H_5DE51DD7
-#define NOUN_QUERY_H_5DE51DD7
-
-namespace verbly {
-  
-  class noun_query {
-    public:
-      noun_query(const data& _data);
-      
-      noun_query& limit(int _limit);
-      noun_query& random();
-      noun_query& except(const noun& _word);
-      noun_query& rhymes_with(const word& _word);
-      noun_query& rhymes_with(rhyme _r);
-      noun_query& has_pronunciation();
-      noun_query& has_rhyming_noun();
-      noun_query& has_rhyming_adjective();
-      noun_query& has_rhyming_adverb();
-      noun_query& has_rhyming_verb();
-      noun_query& with_stress(filter<std::vector<bool>> _arg);
-      
-      noun_query& with_singular_form(std::string _arg);
-      noun_query& with_prefix(filter<std::string> _f);
-      noun_query& with_suffix(filter<std::string> _f);
-      
-      noun_query& requires_plural_form();
-      
-      noun_query& with_complexity(int _arg);
-      
-      noun_query& is_hypernym();
-      noun_query& hypernym_of(filter<noun> _f);
-      noun_query& full_hypernym_of(filter<noun> _f);
-      
-      noun_query& is_hyponym();
-      noun_query& hyponym_of(filter<noun> _f);
-      noun_query& full_hyponym_of(filter<noun> _f);
-      
-      noun_query& is_part_meronym();
-      noun_query& part_meronym_of(filter<noun> _f);
-      noun_query& full_part_meronym_of(filter<noun> _f);
-      
-      noun_query& is_part_holonym();
-      noun_query& part_holonym_of(filter<noun> _f);
-      noun_query& full_part_holonym_of(filter<noun> _f);
-      
-      noun_query& is_substance_meronym();
-      noun_query& substance_meronym_of(filter<noun> _f);
-      noun_query& full_substance_meronym_of(filter<noun> _f);
-      
-      noun_query& is_substance_holonym();
-      noun_query& substance_holonym_of(filter<noun> _f);
-      noun_query& full_substance_holonym_of(filter<noun> _f);
-      
-      noun_query& is_member_meronym();
-      noun_query& member_meronym_of(filter<noun> _f);
-      noun_query& full_member_meronym_of(filter<noun> _f);
-      
-      noun_query& is_member_holonym();
-      noun_query& member_holonym_of(filter<noun> _f);
-      noun_query& full_member_holonym_of(filter<noun> _f);
-      
-      noun_query& is_proper();
-      noun_query& is_not_proper();
-      
-      noun_query& is_instance();
-      noun_query& instance_of(filter<noun> _f);
-      
-      noun_query& is_class();
-      noun_query& class_of(filter<noun> _f);
-      
-      noun_query& has_synonyms();
-      noun_query& synonym_of(filter<noun> _f);
-      
-      noun_query& has_antonyms();
-      noun_query& antonym_of(filter<noun> _f);
-      
-      noun_query& has_pertainym();
-      noun_query& anti_pertainym_of(filter<adjective> _f);
-      
-      noun_query& is_attribute();
-      noun_query& attribute_of(filter<adjective> _f);
-      
-      noun_query& at_least_n_images(int _arg);
-      noun_query& with_wnid(int _arg);
-      
-/*      noun_query& derived_from(const word& _w);
-      noun_query& not_derived_from(const word& _w);*/
-      
-      std::list<noun> run() const;
-      
-      const static int unlimited = -1;
-      
-    private:
-      const data& _data;
-      int _limit = unlimited;
-      bool _random = false;
-      std::list<rhyme> _rhymes;
-      std::list<noun> _except;
-      bool _has_prn = false;
-      bool _has_rhyming_noun = false;
-      bool _has_rhyming_adjective = false;
-      bool _has_rhyming_adverb = false;
-      bool _has_rhyming_verb = false;
-      filter<std::vector<bool>> _stress;
-      
-      std::list<std::string> _with_singular_form;
-      filter<std::string> _with_prefix;
-      filter<std::string> _with_suffix;
-      
-      int _with_complexity = unlimited;
-      
-      bool _requires_plural_form = false;
-      
-      bool _is_hypernym = false;
-      filter<noun> _hypernym_of;
-      filter<noun> _full_hypernym_of;
-      
-      bool _is_hyponym = false;
-      filter<noun> _hyponym_of;
-      filter<noun> _full_hyponym_of;
-      
-      bool _is_part_meronym = false;
-      filter<noun> _part_meronym_of;
-      filter<noun> _full_part_meronym_of;
-      
-      bool _is_substance_meronym = false;
-      filter<noun> _substance_meronym_of;
-      filter<noun> _full_substance_meronym_of;
-      
-      bool _is_member_meronym = false;
-      filter<noun> _member_meronym_of;
-      filter<noun> _full_member_meronym_of;
-      
-      bool _is_part_holonym = false;
-      filter<noun> _part_holonym_of;
-      filter<noun> _full_part_holonym_of;
-      
-      bool _is_substance_holonym = false;
-      filter<noun> _substance_holonym_of;
-      filter<noun> _full_substance_holonym_of;
-      
-      bool _is_member_holonym = false;
-      filter<noun> _member_holonym_of;
-      filter<noun> _full_member_holonym_of;
-      
-      bool _is_proper = false;
-      bool _is_not_proper = false;
-      
-      bool _is_instance = false;
-      filter<noun> _instance_of;
-      
-      bool _is_class = false;
-      filter<noun> _class_of;
-      
-      bool _has_synonyms = false;
-      filter<noun> _synonym_of;
-      
-      bool _has_antonyms = false;
-      filter<noun> _antonym_of;
-      
-      bool _has_pertainym = false;
-      filter<adjective> _anti_pertainym_of;
-      
-      bool _is_attribute = false;
-      filter<adjective> _attribute_of;
-      
-      int _at_least_n_images = unlimited;
-      std::set<int> _with_wnid;
-      
-/*      std::list<adjective> _derived_from_adjective;
-      std::list<adjective> _not_derived_from_adjective;
-      std::list<adverb> _derived_from_adverb;
-      std::list<adverb> _not_derived_from_adverb;
-      std::list<noun> _derived_from_noun;
-      std::list<noun> _not_derived_from_noun;*/
-  };
-  
-};
-
-#endif /* end of include guard: NOUN_QUERY_H_5DE51DD7 */
@@ -1,107 +0,0 @@
-#include "verbly.h"
-
-namespace verbly {
-  
-  std::string preposition::get_form() const
-  {
-    return form;
-  }
-  
-  preposition_query::preposition_query(const data& _data) : _data(_data)
-  {
-    
-  }
-  
-  preposition_query& preposition_query::limit(int _limit)
-  {
-    this->_limit = _limit;
-    
-    return *this;
-  }
-  
-  preposition_query& preposition_query::random()
-  {
-    _random = true;
-    
-    return *this;
-  }
-  
-  preposition_query& preposition_query::in_group(std::string _arg)
-  {
-    _in_group.push_back(_arg);
-    
-    return *this;
-  }
-  
-  std::list<preposition> preposition_query::run() const
-  {
-    std::stringstream construct;
-    construct << "SELECT form FROM prepositions";
-    std::list<binding> bindings;
-    
-    if (!_in_group.empty())
-    {
-      std::list<std::string> clauses(_in_group.size(), "groupname = ?");
-      construct << " WHERE preposition_id IN (SELECT preposition_id FROM preposition_groups WHERE ";
-      construct << verbly::implode(std::begin(clauses), std::end(clauses), " OR ");
-      construct << ")";
-      
-      for (auto g : _in_group)
-      {
-        bindings.emplace_back(g);
-      }
-    }
-    
-    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));
-    }
-    
-    int i = 1;
-    for (auto& binding : bindings)
-    {
-      switch (binding.get_type())
-      {
-        case binding::type::integer:
-        {
-          sqlite3_bind_int(ppstmt, i, binding.get_integer());
-          
-          break;
-        }
-        
-        case binding::type::string:
-        {
-          sqlite3_bind_text(ppstmt, i, binding.get_string().c_str(), binding.get_string().length(), SQLITE_TRANSIENT);
-          
-          break;
-        }
-      }
-      
-      i++;
-    }
-    
-    std::list<preposition> output;
-    while (sqlite3_step(ppstmt) == SQLITE_ROW)
-    {
-      preposition pp;
-      pp.form = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 0)));
-      
-      output.push_back(pp);
-    }
-    
-    return output;
-  }
-
-};
@@ -1,38 +0,0 @@
-#ifndef PREPOSITION_H_FF908021
-#define PREPOSITION_H_FF908021
-
-namespace verbly {
-  
-  class preposition_query;
-  
-  class preposition {
-    public:
-      std::string get_form() const;
-      
-    private:
-      friend class preposition_query;
-      
-      std::string form;
-  };
-  
-  class preposition_query {
-    public:
-      preposition_query(const data& _data);
-      
-      preposition_query& limit(int _limit);
-      preposition_query& random();
-      preposition_query& in_group(std::string _arg);
-      
-      std::list<preposition> run() const;
-    
-      const static int unlimited = -1;
-    private:
-      const data& _data;
-      int _limit = unlimited;
-      bool _random = false;
-      std::list<std::string> _in_group;
-  };
-  
-};
-
-#endif /* end of include guard: PREPOSITION_H_FF908021 */
@@ -0,0 +1,69 @@
+#include "pronunciation.h"
+#include <sqlite3.h>
+#include "form.h"
+#include "lemma.h"
+#include "word.h"
+#include "util.h"
+
+namespace verbly {
+  
+  const object pronunciation::objectType = object::pronunciation;
+  
+  const std::list<std::string> pronunciation::select = {"pronunciation_id", "phonemes", "syllables", "stress", "prerhyme", "rhyme"};
+  
+  const field pronunciation::id = field::integerField(object::pronunciation, "pronunciation_id");
+  const field pronunciation::numOfSyllables = field::integerField(object::pronunciation, "syllables");
+  const field pronunciation::stress = field::stringField(object::pronunciation, "stress");
+  
+  const field pronunciation::form = field::joinThrough(object::pronunciation, "pronunciation_id", object::form, "forms_pronunciations", "form_id");
+  
+  const field pronunciation::prerhyme = field::stringField(object::pronunciation, "prerhyme", true);
+  const field pronunciation::rhyme = field::stringField(object::pronunciation, "rhyme", true);
+  
+  pronunciation::pronunciation(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true)
+  {
+    id_ = sqlite3_column_int(row, 0);
+    
+    std::string phonemesStr(reinterpret_cast<const char*>(sqlite3_column_text(row, 1)));
+    phonemes_ = split<std::vector<std::string>>(phonemesStr, " ");
+    
+    syllables_ = sqlite3_column_int(row, 2);
+    stress_ = std::string(reinterpret_cast<const char*>(sqlite3_column_text(row, 3)));
+    
+    if (sqlite3_column_type(row, 5) != SQLITE_NULL)
+    {
+      hasRhyme_ = true;
+      
+      prerhyme_ = std::string(reinterpret_cast<const char*>(sqlite3_column_text(row, 4)));
+      rhyme_ = std::string(reinterpret_cast<const char*>(sqlite3_column_text(row, 5)));
+    }
+  }
+  
+  filter pronunciation::rhymesWith(const pronunciation& arg)
+  {
+    return (prerhyme != arg.getPrerhyme()) && (rhyme == arg.getRhyme());
+  }
+  
+  /*filter pronunciation::rhymesWith(const class form& arg)
+  {
+    filter result;
+    
+    for (const pronunciation& p : arg.getPronunciations())
+    {
+      result |= rhymesWith(p);
+    }
+    
+    return result;
+  }
+  
+  filter pronunciation::rhymesWith(const lemma& arg)
+  {
+    return rhymesWith(arg.getBaseForm());
+  }
+  
+  filter pronunciation::rhymesWith(const word& arg)
+  {
+    return rhymesWith(arg.getLemma());
+  }*/
+  
+};
@@ -0,0 +1,163 @@
+#ifndef PRONUNCIATION_H_C68F86B0
+#define PRONUNCIATION_H_C68F86B0
+
+#include <stdexcept>
+#include <vector>
+#include <string>
+#include "field.h"
+#include "filter.h"
+
+struct sqlite3_stmt;
+
+namespace verbly {
+  
+  class form;
+  class lemma;
+  class word;
+  class database;
+  
+  class pronunciation {
+  public:
+    
+    // Default constructor
+    
+    pronunciation() = default;
+    
+    // Construct from database
+    
+    pronunciation(const database& db, sqlite3_stmt* row);
+    
+    // Accessors
+    
+    operator bool() const
+    {
+      return valid_;
+    }
+    
+    int getId() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized pronunciation");
+      }
+      
+      return id_;
+    }
+    
+    const std::vector<std::string>& getPhonemes() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized pronunciation");
+      }
+      
+      return phonemes_;
+    }
+    
+    int getSyllables() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized pronunciation");
+      }
+      
+      return syllables_;
+    }
+    
+    std::string getStress() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized pronunciation");
+      }
+      
+      return stress_;
+    }
+    
+    bool hasRhyme() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized pronunciation");
+      }
+      
+      return hasRhyme_;
+    }
+    
+    std::string getPrerhyme() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized pronunciation");
+      }
+      
+      if (!hasRhyme_)
+      {
+        throw std::domain_error("This pronunciation has no rhyme");
+      }
+      
+      return prerhyme_;
+    }
+    
+    std::string getRhyme() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized pronunciation");
+      }
+      
+      if (!hasRhyme_)
+      {
+        throw std::domain_error("This pronunciation has no rhyme");
+      }
+      
+      return rhyme_;
+    }
+    
+    // Type info
+    
+    static const object objectType;
+    
+    static const std::list<std::string> select;
+    
+    // Query fields
+    
+    static const field id;
+    static const field numOfSyllables;
+    static const field stress;
+    
+    operator filter() const
+    {
+      return (id == id_);
+    }
+    
+    static filter rhymesWith(const pronunciation& arg);
+    static filter rhymesWith(const class form& arg);
+    static filter rhymesWith(const lemma& arg);
+    static filter rhymesWith(const word& arg);
+    
+    // Relationships to other objects
+    
+    static const field form;
+    
+  private:
+    bool valid_ = false;
+    
+    int id_;
+    std::vector<std::string> phonemes_;
+    int syllables_;
+    std::string stress_;
+    bool hasRhyme_ = false;
+    std::string prerhyme_;
+    std::string rhyme_;
+    
+    const database* db_;
+    
+    static const field prerhyme;
+    static const field rhyme;
+    
+  };
+  
+};
+
+#endif /* end of include guard: PRONUNCIATION_H_C68F86B0 */
@@ -0,0 +1,123 @@
+#ifndef QUERY_H_7CC5284C
+#define QUERY_H_7CC5284C
+
+#include <vector>
+#include <stdexcept>
+#include <string>
+#include <list>
+#include <sqlite3.h>
+#include <iostream>
+#include "statement.h"
+#include "binding.h"
+
+namespace verbly {
+  
+  class database_error : public std::logic_error {
+  public:
+    
+    database_error(std::string msg, std::string sqlMsg) : std::logic_error(msg + " (" + sqlMsg + ")")
+    {
+    }
+  };
+  
+  template <typename Object>
+  class query {
+  public:
+    
+    query(const database& db, sqlite3* ppdb, filter queryFilter, bool random, int limit) : db_(&db)
+    {
+      statement stmt(Object::objectType, std::move(queryFilter));
+      
+      std::string queryString = stmt.getQueryString(Object::select, random, limit);
+      std::list<binding> bindings = stmt.getBindings();
+      
+      std::cout << queryString << std::endl;
+      
+      if (sqlite3_prepare_v2(ppdb, queryString.c_str(), queryString.length(), &ppstmt_, NULL) != SQLITE_OK)
+      {
+        std::string errorMsg = sqlite3_errmsg(ppdb);
+        sqlite3_finalize(ppstmt_);
+        
+        throw database_error("Error preparing query", errorMsg);
+      }
+      
+      int i = 1;
+      for (const binding& value : bindings)
+      {
+        switch (value.getType())
+        {
+          case binding::type::integer:
+          {
+            if (sqlite3_bind_int(ppstmt_, i, value.getInteger()) != SQLITE_OK)
+            {
+              std::string errorMsg = sqlite3_errmsg(ppdb);
+              sqlite3_finalize(ppstmt_);
+              
+              throw database_error("Error binding value to query", errorMsg);
+            }
+          
+            break;
+          }
+        
+          case binding::type::string:
+          {
+            if (sqlite3_bind_text(ppstmt_, i, value.getString().c_str(), value.getString().length(), SQLITE_TRANSIENT) != SQLITE_OK)
+            {
+              std::string errorMsg = sqlite3_errmsg(ppdb);
+              sqlite3_finalize(ppstmt_);
+              
+              throw database_error("Error binding value to query", errorMsg);
+            }
+          
+            break;
+          }
+          
+          case binding::type::invalid:
+          {
+            throw std::logic_error("Cannot use invalid bindings");
+          }
+        }
+      
+        i++;
+      }
+    }
+    
+    ~query()
+    {
+      sqlite3_finalize(ppstmt_);
+    }
+    
+    std::vector<Object> all() const
+    {
+      std::vector<Object> result;
+      
+      while (sqlite3_step(ppstmt_) == SQLITE_ROW)
+      {
+        result.emplace_back(*db_, ppstmt_);
+      }
+      
+      sqlite3_reset(ppstmt_);
+      
+      return result;
+    }
+
+    Object first() const
+    {
+      std::vector<Object> results = all();
+      if (!results.empty())
+      {
+        return results.front();
+      } else {
+        throw std::logic_error("query returned empty dataset");
+      }
+    }
+    
+  private:
+    const database* db_;
+    sqlite3_stmt* ppstmt_;
+    
+  };
+  
+};
+
+#endif /* end of include guard: QUERY_H_7CC5284C */
@@ -0,0 +1,806 @@
+#include "statement.h"
+#include <sstream>
+#include <utility>
+#include "filter.h"
+#include "util.h"
+#include "notion.h"
+#include "word.h"
+#include "group.h"
+#include "frame.h"
+#include "lemma.h"
+#include "form.h"
+#include "pronunciation.h"
+
+namespace verbly {
+  
+  statement::statement(
+    object context,
+    filter queryFilter) :
+      statement(getTableForContext(context), queryFilter.normalize(context))
+  {
+  }
+  
+  std::string statement::getQueryString(std::list<std::string> select, bool random, int limit) const
+  {
+    std::stringstream queryStream;
+    
+    if (!withs_.empty())
+    {
+      queryStream << "WITH RECURSIVE ";
+    
+      std::list<std::string> ctes;
+      for (const with& cte : withs_)
+      {
+        std::stringstream cteStream;
+        cteStream << cte.getIdentifier();
+        cteStream << " AS (SELECT ";
+        cteStream << cte.getTopTable();
+        cteStream << ".* FROM ";
+        cteStream << cte.getTableForId(cte.getTopTable());
+        cteStream << " AS ";
+        cteStream << cte.getTopTable();
+      
+        for (const join& j : cte.getJoins())
+        {
+          cteStream << " ";
+          cteStream << j;
+        }
+      
+        if (cte.getCondition().getType() != condition::type::empty)
+        {
+          cteStream << " WHERE ";
+          cteStream << cte.getCondition().toSql();
+        }
+        
+        cteStream << " UNION SELECT l.* FROM ";
+        cteStream << cte.getIdentifier();
+        cteStream << " AS t INNER JOIN ";
+        cteStream << cte.getField().getTable();
+        cteStream << " AS j ON t.";
+        cteStream << cte.getField().getColumn();
+        cteStream << " = j.";
+        cteStream << cte.getField().getForeignJoinColumn();
+        cteStream << " INNER JOIN ";
+        cteStream << cte.getTableForId(cte.getTopTable());
+        cteStream << " AS l ON j.";
+        cteStream << cte.getField().getJoinColumn();
+        cteStream << " = l.";
+        cteStream << cte.getField().getColumn();
+        cteStream << ")";
+
+        ctes.push_back(cteStream.str());
+      }
+    
+      queryStream << implode(std::begin(ctes), std::end(ctes), ", ");
+      queryStream << " ";
+    }
+    
+    std::list<std::string> realSelect;
+    for (std::string& s : select)
+    {
+      realSelect.push_back(topTable_ + "." + s);
+    }
+  
+    queryStream << "SELECT ";
+    queryStream << implode(std::begin(realSelect), std::end(realSelect), ", ");
+    queryStream << " FROM ";
+    queryStream << tables_.at(topTable_);
+    queryStream << " AS ";
+    queryStream << topTable_;
+  
+    for (const join& j : joins_)
+    {
+      queryStream << " ";
+      queryStream << j;
+    }
+  
+    if (topCondition_.getType() != condition::type::empty)
+    {
+      queryStream << " WHERE ";
+      queryStream << topCondition_.toSql();
+    }
+    
+    if (random)
+    {
+      queryStream << " ORDER BY RANDOM()";
+    }
+    
+    if (limit > 0)
+    {
+      queryStream << " LIMIT ";
+      queryStream << limit;
+    }
+  
+    return queryStream.str();
+  }
+  
+  std::list<binding> statement::getBindings() const
+  {
+    std::list<binding> result;
+    
+    for (const with& w : withs_)
+    {
+      for (binding value : w.getCondition().flattenBindings())
+      {
+        result.push_back(std::move(value));
+      }
+    }
+    
+    for (binding value : topCondition_.flattenBindings())
+    {
+      result.push_back(std::move(value));
+    }
+    
+    return result;
+  }
+  
+  statement::statement(
+    std::string tableName,
+    filter clause,
+    int nextTableId,
+    int nextWithId) :
+      nextTableId_(nextTableId),
+      nextWithId_(nextWithId),
+      topTable_(instantiateTable(std::move(tableName))),
+      topCondition_(parseFilter(std::move(clause)))
+  {
+  }
+  
+  statement::condition statement::parseFilter(filter clause)
+  {
+    switch (clause.getType())
+    {
+      case filter::type::empty:
+      {
+        return {};
+      }
+    
+      case filter::type::singleton:
+      {
+        switch (clause.getField().getType())
+        {
+          case field::type::undefined:
+          {
+            return {};
+          }
+        
+          case field::type::string:
+          case field::type::integer:
+          case field::type::boolean:
+          {
+            switch (clause.getComparison())
+            {
+              case filter::comparison::is_null:
+              {
+                return condition(topTable_, clause.getField().getColumn(), true);
+              }
+              
+              case filter::comparison::is_not_null:
+              {
+                return condition(topTable_, clause.getField().getColumn(), false);
+              }
+              
+              case filter::comparison::int_equals:
+              {
+                return condition(topTable_, clause.getField().getColumn(), condition::comparison::equals, clause.getIntegerArgument());
+              }
+              
+              case filter::comparison::int_does_not_equal:
+              {
+                return condition(topTable_, clause.getField().getColumn(), condition::comparison::does_not_equal, clause.getIntegerArgument());
+              }
+              
+              case filter::comparison::int_is_at_least:
+              {
+                return condition(topTable_, clause.getField().getColumn(), condition::comparison::is_at_least, clause.getIntegerArgument());
+              }
+              
+              case filter::comparison::int_is_greater_than:
+              {
+                return condition(topTable_, clause.getField().getColumn(), condition::comparison::is_greater_than, clause.getIntegerArgument());
+              }
+              
+              case filter::comparison::int_is_at_most:
+              {
+                return condition(topTable_, clause.getField().getColumn(), condition::comparison::is_at_most, clause.getIntegerArgument());
+              }
+              
+              case filter::comparison::int_is_less_than:
+              {
+                return condition(topTable_, clause.getField().getColumn(), condition::comparison::is_less_than, clause.getIntegerArgument());
+              }
+              
+              case filter::comparison::boolean_equals:
+              {
+                return condition(topTable_, clause.getField().getColumn(), condition::comparison::equals, clause.getBooleanArgument() ? 1 : 0);
+              }
+              
+              case filter::comparison::string_equals:
+              {
+                return condition(topTable_, clause.getField().getColumn(), condition::comparison::equals, clause.getStringArgument());
+              }
+              
+              case filter::comparison::string_does_not_equal:
+              {
+                return condition(topTable_, clause.getField().getColumn(), condition::comparison::does_not_equal, clause.getStringArgument());
+              }
+              
+              case filter::comparison::string_is_like:
+              {
+                return condition(topTable_, clause.getField().getColumn(), condition::comparison::is_like, clause.getStringArgument());
+              }
+              
+              case filter::comparison::string_is_not_like:
+              {
+                return condition(topTable_, clause.getField().getColumn(), condition::comparison::is_not_like, clause.getStringArgument());
+              }
+              
+              case filter::comparison::matches:
+              case filter::comparison::does_not_match:
+              case filter::comparison::hierarchally_matches:
+              case filter::comparison::does_not_hierarchally_match:
+              {
+                throw std::logic_error("Invalid comparison type for field");
+              }
+            }
+          }
+        
+          case field::type::join:
+          {
+            std::string joinTableName;
+            if (clause.getField().hasTable())
+            {
+              joinTableName = clause.getField().getTable();
+            } else {
+              joinTableName = getTableForContext(clause.getField().getJoinObject());
+            }
+
+            statement joinStmt(
+              joinTableName,
+              clause.getJoinCondition().normalize(clause.getField().getJoinObject()),
+              nextTableId_,
+              nextWithId_);
+            
+            std::string joinTable = joinStmt.topTable_;
+            condition curCond = integrate(std::move(joinStmt));
+            
+            bool outer = false;
+            if (clause.getComparison() == filter::comparison::does_not_match)
+            {
+              outer = true;
+              
+              curCond &= condition(joinTable, clause.getField().getColumn(), true);
+            }
+            
+            joins_.emplace_back(outer, joinTableName, topTable_, clause.getField().getColumn(), joinTable, clause.getField().getColumn());
+            
+            return curCond;
+          }
+        
+          case field::type::join_through:
+          {
+            statement joinStmt(
+              getTableForContext(clause.getField().getJoinObject()),
+              clause.getJoinCondition().normalize(clause.getField().getJoinObject()),
+              nextTableId_,
+              nextWithId_);
+              
+            std::string joinTable = joinStmt.topTable_;
+            std::string throughTable = instantiateTable(clause.getField().getTable());
+            condition curCond = integrate(std::move(joinStmt));
+            
+            bool outer = false;
+            if (clause.getComparison() == filter::comparison::does_not_match)
+            {
+              outer = true;
+              
+              curCond &= condition(throughTable, clause.getField().getJoinColumn(), true);
+            }
+            
+            joins_.emplace_back(outer, clause.getField().getTable(), topTable_, clause.getField().getColumn(), throughTable, clause.getField().getJoinColumn());
+            joins_.emplace_back(false, getTableForContext(clause.getField().getJoinObject()), throughTable, clause.getField().getForeignJoinColumn(), joinTable, clause.getField().getForeignColumn());
+            
+            return curCond;
+          }
+        
+          case field::type::hierarchal_join:
+          {
+            std::string withName = std::string(clause.getField().getTable()) + "_tree_" + std::to_string(nextWithId_++);
+            std::string withInstName = instantiateTable(withName);
+            
+            bool outer = false;
+            if (clause.getComparison() == filter::comparison::does_not_hierarchally_match)
+            {
+              outer = true;
+            }
+            
+            joins_.emplace_back(outer, withName, topTable_, clause.getField().getColumn(), withInstName, clause.getField().getColumn());
+            
+            statement withStmt(
+              getTableForContext(clause.getField().getObject()),
+              clause.getJoinCondition().normalize(clause.getField().getObject()),
+              nextTableId_,
+              nextWithId_);
+              
+            for (auto& w : withStmt.withs_)
+            {
+              withs_.push_back(std::move(w));
+            }
+              
+            nextTableId_ = withStmt.nextTableId_;
+            nextWithId_ = withStmt.nextWithId_;
+            
+            withs_.emplace_back(
+              withName,
+              clause.getField(),
+              std::move(withStmt.tables_),
+              std::move(withStmt.topTable_),
+              std::move(withStmt.topCondition_),
+              std::move(withStmt.joins_));
+
+            if (clause.getComparison() == filter::comparison::does_not_hierarchally_match)
+            {
+              return condition(withInstName, clause.getField().getColumn(), true);
+            } else {
+              return {};
+            }
+          }
+        }
+      }
+    
+      case filter::type::group:
+      {
+        condition grp(clause.getOrlogic());
+      
+        for (const filter& child : clause)
+        {
+          condition newChild = parseFilter(child);
+          if (newChild.getType() != condition::type::empty)
+          {
+            grp += std::move(newChild);
+          }
+        }
+        
+        if (grp.getChildren().empty())
+        {
+          grp = {};
+        }
+        
+        return grp;
+      }
+    }
+  }
+  
+  std::string statement::instantiateTable(std::string name)
+  {
+    std::string identifier = name + "_" + std::to_string(nextTableId_++);
+    tables_[identifier] = name;
+    
+    return identifier;
+  }
+  
+  statement::condition statement::integrate(statement subStmt)
+  {
+    for (auto& mapping : subStmt.tables_)
+    {
+      tables_[mapping.first] = mapping.second;
+    }
+        
+    for (auto& j : subStmt.joins_)
+    {
+      joins_.push_back(j);
+    }
+    
+    for (auto& w : subStmt.withs_)
+    {
+      withs_.push_back(w);
+    }
+
+    nextTableId_ = subStmt.nextTableId_;
+    nextWithId_ = subStmt.nextWithId_;
+    
+    return subStmt.topCondition_;
+  }
+  
+  std::ostream& operator<<(std::ostream& oss, const statement::join& j)
+  {
+    if (j.isOuterJoin())
+    {
+      oss << "LEFT";
+    } else {
+      oss << "INNER";
+    }
+    
+    return oss
+      << " JOIN "
+      << j.getForeignTableName()
+      << " AS "
+      << j.getForeignTable()
+      << " ON "
+      << j.getForeignTable()
+      << "."
+      << j.getForeignColumn()
+      << " = "
+      << j.getJoinTable()
+      << "."
+      << j.getJoinColumn();
+  }
+  
+  statement::condition::condition(const condition& other)
+  {
+    type_ = other.type_;
+    
+    switch (type_)
+    {
+      case type::empty:
+      {
+        break;
+      }
+      
+      case type::singleton:
+      {
+        new(&singleton_.table_) std::string(other.singleton_.table_);
+        new(&singleton_.column_) std::string(other.singleton_.column_);
+        singleton_.comparison_ = other.singleton_.comparison_;
+        new(&singleton_.value_) binding(other.singleton_.value_);
+        
+        break;
+      }
+      
+      case type::group:
+      {
+        new(&group_.children_) std::list<condition>(other.group_.children_);
+        group_.orlogic_ = other.group_.orlogic_;
+        
+        break;
+      }
+    }
+  }
+  
+  statement::condition::condition(condition&& other) : condition()
+  {
+    swap(*this, other);
+  }
+  
+  statement::condition& statement::condition::operator=(condition other)
+  {
+    swap(*this, other);
+    
+    return *this;
+  }
+  
+  void swap(statement::condition& first, statement::condition& second)
+  {
+    using type = statement::condition::type;
+    using condition = statement::condition;
+    
+    type tempType = first.type_;
+    std::string tempTable;
+    std::string tempColumn;
+    condition::comparison tempComparison;
+    binding tempBinding;
+    std::list<condition> tempChildren;
+    bool tempOrlogic;
+    
+    switch (tempType)
+    {
+      case type::empty:
+      {
+        break;
+      }
+      
+      case type::singleton:
+      {
+        tempTable = std::move(first.singleton_.table_);
+        tempColumn = std::move(first.singleton_.column_);
+        tempComparison = first.singleton_.comparison_;
+        tempBinding = std::move(first.singleton_.value_);
+        
+        break;
+      }
+      
+      case type::group:
+      {
+        tempChildren = std::move(first.group_.children_);
+        tempOrlogic = first.group_.orlogic_;
+        
+        break;
+      }
+    }
+    
+    first.~condition();
+    
+    first.type_ = second.type_;
+    
+    switch (first.type_)
+    {
+      case type::empty:
+      {
+        break;
+      }
+      
+      case type::singleton:
+      {
+        new(&first.singleton_.table_) std::string(std::move(second.singleton_.table_));
+        new(&first.singleton_.column_) std::string(std::move(second.singleton_.column_));
+        first.singleton_.comparison_ = second.singleton_.comparison_;
+        new(&first.singleton_.value_) binding(std::move(second.singleton_.value_));
+        
+        break;
+      }
+      
+      case type::group:
+      {
+        new(&first.group_.children_) std::list<condition>(std::move(second.group_.children_));
+        first.group_.orlogic_ = second.group_.orlogic_;
+        
+        break;
+      }
+    }
+    
+    second.~condition();
+    
+    second.type_ = tempType;
+    
+    switch (second.type_)
+    {
+      case type::empty:
+      {
+        break;
+      }
+      
+      case type::singleton:
+      {
+        new(&second.singleton_.table_) std::string(std::move(tempTable));
+        new(&second.singleton_.column_) std::string(std::move(tempColumn));
+        second.singleton_.comparison_ = tempComparison;
+        new(&second.singleton_.value_) binding(std::move(tempBinding));
+        
+        break;
+      }
+      
+      case type::group:
+      {
+        new(&second.group_.children_) std::list<condition>(std::move(tempChildren));
+        second.group_.orlogic_ = tempOrlogic;
+        
+        break;
+      }
+    }
+  }
+  
+  statement::condition::~condition()
+  {
+    switch (type_)
+    {
+      case type::empty:
+      {
+        break;
+      }
+      
+      case type::singleton:
+      {
+        using string_type = std::string;
+        
+        singleton_.table_.~string_type();
+        singleton_.column_.~string_type();
+        singleton_.value_.~binding();
+
+        break;
+      }
+      
+      case type::group:
+      {
+        using list_type = std::list<condition>;
+        
+        group_.children_.~list_type();
+        
+        break;
+      }
+    }
+  }
+  
+  statement::condition::condition() : type_(type::empty)
+  {
+  }
+  
+  statement::condition::condition(
+    std::string table,
+    std::string column,
+    bool isNull) :
+      type_(type::singleton)
+  {
+    new(&singleton_.table_) std::string(std::move(table));
+    new(&singleton_.column_) std::string(std::move(column));
+    
+    if (isNull)
+    {
+      singleton_.comparison_ = comparison::is_null;
+    } else {
+      singleton_.comparison_ = comparison::is_not_null;
+    }
+  }
+  
+  statement::condition::condition(
+    std::string table,
+    std::string column,
+    comparison comp,
+    binding value) :
+      type_(type::singleton)
+  {
+    new(&singleton_.table_) std::string(std::move(table));
+    new(&singleton_.column_) std::string(std::move(column));
+    singleton_.comparison_ = comp;
+    new(&singleton_.value_) binding(std::move(value));
+  }
+  
+  std::string statement::condition::toSql() const
+  {
+    switch (type_)
+    {
+      case type::empty:
+      {
+        return "";
+      }
+      
+      case type::singleton:
+      {
+        switch (singleton_.comparison_)
+        {
+          case comparison::equals:
+          {
+            return singleton_.table_ + "." + singleton_.column_ + " = ?";
+          }
+          
+          case comparison::does_not_equal:
+          {
+            return singleton_.table_ + "." + singleton_.column_ + " != ?";
+          }
+          
+          case comparison::is_greater_than:
+          {
+            return singleton_.table_ + "." + singleton_.column_ + " > ?";
+          }
+          
+          case comparison::is_at_most:
+          {
+            return singleton_.table_ + "." + singleton_.column_ + " <= ?";
+          }
+          
+          case comparison::is_less_than:
+          {
+            return singleton_.table_ + "." + singleton_.column_ + " < ?";
+          }
+          
+          case comparison::is_at_least:
+          {
+            return singleton_.table_ + "." + singleton_.column_ + " >= ?";
+          }
+          
+          case comparison::is_like:
+          {
+            return singleton_.table_ + "." + singleton_.column_ + " LIKE ?";
+          }
+          
+          case comparison::is_not_like:
+          {
+            return singleton_.table_ + "." + singleton_.column_ + " NOT LIKE ?";
+          }
+          
+          case comparison::is_not_null:
+          {
+            return singleton_.table_ + "." + singleton_.column_ + " IS NOT NULL";
+          }
+          
+          case comparison::is_null:
+          {
+            return singleton_.table_ + "." + singleton_.column_ + " IS NULL";
+          }
+        }
+      }
+      
+      case type::group:
+      {
+        std::list<std::string> clauses;
+        for (const condition& cond : group_.children_)
+        {
+          clauses.push_back(cond.toSql());
+        }
+        
+        return implode(std::begin(clauses), std::end(clauses), group_.orlogic_ ? " OR " : " AND ");
+      }
+    }
+  }
+  
+  std::list<binding> statement::condition::flattenBindings() const
+  {
+    switch (type_)
+    {
+      case type::empty:
+      {
+        return {};
+      }
+      
+      case type::singleton:
+      {
+        return {singleton_.value_};
+      }
+      
+      case type::group:
+      {
+        std::list<binding> bindings;
+        for (const condition& cond : group_.children_)
+        {
+          for (binding value : cond.flattenBindings())
+          {
+            bindings.push_back(std::move(value));
+          }
+        }
+        
+        return bindings;
+      }
+    }
+  }
+  
+  statement::condition::condition(bool orlogic) : type_(type::group)
+  {
+    new(&group_.children_) std::list<condition>();
+    group_.orlogic_ = orlogic;
+  }
+  
+  statement::condition& statement::condition::operator+=(condition n)
+  {
+    if (type_ == type::group)
+    {
+      group_.children_.push_back(std::move(n));
+      
+      return *this;
+    } else {
+      throw std::domain_error("Cannot add condition to non-group condition");
+    }
+  }
+  
+  statement::condition& statement::condition::operator&=(condition n)
+  {
+    switch (type_)
+    {
+      case type::empty:
+      {
+        *this = std::move(n);
+        
+        break;
+      }
+      
+      case type::singleton:
+      {
+        condition grp(false);
+        grp += *this;
+        grp += std::move(n);
+        
+        *this = grp;
+        
+        break;
+      }
+      
+      case type::group:
+      {
+        *this += std::move(n);
+        
+        break;
+      }
+    }
+    
+    return *this;
+  }
+  
+  const std::list<statement::condition>& statement::condition::getChildren() const
+  {
+    if (type_ == type::group)
+    {
+      return group_.children_;
+    } else {
+      throw std::domain_error("Cannot get children of non-group condition");
+    }
+  }
+  
+};
@@ -0,0 +1,272 @@
+#ifndef STATEMENT_H_29F51659
+#define STATEMENT_H_29F51659
+
+#include <string>
+#include <list>
+#include <map>
+#include <set>
+#include "binding.h"
+#include "enums.h"
+#include "field.h"
+#include "filter.h"
+
+namespace verbly {
+  
+  class filter;
+  
+  class statement {
+  public:
+    
+    statement(object context, filter queryFilter);
+    
+    std::string getQueryString(std::list<std::string> select, bool random, int limit) const;
+    
+    std::list<binding> getBindings() const;
+    
+  private:
+    
+    class join {
+    public:
+      
+      join(
+        bool outer,
+        std::string foreignTableName,
+        std::string joinTable,
+        std::string joinColumn,
+        std::string foreignTable,
+        std::string foreignColumn) :
+          outer_(outer),
+          foreignTableName_(std::move(foreignTableName)),
+          joinTable_(std::move(joinTable)),
+          joinColumn_(std::move(joinColumn)),
+          foreignTable_(std::move(foreignTable)),
+          foreignColumn_(std::move(foreignColumn))
+      {
+      }
+      
+      bool isOuterJoin() const
+      {
+        return outer_;
+      }
+      
+      const std::string& getForeignTableName() const
+      {
+        return foreignTableName_;
+      }
+      
+      const std::string& getJoinTable() const
+      {
+        return joinTable_;
+      }
+      
+      const std::string& getJoinColumn() const
+      {
+        return joinColumn_;
+      }
+      
+      const std::string& getForeignTable() const
+      {
+        return foreignTable_;
+      }
+      
+      const std::string& getForeignColumn() const
+      {
+        return foreignColumn_;
+      }
+      
+    private:
+      bool outer_ = false;
+      std::string foreignTableName_;
+      std::string joinTable_;
+      std::string joinColumn_;
+      std::string foreignTable_;
+      std::string foreignColumn_;
+      
+    };
+    
+    friend std::ostream& operator<<(std::ostream& oss, const join& j);
+    
+    class condition {
+    public:
+      enum class type {
+        empty,
+        singleton,
+        group
+      };
+      
+      enum class comparison {
+        equals,
+        does_not_equal,
+        is_greater_than,
+        is_at_most,
+        is_less_than,
+        is_at_least,
+        is_like,
+        is_not_like,
+        is_not_null,
+        is_null
+      };
+      
+      // Copy and move constructors
+    
+      condition(const condition& other);
+      condition(condition&& other);
+    
+      // Assignment
+    
+      condition& operator=(condition other);
+    
+      // Swap
+    
+      friend void swap(condition& first, condition& second);
+    
+      // Destructor
+    
+      ~condition();
+    
+      // Accessors
+    
+      type getType() const
+      {
+        return type_;
+      }
+      
+      // Empty
+      
+      condition();
+      
+      // Singleton
+      
+      condition(std::string table, std::string column, bool isNull);
+      
+      condition(std::string table, std::string column, comparison comp, binding value);
+      
+      // Group
+      
+      explicit condition(bool orlogic);
+      
+      condition& operator+=(condition n);
+      
+      condition& operator&=(condition n);
+      
+      const std::list<condition>& getChildren() const;
+      
+      // Utility
+      
+      std::string toSql() const;
+      
+      std::list<binding> flattenBindings() const;
+      
+    private:
+      union {
+        struct {
+          std::string table_;
+          std::string column_;
+          comparison comparison_;
+          binding value_;
+        } singleton_;
+        struct {
+          std::list<condition> children_;
+          bool orlogic_;
+        } group_;
+      };
+      type type_;
+    };
+    
+    friend void swap(condition& first, condition& second);
+    
+    class with {
+    public:
+      
+      with(
+        std::string identifier,
+        field f,
+        std::map<std::string, std::string> tables,
+        std::string topTable,
+        condition where,
+        std::list<join> joins) :
+          identifier_(std::move(identifier)),
+          field_(f),
+          tables_(std::move(tables)),
+          topTable_(std::move(topTable)),
+          topCondition_(std::move(where)),
+          joins_(std::move(joins))
+      {
+      }
+      
+      const std::string& getIdentifier() const
+      {
+        return identifier_;
+      }
+      
+      field getField() const
+      {
+        return field_;
+      }
+      
+      std::string getTableForId(std::string identifier) const
+      {
+        return tables_.at(identifier);
+      }
+      
+      const std::string& getTopTable() const
+      {
+        return topTable_;
+      }
+      
+      const condition& getCondition() const
+      {
+        return topCondition_;
+      }
+      
+      const std::list<join>& getJoins() const
+      {
+        return joins_;
+      }
+      
+    private:
+      std::string identifier_;
+      field field_;
+      std::map<std::string, std::string> tables_;
+      std::string topTable_;
+      condition topCondition_;
+      std::list<join> joins_;
+      
+    };
+    
+    static constexpr const char* getTableForContext(object context)
+    {
+      return (context == object::notion) ? "notions"
+        : (context == object::word) ? "words"
+        : (context == object::group) ? "groups"
+        : (context == object::frame) ? "frames"
+        : (context == object::lemma) ? "lemmas_forms"
+        : (context == object::form) ? "forms"
+        : (context == object::pronunciation) ? "pronunciations"
+        : throw std::domain_error("Provided context has no associated table");
+    }
+    
+    static const std::list<field> getSelectForContext(object context);
+    
+    statement(std::string tableName, filter clause, int nextTableId = 0, int nextWithId = 0);
+      
+    condition parseFilter(filter queryFilter);
+    
+    std::string instantiateTable(std::string name);
+    
+    condition integrate(statement subStmt);
+    
+    int nextTableId_;
+    int nextWithId_;
+    
+    std::map<std::string, std::string> tables_;
+    std::string topTable_;
+    std::list<join> joins_;
+    std::list<with> withs_;
+    condition topCondition_;
+
+  };
+  
+};
+
+#endif /* end of include guard: STATEMENT_H_29F51659 */
@@ -1,6 +1,10 @@
 #ifndef UTIL_H_15DDCA2D
 #define UTIL_H_15DDCA2D
 
+#include <string>
+#include <sstream>
+#include <iterator>
+
 namespace verbly {
   
   template <class InputIterator>
@@ -21,25 +25,33 @@ namespace verbly {
     return result.str();
   }
   
-  template <class Container>
-  Container split(std::string input, std::string delimiter)
+  template <class OutputIterator>
+  void split(std::string input, std::string delimiter, OutputIterator out)
   {
-    Container result;
-    
     while (!input.empty())
     {
       int divider = input.find(delimiter);
       if (divider == std::string::npos)
       {
-        result.push_back(input);
+        *out = input;
+        out++;
         
         input = "";
       } else {
-        result.push_back(input.substr(0, divider));
+        *out = input.substr(0, divider);
+        out++;
         
         input = input.substr(divider+delimiter.length());
       }
     }
+  }
+  
+  template <class Container>
+  Container split(std::string input, std::string delimiter)
+  {
+    Container result;
+    
+    split(input, delimiter, std::back_inserter(result));
     
     return result;
   }
@@ -1,64 +0,0 @@
-#include "verbly.h"
-
-namespace verbly {
-  
-  verb::verb()
-  {
-    
-  }
-  
-  verb::verb(const data& _data, int _id) : word(_data, _id)
-  {
-    
-  }
-  
-  std::string verb::base_form() const
-  {
-    assert(_valid == true);
-    
-    return _infinitive;
-  }
-  
-  std::string verb::infinitive_form() const
-  {
-    assert(_valid == true);
-    
-    return _infinitive;
-  }
-  
-  std::string verb::past_tense_form() const
-  {
-    assert(_valid == true);
-    
-    return _past_tense;
-  }
-  
-  std::string verb::past_participle_form() const
-  {
-    assert(_valid == true);
-    
-    return _past_participle;
-  }
-  
-  std::string verb::ing_form() const
-  {
-    assert(_valid == true);
-    
-    return _ing_form;
-  }
-  
-  std::string verb::s_form() const
-  {
-    assert(_valid == true);
-    
-    return _s_form;
-  }
-  
-  frame_query verb::frames() const
-  {
-    assert(_valid == true);
-    
-    return _data->frames().for_verb(*this);
-  }
-    
-};
@@ -1,34 +0,0 @@
-#ifndef VERB_H_BCC929AD
-#define VERB_H_BCC929AD
-
-namespace verbly {
-  
-  class frame_query;
-  
-  class verb : public word {
-    private:
-      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();
-      verb(const data& _data, int _id);
-      
-      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;
-      
-      frame_query frames() const;
-  };
-  
-};
-
-#endif /* end of include guard: VERB_H_BCC929AD */
@@ -1,315 +0,0 @@
-#include "verbly.h"
-
-namespace verbly {
-  
-  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()
-  {
-    this->_random = true;
-  
-    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.get_rhymes())
-    {
-      _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::rhymes_with(rhyme _r)
-  {
-    _rhymes.push_back(_r);
-    
-    return *this;
-  }
-  
-  verb_query& verb_query::has_pronunciation()
-  {
-    this->_has_prn = true;
-    
-    return *this;
-  }
-  
-  verb_query& verb_query::has_rhyming_noun()
-  {
-    _has_rhyming_noun = true;
-    
-    return *this;
-  }
-  
-  verb_query& verb_query::has_rhyming_adjective()
-  {
-    _has_rhyming_adjective = true;
-    
-    return *this;
-  }
-  
-  verb_query& verb_query::has_rhyming_adverb()
-  {
-    _has_rhyming_adverb = true;
-    
-    return *this;
-  }
-  
-  verb_query& verb_query::has_rhyming_verb()
-  {
-    _has_rhyming_verb = true;
-    
-    return *this;
-  }
-  
-  verb_query& verb_query::with_stress(filter<std::vector<bool>> _arg)
-  {
-    _stress = _arg;
-    
-    return *this;
-  }
-  
-  verb_query& verb_query::has_frames()
-  {
-    this->_has_frames = true;
-    
-    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;
-    std::list<binding> bindings;
-    
-    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(), "(prerhyme != ? AND rhyme = ?)");
-      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 rhy : _rhymes)
-      {
-        bindings.emplace_back(rhy.get_prerhyme());
-        bindings.emplace_back(rhy.get_rhyme());
-      }
-    }
-    
-    if (_has_rhyming_noun)
-    {
-      conditions.push_back("verb_id IN (SELECT a.verb_id FROM verbs AS a INNER JOIN verb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN noun_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
-    }
-    
-    if (_has_rhyming_adjective)
-    {
-      conditions.push_back("verb_id IN (SELECT a.verb_id FROM verbs AS a INNER JOIN verb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN adjective_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
-    }
-    
-    if (_has_rhyming_adverb)
-    {
-      conditions.push_back("verb_id IN (SELECT a.verb_id FROM verbs AS a INNER JOIN verb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN adverb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
-    }
-    
-    if (_has_rhyming_verb)
-    {
-      conditions.push_back("verb_id IN (SELECT a.verb_id FROM verbs AS a INNER JOIN verb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN verb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme AND rhmp.verb_id != curp.verb_id)");
-    }
-    
-    if (!_stress.empty())
-    {
-      std::stringstream cond;
-      if (_stress.get_notlogic())
-      {
-        cond << "verb_id NOT IN";
-      } else {
-        cond << "verb_id IN";
-      }
-      
-      cond << "(SELECT verb_id FROM verb_pronunciations WHERE ";
-      
-      std::function<std::string (filter<std::vector<bool>>, bool)> recur = [&] (filter<std::vector<bool>> f, bool notlogic) -> std::string {
-        switch (f.get_type())
-        {
-          case filter<std::vector<bool>>::type::singleton:
-          {
-            std::ostringstream _val;
-            for (auto syl : f.get_elem())
-            {
-              if (syl)
-              {
-                _val << "1";
-              } else {
-                _val << "0";
-              }
-            }
-            
-            bindings.emplace_back(_val.str());
-            
-            if (notlogic == f.get_notlogic())
-            {
-              return "stress = ?";
-            } else {
-              return "stress != ?";
-            }
-          }
-          
-          case filter<std::vector<bool>>::type::group:
-          {
-            bool truelogic = notlogic != f.get_notlogic();
-            
-            std::list<std::string> clauses;
-            std::transform(std::begin(f), std::end(f), std::back_inserter(clauses), [&] (filter<std::vector<bool>> f2) {
-              return recur(f2, truelogic);
-            });
-            
-            if (truelogic == f.get_orlogic())
-            {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " AND ") + ")";
-            } else {
-              return "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
-            }
-          }
-        }
-      };
-      
-      cond << recur(_stress, _stress.get_notlogic());
-      cond << ")";
-      conditions.push_back(cond.str());
-    }
-    
-    for (auto except : _except)
-    {
-      conditions.push_back("verb_id != ?");
-      bindings.emplace_back(except._id);
-    }
-    
-    if (!_has_frames)
-    {
-      conditions.push_back("verb_id IN (SELECT verb_id FROM verb_groups)");
-    }
-    
-    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));
-    }
-    
-    int i = 1;
-    for (auto& binding : bindings)
-    {
-      switch (binding.get_type())
-      {
-        case binding::type::integer:
-        {
-          sqlite3_bind_int(ppstmt, i, binding.get_integer());
-          
-          break;
-        }
-        
-        case binding::type::string:
-        {
-          sqlite3_bind_text(ppstmt, i, binding.get_string().c_str(), binding.get_string().length(), SQLITE_TRANSIENT);
-          
-          break;
-        }
-      }
-      
-      i++;
-    }
-    
-    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, prerhyme, rhyme 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);
-        
-        if ((sqlite3_column_type(ppstmt, 1) != SQLITE_NULL) && (sqlite3_column_type(ppstmt, 2) != SQLITE_NULL))
-        {
-          std::string prerhyme(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
-          std::string rhyming(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 2)));
-          verb.rhymes.emplace_back(prerhyme, rhyming);
-        }
-      }
-      
-      sqlite3_finalize(ppstmt);
-    }
-    
-    return output;
-  }
-
-};
@@ -1,45 +0,0 @@
-#ifndef VERB_QUERY_H_34E5A679
-#define VERB_QUERY_H_34E5A679
-
-namespace verbly {
-
-  class verb_query {
-    public:
-      verb_query(const data& _data);
-      
-      verb_query& limit(int _limit);
-      verb_query& random();
-      verb_query& except(const verb& _word);
-      verb_query& rhymes_with(const word& _word);
-      verb_query& rhymes_with(rhyme _r);
-      verb_query& has_pronunciation();
-      verb_query& has_rhyming_noun();
-      verb_query& has_rhyming_adjective();
-      verb_query& has_rhyming_adverb();
-      verb_query& has_rhyming_verb();
-      verb_query& with_stress(filter<std::vector<bool>> _arg);
-      
-      verb_query& has_frames();
-      
-      std::list<verb> run() const;
-      
-      const static int unlimited = -1;
-      
-    private:
-      const data& _data;
-      int _limit = unlimited;
-      bool _random = false;
-      std::list<rhyme> _rhymes;
-      std::list<verb> _except;
-      bool _has_prn = false;
-      bool _has_frames = false;
-      bool _has_rhyming_noun = false;
-      bool _has_rhyming_adjective = false;
-      bool _has_rhyming_adverb = false;
-      bool _has_rhyming_verb = false;
-      filter<std::vector<bool>> _stress;
-  };
-
-};
-
-#endif /* end of include guard: VERB_QUERY_H_34E5A679 */
@@ -1,35 +1,17 @@
 #ifndef VERBLY_H_5B39CE50
 #define VERBLY_H_5B39CE50
 
-#include <string>
-#include <list>
-#include <sstream>
-#include <algorithm>
-#include <cassert>
-#include <set>
-#include <stdexcept>
-#include <vector>
-#include <map>
-#include <iterator>
-#include <sstream>
-#include <functional>
-#include <iostream>
-#include <new>
-
 #include "util.h"
-#include "data.h"
+#include "database.h"
+#include "filter.h"
+#include "field.h"
+#include "query.h"
+#include "notion.h"
 #include "word.h"
-#include "verb.h"
-#include "adverb.h"
-#include "adjective.h"
-#include "noun.h"
+#include "group.h"
 #include "frame.h"
-#include "preposition.h"
-#include "token.h"
-#include "noun_query.h"
-#include "adverb_query.h"
-#include "adjective_query.h"
-#include "verb_query.h"
-#include "frame_query.h"
+#include "lemma.h"
+#include "form.h"
+#include "pronunciation.h"
 
 #endif /* end of include guard: VERBLY_H_5B39CE50 */
@@ -1,60 +1,112 @@
-#include "verbly.h"
-#include <algorithm>
+#include "word.h"
+#include <sqlite3.h>
+#include "form.h"
+#include "util.h"
+#include "database.h"
+#include "query.h"
 
 namespace verbly {
   
-  rhyme::rhyme(std::string prerhyme, std::string phonemes) : _prerhyme(prerhyme), _rhyme(phonemes)
-  {
-    
-  }
+  const object word::objectType = object::word;
   
-  std::string rhyme::get_prerhyme() const
-  {
-    return _prerhyme;
-  }
+  const std::list<std::string> word::select = {"word_id", "notion_id", "lemma_id", "tag_count", "position", "group_id"};
   
-  std::string rhyme::get_rhyme() const
-  {
-    return _rhyme;
-  }
+  const field word::id = field::integerField(object::word, "word_id");
+  const field word::tagCount = field::integerField(object::word, "tag_count", true);
+  const field word::adjectivePosition = field::integerField(object::word, "position", true);
+  
+  const field word::notion = field::joinField(object::word, "notion_id", object::notion);
+  const field word::lemma = field::joinField(object::word, "lemma_id", object::lemma);
+  const field word::group = field::joinField(object::word, "group_id", object::group, true);
+  
+  const field word::antonyms = field::selfJoin(object::word, "word_id", "antonymy", "antonym_2_id", "antonym_1_id");
+  
+  const field word::specifications = field::selfJoin(object::word, "word_id", "specification", "general_id", "specific_id");
+  const field word::generalizations = field::selfJoin(object::word, "word_id", "specification", "specific_id", "general_id");
   
-  bool rhyme::operator==(const rhyme& other) const
+  const field word::pertainyms = field::selfJoin(object::word, "word_id", "pertainymy", "noun_id", "pertainym_id");
+  const field word::antiPertainyms = field::selfJoin(object::word, "word_id", "pertainymy", "pertainym_id", "noun_id");
+  
+  const field word::mannernyms = field::selfJoin(object::word, "word_id", "mannernymy", "adjective_id", "mannernym_id");
+  const field word::antiMannernyms = field::selfJoin(object::word, "word_id", "mannernymy", "mannernym_id", "adjective_id");
+  
+  const field word::usageTerms = field::selfJoin(object::word, "word_id", "usage", "domain_id", "term_id");
+  const field word::usageDomains = field::selfJoin(object::word, "word_id", "usage", "term_id", "domain_id");
+  
+  const field word::topicalTerms = field::selfJoin(object::word, "word_id", "topicality", "domain_id", "term_id");
+  const field word::topicalDomains = field::selfJoin(object::word, "word_id", "topicality", "term_id", "domain_id");
+  
+  const field word::regionalTerms = field::selfJoin(object::word, "word_id", "regionality", "domain_id", "term_id");
+  const field word::regionalDomains = field::selfJoin(object::word, "word_id", "regionality", "term_id", "domain_id");
+  
+  word::word(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true)
   {
-    return std::tie(_prerhyme, _rhyme) == std::tie(other._prerhyme, other._rhyme);
+    id_ = sqlite3_column_int(row, 0);
+    notionId_ = sqlite3_column_int(row, 1);
+    lemmaId_ = sqlite3_column_int(row, 2);
+    
+    if (sqlite3_column_type(row, 3) != SQLITE_NULL)
+    {
+      hasTagCount_ = true;
+      tagCount_ = sqlite3_column_int(row, 3);
+    }
+    
+    if (sqlite3_column_type(row, 4) != SQLITE_NULL)
+    {
+      adjectivePosition_ = static_cast<positioning>(sqlite3_column_int(row, 4));
+    }
+    
+    if (sqlite3_column_type(row, 5) != SQLITE_NULL)
+    {
+      hasGroup_ = true;
+      groupId_ = sqlite3_column_int(row, 5);
+    }
   }
   
-  word::word()
+  const notion& word::getNotion() const
   {
+    if (!valid_)
+    {
+      throw std::domain_error("Bad access to uninitialized word");
+    }
+    
+    if (!notion_)
+    {
+      notion_ = db_->notions(notion::id == notionId_).first();
+    }
     
+    return notion_;
   }
   
-  word::word(const data& _data, int _id) : _data(&_data), _id(_id), _valid(true)
+  const lemma& word::getLemma() const
   {
+    if (!valid_)
+    {
+      throw std::domain_error("Bad access to uninitialized word");
+    }
     
+    if (!lemma_)
+    {
+      lemma_ = db_->lemmas(lemma::id == lemmaId_).first();
+    }
+    
+    return lemma_;
   }
   
-  std::list<rhyme> word::get_rhymes() const
+  std::string word::getBaseForm() const
   {
-    assert(_valid == true);
-    
-    return rhymes;
+    return getLemma().getBaseForm().getText();
   }
   
-  bool word::starts_with_vowel_sound() const
+  std::list<std::string> word::getInflections(inflection category) const
   {
-    assert(_valid == true);
-    
-    if (pronunciations.size() > 0)
+    std::list<std::string> result;
+    for (const form& infl : getLemma().getInflections(category))
     {
-      return std::any_of(std::begin(pronunciations), std::end(pronunciations), [] (std::list<std::string> phonemes) {
-        return (phonemes.front().find_first_of("012") != std::string::npos);
-      });
-    } else {
-      // If the word is not in CMUDICT, fall back to checking whether the first letter is a vowel
-      // Not perfect but will work in most cases
-      char ch = tolower(base_form().front());
-      return (ch == 'a') || (ch == 'e') || (ch == 'i') || (ch == 'o') || (ch == 'u');
+      result.push_back(infl.getText());
     }
+
+    return result;
   }
   
 };
@@ -1,48 +1,173 @@
-#ifndef WORD_H_8FC89498
-#define WORD_H_8FC89498
+#ifndef WORD_H_DF91B1B4
+#define WORD_H_DF91B1B4
+
+#include <stdexcept>
+#include <map>
+#include "field.h"
+#include "filter.h"
+#include "notion.h"
+#include "lemma.h"
+#include "group.h"
+
+struct sqlite3_stmt;
 
 namespace verbly {
   
-  class rhyme {
-    public:
-      rhyme(std::string prerhyme, std::string phonemes);
+  class database;
+  
+  class word {
+  public:
+    
+    // Default constructor
+    
+    word() = default;
+    
+    // Construct from database
+    
+    word(const database& db, sqlite3_stmt* row);
+    
+    // Accessors
+    
+    operator bool() const
+    {
+      return valid_;
+    }
+    
+    int getId() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized word");
+      }
       
-      std::string get_prerhyme() const;
-      std::string get_rhyme() const;
+      return id_;
+    }
+    
+    bool hasTagCount() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized word");
+      }
       
-      bool operator==(const rhyme& other) const;
+      return hasTagCount_;
+    }
+    
+    int getTagCount() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized word");
+      }
       
-    private:
-      std::string _prerhyme;
-      std::string _rhyme;
-  };
-  
-  class word {
-    protected:
-      const data* _data;
-      int _id;
-      bool _valid = false;
+      if (!hasTagCount_)
+      {
+        throw std::domain_error("Word has no tag count");
+      }
       
-      std::list<std::list<std::string>> pronunciations;
-      std::list<rhyme> rhymes;
+      return tagCount_;
+    }
+    
+    bool hasAdjectivePositioning() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized word");
+      }
       
-      word();
-      word(const data& _data, int _id);
+      return (adjectivePosition_ != positioning::undefined);
+    }
+    
+    positioning getAdjectivePosition() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized word");
+      }
       
-      friend class adjective_query;
-      friend class verb_query;
-      friend class noun_query;
-      friend class adverb_query;
-      friend class frame_query;
-      friend class preposition_query;
-    
-    public:
-      virtual std::string base_form() const = 0;
+      if (adjectivePosition_ == positioning::undefined)
+      {
+        throw std::domain_error("Word has no adjective position");
+      }
       
-      std::list<rhyme> get_rhymes() const;
-      bool starts_with_vowel_sound() const;
+      return adjectivePosition_;
+    }
+    
+    const notion& getNotion() const;
+    
+    const lemma& getLemma() const;
+    
+    // Convenience accessors
+    
+    std::string getBaseForm() const;
+  
+    std::list<std::string> getInflections(inflection infl) const;
+    
+    // Type info
+    
+    static const object objectType;
+    
+    static const std::list<std::string> select;
+    
+    // Query fields
+    
+    static const field id;
+    static const field tagCount;
+    static const field adjectivePosition;
+    
+    operator filter() const
+    {
+      return (id == id_);
+    }
+    
+    // Relationships with other objects
+    
+    static const field notion;
+    static const field lemma;
+    static const field group;
+    
+    // Relationships with self
+    
+    static const field antonyms;
+    
+    static const field specifications;
+    static const field generalizations;
+    
+    static const field pertainyms;
+    static const field antiPertainyms;
+    
+    static const field mannernyms;
+    static const field antiMannernyms;
+    
+    static const field usageTerms;
+    static const field usageDomains;
+    
+    static const field topicalTerms;
+    static const field topicalDomains;
+    
+    static const field regionalTerms;
+    static const field regionalDomains;
+    
+  private:
+    bool valid_ = false;
+    
+    int id_;
+    bool hasTagCount_ = false;
+    int tagCount_;
+    positioning adjectivePosition_ = positioning::undefined;
+    int notionId_;
+    int lemmaId_;
+    bool hasGroup_ = false;
+    int groupId_;
+    
+    const database* db_;
+    
+    mutable class notion notion_;
+    mutable class lemma lemma_;
+    mutable class group group_;
+    
   };
   
 };
 
-#endif /* end of include guard: WORD_H_8FC89498 */
+#endif /* end of include guard: WORD_H_DF91B1B4 */