feat: add sequence meta api

src/common/exception/src/exception_code.rs

@@ -152,6 +152,10 @@ build_exceptions! {
     UnmatchMaskPolicyReturnType(1121),
     Timeout(1122),
     Outdated(1123),
+    // sequence
+    OutofSequenceRange(1124),
+    WrongSequenceCount(1125),
+    UnknownSequence(1126),
 
     // Data Related Errors
 
@@ -360,6 +364,9 @@ build_exceptions! {
     // Script error codes.
     ScriptSemanticError(3001),
     ScriptExecutionError(3002),
+
+    // sequence
+    SequenceError(3101),
 }
 
 // Storage errors [3001, 4000].

src/meta/api/src/lib.rs

@@ -29,6 +29,7 @@ pub mod reply;
 mod schema_api;
 mod schema_api_impl;
 mod schema_api_test_suite;
+mod sequence_api;
 mod share_api;
 mod share_api_impl;
 mod share_api_test_suite;
@@ -37,13 +38,15 @@ pub mod txn_backoff;
 pub(crate) mod util;
 
 pub mod crud;
+mod sequence_api_impl;
 
 pub use background_api::BackgroundApi;
 pub use background_api_test_suite::BackgroundApiTestSuite;
 pub use data_mask_api::DatamaskApi;
 pub use schema_api::SchemaApi;
 pub(crate) use schema_api_impl::get_db_or_err;
 pub use schema_api_test_suite::SchemaApiTestSuite;
+pub use sequence_api::SequenceApi;
 pub use share_api::ShareApi;
 pub use share_api_test_suite::ShareApiTestSuite;
 pub use util::assert_table_exist;

src/meta/api/src/schema_api_test_suite.rs

@@ -45,6 +45,7 @@ use databend_common_meta_app::schema::CreateDatabaseReq;
 use databend_common_meta_app::schema::CreateIndexReq;
 use databend_common_meta_app::schema::CreateLockRevReq;
 use databend_common_meta_app::schema::CreateOption;
+use databend_common_meta_app::schema::CreateSequenceReq;
 use databend_common_meta_app::schema::CreateTableIndexReq;
 use databend_common_meta_app::schema::CreateTableReq;
 use databend_common_meta_app::schema::CreateVirtualColumnReq;
@@ -60,6 +61,7 @@ use databend_common_meta_app::schema::DeleteLockRevReq;
 use databend_common_meta_app::schema::DropCatalogReq;
 use databend_common_meta_app::schema::DropDatabaseReq;
 use databend_common_meta_app::schema::DropIndexReq;
+use databend_common_meta_app::schema::DropSequenceReq;
 use databend_common_meta_app::schema::DropTableByIdReq;
 use databend_common_meta_app::schema::DropTableIndexReq;
 use databend_common_meta_app::schema::DropVirtualColumnReq;
@@ -70,6 +72,8 @@ use databend_common_meta_app::schema::GetCatalogReq;
 use databend_common_meta_app::schema::GetDatabaseReq;
 use databend_common_meta_app::schema::GetIndexReq;
 use databend_common_meta_app::schema::GetLVTReq;
+use databend_common_meta_app::schema::GetSequenceNextValueReq;
+use databend_common_meta_app::schema::GetSequenceReq;
 use databend_common_meta_app::schema::GetTableCopiedFileReq;
 use databend_common_meta_app::schema::GetTableReq;
 use databend_common_meta_app::schema::IcebergCatalogOption;
@@ -90,6 +94,7 @@ use databend_common_meta_app::schema::ListVirtualColumnsReq;
 use databend_common_meta_app::schema::LockKey;
 use databend_common_meta_app::schema::RenameDatabaseReq;
 use databend_common_meta_app::schema::RenameTableReq;
+use databend_common_meta_app::schema::SequenceNameIdent;
 use databend_common_meta_app::schema::SetLVTReq;
 use databend_common_meta_app::schema::SetTableColumnMaskPolicyAction;
 use databend_common_meta_app::schema::SetTableColumnMaskPolicyReq;
@@ -144,6 +149,7 @@ use crate::testing::get_kv_data;
 use crate::testing::get_kv_u64_data;
 use crate::DatamaskApi;
 use crate::SchemaApi;
+use crate::SequenceApi;
 use crate::ShareApi;
 use crate::DEFAULT_MGET_SIZE;
 
@@ -274,7 +280,7 @@ impl SchemaApiTestSuite {
     pub async fn test_single_node<B, MT>(b: B) -> anyhow::Result<()>
     where
         B: kvapi::ApiBuilder<MT>,
-        MT: ShareApi + kvapi::AsKVApi<Error = MetaError> + SchemaApi + DatamaskApi,
+        MT: ShareApi + kvapi::AsKVApi<Error = MetaError> + SchemaApi + DatamaskApi + SequenceApi,
     {
         let suite = SchemaApiTestSuite {};
 
@@ -351,6 +357,7 @@ impl SchemaApiTestSuite {
 
         suite.get_table_name_by_id(&b.build().await).await?;
         suite.get_db_name_by_id(&b.build().await).await?;
+        suite.test_sequence(&b.build().await).await?;
 
         Ok(())
     }
@@ -5203,6 +5210,123 @@ impl SchemaApiTestSuite {
         Ok(())
     }
 
+    #[minitrace::trace]
+    async fn test_sequence<MT: SchemaApi + SequenceApi + kvapi::AsKVApi<Error = MetaError>>(
+        &self,
+        mt: &MT,
+    ) -> anyhow::Result<()> {
+        let tenant = "tenant1";
+        let sequence_name = "seq";
+
+        let create_on = Utc::now();
+
+        info!("--- create sequence");
+        {
+            let req = CreateSequenceReq {
+                create_option: CreateOption::Create,
+                name_ident: SequenceNameIdent {
+                    tenant: Tenant::new_or_err(tenant, func_name!())?,
+                    sequence_name: sequence_name.to_string(),
+                },
+                create_on,
+                comment: Some("seq".to_string()),
+            };
+
+            let _resp = mt.create_sequence(req).await?;
+        }
+
+        info!("--- get sequence");
+        {
+            let req = GetSequenceReq {
+                name_ident: SequenceNameIdent {
+                    tenant: Tenant::new_or_err(tenant, func_name!())?,
+                    sequence_name: sequence_name.to_string(),
+                },
+            };
+            let resp = mt.get_sequence(req).await?;
+            assert_eq!(resp.meta.comment, Some("seq".to_string()));
+            assert_eq!(resp.meta.current, 1);
+        }
+
+        info!("--- get sequence nextval");
+        {
+            let req = GetSequenceNextValueReq {
+                name_ident: SequenceNameIdent {
+                    tenant: Tenant::new_or_err(tenant, func_name!())?,
+                    sequence_name: sequence_name.to_string(),
+                },
+                count: 10,
+            };
+            let resp = mt.get_sequence_next_value(req).await?;
+            assert_eq!(resp.start, 1);
+            assert_eq!(resp.end, 10);
+        }
+
+        info!("--- get sequence after nextval");
+        {
+            let req = GetSequenceReq {
+                name_ident: SequenceNameIdent {
+                    tenant: Tenant::new_or_err(tenant, func_name!())?,
+                    sequence_name: sequence_name.to_string(),
+                },
+            };
+
+            let resp = mt.get_sequence(req).await?;
+            assert_eq!(resp.meta.comment, Some("seq".to_string()));
+            assert_eq!(resp.meta.current, 11);
+        }
+
+        info!("--- replace sequence");
+        {
+            let req = CreateSequenceReq {
+                create_option: CreateOption::CreateOrReplace,
+                name_ident: SequenceNameIdent {
+                    tenant: Tenant::new_or_err(tenant, func_name!())?,
+                    sequence_name: sequence_name.to_string(),
+                },
+                create_on,
+                comment: Some("seq1".to_string()),
+            };
+
+            let _resp = mt.create_sequence(req).await?;
+
+            let req = GetSequenceReq {
+                name_ident: SequenceNameIdent {
+                    tenant: Tenant::new_or_err(tenant, func_name!())?,
+                    sequence_name: sequence_name.to_string(),
+                },
+            };
+
+            let resp = mt.get_sequence(req).await?;
+            assert_eq!(resp.meta.comment, Some("seq1".to_string()));
+            assert_eq!(resp.meta.current, 1);
+        }
+
+        {
+            let req = DropSequenceReq {
+                name_ident: SequenceNameIdent {
+                    tenant: Tenant::new_or_err(tenant, func_name!())?,
+                    sequence_name: sequence_name.to_string(),
+                },
+                if_exists: true,
+            };
+
+            let _resp = mt.drop_sequence(req).await?;
+
+            let req = GetSequenceReq {
+                name_ident: SequenceNameIdent {
+                    tenant: Tenant::new_or_err(tenant, func_name!())?,
+                    sequence_name: sequence_name.to_string(),
+                },
+            };
+
+            let resp = mt.get_sequence(req).await;
+            assert!(resp.is_err());
+        }
+
+        Ok(())
+    }
+
     #[minitrace::trace]
     async fn get_table_copied_file<MT: SchemaApi>(&self, mt: &MT) -> anyhow::Result<()> {
         let tenant_name = "tenant1";

src/meta/api/src/sequence_api.rs

@@ -0,0 +1,41 @@
+// Copyright 2021 Datafuse Labs
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use databend_common_meta_app::schema::CreateSequenceReply;
+use databend_common_meta_app::schema::CreateSequenceReq;
+use databend_common_meta_app::schema::DropSequenceReply;
+use databend_common_meta_app::schema::DropSequenceReq;
+use databend_common_meta_app::schema::GetSequenceNextValueReply;
+use databend_common_meta_app::schema::GetSequenceNextValueReq;
+use databend_common_meta_app::schema::GetSequenceReply;
+use databend_common_meta_app::schema::GetSequenceReq;
+
+use crate::kv_app_error::KVAppError;
+
+#[async_trait::async_trait]
+pub trait SequenceApi: Send + Sync {
+    async fn create_sequence(
+        &self,
+        req: CreateSequenceReq,
+    ) -> Result<CreateSequenceReply, KVAppError>;
+
+    async fn get_sequence(&self, req: GetSequenceReq) -> Result<GetSequenceReply, KVAppError>;
+
+    async fn get_sequence_next_value(
+        &self,
+        req: GetSequenceNextValueReq,
+    ) -> Result<GetSequenceNextValueReply, KVAppError>;
+
+    async fn drop_sequence(&self, req: DropSequenceReq) -> Result<DropSequenceReply, KVAppError>;
+}