[15721] Sequence second PR

src/catalog/catalog.cpp

@@ -30,6 +30,8 @@
 #include "function/date_functions.h"
 #include "function/decimal_functions.h"
 #include "function/old_engine_string_functions.h"
+#include "function/string_functions.h"
+#include "function/sequence_functions.h"
 #include "function/timestamp_functions.h"
 #include "index/index_factory.h"
 #include "settings/settings_manager.h"
@@ -1204,6 +1206,20 @@ void Catalog::InitializeFunctions() {
           function::BuiltInFuncType{OperatorId::Like,
                                     function::OldEngineStringFunctions::Like},
           txn);
+      // Sequence
+      AddBuiltinFunction(
+              "nextval", {type::TypeId::VARCHAR}, type::TypeId::INTEGER,
+              internal_lang, "Nextval",
+              function::BuiltInFuncType{OperatorId::Nextval,
+                                        function::SequenceFunctions::_Nextval},
+              txn);
+      AddBuiltinFunction(
+              "currval", {type::TypeId::VARCHAR}, type::TypeId::INTEGER,
+              internal_lang, "Currval",
+              function::BuiltInFuncType{OperatorId::Currval,
+                                        function::SequenceFunctions::_Currval},
+              txn);
+
 
       /**
        * decimal functions

src/catalog/catalog_cache.cpp

@@ -13,8 +13,10 @@
 #include <memory>
 
 #include "catalog/catalog_cache.h"
+#include <boost/functional/hash.hpp>
 
 #include "catalog/database_catalog.h"
+#include "catalog/sequence_catalog.h"
 #include "common/logger.h"
 
 namespace peloton {
@@ -157,5 +159,76 @@ std::shared_ptr<IndexCatalogObject> CatalogCache::GetCachedIndexObject(
   return nullptr;
 }
 
+/*@brief   insert sequence catalog object into cache
+ * @param   sequence_object
+ * @return  false only if sequence already exists in cache
+ */
+bool CatalogCache::InsertSequenceObject(
+    std::shared_ptr<SequenceCatalogObject> sequence_object) {
+  if (!sequence_object || sequence_object->seq_oid == INVALID_OID) {
+    return false;  // invalid object
+  }
+
+  std::size_t hash_key = GetHashKey(sequence_object->seq_name,
+                                    sequence_object->db_oid);
+
+  // check if already in cache
+  if (sequence_objects_cache.find(hash_key) !=
+          sequence_objects_cache.end()) {
+    LOG_DEBUG("Sequence %s already exists in cache!",
+              sequence_object->seq_name.c_str());
+    return false;
+  }
+
+  sequence_objects_cache.insert(
+          std::make_pair(hash_key, sequence_object));
+  return true;
+}
+
+/*@brief   evict sequence catalog object from cache
+ * @param   sequence_name, database_oid
+ * @return  true if specified sequence is found and evicted;
+ *          false if not found
+ */
+bool CatalogCache::EvictSequenceObject(const std::string & sequence_name,
+         oid_t database_oid) {
+  std::size_t hash_key = GetHashKey(sequence_name, database_oid);
+
+  auto it = sequence_objects_cache.find(hash_key);
+  if (it == sequence_objects_cache.end()) {
+    return false;  // sequence not found in cache
+  }
+
+  auto sequence_object = it->second;
+  PELOTON_ASSERT(sequence_object);
+  sequence_objects_cache.erase(it);
+  return true;
+}
+
+/*@brief   get sequence catalog object from cache
+ * @param  sequence_name, database_oid
+ * @return  sequence catalog object; if not found return object with invalid oid
+ */
+std::shared_ptr<SequenceCatalogObject> CatalogCache::GetSequenceObject(
+            const std::string & sequence_name, oid_t database_oid) {
+  std::size_t hash_key = GetHashKey(sequence_name, database_oid);
+  auto it = sequence_objects_cache.find(hash_key);
+  if (it == sequence_objects_cache.end()) {
+    return nullptr;
+  }
+  return it->second;
+}
+
+/*@brief  get the hash key given the sequence information
+ * @param  sequence_name, database_oid
+ * @return  hash key
+ */
+std::size_t CatalogCache::GetHashKey(const std::string sequence_name,
+     oid_t database_oid) {
+  std::tuple<std::string, size_t> key(sequence_name, database_oid);
+  boost::hash<std::tuple<std::string, size_t>> key_hash;
+  return key_hash(key);
+}
+
 }  // namespace catalog
 }  // namespace peloton