16 files changed, 813 insertions, 331 deletions

@@ -33,7 +33,7 @@ namespace verbly {
   
   adjective_query& adjective_query::rhymes_with(const word& _word)
   {
-    for (auto rhyme : _word.rhyme_phonemes())
+    for (auto rhyme : _word.get_rhymes())
     {
       _rhymes.push_back(rhyme);
     }
@@ -53,6 +53,34 @@ namespace verbly {
     return *this;
   }
   
+  adjective_query& adjective_query::has_rhyming_noun()
+  {
+    _has_rhyming_noun = true;
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::has_rhyming_adjective()
+  {
+    _has_rhyming_adjective = true;
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::has_rhyming_adverb()
+  {
+    _has_rhyming_adverb = true;
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::has_rhyming_verb()
+  {
+    _has_rhyming_verb = true;
+    
+    return *this;
+  }
+  
   adjective_query& adjective_query::with_prefix(filter<std::string> _f)
   {
     _f.clean();
@@ -218,6 +246,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 +255,41 @@ namespace verbly {
     
     if (!_rhymes.empty())
     {
-      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE @RHMPRN");
+      std::list<std::string> clauses(_rhymes.size(), "(prerhyme != ? AND rhyme = ?)");
       std::string cond = "adjective_id IN (SELECT adjective_id FROM adjective_pronunciations WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
       conditions.push_back(cond);
+      
+      for (auto rhy : _rhymes)
+      {
+        bindings.emplace_back(rhy.get_prerhyme());
+        bindings.emplace_back(rhy.get_rhyme());
+      }
+    }
+    
+    if (_has_rhyming_noun)
+    {
+      conditions.push_back("adjective_id IN (SELECT a.adjective_id FROM adjectives AS a INNER JOIN adjective_pronunciations AS curp ON curp.adjective_id = a.adjective_id INNER JOIN noun_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
+    }
+    
+    if (_has_rhyming_adjective)
+    {
+      conditions.push_back("adjective_id IN (SELECT a.adjective_id FROM adjectives AS a INNER JOIN adjective_pronunciations AS curp ON curp.adjective_id = a.adjective_id INNER JOIN adjective_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme AND rhmp.adjective_id != curp.adjective_id)");
+    }
+    
+    if (_has_rhyming_adverb)
+    {
+      conditions.push_back("adjective_id IN (SELECT a.adjective_id FROM adjectives AS a INNER JOIN adjective_pronunciations AS curp ON curp.adjective_id = a.adjective_id INNER JOIN adverb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
+    }
+    
+    if (_has_rhyming_verb)
+    {
+      conditions.push_back("adjective_id IN (SELECT a.adjective_id FROM adjectives AS a INNER JOIN adjective_pronunciations AS curp ON curp.adjective_id = a.adjective_id INNER JOIN verb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
     }
     
     for (auto except : _except)
     {
-      conditions.push_back("adjective_id != @EXCID");
+      conditions.push_back("adjective_id != ?");
+      bindings.emplace_back(except._id);
     }
     
     if (_requires_comparative_form)
@@ -261,11 +317,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 +356,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 +390,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 +416,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 +472,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 +528,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 +584,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 +640,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 +696,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 +752,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 +851,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_TRANSIENT);
+          
+          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)
     {
@@ -913,7 +943,7 @@ namespace verbly {
     
     for (auto& adjective : output)
     {
-      query = "SELECT pronunciation FROM adjective_pronunciations WHERE adjective_id = ?";
+      query = "SELECT pronunciation, prerhyme, rhyme FROM adjective_pronunciations WHERE adjective_id = ?";
       if (sqlite3_prepare_v2(_data.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
       {
         throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
@@ -927,6 +957,13 @@ namespace verbly {
         auto phonemes = verbly::split<std::list<std::string>>(pronunciation, " ");
         
         adjective.pronunciations.push_back(phonemes);
+        
+        if ((sqlite3_column_type(ppstmt, 1) != SQLITE_NULL) && (sqlite3_column_type(ppstmt, 2) != SQLITE_NULL))
+        {
+          std::string prerhyme(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
+          std::string rhyming(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 2)));
+          adjective.rhymes.emplace_back(prerhyme, rhyming);
+        }
       }
       
       sqlite3_finalize(ppstmt);
@@ -12,6 +12,10 @@ namespace verbly {
       adjective_query& except(const adjective& _word);
       adjective_query& rhymes_with(const word& _word);
       adjective_query& has_pronunciation();
+      adjective_query& has_rhyming_noun();
+      adjective_query& has_rhyming_adjective();
+      adjective_query& has_rhyming_adverb();
+      adjective_query& has_rhyming_verb();
       
       adjective_query& requires_comparative_form();
       adjective_query& requires_superlative_form();
@@ -54,9 +58,13 @@ namespace verbly {
       const data& _data;
       int _limit = unlimited;
       bool _random = false;
-      std::list<std::string> _rhymes;
+      std::list<rhyme> _rhymes;
       std::list<adjective> _except;
       bool _has_prn = false;
+      bool _has_rhyming_noun = false;
+      bool _has_rhyming_adjective = false;
+      bool _has_rhyming_adverb = false;
+      bool _has_rhyming_verb = false;
       
       bool _requires_comparative_form = false;
       bool _requires_superlative_form = false;
@@ -33,7 +33,7 @@ namespace verbly {
   
   adverb_query& adverb_query::rhymes_with(const word& _word)
   {
-    for (auto rhyme : _word.rhyme_phonemes())
+    for (auto rhyme : _word.get_rhymes())
     {
       _rhymes.push_back(rhyme);
     }
@@ -53,6 +53,34 @@ namespace verbly {
     return *this;
   }
   
+  adverb_query& adverb_query::has_rhyming_noun()
+  {
+    _has_rhyming_noun = true;
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::has_rhyming_adjective()
+  {
+    _has_rhyming_adjective = true;
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::has_rhyming_adverb()
+  {
+    _has_rhyming_adverb = true;
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::has_rhyming_verb()
+  {
+    _has_rhyming_verb = true;
+    
+    return *this;
+  }
+  
   adverb_query& adverb_query::requires_comparative_form()
   {
     _requires_comparative_form = true;
@@ -172,6 +200,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 +209,41 @@ namespace verbly {
     
     if (!_rhymes.empty())
     {
-      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE @RHMPRN");
+      std::list<std::string> clauses(_rhymes.size(), "(prerhyme != ? AND rhyme = ?)");
       std::string cond = "adverb_id IN (SELECT adverb_id FROM adverb_pronunciations WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
       conditions.push_back(cond);
+      
+      for (auto rhy : _rhymes)
+      {
+        bindings.emplace_back(rhy.get_prerhyme());
+        bindings.emplace_back(rhy.get_rhyme());
+      }
+    }
+    
+    if (_has_rhyming_noun)
+    {
+      conditions.push_back("adverb_id IN (SELECT a.adverb_id FROM adverbs AS a INNER JOIN adverb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN noun_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
+    }
+    
+    if (_has_rhyming_adjective)
+    {
+      conditions.push_back("adverb_id IN (SELECT a.adverb_id FROM adverbs AS a INNER JOIN adverb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN adjective_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
+    }
+    
+    if (_has_rhyming_adverb)
+    {
+      conditions.push_back("adverb_id IN (SELECT a.adverb_id FROM adverbs AS a INNER JOIN adverb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN adverb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme AND rhmp.adverb_id != curp.adverb_id)");
+    }
+    
+    if (_has_rhyming_verb)
+    {
+      conditions.push_back("adverb_id IN (SELECT a.adverb_id FROM adverbs AS a INNER JOIN adverb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN verb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
     }
     
     for (auto except : _except)
     {
-      conditions.push_back("adverb_id != @EXCID");
+      conditions.push_back("adverb_id != ?");
+      bindings.emplace_back(except._id);
     }
     
     if (_requires_comparative_form)
@@ -207,11 +263,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 +302,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 +336,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 +362,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 +418,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 +474,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 +573,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_TRANSIENT);
+          
+          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)
     {
@@ -608,7 +650,7 @@ namespace verbly {
     
     for (auto& adverb : output)
     {
-      query = "SELECT pronunciation FROM adverb_pronunciations WHERE adverb_id = ?";
+      query = "SELECT pronunciation, prerhyme, rhyme FROM adverb_pronunciations WHERE adverb_id = ?";
       if (sqlite3_prepare_v2(_data.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
       {
         throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
@@ -622,6 +664,13 @@ namespace verbly {
         auto phonemes = verbly::split<std::list<std::string>>(pronunciation, " ");
         
         adverb.pronunciations.push_back(phonemes);
+        
+        if ((sqlite3_column_type(ppstmt, 1) != SQLITE_NULL) && (sqlite3_column_type(ppstmt, 2) != SQLITE_NULL))
+        {
+          std::string prerhyme(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
+          std::string rhyming(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 2)));
+          adverb.rhymes.emplace_back(prerhyme, rhyming);
+        }
       }
       
       sqlite3_finalize(ppstmt);
@@ -12,6 +12,10 @@ namespace verbly {
       adverb_query& except(const adverb& _word);
       adverb_query& rhymes_with(const word& _word);
       adverb_query& has_pronunciation();
+      adverb_query& has_rhyming_noun();
+      adverb_query& has_rhyming_adjective();
+      adverb_query& has_rhyming_adverb();
+      adverb_query& has_rhyming_verb();
       
       adverb_query& requires_comparative_form();
       adverb_query& requires_superlative_form();
@@ -41,9 +45,13 @@ namespace verbly {
       const data& _data;
       int _limit = unlimited;
       bool _random = false;
-      std::list<std::string> _rhymes;
+      std::list<rhyme> _rhymes;
       std::list<adverb> _except;
       bool _has_prn = false;
+      bool _has_rhyming_noun = false;
+      bool _has_rhyming_adjective = false;
+      bool _has_rhyming_adverb = false;
+      bool _has_rhyming_verb = false;
       
       bool _requires_comparative_form = false;
       bool _requires_superlative_form = false;
@@ -1,7 +1,7 @@
 #include "verbly.h"
 
 namespace verbly {
-
+  
   data::data(std::string datafile)
   {
     if (sqlite3_open_v2(datafile.c_str(), &ppdb, SQLITE_OPEN_READONLY, NULL) != SQLITE_OK)
@@ -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_TRANSIENT);
+          
+          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;
   };
   
@@ -33,7 +33,7 @@ namespace verbly {
   
   noun_query& noun_query::rhymes_with(const word& _word)
   {
-    for (auto rhyme : _word.rhyme_phonemes())
+    for (auto rhyme : _word.get_rhymes())
     {
       _rhymes.push_back(rhyme);
     }
@@ -53,6 +53,34 @@ namespace verbly {
     return *this;
   }
   
+  noun_query& noun_query::has_rhyming_noun()
+  {
+    _has_rhyming_noun = true;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::has_rhyming_adjective()
+  {
+    _has_rhyming_adjective = true;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::has_rhyming_adverb()
+  {
+    _has_rhyming_adverb = true;
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::has_rhyming_verb()
+  {
+    _has_rhyming_verb = true;
+    
+    return *this;
+  }
+  
   noun_query& noun_query::with_singular_form(std::string _arg)
   {
     _with_singular_form.push_back(_arg);
@@ -377,6 +405,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)
   {
@@ -464,8 +507,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)
     {
@@ -474,21 +518,53 @@ namespace verbly {
     
     if (!_rhymes.empty())
     {
-      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE @RHMPRN");
+      std::list<std::string> clauses(_rhymes.size(), "(prerhyme != ? AND rhyme = ?)");
       std::string cond = "noun_id IN (SELECT noun_id FROM noun_pronunciations WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
       conditions.push_back(cond);
+      
+      for (auto rhy : _rhymes)
+      {
+        bindings.emplace_back(rhy.get_prerhyme());
+        bindings.emplace_back(rhy.get_rhyme());
+      }
     }
     
+    if (_has_rhyming_noun)
+    {
+      conditions.push_back("noun_id IN (SELECT a.noun_id FROM nouns AS a INNER JOIN noun_pronunciations AS curp ON curp.noun_id = a.noun_id INNER JOIN noun_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme AND rhmp.noun_id != curp.noun_id)");
+    }
+    
+    if (_has_rhyming_adjective)
+    {
+      conditions.push_back("noun_id IN (SELECT a.noun_id FROM nouns AS a INNER JOIN noun_pronunciations AS curp ON curp.noun_id = a.noun_id INNER JOIN adjective_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
+    }
+    
+    if (_has_rhyming_adverb)
+    {
+      conditions.push_back("noun_id IN (SELECT a.noun_id FROM nouns AS a INNER JOIN noun_pronunciations AS curp ON curp.noun_id = a.noun_id INNER JOIN adverb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
+    }
+    
+    if (_has_rhyming_verb)
+    {
+      conditions.push_back("noun_id IN (SELECT a.noun_id FROM nouns AS a INNER JOIN noun_pronunciations AS curp ON curp.noun_id = a.noun_id INNER JOIN verb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
+    }
+
     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 (_requires_plural_form)
@@ -503,11 +579,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 ?";
             }
           }
           
@@ -540,11 +618,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 ?";
             }
           }
           
@@ -572,7 +652,8 @@ namespace verbly {
     
     if (_with_complexity != unlimited)
     {
-      conditions.push_back("complexity = @COMPLEX");
+      conditions.push_back("complexity = ?");
+      bindings.emplace_back(_with_complexity);
     }
     
     if (_is_hypernym)
@@ -597,11 +678,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 != ?";
             }
           }
           
@@ -725,11 +808,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 != ?";
             }
           }
           
@@ -779,11 +864,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 != ?";
             }
           }
           
@@ -870,11 +957,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 != ?";
             }
           }
           
@@ -961,11 +1050,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 != ?";
             }
           }
           
@@ -1052,11 +1143,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 != ?";
             }
           }
           
@@ -1143,11 +1236,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 != ?";
             }
           }
           
@@ -1234,11 +1329,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 != ?";
             }
           }
           
@@ -1335,11 +1432,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 != ?";
             }
           }
           
@@ -1389,11 +1488,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 != ?";
             }
           }
           
@@ -1443,11 +1544,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 != ?";
             }
           }
           
@@ -1497,11 +1600,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 != ?";
             }
           }
           
@@ -1551,11 +1656,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 != ?";
             }
           }
           
@@ -1605,11 +1712,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 != ?";
             }
           }
           
@@ -1636,6 +1745,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())
     {
@@ -1701,115 +1829,30 @@ 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_TRANSIENT);
+          
+          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)
     {
@@ -1851,6 +1894,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);
     }
@@ -1859,7 +1904,7 @@ namespace verbly {
     
     for (auto& noun : output)
     {
-      query = "SELECT pronunciation FROM noun_pronunciations WHERE noun_id = ?";
+      query = "SELECT pronunciation, prerhyme, rhyme FROM noun_pronunciations WHERE noun_id = ?";
       if (sqlite3_prepare_v2(_data.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
       {
         throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
@@ -1873,6 +1918,14 @@ namespace verbly {
         auto phonemes = verbly::split<std::list<std::string>>(pronunciation, " ");
         
         noun.pronunciations.push_back(phonemes);
+        
+        if ((sqlite3_column_type(ppstmt, 1) != SQLITE_NULL) && (sqlite3_column_type(ppstmt, 2) != SQLITE_NULL))
+        {
+          std::string prerhyme(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
+          std::string rhyming(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 2)));
+          
+          noun.rhymes.emplace_back(prerhyme, rhyming);
+        }
       }
       
       sqlite3_finalize(ppstmt);
@@ -12,6 +12,10 @@ namespace verbly {
       noun_query& except(const noun& _word);
       noun_query& rhymes_with(const word& _word);
       noun_query& has_pronunciation();
+      noun_query& has_rhyming_noun();
+      noun_query& has_rhyming_adjective();
+      noun_query& has_rhyming_adverb();
+      noun_query& has_rhyming_verb();
       
       noun_query& with_singular_form(std::string _arg);
       noun_query& with_prefix(filter<std::string> _f);
@@ -74,6 +78,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);*/
       
@@ -85,9 +92,13 @@ namespace verbly {
       const data& _data;
       int _limit = unlimited;
       bool _random = false;
-      std::list<std::string> _rhymes;
+      std::list<rhyme> _rhymes;
       std::list<noun> _except;
       bool _has_prn = false;
+      bool _has_rhyming_noun = false;
+      bool _has_rhyming_adjective = false;
+      bool _has_rhyming_adverb = false;
+      bool _has_rhyming_verb = false;
       
       std::list<std::string> _with_singular_form;
       filter<std::string> _with_prefix;
@@ -150,6 +161,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_TRANSIENT);
+          
+          break;
+        }
+      }
+      
+      i++;
     }
     
     std::list<preposition> output;
@@ -33,7 +33,7 @@ namespace verbly {
   
   verb_query& verb_query::rhymes_with(const word& _word)
   {
-    for (auto rhyme : _word.rhyme_phonemes())
+    for (auto rhyme : _word.get_rhymes())
     {
       _rhymes.push_back(rhyme);
     }
@@ -53,6 +53,34 @@ namespace verbly {
     return *this;
   }
   
+  verb_query& verb_query::has_rhyming_noun()
+  {
+    _has_rhyming_noun = true;
+    
+    return *this;
+  }
+  
+  verb_query& verb_query::has_rhyming_adjective()
+  {
+    _has_rhyming_adjective = true;
+    
+    return *this;
+  }
+  
+  verb_query& verb_query::has_rhyming_adverb()
+  {
+    _has_rhyming_adverb = true;
+    
+    return *this;
+  }
+  
+  verb_query& verb_query::has_rhyming_verb()
+  {
+    _has_rhyming_verb = true;
+    
+    return *this;
+  }
+  
   verb_query& verb_query::has_frames()
   {
     this->_has_frames = true;
@@ -65,6 +93,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 +102,41 @@ namespace verbly {
     
     if (!_rhymes.empty())
     {
-      std::list<std::string> clauses(_rhymes.size(), "pronunciation LIKE @RHMPRN");
+      std::list<std::string> clauses(_rhymes.size(), "(prerhyme != ? AND rhyme = ?)");
       std::string cond = "verb_id IN (SELECT verb_id FROM verb_pronunciations WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
       conditions.push_back(cond);
+      
+      for (auto rhy : _rhymes)
+      {
+        bindings.emplace_back(rhy.get_prerhyme());
+        bindings.emplace_back(rhy.get_rhyme());
+      }
+    }
+    
+    if (_has_rhyming_noun)
+    {
+      conditions.push_back("verb_id IN (SELECT a.verb_id FROM verbs AS a INNER JOIN verb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN noun_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
+    }
+    
+    if (_has_rhyming_adjective)
+    {
+      conditions.push_back("verb_id IN (SELECT a.verb_id FROM verbs AS a INNER JOIN verb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN adjective_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
+    }
+    
+    if (_has_rhyming_adverb)
+    {
+      conditions.push_back("verb_id IN (SELECT a.verb_id FROM verbs AS a INNER JOIN verb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN adverb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme)");
+    }
+    
+    if (_has_rhyming_verb)
+    {
+      conditions.push_back("verb_id IN (SELECT a.verb_id FROM verbs AS a INNER JOIN verb_pronunciations AS curp ON curp.noun_id = a.adverb_id INNER JOIN verb_pronunciations AS rhmp ON rhmp.prerhyme != curp.prerhyme AND rhmp.rhyme = curp.rhyme AND rhmp.verb_id != curp.verb_id)");
     }
     
     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 +167,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_TRANSIENT);
+          
+          break;
+        }
       }
-    }
-    
-    for (auto except : _except)
-    {
-      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@EXCID"), except._id);
+      
+      i++;
     }
     
     std::list<verb> output;
@@ -145,7 +207,7 @@ namespace verbly {
     
     for (auto& verb : output)
     {
-      query = "SELECT pronunciation FROM verb_pronunciations WHERE verb_id = ?";
+      query = "SELECT pronunciation, prerhyme, rhyme FROM verb_pronunciations WHERE verb_id = ?";
       if (sqlite3_prepare_v2(_data.ppdb, query.c_str(), query.length(), &ppstmt, NULL) != SQLITE_OK)
       {
         throw std::runtime_error(sqlite3_errmsg(_data.ppdb));
@@ -159,6 +221,13 @@ namespace verbly {
         auto phonemes = verbly::split<std::list<std::string>>(pronunciation, " ");
         
         verb.pronunciations.push_back(phonemes);
+        
+        if ((sqlite3_column_type(ppstmt, 1) != SQLITE_NULL) && (sqlite3_column_type(ppstmt, 2) != SQLITE_NULL))
+        {
+          std::string prerhyme(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 1)));
+          std::string rhyming(reinterpret_cast<const char*>(sqlite3_column_text(ppstmt, 2)));
+          verb.rhymes.emplace_back(prerhyme, rhyming);
+        }
       }
       
       sqlite3_finalize(ppstmt);
@@ -12,6 +12,10 @@ namespace verbly {
       verb_query& except(const verb& _word);
       verb_query& rhymes_with(const word& _word);
       verb_query& has_pronunciation();
+      verb_query& has_rhyming_noun();
+      verb_query& has_rhyming_adjective();
+      verb_query& has_rhyming_adverb();
+      verb_query& has_rhyming_verb();
       
       verb_query& has_frames();
       
@@ -23,10 +27,14 @@ namespace verbly {
       const data& _data;
       int _limit = unlimited;
       bool _random = false;
-      std::list<std::string> _rhymes;
+      std::list<rhyme> _rhymes;
       std::list<verb> _except;
       bool _has_prn = false;
       bool _has_frames = false;
+      bool _has_rhyming_noun = false;
+      bool _has_rhyming_adjective = false;
+      bool _has_rhyming_adverb = false;
+      bool _has_rhyming_verb = false;
   };
 
 };
@@ -3,6 +3,26 @@
 
 namespace verbly {
   
+  rhyme::rhyme(std::string prerhyme, std::string phonemes) : _prerhyme(prerhyme), _rhyme(phonemes)
+  {
+    
+  }
+  
+  std::string rhyme::get_prerhyme() const
+  {
+    return _prerhyme;
+  }
+  
+  std::string rhyme::get_rhyme() const
+  {
+    return _rhyme;
+  }
+  
+  bool rhyme::operator==(const rhyme& other) const
+  {
+    return std::tie(_prerhyme, _rhyme) == std::tie(other._prerhyme, other._rhyme);
+  }
+  
   word::word()
   {
     
@@ -13,28 +33,11 @@ namespace verbly {
     
   }
   
-  std::list<std::string> word::rhyme_phonemes() const
+  std::list<rhyme> word::get_rhymes() const
   {
     assert(_valid == true);
     
-    std::list<std::string> result;
-    
-    for (auto pronunciation : pronunciations)
-    {
-      auto phemstrt = std::find_if(std::begin(pronunciation), std::end(pronunciation), [] (std::string phoneme) {
-        return phoneme.find("1") != std::string::npos;
-      });
-      
-      std::stringstream rhymer;
-      for (auto it = phemstrt; it != std::end(pronunciation); it++)
-      {
-        rhymer << " " << *it;
-      }
-      
-      result.push_back(rhymer.str());
-    }
-    
-    return result;
+    return rhymes;
   }
   
   bool word::starts_with_vowel_sound() const
@@ -3,6 +3,20 @@
 
 namespace verbly {
   
+  class rhyme {
+    public:
+      rhyme(std::string prerhyme, std::string phonemes);
+      
+      std::string get_prerhyme() const;
+      std::string get_rhyme() const;
+      
+      bool operator==(const rhyme& other) const;
+      
+    private:
+      std::string _prerhyme;
+      std::string _rhyme;
+  };
+  
   class word {
     protected:
       const data* _data;
@@ -10,6 +24,7 @@ namespace verbly {
       bool _valid = false;
       
       std::list<std::list<std::string>> pronunciations;
+      std::list<rhyme> rhymes;
       
       word();
       word(const data& _data, int _id);
@@ -24,7 +39,7 @@ namespace verbly {
     public:
       virtual std::string base_form() const = 0;
       
-      std::list<std::string> rhyme_phonemes() const;
+      std::list<rhyme> get_rhymes() const;
       bool starts_with_vowel_sound() const;
   };