1 files changed, 142 insertions, 0 deletions

@@ -0,0 +1,142 @@
+#include "verbly.h"
+#include <json.hpp>
+
+using json = nlohmann::json;
+
+namespace verbly {
+
+  frame_query::frame_query(const data& _data) : _data(_data)
+  {
+    
+  }
+  
+  frame_query& frame_query::for_verb(const verb& _v)
+  {
+    _for_verb.push_back(_v);
+    
+    return *this;
+  }
+  
+  frame::selrestr parse_selrestr(const json data)
+  {
+    if (data.find("children") != data.end())
+    {
+      std::list<frame::selrestr> children;
+      std::transform(std::begin(data["children"]), std::end(data["children"]), std::back_inserter(children), &parse_selrestr);
+      
+      return frame::selrestr{children, data["logic"] == "or"};
+    } else if (data.find("type") != data.end())
+    {
+      return frame::selrestr{data["type"].get<std::string>(), data["pos"].get<bool>()};
+    } else {
+      return frame::selrestr{};
+    }
+  }
+  
+  std::list<frame> frame_query::run() const
+  {
+    std::stringstream construct;
+    construct << "SELECT frames.data, groups.data FROM frames INNER JOIN groups ON frames.group_id = groups.group_id";
+    
+    if (!_for_verb.empty())
+    {
+      std::list<std::string> clauses(_for_verb.size(), "verb_id = @VERID");
+      construct << " WHERE frames.group_id IN (SELECT group_id FROM verb_groups WHERE ";
+      construct << verbly::implode(std::begin(clauses), std::end(clauses), " OR ");
+      construct << ")";
+    }
+    
+    sqlite3_stmt* ppstmt;
+    std::string query = construct.str();
+    if (sqlite3_prepare_v2(_data.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
+    {
+      throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
+    }
+    
+    for (auto verb : _for_verb)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@VERID"), verb._id);
+    }
+    
+    std::list<frame> output;
+    while (sqlite3_step(ppstmt) == SQLITE_ROW)
+    {
+      frame f;
+      
+      std::string fdatat(reinterpret_cast<const char*>(sqlite3_column_blob(ppstmt, 0)));
+      const json fdata = json::parse(fdatat);
+      for (const auto& part : fdata)
+      {
+        frame::part p;
+        
+        if (part["type"] == "np")
+        {
+          p._type = frame::part::type::noun_phrase;
+          new(&p._noun_phrase.role) std::string(part["role"].get<std::string>());
+          new(&p._noun_phrase.selrestrs) frame::selrestr(parse_selrestr(part["selrestrs"]));
+          new(&p._noun_phrase.synrestrs) std::set<std::string>();
+          for (auto synrestr : part["synrestrs"])
+          {
+            p._noun_phrase.synrestrs.insert(synrestr.get<std::string>());
+          }
+        } else if (part["type"] == "pp")
+        {
+          if (!part["values"].empty())
+          {
+            p._type = frame::part::type::literal_preposition;
+            new(&p._literal_preposition.choices) std::vector<std::string>();
+            for (auto choice : part["values"])
+            {
+              p._literal_preposition.choices.push_back(choice.get<std::string>());
+            }
+          } else if (!part["preprestrs"].empty())
+          {
+            p._type = frame::part::type::selection_preposition;
+            new(&p._selection_preposition.preprestrs) std::vector<std::string>();
+            for (auto preprestr : part["preprestrs"])
+            {
+              p._selection_preposition.preprestrs.push_back(preprestr.get<std::string>());
+            }
+          }
+        } else if (part["type"] == "v")
+        {
+          p._type = frame::part::type::verb;
+        } else if (part["type"] == "adj")
+        {
+          p._type = frame::part::type::adjective;
+        } else if (part["type"] == "adv")
+        {
+          p._type = frame::part::type::adverb;
+        } else if (part["type"] == "lex")
+        {
+          p._type = frame::part::type::literal;
+          new(&p._literal.lexval) std::string(part["value"].get<std::string>());
+        }
+        
+        f._parts.push_back(p);
+      }
+      
+      std::string rdatat(reinterpret_cast<const char*>(sqlite3_column_blob(ppstmt, 1)));
+      const json rdata = json::parse(rdatat);
+      for (const auto& role : rdata)
+      {
+        std::string rt = role["type"];
+        frame::selrestr rs;
+        
+        if (role.find("selrestrs") != role.end())
+        {
+          rs = parse_selrestr(role["selrestrs"]);
+        }
+        
+        f._roles[rt] = rs;
+      }
+      
+      output.push_back(f);
+    }
+    
+    sqlite3_finalize(ppstmt);
+    
+    return output;
+  }
+
+};