24 files changed, 644 insertions, 509 deletions

@@ -41,39 +41,71 @@ namespace verbly {
     sqlite3_close_v2(ppdb_);
   }
 
-  query<notion> database::notions(filter where, bool random, int limit) const
+  query<notion> database::notions(filter where, order sortOrder, int limit) const
   {
-    return query<notion>(*this, ppdb_, std::move(where), random, limit);
+    return query<notion>(*this, ppdb_, std::move(where), std::move(sortOrder), limit);
   }
 
-  query<word> database::words(filter where, bool random, int limit) const
+  query<word> database::words(filter where, order sortOrder, int limit) const
   {
-    return query<word>(*this, ppdb_, std::move(where), random, limit);
+    return query<word>(*this, ppdb_, std::move(where), std::move(sortOrder), limit);
   }
 
-  query<group> database::groups(filter where, bool random, int limit) const
+  query<frame> database::frames(filter where, order sortOrder, int limit) const
   {
-    return query<group>(*this, ppdb_, std::move(where), random, limit);
+    return query<frame>(*this, ppdb_, std::move(where), std::move(sortOrder), limit);
   }
 
-  query<frame> database::frames(filter where, bool random, int limit) const
+  query<part> database::parts(filter where, order sortOrder, int limit) const
   {
-    return query<frame>(*this, ppdb_, std::move(where), random, limit);
+    return query<part>(*this, ppdb_, std::move(where), std::move(sortOrder), limit);
   }
 
-  query<lemma> database::lemmas(filter where, bool random, int limit) const
+  query<lemma> database::lemmas(filter where, order sortOrder, int limit) const
   {
-    return query<lemma>(*this, ppdb_, std::move(where), random, limit);
+    return query<lemma>(*this, ppdb_, std::move(where), std::move(sortOrder), limit);
   }
 
-  query<form> database::forms(filter where, bool random, int limit) const
+  query<form> database::forms(filter where, order sortOrder, int limit) const
   {
-    return query<form>(*this, ppdb_, std::move(where), random, limit);
+    return query<form>(*this, ppdb_, std::move(where), std::move(sortOrder), limit);
   }
 
-  query<pronunciation> database::pronunciations(filter where, bool random, int limit) const
+  query<pronunciation> database::pronunciations(filter where, order sortOrder, int limit) const
   {
-    return query<pronunciation>(*this, ppdb_, std::move(where), random, limit);
+    return query<pronunciation>(*this, ppdb_, std::move(where), std::move(sortOrder), limit);
+  }
+
+  std::set<std::string> database::synrestrs(int partId) const
+  {
+    std::string queryString = "SELECT synrestr FROM synrestrs WHERE part_id = ?";
+
+    sqlite3_stmt* ppstmt;
+    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);
+    }
+
+    if (sqlite3_bind_int(ppstmt, 1, partId) != SQLITE_OK)
+    {
+      std::string errorMsg = sqlite3_errmsg(ppdb_);
+      sqlite3_finalize(ppstmt);
+
+      throw database_error("Error binding value to query", errorMsg);
+    }
+
+    std::set<std::string> result;
+    while (sqlite3_step(ppstmt) == SQLITE_ROW)
+    {
+      result.insert(reinterpret_cast<const char*>(sqlite3_column_blob(ppstmt, 0)));
+    }
+
+    sqlite3_finalize(ppstmt);
+
+    return result;
   }
 
 };
@@ -4,13 +4,15 @@
 #include <string>
 #include <exception>
 #include <list>
+#include <set>
 #include "notion.h"
 #include "word.h"
-#include "group.h"
 #include "frame.h"
+#include "part.h"
 #include "lemma.h"
 #include "form.h"
 #include "pronunciation.h"
+#include "order.h"
 
 struct sqlite3;
 
@@ -46,19 +48,21 @@ namespace verbly {
 
     // Queries
 
-    query<notion> notions(filter where, bool random = true, int limit = 1) const;
+    query<notion> notions(filter where, order sortOrder = {}, int limit = 1) const;
 
-    query<word> words(filter where, bool random = true, int limit = 1) const;
+    query<word> words(filter where, order sortOrder = {}, int limit = 1) const;
 
-    query<group> groups(filter where, bool random = true, int limit = 1) const;
+    query<frame> frames(filter where, order sortOrder = {}, int limit = 1) const;
 
-    query<frame> frames(filter where, bool random = true, int limit = 1) const;
+    query<part> parts(filter where, order sortOrder = {}, int limit = 1) const;
 
-    query<lemma> lemmas(filter where, bool random = true, int limit = 1) const;
+    query<lemma> lemmas(filter where, order sortOrder = {}, int limit = 1) const;
 
-    query<form> forms(filter where, bool random = true, int limit = 1) const;
+    query<form> forms(filter where, order sortOrder = {}, int limit = 1) const;
 
-    query<pronunciation> pronunciations(filter where, bool random = true, int limit = 1) const;
+    query<pronunciation> pronunciations(filter where, order sortOrder = {}, int limit = 1) const;
+
+    std::set<std::string> synrestrs(int partId) const;
 
   private:
 
@@ -33,13 +33,23 @@ namespace verbly {
     undefined = -1,
     notion = 0,
     word = 1,
-    group = 2,
-    frame = 3,
+    frame = 2,
+    part = 3,
     lemma = 4,
     form = 5,
     pronunciation = 6
   };
 
+  enum class part_type {
+    invalid = -1,
+    noun_phrase = 0,
+    verb = 1,
+    preposition = 2,
+    adjective = 3,
+    adverb = 4,
+    literal = 5
+  };
+
 };
 
 #endif /* end of include guard: ENUMS_H_260BA847 */
@@ -48,6 +48,11 @@ namespace verbly {
     return filter(*this, filter::comparison::int_equals, static_cast<int>(value));
   }
 
+  filter field::operator==(part_type 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);
@@ -68,6 +73,21 @@ namespace verbly {
     return filter(*this, filter::comparison::string_is_like, std::move(value));
   }
 
