Restructured verb frame schema to be more queryable

Groups are much less significant now, and they no longer have a database
table, nor are they considered a top level object anymore. Instead of
containing their own role data, that data is folded into the frames so
that it's easier to query; as a result, each group has its own copy of
the frames that it contains. Additionally, parts are considered top
level objects now, and you can query for frames based on attributes of
their indexed parts. Synrestrs are also contained in their own table
now, so that parts can be filtered against their synrestrs; they are
however not considered top level objects.

Created a new type of field, the "join where" or "condition join" field,
which is a normal join field that has a built in condition on a
specified field. This is used to allow creating multiple distinct join
fields from one object to another. This is required for the lemma::form
and frame::part joins, because filters for forms of separate inflections
should not be coalesced; similarly, filters on differently indexed frame
parts should not be coalesced.

Queries can now be ordered, ascending or descending, by a field, in
addition to randomly as before. This is necessary for accessing the
parts of a verb frame in the correct order, but may be useful to an end
user as well.

Fixed a bug with statement generation in that condition groups were not
being surrounded in parentheses, which made mixing OR groups and AND
groups generate inaccurate statements. This has been fixed;
additionally, parentheses are not placed around the top level condition,
and nested condition groups with the same logic type are coalesced, to
make query strings as easy to read as possible.

Also simplified the form::lemma field; it no longer conditions on the
inflection of the form like the lemma::form field does.

Also added a debug flag to statement::getQueryString that makes it
return a query string with all of the bindings filled in, for debug use
only.

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_;
 
   };