11 files changed, 503 insertions, 296 deletions

@@ -218,6 +218,7 @@ namespace verbly {
     std::stringstream construct;
     construct << "SELECT adjective_id, base_form, comparative, superlative, position FROM adjectives";
     std::list<std::string> conditions;
+    std::list<binding> bindings;
     
     if (_has_prn)
     {
@@ -226,14 +227,20 @@ namespace verbly {
     
     if (!_rhymes.empty())
     {
-      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE @RHMPRN");
+      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE ?");
       std::string cond = "adjective_id IN (SELECT adjective_id FROM adjective_pronunciations WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
       conditions.push_back(cond);
+      
+      for (auto rhyme : _rhymes)
+      {
+        bindings.emplace_back("%" + rhyme);
+      }
     }
     
     for (auto except : _except)
     {
-      conditions.push_back("adjective_id != @EXCID");
+      conditions.push_back("adjective_id != ?");
+      bindings.emplace_back(except._id);
     }
     
     if (_requires_comparative_form)
@@ -261,11 +268,13 @@ namespace verbly {
         {
           case filter<std::string>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem() + "%");
+            
             if (notlogic == f.get_notlogic())
             {
-              return "base_form LIKE @PREFIX";
+              return "base_form LIKE ?";
             } else {
-              return "base_form NOT LIKE @PREFIX";
+              return "base_form NOT LIKE ?";
             }
           }
           
@@ -298,11 +307,13 @@ namespace verbly {
         {
           case filter<std::string>::type::singleton:
           {
+            bindings.emplace_back("%" + f.get_elem());
+            
             if (notlogic == f.get_notlogic())
             {
-              return "base_form LIKE @SUFFIX";
+              return "base_form LIKE ?";
             } else {
-              return "base_form NOT LIKE @SUFFIX";
+              return "base_form NOT LIKE ?";
             }
           }
           
@@ -330,7 +341,8 @@ namespace verbly {
     
     if (_with_complexity != unlimited)
     {
-      conditions.push_back("complexity = @COMPLEX");
+      conditions.push_back("complexity = ?");
+      bindings.emplace_back(_with_complexity);
     }
     
     if (_is_variant)
@@ -355,11 +367,13 @@ namespace verbly {
         {
           case filter<noun>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "noun_id = @ATTRID";
+              return "noun_id = ?";
             } else {
-              return "noun_id != @ATTRID";
+              return "noun_id != ?";
             }
           }
           
@@ -409,11 +423,13 @@ namespace verbly {
         {
           case filter<adjective>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "adjective_1_id = @ANTID";
+              return "adjective_1_id = ?";
             } else {
-              return "adjective_1_id != @ANTID";
+              return "adjective_1_id != ?";
             }
           }
           
@@ -463,11 +479,13 @@ namespace verbly {
         {
           case filter<adjective>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "adjective_1_id = @SYNID";
+              return "adjective_1_id = ?";
             } else {
-              return "adjective_1_id != @SYNID";
+              return "adjective_1_id != ?";
             }
           }
           
@@ -517,11 +535,13 @@ namespace verbly {
         {
           case filter<adjective>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "specific_id = @SPECID";
+              return "specific_id = ?";
             } else {
-              return "specific_id != @SPECID";
+              return "specific_id != ?";
             }
           }
           
@@ -571,11 +591,13 @@ namespace verbly {
         {
           case filter<adjective>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "general_id = @GENID";
+              return "general_id = ?";
             } else {
-              return "general_id != @GENID";
+              return "general_id != ?";
             }
           }
           
@@ -625,11 +647,13 @@ namespace verbly {
         {
           case filter<noun>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "noun_id = @APERID";
+              return "noun_id = ?";
             } else {
-              return "noun_id != @APERID";
+              return "noun_id != ?";
             }
           }
           
@@ -679,11 +703,13 @@ namespace verbly {
         {
           case filter<adverb>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "mannernym_id = @MANID";
+              return "mannernym_id = ?";
             } else {
-              return "mannernym_id != @MANID";
+              return "mannernym_id != ?";
             }
           }
           
@@ -776,74 +802,29 @@ namespace verbly {
       throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
     }
     
-    if (!_rhymes.empty())
+    int i = 1;
+    for (auto& binding : bindings)
     {
-      int i = 0;
-      for (auto rhyme : _rhymes)
+      switch (binding.get_type())
       {
-        std::string rhymer = "%" + rhyme;
-        sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@RHMPRN"), rhymer.c_str(), rhymer.length(), SQLITE_STATIC);
+        case binding::type::integer:
+        {
+          sqlite3_bind_int(ppstmt, i, binding.get_integer());
+          
+          break;
+        }
         
-        i++;
+        case binding::type::string:
+        {
+          sqlite3_bind_text(ppstmt, i, binding.get_string().c_str(), binding.get_string().length(), SQLITE_STATIC);
+          
+          break;
+        }
       }
+      
+      i++;
     }
     
-    for (auto except : _except)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@EXCID"), except._id);
-    }
-    
-    for (auto prefix : _with_prefix.inorder_flatten())
-    {
-      std::string pfat = prefix + "%";
-      sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@PREFIX"), pfat.c_str(), pfat.length(), SQLITE_STATIC);
-    }
-    
-    for (auto suffix : _with_suffix.inorder_flatten())
-    {
-      std::string pfat = "%" + suffix;
-      sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SUFFIX"), pfat.c_str(), pfat.length(), SQLITE_STATIC);
-    }
-    
-    if (_with_complexity != unlimited)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@COMPLEX"), _with_complexity);
-    }
-    
-    for (auto attribute : _variant_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@ATTRID"), attribute._id);
-    }
-    
-    for (auto antonym : _antonym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@ANTID"), antonym._id);
-    }
-    
-    for (auto synonym : _synonym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SYNID"), synonym._id);
-    }
-    
-    for (auto specific : _generalization_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SPECID"), specific._id);
-    }
-    
-    for (auto general : _specification_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@GENID"), general._id);
-    }
-    
-    for (auto n : _pertainym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@APERID"), n._id);
-    }
-    
-    for (auto mannernym : _anti_mannernym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@MANID"), mannernym._id);
-    }
     /*
     for (auto adj : _derived_from_adjective)
     {
@@ -172,6 +172,7 @@ namespace verbly {
     std::stringstream construct;
     construct << "SELECT adverb_id, base_form, comparative, superlative FROM adverbs";
     std::list<std::string> conditions;
+    std::list<binding> bindings;
     
     if (_has_prn)
     {
@@ -180,14 +181,20 @@ namespace verbly {
     
     if (!_rhymes.empty())
     {
-      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE @RHMPRN");
+      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE ?");
       std::string cond = "adverb_id IN (SELECT adverb_id FROM adverb_pronunciations WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
       conditions.push_back(cond);
+      
+      for (auto rhyme : _rhymes)
+      {
+        bindings.emplace_back("%" + rhyme);
+      }
     }
     
     for (auto except : _except)
     {
-      conditions.push_back("adverb_id != @EXCID");
+      conditions.push_back("adverb_id != ?");
+      bindings.emplace_back(except._id);
     }
     
     if (_requires_comparative_form)
@@ -207,11 +214,13 @@ namespace verbly {
         {
           case filter<std::string>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem() + "%");
+            
             if (notlogic == f.get_notlogic())
             {
-              return "base_form LIKE @PREFIX";
+              return "base_form LIKE ?";
             } else {
-              return "base_form NOT LIKE @PREFIX";
+              return "base_form NOT LIKE ?";
             }
           }
           
@@ -244,11 +253,13 @@ namespace verbly {
         {
           case filter<std::string>::type::singleton:
           {
+            bindings.emplace_back("%" + f.get_elem());
+            
             if (notlogic == f.get_notlogic())
             {
-              return "base_form LIKE @SUFFIX";
+              return "base_form LIKE ?";
             } else {
-              return "base_form NOT LIKE @SUFFIX";
+              return "base_form NOT LIKE ?";
             }
           }
           
@@ -276,7 +287,8 @@ namespace verbly {
     
     if (_with_complexity != unlimited)
     {
-      conditions.push_back("complexity = @COMPLEX");
+      conditions.push_back("complexity = ?");
+      bindings.emplace_back(_with_complexity);
     }
     
     if (_has_antonyms)
@@ -301,11 +313,13 @@ namespace verbly {
         {
           case filter<adverb>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "adverb_1_id = @ANTID";
+              return "adverb_1_id = ?";
             } else {
-              return "adverb_1_id != @ANTID";
+              return "adverb_1_id != ?";
             }
           }
           
@@ -355,11 +369,13 @@ namespace verbly {
         {
           case filter<adverb>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "adverb_1_id = @SYNID";
+              return "adverb_1_id = ?";
             } else {
-              return "adverb_1_id != @SYNID";
+              return "adverb_1_id != ?";
             }
           }
           
@@ -409,11 +425,13 @@ namespace verbly {
         {
           case filter<adjective>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "adjective_id = @AMANID";
+              return "adjective_id = ?";
             } else {
-              return "adjective_id != @AMANID";
+              return "adjective_id != ?";
             }
           }
           
@@ -506,54 +524,29 @@ namespace verbly {
       throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
     }
     
-    if (!_rhymes.empty())
+    int i = 1;
+    for (auto& binding : bindings)
     {
-      int i = 0;
-      for (auto rhyme : _rhymes)
+      switch (binding.get_type())
       {
-        std::string rhymer = "%" + rhyme;
-        sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@RHMPRN"), rhymer.c_str(), rhymer.length(), SQLITE_STATIC);
+        case binding::type::integer:
+        {
+          sqlite3_bind_int(ppstmt, i, binding.get_integer());
+          
+          break;
+        }
         
-        i++;
+        case binding::type::string:
+        {
+          sqlite3_bind_text(ppstmt, i, binding.get_string().c_str(), binding.get_string().length(), SQLITE_STATIC);
+          
+          break;
+        }
       }
+      
+      i++;
     }
     
-    for (auto except : _except)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@EXCID"), except._id);
-    }
-    
-    for (auto prefix : _with_prefix.inorder_flatten())
-    {
-      std::string pfat = prefix + "%";
-      sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@PREFIX"), pfat.c_str(), pfat.length(), SQLITE_STATIC);
-    }
-    
-    for (auto suffix : _with_suffix.inorder_flatten())
-    {
-      std::string pfat = "%" + suffix;
-      sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SUFFIX"), pfat.c_str(), pfat.length(), SQLITE_STATIC);
-    }
-    
-    if (_with_complexity != unlimited)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@COMPLEX"), _with_complexity);
-    }
-    
-    for (auto antonym : _antonym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@ANTID"), antonym._id);
-    }
-    
-    for (auto synonym : _synonym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SYNID"), synonym._id);
-    }
-    
-    for (auto adj : _mannernym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@AMANID"), adj._id);
-    }
     /*
     for (auto adj : _derived_from_adjective)
     {
@@ -57,4 +57,121 @@ namespace verbly {
     return preposition_query(*this);
   }
   
+  binding::type binding::get_type() const
+  {
+    return _type;
+  }
+  
+  binding::binding(const binding& other)
+  {
+    _type = other._type;
+    
+    switch (_type)
+    {
+      case type::integer:
+      {
+        _integer = other._integer;
+        
+        break;
+      }
+      
+      case type::string:
+      {
+        new(&_string) std::string(other._string);
+        
+        break;
+      }
+    }
+  }
+  
+  binding::~binding()
+  {
+    switch (_type)
+    {
+      case type::string:
+      {
+        using string_type = std::string;
+        _string.~string_type();
+        
+        break;
+      }
+    }
+  }
+  
+  binding& binding::operator=(const binding& other)
+  {
+    this->~binding();
+    
+    _type = other._type;
+    
+    switch (_type)
+    {
+      case type::integer:
+      {
+        _integer = other._integer;
+        
+        break;
+      }
+      
+      case type::string:
+      {
+        new(&_string) std::string(other._string);
+        
+        break;
+      }
+    }
+    
+    return *this;
+  }
+  
+  binding::binding(int _arg)
+  {
+    _type = type::integer;
+    _integer = _arg;
+  }
+  
+  int binding::get_integer() const
+  {
+    assert(_type == type::integer);
+    
+    return _integer;
+  }
+  
+  void binding::set_integer(int _arg)
+  {
+    *this = binding(_arg);
+  }
+  
+  binding& binding::operator=(int _arg)
+  {
+    *this = binding(_arg);
+    
+    return *this;
+  }
+  
+  binding::binding(std::string _arg)
+  {
+    _type = type::string;
+    new(&_string) std::string(_arg);
+  }
+  
+  std::string binding::get_string() const
+  {
+    assert(_type == type::string);
+    
+    return _string;
+  }
+  
+  void binding::set_string(std::string _arg)
+  {
+    *this = binding(_arg);
+  }
+  
+  binding& binding::operator=(std::string _arg)
+  {
+    *this = binding(_arg);
+    
+    return *this;
+  }
+  
 };
@@ -343,6 +343,38 @@ namespace verbly {
       };
   };
   
+  class binding {
+    public:
+      enum class type {
+        integer,
+        string
+      };
+  
+      type get_type() const;
+      binding(const binding& other);
+      ~binding();
+      binding& operator=(const binding& other);
+    
+      // Integer
+      binding(int _arg);
+      int get_integer() const;
+      void set_integer(int _arg);
+      binding& operator=(int _arg);
+    
+      // String
+      binding(std::string _arg);
+      std::string get_string() const;
+      void set_string(std::string _arg);
+      binding& operator=(std::string _arg);
+    
+    private:
+      union {
+        int _integer;
+        std::string _string;
+      };
+      type _type;
+  };
+  
 };
 
 #endif /* end of include guard: DATA_H_C4AEC3DD */
@@ -37,13 +37,19 @@ namespace verbly {
   {
     std::stringstream construct;
     construct << "SELECT frames.data, groups.data FROM frames INNER JOIN groups ON frames.group_id = groups.group_id";
+    std::list<binding> bindings;
     
     if (!_for_verb.empty())
     {
-      std::list<std::string> clauses(_for_verb.size(), "verb_id = @VERID");
+      std::list<std::string> clauses(_for_verb.size(), "verb_id = ?");
       construct << " WHERE frames.group_id IN (SELECT group_id FROM verb_groups WHERE ";
       construct << verbly::implode(std::begin(clauses), std::end(clauses), " OR ");
       construct << ")";
+      
+      for (auto v : _for_verb)
+      {
+        bindings.emplace_back(v._id);
+      }
     }
     
     sqlite3_stmt* ppstmt;
@@ -53,9 +59,27 @@ namespace verbly {
       throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
     }
     
-    for (auto verb : _for_verb)
+    int i = 1;
+    for (auto& binding : bindings)
     {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@VERID"), verb._id);
+      switch (binding.get_type())
+      {
+        case binding::type::integer:
+        {
+          sqlite3_bind_int(ppstmt, i, binding.get_integer());
+          
+          break;
+        }
+        
+        case binding::type::string:
+        {
+          sqlite3_bind_text(ppstmt, i, binding.get_string().c_str(), binding.get_string().length(), SQLITE_STATIC);
+          
+          break;
+        }
+      }
+      
+      i++;
     }
     
     std::list<frame> output;
@@ -34,6 +34,13 @@ namespace verbly {
     
     return _plural;
   }
+  
+  int noun::wnid() const
+  {
+    assert(_valid == true);
+    
+    return _wnid;
+  }
 
   bool noun::has_plural_form() const
   {
@@ -196,6 +203,16 @@ namespace verbly {
     return _data->adjectives().variant_of(*this);
   }
   
+  std::string noun::imagenet_url() const
+  {
+    std::stringstream url;
+    url << "http://www.image-net.org/api/text/imagenet.synset.geturls?wnid=n";
+    url.width(8);
+    url.fill('0');
+    url << (_wnid % 100000000);
+    return url.str();
+  }
+  
   bool noun::operator<(const noun& other) const
   {
     return _id < other._id;
@@ -7,6 +7,7 @@ namespace verbly {
     private:
       std::string _singular;
       std::string _plural;
+      int _wnid;
       
       friend class noun_query;
       
@@ -17,6 +18,7 @@ namespace verbly {
       std::string base_form() const;
       std::string singular_form() const;
       std::string plural_form() const;
+      int wnid() const;
       
       bool has_plural_form() const;
       
@@ -43,6 +45,8 @@ namespace verbly {
       adjective_query pertainyms() const;
       adjective_query variations() const;
       
+      std::string imagenet_url() const;
+      
       bool operator<(const noun& other) const;
   };
   
@@ -370,6 +370,21 @@ namespace verbly {
     
     return *this;
   }
+  
+  noun_query& noun_query::at_least_n_images(int _arg)
+  {
+    _at_least_n_images = _arg;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::with_wnid(int _arg)
+  {
+    _with_wnid.insert(_arg);
+    
+    return *this;
+  }
+  
   /*
   noun_query& noun_query::derived_from(const word& _w)
   {
@@ -457,8 +472,9 @@ namespace verbly {
       construct << " ";
     }
     
-    construct << "SELECT noun_id, singular, plural FROM nouns";
+    construct << "SELECT noun_id, singular, plural, wnid FROM nouns";
     std::list<std::string> conditions;
+    std::list<binding> bindings;
     
     if (_has_prn)
     {
@@ -467,21 +483,32 @@ namespace verbly {
     
     if (!_rhymes.empty())
     {
-      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE @RHMPRN");
+      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE ?");
       std::string cond = "noun_id IN (SELECT noun_id FROM noun_pronunciations WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
       conditions.push_back(cond);
+      
+      for (auto rhyme : _rhymes)
+      {
+        bindings.emplace_back("%" + rhyme);
+      }
     }
     
     for (auto except : _except)
     {
-      conditions.push_back("noun_id != @EXCID");
+      conditions.push_back("noun_id != ?");
+      bindings.emplace_back(except._id);
     }
     
     if (!_with_singular_form.empty())
     {
-      std::list<std::string> clauses(_with_singular_form.size(), "singular = @SFORM");
+      std::list<std::string> clauses(_with_singular_form.size(), "singular = ?");
       std::string cond = "(" + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
       conditions.push_back(cond);
+      
+      for (auto form : _with_singular_form)
+      {
+        bindings.emplace_back(form);
+      }
     }
     
     if (!_with_prefix.empty())
@@ -491,11 +518,13 @@ namespace verbly {
         {
           case filter<std::string>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem() + "%");
+            
             if (notlogic == f.get_notlogic())
             {
-              return "singular LIKE @PREFIX";
+              return "singular LIKE ?";
             } else {
-              return "singular NOT LIKE @PREFIX";
+              return "singular NOT LIKE ?";
             }
           }
           
@@ -528,11 +557,13 @@ namespace verbly {
         {
           case filter<std::string>::type::singleton:
           {
+            bindings.emplace_back("%" + f.get_elem());
+            
             if (notlogic == f.get_notlogic())
             {
-              return "singular LIKE @SUFFIX";
+              return "singular LIKE ?";
             } else {
-              return "singular NOT LIKE @SUFFIX";
+              return "singular NOT LIKE ?";
             }
           }
           
@@ -560,7 +591,8 @@ namespace verbly {
     
     if (_with_complexity != unlimited)
     {
-      conditions.push_back("complexity = @COMPLEX");
+      conditions.push_back("complexity = ?");
+      bindings.emplace_back(_with_complexity);
     }
     
     if (_is_hypernym)
@@ -585,11 +617,13 @@ namespace verbly {
         {
           case filter<noun>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "hyponym_id = @HYPO";
+              return "hyponym_id = ?";
             } else {
-              return "hyponym_id != @HYPO";
+              return "hyponym_id != ?";
             }
           }
           
@@ -713,11 +747,13 @@ namespace verbly {
         {
           case filter<noun>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "hypernym_id = @HYPER";
+              return "hypernym_id = ?";
             } else {
-              return "hypernym_id != @HYPER";
+              return "hypernym_id != ?";
             }
           }
           
@@ -767,11 +803,13 @@ namespace verbly {
         {
           case filter<noun>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "holonym_id = @PHOLO";
+              return "holonym_id = ?";
             } else {
-              return "holonym_id != @PHOLO";
+              return "holonym_id != ?";
             }
           }
           
@@ -858,11 +896,13 @@ namespace verbly {
         {
           case filter<noun>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "meronym_id = @PMERO";
+              return "meronym_id = ?";
             } else {
-              return "meronym_id != @PMERO";
+              return "meronym_id != ?";
             }
           }
           
@@ -949,11 +989,13 @@ namespace verbly {
         {
           case filter<noun>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "holonym_id = @SHOLO";
+              return "holonym_id = ?";
             } else {
-              return "holonym_id != @SHOLO";
+              return "holonym_id != ?";
             }
           }
           
@@ -1040,11 +1082,13 @@ namespace verbly {
         {
           case filter<noun>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "meronym_id = @SMERO";
+              return "meronym_id = ?";
             } else {
-              return "meronym_id != @SMERO";
+              return "meronym_id != ?";
             }
           }
           
@@ -1131,11 +1175,13 @@ namespace verbly {
         {
           case filter<noun>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "holonym_id = @MHOLO";
+              return "holonym_id = ?";
             } else {
-              return "holonym_id != @MHOLO";
+              return "holonym_id != ?";
             }
           }
           
@@ -1222,11 +1268,13 @@ namespace verbly {
         {
           case filter<noun>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "meronym_id = @MMERO";
+              return "meronym_id = ?";
             } else {
-              return "meronym_id != @MMERO";
+              return "meronym_id != ?";
             }
           }
           
@@ -1323,11 +1371,13 @@ namespace verbly {
         {
           case filter<noun>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "class_id = @CLSID";
+              return "class_id = ?";
             } else {
-              return "class_id != @CLSID";
+              return "class_id != ?";
             }
           }
           
@@ -1377,11 +1427,13 @@ namespace verbly {
         {
           case filter<noun>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "instance_id = @INSID";
+              return "instance_id = ?";
             } else {
-              return "instance_id != @INSID";
+              return "instance_id != ?";
             }
           }
           
@@ -1431,11 +1483,13 @@ namespace verbly {
         {
           case filter<noun>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "noun_1_id = @SYNID";
+              return "noun_1_id = ?";
             } else {
-              return "noun_1_id != @SYNID";
+              return "noun_1_id != ?";
             }
           }
           
@@ -1485,11 +1539,13 @@ namespace verbly {
         {
           case filter<noun>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "noun_1_id = @ANTID";
+              return "noun_1_id = ?";
             } else {
-              return "noun_1_id != @ANTID";
+              return "noun_1_id != ?";
             }
           }
           
@@ -1539,11 +1595,13 @@ namespace verbly {
         {
           case filter<adjective>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "pertainym_id = @PERID";
+              return "pertainym_id = ?";
             } else {
-              return "pertainym_id != @PERID";
+              return "pertainym_id != ?";
             }
           }
           
@@ -1593,11 +1651,13 @@ namespace verbly {
         {
           case filter<adjective>::type::singleton:
           {
+            bindings.emplace_back(f.get_elem()._id);
+            
             if (notlogic == f.get_notlogic())
             {
-              return "adjective_id = @VALID";
+              return "adjective_id = ?";
             } else {
-              return "adjective_id != @VALID";
+              return "adjective_id != ?";
             }
           }
           
@@ -1624,6 +1684,25 @@ namespace verbly {
       cond << ")";
       conditions.push_back(cond.str());
     }
+    
+    if (_at_least_n_images != unlimited)
+    {
+      conditions.push_back("images >= ?");
+      bindings.emplace_back(_at_least_n_images);
+    }
+    
+    if (!_with_wnid.empty())
+    {
+      std::vector<std::string> clauses(_with_wnid.size(), "wnid = ?");
+      std::string cond = verbly::implode(std::begin(clauses), std::end(clauses), " OR ");
+      conditions.push_back("(" + cond + ")");
+      
+      for (auto wnid : _with_wnid)
+      {
+        bindings.emplace_back(wnid);
+      }
+    }
+    
     /*
     if (!_derived_from_adjective.empty())
     {
@@ -1690,114 +1769,29 @@ namespace verbly {
       throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
     }
     
-    if (!_rhymes.empty())
+    int i = 1;
+    for (auto& binding : bindings)
     {
-      int i = 0;
-      for (auto rhyme : _rhymes)
+      switch (binding.get_type())
       {
-        std::string rhymer = "%" + rhyme;
-        sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@RHMPRN"), rhymer.c_str(), rhymer.length(), SQLITE_STATIC);
+        case binding::type::integer:
+        {
+          sqlite3_bind_int(ppstmt, i, binding.get_integer());
+          
+          break;
+        }
         
-        i++;
+        case binding::type::string:
+        {
+          sqlite3_bind_text(ppstmt, i, binding.get_string().c_str(), binding.get_string().length(), SQLITE_STATIC);
+          
+          break;
+        }
       }
+      
+      i++;
     }
     
-    for (auto except : _except)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@EXCID"), except._id);
-    }
-    
-    for (auto sform : _with_singular_form)
-    {
-      sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SFORM"), sform.c_str(), sform.size(), SQLITE_STATIC);
-    }
-    
-    for (auto prefix : _with_prefix.inorder_flatten())
-    {
-      std::string pfat = prefix + "%";
-      sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@PREFIX"), pfat.c_str(), pfat.length(), SQLITE_STATIC);
-    }
-    
-    for (auto suffix : _with_suffix.inorder_flatten())
-    {
-      std::string pfat = "%" + suffix;
-      sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SUFFIX"), pfat.c_str(), pfat.length(), SQLITE_STATIC);
-    }
-    
-    if (_with_complexity != unlimited)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@COMPLEX"), _with_complexity);
-    }
-    
-    for (auto hyponym : _hypernym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@HYPO"), hyponym._id);
-    }
-    
-    for (auto hypernym : _hyponym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@HYPER"), hypernym._id);
-    }
-    
-    for (auto holonym : _part_meronym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@PHOLO"), holonym._id);
-    }
-    
-    for (auto meronym : _part_holonym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@PMERO"), meronym._id);
-    }
-    
-    for (auto holonym : _substance_meronym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SHOLO"), holonym._id);
-    }
-    
-    for (auto meronym : _substance_holonym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SMERO"), meronym._id);
-    }
-    
-    for (auto holonym : _member_meronym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@MHOLO"), holonym._id);
-    }
-    
-    for (auto meronym : _member_holonym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@MMERO"), meronym._id);
-    }
-    
-    for (auto cls : _instance_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@CLSID"), cls._id);
-    }
-    
-    for (auto inst : _class_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@INSID"), inst._id);
-    }
-    
-    for (auto synonym : _synonym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@SYNID"), synonym._id);
-    }
-    
-    for (auto antonym : _antonym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@ANTID"), antonym._id);
-    }
-    
-    for (auto pertainym : _anti_pertainym_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@PERID"), pertainym._id);
-    }
-    
-    for (auto value : _attribute_of.inorder_flatten())
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@VALID"), value._id);
-    }
     /*
     for (auto adj : _derived_from_adjective)
     {
@@ -1839,6 +1833,8 @@ namespace verbly {
       {
         tnc._plural = std::string(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 2)));
       }
+      
+      tnc._wnid = sqlite3_column_int(ppstmt, 3);
   
       output.push_back(tnc);
     }
@@ -72,6 +72,9 @@ namespace verbly {
       noun_query& is_attribute();
       noun_query& attribute_of(filter<adjective> _f);
       
+      noun_query& at_least_n_images(int _arg);
+      noun_query& with_wnid(int _arg);
+      
 /*      noun_query& derived_from(const word& _w);
       noun_query& not_derived_from(const word& _w);*/
       
@@ -146,6 +149,9 @@ namespace verbly {
       bool _is_attribute = false;
       filter<adjective> _attribute_of;
       
+      int _at_least_n_images = unlimited;
+      std::set<int> _with_wnid;
+      
 /*      std::list<adjective> _derived_from_adjective;
       std::list<adjective> _not_derived_from_adjective;
       std::list<adverb> _derived_from_adverb;
@@ -37,13 +37,19 @@ namespace verbly {
   {
     std::stringstream construct;
     construct << "SELECT form FROM prepositions";
+    std::list<binding> bindings;
     
     if (!_in_group.empty())
     {
-      std::list<std::string> clauses(_in_group.size(), "groupname = @GNAME");
+      std::list<std::string> clauses(_in_group.size(), "groupname = ?");
       construct << " WHERE preposition_id IN (SELECT preposition_id FROM preposition_groups WHERE ";
       construct << verbly::implode(std::begin(clauses), std::end(clauses), " OR ");
       construct << ")";
+      
+      for (auto g : _in_group)
+      {
+        bindings.emplace_back(g);
+      }
     }
     
     if (_random)
@@ -63,9 +69,27 @@ namespace verbly {
       throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
     }
     
-    for (auto& group : _in_group)
+    int i = 1;
+    for (auto& binding : bindings)
     {
-      sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@GNAME"), group.c_str(), group.length(), SQLITE_STATIC);
+      switch (binding.get_type())
+      {
+        case binding::type::integer:
+        {
+          sqlite3_bind_int(ppstmt, i, binding.get_integer());
+          
+          break;
+        }
+        
+        case binding::type::string:
+        {
+          sqlite3_bind_text(ppstmt, i, binding.get_string().c_str(), binding.get_string().length(), SQLITE_STATIC);
+          
+          break;
+        }
+      }
+      
+      i++;
     }
     
     std::list<preposition> output;
@@ -65,6 +65,7 @@ namespace verbly {
     std::stringstream construct;
     construct << "SELECT verb_id, infinitive, past_tense, past_participle, ing_form, s_form FROM verbs";
     std::list<std::string> conditions;
+    std::list<binding> bindings;
     
     if (_has_prn)
     {
@@ -73,14 +74,20 @@ namespace verbly {
     
     if (!_rhymes.empty())
     {
-      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE @RHMPRN");
+      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE ?");
       std::string cond = "verb_id IN (SELECT verb_id FROM verb_pronunciations WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
       conditions.push_back(cond);
+      
+      for (auto rhyme : _rhymes)
+      {
+        bindings.emplace_back("%" + rhyme);
+      }
     }
     
     for (auto except : _except)
     {
-      conditions.push_back("verb_id != @EXCID");
+      conditions.push_back("verb_id != ?");
+      bindings.emplace_back(except._id);
     }
     
     if (!_has_frames)
@@ -111,21 +118,27 @@ namespace verbly {
       throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
     }
     
-    if (!_rhymes.empty())
+    int i = 1;
+    for (auto& binding : bindings)
     {
-      int i = 0;
-      for (auto rhyme : _rhymes)
+      switch (binding.get_type())
       {
-        std::string rhymer = "%" + rhyme;
-        sqlite3_bind_text(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@RHMPRN"), rhymer.c_str(), rhymer.length(), SQLITE_STATIC);
+        case binding::type::integer:
+        {
+          sqlite3_bind_int(ppstmt, i, binding.get_integer());
+          
+          break;
+        }
         
-        i++;
+        case binding::type::string:
+        {
+          sqlite3_bind_text(ppstmt, i, binding.get_string().c_str(), binding.get_string().length(), SQLITE_STATIC);
+          
+          break;
+        }
       }
-    }
-    
-    for (auto except : _except)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@EXCID"), except._id);
+      
+      i++;
     }
     
     std::list<verb> output;