+  filter field::operator==(const char* value) const
+  {
+    return filter(*this, filter::comparison::string_equals, std::string(value));
+  }
+
+  filter field::operator!=(const char* value) const
+  {
+    return filter(*this, filter::comparison::string_does_not_equal, std::string(value));
+  }
+
+  filter field::operator%=(const char* value) const
+  {
+    return filter(*this, filter::comparison::string_is_like, std::string(value));
+  }
+
   field::operator filter() const
   {
     if (isJoin())
@@ -17,6 +17,7 @@ namespace verbly {
       integer,
       boolean,
       join,
+      join_where,
       join_through,
       hierarchal_join
     };
@@ -95,6 +96,17 @@ namespace verbly {
       return field(obj, type::join, name, nullable, table);
     }
 
+    static field joinWhere(
+      object obj,
+      const char* name,
+      object joinWith,
+      const field& conditionField,
+      int conditionValue,
+      bool nullable = false)
+    {
+      return field(obj, type::join_where, name, nullable, 0, joinWith, 0, 0, 0, &conditionField, conditionValue);
+    }
+
     static field joinThrough(
       object obj,
       const char* name,
@@ -151,7 +163,10 @@ namespace verbly {
 
     bool isJoin() const
     {
-      return ((type_ == type::join) || (type_ == type::join_through) || (type_ == type::hierarchal_join));
+      return ((type_ == type::join)
+        || (type_ == type::join_where)
+        || (type_ == type::join_through)
+        || (type_ == type::hierarchal_join));
     }
 
     const char* getColumn() const
@@ -180,7 +195,7 @@ namespace verbly {
     {
       return (type_ == type::hierarchal_join)
         ? object_
-        : ((type_ == type::join) || (type_ == type::join_through))
+        : ((type_ == type::join) || (type_ == type::join_where) || (type_ == type::join_through))
         ? joinObject_
         : throw std::domain_error("Non-join fields don't have join objects");
     }
@@ -209,6 +224,22 @@ namespace verbly {
         : throw std::domain_error("Only many-to-many join fields have a foreign join column");
     }
 
+    // Condition joins
+
+    const field& getConditionField() const
+    {
+      return (type_ == type::join_where)
+        ? *conditionField_
+        : throw std::domain_error("Only condition join fields have a condition field");
+    }
+
+    int getConditionValue() const
+    {
+      return (type_ == type::join_where)
+        ? conditionValue_
+        : throw std::domain_error("Only condition join fields have a condition value");
+    }
+
     // Ordering
 
     bool operator<(const field& other) const
@@ -217,20 +248,30 @@ namespace verbly {
       // 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_);
+      // table (hypernymy); however, they have different join columns. For
+      // condition joins, the condition field and condition value are also
+      // significant.
+      if (conditionField_)
+      {
+        return std::tie(object_, column_, table_, joinColumn_, *conditionField_, conditionValue_)
+          < std::tie(other.object_, other.column_, other.table_, other.joinColumn_, *other.conditionField_, other.conditionValue_);
+      } else {
+        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_);
+      // See operator<() for documentation.
+      if (conditionField_)
+      {
+        return std::tie(object_, column_, table_, joinColumn_, *conditionField_, conditionValue_)
+          == std::tie(other.object_, other.column_, other.table_, other.joinColumn_, *other.conditionField_, other.conditionValue_);
+      } else {
+        return std::tie(object_, column_, table_, joinColumn_) == std::tie(other.object_, other.column_, other.table_, other.joinColumn_);
+      }
     }
 
     // Filter construction
@@ -245,6 +286,7 @@ namespace verbly {
     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==(part_type value) const; // Verb frame part type equality
 
     filter operator==(bool value) const; // Boolean equality
 
@@ -252,6 +294,10 @@ namespace verbly {
     filter operator!=(std::string value) const; // String inequality
     filter operator%=(std::string value) const; // String matching
 
+    filter operator==(const char* value) const; // String equality
+    filter operator!=(const char* value) const; // String inequality
+    filter operator%=(const char* value) const; // String matching
+
     operator filter() const; // Non-nullity
     filter operator!() const; // Nullity
 
@@ -270,7 +316,9 @@ namespace verbly {
       object joinObject = object::undefined,
       const char* foreignColumn = 0,
       const char* joinColumn = 0,
-      const char* foreignJoinColumn = 0) :
+      const char* foreignJoinColumn = 0,
+      const field* conditionField = 0,
+      int conditionValue = 0) :
         object_(obj),
         type_(datatype),
         column_(column),
@@ -279,7 +327,9 @@ namespace verbly {
         joinObject_(joinObject),
         foreignColumn_(foreignColumn),
         joinColumn_(joinColumn),
-        foreignJoinColumn_(foreignJoinColumn)
+        foreignJoinColumn_(foreignJoinColumn),
+        conditionField_(conditionField),
+        conditionValue_(conditionValue)
     {
     }
 
@@ -300,6 +350,10 @@ namespace verbly {
     const char* joinColumn_ = 0;
     const char* foreignJoinColumn_ = 0;
 
+    // Condition joins
+    const field* conditionField_ = 0;
+    int conditionValue_ = 0;
+
   };
 
 };
@@ -3,8 +3,8 @@
 #include <map>
 #include "notion.h"
 #include "word.h"
-#include "group.h"
 #include "frame.h"
+#include "part.h"
 #include "lemma.h"
 #include "form.h"
 #include "pronunciation.h"
@@ -594,6 +594,7 @@ namespace verbly {
     switch (joinOn.getType())
     {
       case field::type::join:
+      case field::type::join_where:
       case field::type::join_through:
       {
         switch (filterType)
@@ -1108,8 +1109,8 @@ namespace verbly {
                 }
 
                 case object::word:
-                case object::group:
                 case object::frame:
+                case object::part:
                 case object::lemma:
                 case object::form:
                 case object::pronunciation:
@@ -1134,10 +1135,10 @@ namespace verbly {
                   return *this;
                 }
 
-                case object::group:
                 case object::frame:
+                case object::part:
                 {
-                  return (verbly::word::group %= *this);
+                  return (verbly::word::frame %= *this);
                 }
 
                 case object::lemma:
@@ -1148,12 +1149,12 @@ namespace verbly {
                 }
               }
 
-              case object::group:
+              case object::frame:
               {
                 switch (singleton_.filterField.getObject())
                 {
                   case object::undefined:
-                  case object::group:
+                  case object::frame:
                   {
                     return *this;
                   }
@@ -1164,34 +1165,34 @@ namespace verbly {
                   case object::form:
                   case object::pronunciation:
                   {
-                    return (verbly::group::word %= *this);
+                    return (verbly::frame::word %= *this);
                   }
 
-                  case object::frame:
+                  case object::part:
                   {
-                    return (verbly::group::frame %= *this);
+                    return (verbly::frame::part() %= *this);
                   }
                 }
               }
 
-              case object::frame:
+              case object::part:
               {
                 switch (singleton_.filterField.getObject())
                 {
                   case object::undefined:
-                  case object::frame:
+                  case object::part:
                   {
                     return *this;
                   }
 
                   case object::notion:
                   case object::word:
-                  case object::group:
+                  case object::frame:
                   case object::lemma:
                   case object::form:
                   case object::pronunciation:
                   {
-                    return (verbly::frame::group %= *this);
+                    return (verbly::part::frame %= *this);
                   }
                 }
               }
@@ -1202,8 +1203,8 @@ namespace verbly {
                 {
                   case object::notion:
                   case object::word:
-                  case object::group:
                   case object::frame:
+                  case object::part:
                   {
                     return verbly::lemma::word %= *this;
                   }
@@ -1228,11 +1229,11 @@ namespace verbly {
                 {
                   case object::notion:
                   case object::word:
-                  case object::group:
                   case object::frame:
+                  case object::part:
                   case object::lemma:
                   {
-                    return verbly::form::lemma(inflection::base) %= *this;
+                    return verbly::form::lemma %= *this;
                   }
 
                   case object::undefined:
@@ -1254,8 +1255,8 @@ namespace verbly {
                 {
                   case object::notion:
                   case object::word:
-                  case object::group:
                   case object::frame:
+                  case object::part:
                   case object::lemma:
                   case object::form:
                   {
@@ -16,11 +16,9 @@ namespace verbly {
   const field form::complexity = field::integerField(object::form, "complexity");
   const field form::proper = field::booleanField(object::form, "proper");
 
+  const field form::lemma = field::joinField(object::form, "form_id", object::lemma);
   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);
@@ -29,16 +27,6 @@ namespace verbly {
     proper_ = (sqlite3_column_int(row, 3) == 1);
   }
 
-  filter operator%=(form::inflection_field check, filter joinCondition)
-  {
-    return (form::lemmaJoin %= (joinCondition && (form::inflectionCategory == check.getCategory())));
-  }
-
-  form::inflection_field::operator filter() const
-  {
-    return (form::lemmaJoin %= (form::inflectionCategory == category_));
-  }
-
   const std::vector<pronunciation>& form::getPronunciations() const
   {
     if (!valid_)
@@ -48,7 +36,7 @@ namespace verbly {
 
     if (!initializedPronunciations_)
     {
-      pronunciations_ = db_->pronunciations(pronunciation::form %= *this, false, -1).all();
+      pronunciations_ = db_->pronunciations(pronunciation::form %= *this, verbly::pronunciation::id, -1).all();
       initializedPronunciations_ = true;
     }
 
@@ -104,33 +104,9 @@ namespace verbly {
 
     // Relationships to other objects
 
-    static const field pronunciation;
-
-    class inflection_field {
-    public:
-
-      inflection_field(inflection category) : category_(category)
-      {
-      }
-
-      const inflection getCategory() const
-      {
-        return category_;
-      }
+    static const field lemma;
 
-      operator filter() const;
-
-    private:
-
-      const inflection category_;
-    };
-
-    static const inflection_field lemma(inflection category)
-    {
-      return inflection_field(category);
-    }
-
-    friend filter operator%=(form::inflection_field check, filter joinCondition);
+    static const field pronunciation;
 
   private:
     bool valid_ = false;
@@ -145,9 +121,6 @@ namespace verbly {
     mutable bool initializedPronunciations_ = false;
     mutable std::vector<class pronunciation> pronunciations_;
 
-    static const field lemmaJoin;
-    static const field inflectionCategory;
-
   };
 
 };
@@ -1,95 +1,36 @@
 #include "frame.h"
 #include <sqlite3.h>
-#include <json.hpp>
+#include "database.h"
+#include "query.h"
 
 namespace verbly {
 
   const object frame::objectType = object::frame;
 
-  const std::list<std::string> frame::select = {"frame_id", "data"};
+  const std::list<std::string> frame::select = {"frame_id", "group_id", "length"};
 
   const field frame::id = field::integerField(object::frame, "frame_id");
+  const field frame::length = field::integerField(object::frame, "length");
 
-  const field frame::group = field::joinThrough(object::frame, "frame_id", object::group, "groups_frames", "group_id");
+  const field frame::word = field::joinField(object::frame, "group_id", object::word);
 
-  frame::frame(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true)
+  field frame::part()
   {
-    id_ = sqlite3_column_int(row, 0);
-
-    std::string partsJsonStr(reinterpret_cast<const char*>(sqlite3_column_blob(row, 1)));
-    nlohmann::json partsJson = nlohmann::json::parse(std::move(partsJsonStr));
-
-    for (const nlohmann::json& partJson : partsJson)
-    {
-      part::type partType = static_cast<part::type>(partJson["type"].get<int>());
-
-      switch (partType)
-      {
-        case part::type::noun_phrase:
-        {
-          std::set<std::string> synrestrs;
-          for (const nlohmann::json& synrestrJson : partJson["synrestrs"])
-          {
-            synrestrs.insert(synrestrJson.get<std::string>());
-          }
-
-          parts_.push_back(part::createNounPhrase(
-            partJson["role"].get<std::string>(),
-            selrestr(partJson["selrestrs"]),
-            std::move(synrestrs)));
-
-          break;
-        }
-
-        case part::type::preposition:
-        {
-          std::vector<std::string> choices;
-          for (const nlohmann::json& choiceJson : partJson["choices"])
-          {
-            choices.push_back(choiceJson.get<std::string>());
-          }
-
-          parts_.push_back(part::createPreposition(
-            std::move(choices),
-            partJson["literal"].get<bool>()));
-
-          break;
-        }
-
-        case part::type::verb:
-        {
-          parts_.push_back(part::createVerb());
-
-          break;
-        }
-
-        case part::type::adjective:
-        {
-          parts_.push_back(part::createAdjective());
-
-          break;
-        }
-
-        case part::type::adverb:
-        {
-          parts_.push_back(part::createAdverb());
-
-          break;
-        }
+    return field::joinField(object::frame, "frame_id", object::part);
+  }
 
-        case part::type::literal:
-        {
-          parts_.push_back(part::createLiteral(partJson["value"].get<std::string>()));
+  field frame::part(int index)
+  {
+    return field::joinWhere(object::frame, "frame_id", object::part, part::index, index);
+  }
 
-          break;
-        }
+  frame::frame(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true)
+  {
+    id_ = sqlite3_column_int(row, 0);
+    groupId_ = sqlite3_column_int(row, 1);
+    length_ = sqlite3_column_int(row, 2);
 
-        case part::type::invalid:
-        {
-          throw std::domain_error("Invalid part data");
-        }
-      }
-    }
+    parts_ = db.parts(*this, verbly::part::index, -1).all();
   }
 
 };
@@ -41,6 +41,16 @@ namespace verbly {
       return id_;
     }
 
+    int getLength() const
+    {
+      if (!valid_)
+      {
+        throw std::domain_error("Bad access to uninitialized frame");
+      }
+
+      return length_;
+    }
+
     const std::vector<part>& getParts() const
     {
       if (!valid_)
@@ -61,6 +71,8 @@ namespace verbly {
 
     static const field id;
 
+    static const field length;
+
     operator filter() const
     {
       if (!valid_)
@@ -73,13 +85,18 @@ namespace verbly {
 
     // Relationships to other objects
 
-    static const field group;
+    static const field word;
+
+    static field part();
+    static field part(int index);
 
   private:
     bool valid_ = false;
 
     int id_;
-    std::vector<part> parts_;
+    int groupId_;
+    int length_;
+    std::vector<class part> parts_;
 
     const database* db_;
 
@@ -1,61 +0,0 @@
-#include "group.h"
-#include <sqlite3.h>
-#include <json.hpp>
-#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);
-
-    std::string rolesJsonStr(reinterpret_cast<const char*>(sqlite3_column_blob(row, 1)));
-    nlohmann::json rolesJson = nlohmann::json::parse(std::move(rolesJsonStr));
-    for (const nlohmann::json& roleJson : rolesJson)
-    {
-      std::string roleName = roleJson["type"];
-      selrestr roleSelrestr;
-
-      if (roleJson.find("selrestrs") != roleJson.end())
-      {
-        roleSelrestr = selrestr(roleJson["selrestrs"]);
-      }
-
-      roles_[roleName] = role(roleName, std::move(roleSelrestr));
-    }
-  }
-
-  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_;
-  }
-
-  const role& group::getRole(std::string roleName) const
-  {
-    return roles_.at(roleName);
-  }
-
-};
-
@@ -1,91 +0,0 @@
-#ifndef GROUP_H_BD6933C0
-#define GROUP_H_BD6933C0
-
-#include <stdexcept>
-#include <list>
-#include <vector>
-#include "field.h"
-#include "filter.h"
-#include "frame.h"
-#include "role.h"
-
-struct sqlite3_stmt;
-
-namespace verbly {
-
-  class database;
-
-  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;
-
-    const role& getRole(std::string roleName) 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_;
-    std::map<std::string, role> roles_;
-
-    const database* db_;
-
-    mutable bool initializedFrames_ = false;
-    mutable std::vector<class frame> frames_;
-
-  };
-
-};
-
-#endif /* end of include guard: GROUP_H_BD6933C0 */
@@ -10,20 +10,13 @@ namespace verbly {
   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());
-  }
+  const field lemma::word = field::joinField(object::lemma, "lemma_id", object::word);
 
-  lemma::inflection_field::operator filter() const
+  field lemma::form(inflection category)
   {
-    return (lemma::inflectionCategory == category_);
+    return field::joinWhere(object::lemma, "form_id", object::form, inflectionCategory, static_cast<int>(category));
   }
 
   lemma::lemma(const database& db, sqlite3_stmt* row) : db_(&db), valid_(true)
@@ -68,7 +61,7 @@ namespace verbly {
 
   void lemma::initializeForm(inflection infl) const
   {
-    forms_[infl] = db_->forms(form::lemma(infl) %= *this, false, -1).all();
+    forms_[infl] = db_->forms(form::lemma %= ((inflectionCategory == infl) && *this), verbly::form::id, -1).all();
   }
 
 };
@@ -74,31 +74,7 @@ namespace verbly {
 
     static const field word;
 
-    class inflection_field {
-    public:
-
-      inflection_field(inflection category) : category_(category)
-      {
-      }
-
-      const inflection getCategory() const
-      {
-        return category_;
-      }
-
-      operator filter() const;
-
-    private:
-
-      const inflection category_;
-    };
-
-    static const inflection_field form(inflection category)
-    {
-      return inflection_field(category);
-    }
-
-    friend filter operator%=(lemma::inflection_field check, filter joinCondition);
+    static field form(inflection category);
 
   private:
 
@@ -112,7 +88,6 @@ namespace verbly {
 
     const database* db_;
 
-    static const field formJoin;
     static const field inflectionCategory;
 
   };
@@ -0,0 +1,69 @@
+#ifndef ORDER_H_0EC669D5
+#define ORDER_H_0EC669D5
+
+#include <stdexcept>
+#include "field.h"
+
+namespace verbly {
+
+  class order {
+  public:
+    enum class type {
+      random,
+      field
+    };
+
+    // Type
+
+    type getType() const
+    {
+      return type_;
+    }
+
+    // Random
+
+    order() : type_(type::random)
+    {
+    }
+
+    // Field
+
+    order(
+      field arg,
+      bool asc = true) :
+        type_(type::field),
+        sortField_(std::move(arg)),
+        ascending_(asc)
+    {
+    }
+
+    field getSortField() const
+    {
+      if (type_ != type::field)
+      {
+        throw std::domain_error("Invalid access to non-field order");
+      }
+
+      return sortField_;
+    }
+
+    bool isAscending() const
+    {
+      if (type_ != type::field)
+      {
+        throw std::domain_error("Invalid access to non-field order");
+      }
+
+      return ascending_;
+    }
+
+  private:
+    type type_;
+    field sortField_;
+    bool ascending_;
+
+  };
+
+};
+
+#endif /* end of include guard: ORDER_H_0EC669D5 */
@@ -1,12 +1,30 @@
 #include "part.h"
 #include <stdexcept>
+#include <sqlite3.h>
 #include "selrestr.h"
+#include "database.h"
 
 namespace verbly {
 
+  const object part::objectType = object::part;
+
+  const std::list<std::string> part::select = {"part_id", "frame_id", "part_index", "type", "role", "selrestrs", "prepositions", "preposition_literality", "literal_value"};
+
+  const field part::index = field::integerField(object::part, "part_index");
+  const field part::type = field::integerField(object::part, "type");
+
+  const field part::role = field::stringField(object::part, "role", true);
+
+  const field part::frame = field::joinField(object::part, "frame_id", object::frame);
+
+  const field part::synrestr_field::synrestrJoin = field::joinField(object::part, "part_id", "synrestrs");
+  const field part::synrestr_field::synrestrField = field::stringField("synrestrs", "synrestr");
+
+  const part::synrestr_field part::synrestr = {};
+
   part part::createNounPhrase(std::string role, selrestr selrestrs, std::set<std::string> synrestrs)
   {
-    part p(type::noun_phrase);
+    part p(part_type::noun_phrase);
 
     new(&p.noun_phrase_.role) std::string(std::move(role));
     new(&p.noun_phrase_.selrestrs) selrestr(std::move(selrestrs));
@@ -17,12 +35,12 @@ namespace verbly {
 
   part part::createVerb()
   {
-    return part(type::verb);
+    return part(part_type::verb);
   }
 
   part part::createPreposition(std::vector<std::string> choices, bool literal)
   {
-    part p(type::preposition);
+    part p(part_type::preposition);
 
     new(&p.preposition_.choices) std::vector<std::string>(std::move(choices));
     p.preposition_.literal = literal;
@@ -32,30 +50,79 @@ namespace verbly {
 
   part part::createAdjective()
   {
-    return part(type::adjective);
+    return part(part_type::adjective);
   }
 
   part part::createAdverb()
   {
-    return part(type::adverb);
+    return part(part_type::adverb);
   }
 
   part part::createLiteral(std::string value)
   {
-    part p(type::literal);
+    part p(part_type::literal);
 
     new(&p.literal_) std::string(std::move(value));
 
     return p;
   }
 
+  part::part(const database& db, sqlite3_stmt* row)
+  {
+    int id = sqlite3_column_int(row, 0);
+
+    type_ = static_cast<part_type>(sqlite3_column_int(row, 3));
+
+    switch (type_)
+    {
+      case part_type::noun_phrase:
+      {
+        new(&noun_phrase_.role) std::string(reinterpret_cast<const char*>(sqlite3_column_blob(row, 4)));
+        new(&noun_phrase_.selrestrs) selrestr(nlohmann::json::parse(reinterpret_cast<const char*>(sqlite3_column_blob(row, 5))));
+        new(&noun_phrase_.synrestrs) std::set<std::string>(db.synrestrs(id));
+
+        break;
+      }
+
+      case part_type::preposition:
+      {
+        new(&preposition_.choices) std::vector<std::string>();
+        preposition_.literal = (sqlite3_column_int(row, 7) == 1);
+
+        std::string choicesJsonStr(reinterpret_cast<const char*>(sqlite3_column_blob(row, 6)));
+        nlohmann::json choicesJson = nlohmann::json::parse(std::move(choicesJsonStr));
+        for (const nlohmann::json& choiceJson : choicesJson)
+        {
+          preposition_.choices.push_back(choiceJson.get<std::string>());
+        }
+
+        break;
+      }
+
+      case part_type::literal:
+      {
+        new(&literal_) std::string(reinterpret_cast<const char*>(sqlite3_column_blob(row, 8)));
+
+        break;
+      }
+
+      case part_type::verb:
+      case part_type::adjective:
+      case part_type::adverb:
+      case part_type::invalid:
+      {
+        break;
+      }
+    }
+  }
+
   part::part(const part& other)
   {
     type_ = other.type_;
 
     switch (type_)
     {
-      case type::noun_phrase:
+      case part_type::noun_phrase:
       {
         new(&noun_phrase_.role) std::string(other.noun_phrase_.role);
         new(&noun_phrase_.selrestrs) selrestr(other.noun_phrase_.selrestrs);
@@ -64,7 +131,7 @@ namespace verbly {
         break;
       }
 
-      case type::preposition:
+      case part_type::preposition:
       {
         new(&preposition_.choices) std::vector<std::string>(other.preposition_.choices);
         preposition_.literal = other.preposition_.literal;
@@ -72,17 +139,17 @@ namespace verbly {
         break;
       }
 
-      case type::literal:
+      case part_type::literal:
       {
         new(&literal_) std::string(other.literal_);
 
         break;
       }
 
-      case type::verb:
-      case type::adjective:
-      case type::adverb:
-      case type::invalid:
+      case part_type::verb:
+      case part_type::adjective:
+      case part_type::adverb:
+      case part_type::invalid:
       {
         break;
       }
@@ -103,7 +170,7 @@ namespace verbly {
 
   void swap(part& first, part& second)
   {
-    using type = part::type;
+    using type = part_type;
 
     type tempType = first.type_;
     std::string tempRole;
@@ -231,7 +298,7 @@ namespace verbly {
   {
     switch (type_)
     {
-      case type::noun_phrase:
+      case part_type::noun_phrase:
       {
         using string_type = std::string;
         using set_type = std::set<std::string>;
@@ -243,7 +310,7 @@ namespace verbly {
         break;
       }
 
-      case type::preposition:
+      case part_type::preposition:
       {
         using vector_type = std::vector<std::string>;
 
@@ -252,7 +319,7 @@ namespace verbly {
         break;
       }
 
-      case type::literal:
+      case part_type::literal:
       {
         using string_type = std::string;
 
@@ -261,10 +328,10 @@ namespace verbly {
         break;
       }
 
-      case type::verb:
-      case type::adjective:
-      case type::adverb:
-      case type::invalid:
+      case part_type::verb:
+      case part_type::adjective:
+      case part_type::adverb:
+      case part_type::invalid:
       {
         break;
       }
@@ -273,7 +340,7 @@ namespace verbly {
 
   std::string part::getNounRole() const
   {
-    if (type_ == type::noun_phrase)
+    if (type_ == part_type::noun_phrase)
     {
       return noun_phrase_.role;
     } else {
@@ -283,7 +350,7 @@ namespace verbly {
 
   selrestr part::getNounSelrestrs() const
   {
-    if (type_ == type::noun_phrase)
+    if (type_ == part_type::noun_phrase)
     {
       return noun_phrase_.selrestrs;
     } else {
@@ -293,7 +360,7 @@ namespace verbly {
 
   std::set<std::string> part::getNounSynrestrs() const
   {
-    if (type_ == type::noun_phrase)
+    if (type_ == part_type::noun_phrase)
     {
       return noun_phrase_.synrestrs;
     } else {
@@ -303,7 +370,7 @@ namespace verbly {
 
   bool part::nounHasSynrestr(std::string synrestr) const
   {
-    if (type_ != type::noun_phrase)
+    if (type_ != part_type::noun_phrase)
     {
       throw std::domain_error("part::nounHasSynrestr is only valid for noun phrase parts");
     }
@@ -313,7 +380,7 @@ namespace verbly {
 
   std::vector<std::string> part::getPrepositionChoices() const
   {
-    if (type_ == type::preposition)
+    if (type_ == part_type::preposition)
     {
       return preposition_.choices;
     } else {
@@ -323,7 +390,7 @@ namespace verbly {
 
   bool part::isPrepositionLiteral() const
   {
-    if (type_ == type::preposition)
+    if (type_ == part_type::preposition)
     {
       return preposition_.literal;
     } else {
@@ -333,7 +400,7 @@ namespace verbly {
 
   std::string part::getLiteralValue() const
   {
-    if (type_ == type::literal)
+    if (type_ == part_type::literal)
     {
       return literal_;
     } else {
@@ -341,4 +408,9 @@ namespace verbly {
     }
   }
 
+  filter part::synrestr_field::operator%=(std::string synrestr) const
+  {
+    return (synrestrJoin %= (synrestrField == synrestr));
+  }
+
 };
@@ -4,21 +4,20 @@
 #include <string>
 #include <vector>
 #include <set>
+#include <list>
 #include "selrestr.h"
+#include "field.h"
+#include "filter.h"
+#include "enums.h"
+
+struct sqlite3_stmt;
 
 namespace verbly {
 
+  class database;
+
   class part {
   public:
-    enum class type {
-      invalid = -1,
-      noun_phrase = 0,
-      verb = 1,
-      preposition = 2,
-      adjective = 3,
-      adverb = 4,
-      literal = 5
-    };
 
     // Static factories
 
@@ -40,6 +39,10 @@ namespace verbly {
     {
     }
 
+    // Construct from database
+
+    part(const database& db, sqlite3_stmt* row);
+
     // Copy and move constructors
 
     part(const part& other);
@@ -60,7 +63,12 @@ namespace verbly {
 
     // General accessors
 
-    type getType() const
+    operator bool() const
+    {
+      return (type_ != part_type::invalid);
+    }
+
+    part_type getType() const
     {
       return type_;
     }
@@ -85,11 +93,43 @@ namespace verbly {
 
     std::string getLiteralValue() const;
 
+    // Type info
+
+    static const object objectType;
+
+    static const std::list<std::string> select;
+
+    // Query fields
+
+    static const field index;
+    static const field type;
+
+    static const field role;
+
+    // Relationships to other objects
+
+    static const field frame;
+
+    // Noun synrestr relationship
+
+    class synrestr_field {
+    public:
+
+      filter operator%=(std::string synrestr) const;
+
+    private:
+
+      static const field synrestrJoin;
+      static const field synrestrField;
+    };
+
+    static const synrestr_field synrestr;
+
   private:
 
     // Private constructors
 
-    part(type t) : type_(t)
+    part(part_type t) : type_(t)
     {
     }
 
@@ -108,7 +148,7 @@ namespace verbly {
       std::string literal_;
     };
 
-    type type_ = type::invalid;
+    part_type type_ = part_type::invalid;
 
   };
 
@@ -9,6 +9,7 @@
 #include <iostream>
 #include "statement.h"
 #include "binding.h"
+#include "order.h"
 
 namespace verbly {
 
@@ -24,11 +25,17 @@ namespace verbly {
   class query {
   public:
 
-    query(const database& db, sqlite3* ppdb, filter queryFilter, bool random, int limit) : db_(&db)
+    query(const database& db, sqlite3* ppdb, filter queryFilter, order sortOrder, int limit) : db_(&db)
     {
+      if ((sortOrder.getType() == order::type::field)
+        && (sortOrder.getSortField().getObject() != Object::objectType))
+      {
+        throw std::invalid_argument("Can only sort query by a field in the result table");
+      }
+
       statement stmt(Object::objectType, std::move(queryFilter));
 
-      std::string queryString = stmt.getQueryString(Object::select, random, limit);
+      std::string queryString = stmt.getQueryString(Object::select, std::move(sortOrder), limit);
       std::list<binding> bindings = stmt.getBindings();
 
       if (sqlite3_prepare_v2(ppdb, queryString.c_str(), queryString.length(), &ppstmt_, NULL) != SQLITE_OK)
@@ -1,60 +0,0 @@
-#ifndef ROLE_H_249F9A9C
-#define ROLE_H_249F9A9C
-
-#include <stdexcept>
-#include <string>
-#include "../lib/selrestr.h"
-
-namespace verbly {
-
-  class role {
-  public:
-
-    // Default constructor
-
-    role() = default;
-
-    // Constructor
-
-    role(
-      std::string name,
-      selrestr selrestrs = {}) :
-        valid_(true),
-        name_(name),
-        selrestrs_(selrestrs)
-    {
-    }
-
-    // Accessors
-
-    const std::string& getName() const
-    {
-      if (!valid_)
-      {
-        throw std::domain_error("Bad access to invalid role");
-      }
-
-      return name_;
-    }
-
-    const selrestr& getSelrestrs() const
-    {
-      if (!valid_)
-      {
-        throw std::domain_error("Bad access to invalid role");
-      }
-
-      return selrestrs_;
-    }
-
-  private:
-
-    bool valid_ = false;
-    std::string name_;
-    selrestr selrestrs_;
-
-  };
-
-};
-
-#endif /* end of include guard: ROLE_H_249F9A9C */
@@ -5,11 +5,12 @@
 #include "util.h"
 #include "notion.h"
 #include "word.h"
-#include "group.h"
 #include "frame.h"
+#include "part.h"
 #include "lemma.h"
 #include "form.h"
 #include "pronunciation.h"
+#include "order.h"
 
 namespace verbly {
 
@@ -20,7 +21,7 @@ namespace verbly {
   {
   }
 
-  std::string statement::getQueryString(std::list<std::string> select, bool random, int limit) const
+  std::string statement::getQueryString(std::list<std::string> select, order sortOrder, int limit, bool debug) const
   {
     std::stringstream queryStream;
 
@@ -49,7 +50,7 @@ namespace verbly {
         if (cte.getCondition().getType() != condition::type::empty)
         {
           cteStream << " WHERE ";
-          cteStream << cte.getCondition().toSql();
+          cteStream << cte.getCondition().flatten().toSql(true, debug);
         }
 
         if (cte.isRecursive())
@@ -101,12 +102,28 @@ namespace verbly {
     if (topCondition_.getType() != condition::type::empty)
     {
       queryStream << " WHERE ";
-      queryStream << topCondition_.toSql();
+      queryStream << topCondition_.flatten().toSql(true, debug);
     }
-
-    if (random)
+    
+    queryStream << " ORDER BY ";
+    
+    switch (sortOrder.getType())
     {
-      queryStream << " ORDER BY RANDOM()";
+      case order::type::random:
+      {
+        queryStream << "RANDOM()";
+        
+        break;
+      }
+      
+      case order::type::field:
+      {
+        queryStream << topTable_;
+        queryStream << ".";
+        queryStream << sortOrder.getSortField().getColumn();
+        
+        break;
+      }
     }
 
     if (limit > 0)
@@ -260,6 +277,7 @@ namespace verbly {
           }
 
           case field::type::join:
+          case field::type::join_where:
           {
             // First, figure out what table we need to join against.
             std::string joinTableName;
@@ -269,13 +287,22 @@ namespace verbly {
             } else {
               joinTableName = getTableForContext(clause.getField().getJoinObject());
             }
+            
+            filter joinCondition = clause.getJoinCondition();
+            
+            // If this is a condition join, we need to add the field join
+            // condition to the clause.
+            if (clause.getField().getType() == field::type::join_where)
+            {
+              joinCondition &= (clause.getField().getConditionField() == clause.getField().getConditionValue());
+            }
 
             // Recursively parse the subquery, and therefore obtain an
             // instantiated table to join against, as well as any joins or CTEs
             // that the subquery may require to function.
             statement joinStmt(
               joinTableName,
-              clause.getJoinCondition().normalize(clause.getField().getJoinObject()),
+              std::move(joinCondition).normalize(clause.getField().getJoinObject()),
               nextTableId_,
               nextWithId_);
 
@@ -801,7 +828,7 @@ namespace verbly {
     new(&singleton_.value_) binding(std::move(value));
   }
 
-  std::string statement::condition::toSql() const
+  std::string statement::condition::toSql(bool toplevel, bool debug) const
   {
     switch (type_)
     {
@@ -816,42 +843,92 @@ namespace verbly {
         {
           case comparison::equals:
           {
-            return singleton_.table_ + "." + singleton_.column_ + " = ?";
+            if (debug)
+            {
+              if (singleton_.value_.getType() == binding::type::string)
+              {
+                return singleton_.table_ + "." + singleton_.column_ + " = \"" + singleton_.value_.getString() + "\"";
+              } else {
+                return singleton_.table_ + "." + singleton_.column_ + " = " + std::to_string(singleton_.value_.getInteger());
+              }
+            } else {
+              return singleton_.table_ + "." + singleton_.column_ + " = ?";
+            }
           }
 
           case comparison::does_not_equal:
           {
-            return singleton_.table_ + "." + singleton_.column_ + " != ?";
+            if (debug)
+            {
+              if (singleton_.value_.getType() == binding::type::string)
+              {
+                return singleton_.table_ + "." + singleton_.column_ + " != \"" + singleton_.value_.getString() + "\"";
+              } else {
+                return singleton_.table_ + "." + singleton_.column_ + " != " + std::to_string(singleton_.value_.getInteger());
+              }
+            } else {
+              return singleton_.table_ + "." + singleton_.column_ + " != ?";
+            }
           }
 
           case comparison::is_greater_than:
           {
-            return singleton_.table_ + "." + singleton_.column_ + " > ?";
+            if (debug)
+            {
+              return singleton_.table_ + "." + singleton_.column_ + " > " + std::to_string(singleton_.value_.getInteger());
+            } else {
+              return singleton_.table_ + "." + singleton_.column_ + " > ?";
+            }
           }
 
           case comparison::is_at_most:
           {
-            return singleton_.table_ + "." + singleton_.column_ + " <= ?";
+            if (debug)
+            {
+              return singleton_.table_ + "." + singleton_.column_ + " <= " + std::to_string(singleton_.value_.getInteger());
+            } else {
+              return singleton_.table_ + "." + singleton_.column_ + " <= ?";
+            }
           }
 
           case comparison::is_less_than:
           {
-            return singleton_.table_ + "." + singleton_.column_ + " < ?";
+            if (debug)
+            {
+              return singleton_.table_ + "." + singleton_.column_ + " < " + std::to_string(singleton_.value_.getInteger());
+            } else {
+              return singleton_.table_ + "." + singleton_.column_ + " < ?";
+            }
           }
 
           case comparison::is_at_least:
           {
-            return singleton_.table_ + "." + singleton_.column_ + " >= ?";
+            if (debug)
+            {
+              return singleton_.table_ + "." + singleton_.column_ + " >= " + std::to_string(singleton_.value_.getInteger());
+            } else {
+              return singleton_.table_ + "." + singleton_.column_ + " >= ?";
+            }
           }
 
           case comparison::is_like:
           {
-            return singleton_.table_ + "." + singleton_.column_ + " LIKE ?";
+            if (debug)
+            {
+              return singleton_.table_ + "." + singleton_.column_ + " LIKE \"" + singleton_.value_.getString() + "\"";
+            } else {
+              return singleton_.table_ + "." + singleton_.column_ + " LIKE ?";
+            }
           }
 
           case comparison::is_not_like:
           {
-            return singleton_.table_ + "." + singleton_.column_ + " NOT LIKE ?";
+            if (debug)
+            {
+              return singleton_.table_ + "." + singleton_.column_ + " NOT LIKE \"" + singleton_.value_.getString() + "\"";
+            } else {
+              return singleton_.table_ + "." + singleton_.column_ + " NOT LIKE ?";
+            }
           }
 
           case comparison::is_not_null:
@@ -871,10 +948,25 @@ namespace verbly {
         std::list<std::string> clauses;
         for (const condition& cond : group_.children_)
         {
-          clauses.push_back(cond.toSql());
+          clauses.push_back(cond.toSql(false, debug));
         }
 
-        return implode(std::begin(clauses), std::end(clauses), group_.orlogic_ ? " OR " : " AND ");
+        if (clauses.empty())
+        {
+          return "";
+        } else if (clauses.size() == 1)
+        {
+          return clauses.front();
+        } else {
+          std::string result = implode(std::begin(clauses), std::end(clauses), group_.orlogic_ ? " OR " : " AND ");
+          
+          if (toplevel)
+          {
+            return result;
+          } else {
+            return "(" + result + ")";
+          }
+        }
       }
     }
   }
@@ -988,5 +1080,39 @@ namespace verbly {
       throw std::domain_error("Cannot get children of non-group condition");
     }
   }
+  
+  statement::condition statement::condition::flatten() const
+  {
+    switch (type_)
+    {
+      case type::empty:
+      case type::singleton:
+      {
+        return *this;
+      }
+      
+      case type::group:
+      {
+        condition result(group_.orlogic_);
+        
+        for (const condition& child : group_.children_)
+        {
+          condition newChild = child.flatten();
+          
+          if ((newChild.type_ == type::group) && (newChild.group_.orlogic_ == group_.orlogic_))
+          {
+            for (condition subChild : std::move(newChild.group_.children_))
+            {
+              result += std::move(subChild);
+            }
+          } else {
+            result += std::move(newChild);
+          }
+        }
+        
+        return result;
+      }
+    }
+  }
 
 };
@@ -13,13 +13,14 @@
 namespace verbly {
 
   class filter;
+  class order;
 
   class statement {
   public:
 
     statement(object context, filter queryFilter);
 
-    std::string getQueryString(std::list<std::string> select, bool random, int limit) const;
+    std::string getQueryString(std::list<std::string> select, order sortOrder, int limit, bool debug = false) const;
 
     std::list<binding> getBindings() const;
 
@@ -153,10 +154,12 @@ namespace verbly {
 
       // Utility
 
-      std::string toSql() const;
+      std::string toSql(bool toplevel, bool debug = false) const;
 
       std::list<binding> flattenBindings() const;
 
+      condition flatten() const;
+
     private:
       union {
         struct {
@@ -246,8 +249,8 @@ namespace verbly {
     {
       return (context == object::notion) ? "notions"
         : (context == object::word) ? "words"
-        : (context == object::group) ? "groups"
         : (context == object::frame) ? "frames"
+        : (context == object::part) ? "parts"
         : (context == object::lemma) ? "lemmas_forms"
         : (context == object::form) ? "forms"
         : (context == object::pronunciation) ? "pronunciations"
@@ -6,16 +6,15 @@
 #include "filter.h"
 #include "field.h"
 #include "query.h"
+#include "order.h"
 #include "notion.h"
 #include "word.h"
-#include "group.h"
 #include "frame.h"
+#include "part.h"
 #include "lemma.h"
 #include "form.h"
 #include "pronunciation.h"
 #include "token.h"
 #include "selrestr.h"
-#include "part.h"
-#include "role.h"
 
 #endif /* end of include guard: VERBLY_H_5B39CE50 */
@@ -17,7 +17,7 @@ namespace verbly {
 
   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::frame = field::joinField(object::word, "group_id", object::frame, true);
 
   const field word::antonyms = field::selfJoin(object::word, "word_id", "antonymy", "antonym_2_id", "antonym_1_id");
 
@@ -93,7 +93,27 @@ namespace verbly {
     return lemma_;
   }
 
-  const group& word::getGroup() const
+  bool word::hasFrames() const
+  {
+    if (!valid_)
+    {
+      throw std::domain_error("Bad access to uninitialized word");
+    }
+
+    if (!hasGroup_)
+    {
+      return false;
+    }
+
+    if (!initializedFrames_)
+    {
+      initializeFrames();
+    }
+
+    return !frames_.empty();
+  }
+
+  const std::vector<frame>& word::getFrames() const
   {
     if (!valid_)
     {
@@ -105,12 +125,12 @@ namespace verbly {
       throw std::domain_error("Word does not have a group");
     }
 
-    if (!group_)
+    if (!initializedFrames_)
     {
-      group_ = db_->groups(group::id == groupId_).first();
+      initializeFrames();
     }
 
-    return group_;
+    return frames_;
   }
 
   std::string word::getBaseForm() const
@@ -129,4 +149,10 @@ namespace verbly {
     return result;
   }
 
+  void word::initializeFrames() const
+  {
+    initializedFrames_ = true;
+    frames_ = db_->frames(*this, {}, -1).all();
+  }
+
 };
@@ -7,7 +7,7 @@
 #include "filter.h"
 #include "notion.h"
 #include "lemma.h"
-#include "group.h"
+#include "frame.h"
 
 struct sqlite3_stmt;
 
@@ -97,17 +97,9 @@ namespace verbly {
 
     const lemma& getLemma() const;
 
-    bool hasGroup() const
-    {
-      if (!valid_)
-      {
-        throw std::domain_error("Bad access to uninitialized word");
-      }
+    bool hasFrames() const;
 
-      return hasGroup_;
-    }
-
-    const group& getGroup() const;
+    const std::vector<frame>& getFrames() const;
 
     // Convenience accessors
 
@@ -136,7 +128,7 @@ namespace verbly {
 
     static const field notion;
     static const field lemma;
-    static const field group;
+    static const field frame;
 
     // Relationships with self
 
@@ -161,6 +153,9 @@ namespace verbly {
     static const field regionalDomains;
 
   private:
+
+    void initializeFrames() const;
+
     bool valid_ = false;
 
     int id_;
@@ -176,7 +171,9 @@ namespace verbly {
 
     mutable class notion notion_;
     mutable class lemma lemma_;
-    mutable class group group_;
+
+    mutable bool initializedFrames_ = false;
+    mutable std::vector<class frame> frames_;
 
   };