feat: Move create table logic to frontend (#455)

* refactor: dependency, from frontend depends on datanode to datanode depends on frontend * wip: start frontend in datanode * wip: migrate create database to frontend * wip: impl alter table * fix: CR comments * feat: add table id and region ids field to CreateExpr * chore: rebase develop * refactor: frontend catalog should set from datanode * feat: gRPC AddColumn request support add multi columns * wip: move create table and create-on-insertion to frontend * wip: error handling * fix: some unit tests * fix: all unit tests * chore: merge develop * feat: add create/alter-on-insertion to dist_insert/sql_dist_insert * fix: add region number/catalog/schema to InsertExpr * feat: add handle_create_table/handle_create_database... * fix: remove catalog from insert expr * fix: CR comments * fix: when running in standalone mode, mysql opts and postgres opts should pass to frontend so that auctually running service can change the port to listen on * refactor: add a standalone subcommand, move frontend start stuff to cmd package * chore: optimize create table failure logs * docs: change readme * docs: update readme
2026-05-26 01:40:36 +00:00 · 2022-11-14 10:54:35 +08:00
parent 488eabce4a
commit fae331d2ba
52 changed files with 1356 additions and 721 deletions
--- a/src/api/greptime/v1/admin.proto
+++ b/src/api/greptime/v1/admin.proto
@@ -41,6 +41,8 @@ message CreateExpr {
  repeated string primary_keys = 7;
  bool create_if_not_exists = 8;
  map<string, string> table_options = 9;
+  optional uint32 table_id = 10;
+  repeated uint32 region_ids = 11;
 }

 message AlterExpr {
@@ -48,12 +50,17 @@ message AlterExpr {
  optional string schema_name = 2;
  string table_name = 3;
  oneof kind {
-    AddColumn add_column = 4;
+    AddColumns add_columns = 4;
  }
 }

+message AddColumns {
+  repeated AddColumn add_columns = 1;
+}
+
 message AddColumn {
  ColumnDef column_def = 1;
+  bool is_key = 2;
 }

 message CreateDatabaseExpr {
--- a/src/api/greptime/v1/database.proto
+++ b/src/api/greptime/v1/database.proto
@@ -38,14 +38,15 @@ message PhysicalPlan {
 }

 message InsertExpr {
-  string table_name = 1;
+  string schema_name = 1;
+  string table_name = 2;

  message Values {
-    repeated bytes values = 1;
+    repeated bytes values = 3;
  }

  oneof expr {
-    Values values = 2;
+    Values values = 4;

    // TODO(LFC): Remove field "sql" in InsertExpr.
    // When Frontend instance received an insertion SQL (`insert into ...`), it's anticipated to parse the SQL and
@@ -54,10 +55,12 @@ message InsertExpr {
    // Then why the "sql" field exists here? It's because the Frontend needs table schema to create the values to insert,
    // which is currently not able to find anywhere. (Maybe the table schema is suppose to be fetched from Meta?)
    // The "sql" field is meant to be removed in the future.
-    string sql = 3;
+    string sql = 5;
  }

-  map<string, bytes> options = 4;
+  /// The region number of current insert request.
+  uint32 region_number = 6;
+  map<string, bytes> options = 7;
 }

 // TODO(jiachun)
--- a/src/api/src/lib.rs
+++ b/src/api/src/lib.rs
@@ -1,6 +1,7 @@
 pub mod error;
 pub mod helper;
 pub mod prometheus;
+pub mod result;
 pub mod serde;
 pub mod v1;

--- a/src/api/src/result.rs
+++ b/src/api/src/result.rs
@@ -0,0 +1,188 @@
+use common_error::prelude::ErrorExt;
+
+use crate::v1::{
+    admin_result, codec::SelectResult, object_result, AdminResult, MutateResult, ObjectResult,
+    ResultHeader, SelectResult as SelectResultRaw,
+};
+
+pub const PROTOCOL_VERSION: u32 = 1;
+
+pub type Success = u32;
+pub type Failure = u32;
+
+#[derive(Default)]
+pub struct ObjectResultBuilder {
+    version: u32,
+    code: u32,
+    err_msg: Option<String>,
+    result: Option<Body>,
+}
+
+pub enum Body {
+    Mutate((Success, Failure)),
+    Select(SelectResult),
+}
+
+impl ObjectResultBuilder {
+    pub fn new() -> Self {
+        Self {
+            version: PROTOCOL_VERSION,
+            ..Default::default()
+        }
+    }
+
+    #[allow(dead_code)]
+    pub fn version(mut self, version: u32) -> Self {
+        self.version = version;
+        self
+    }
+
+    pub fn status_code(mut self, code: u32) -> Self {
+        self.code = code;
+        self
+    }
+
+    pub fn err_msg(mut self, err_msg: String) -> Self {
+        self.err_msg = Some(err_msg);
+        self
+    }
+
+    pub fn mutate_result(mut self, success: u32, failure: u32) -> Self {
+        self.result = Some(Body::Mutate((success, failure)));
+        self
+    }
+
+    pub fn select_result(mut self, select_result: SelectResult) -> Self {
+        self.result = Some(Body::Select(select_result));
+        self
+    }
+
+    pub fn build(self) -> ObjectResult {
+        let header = Some(ResultHeader {
+            version: self.version,
+            code: self.code,
+            err_msg: self.err_msg.unwrap_or_default(),
+        });
+
+        let result = match self.result {
+            Some(Body::Mutate((success, failure))) => {
+                Some(object_result::Result::Mutate(MutateResult {
+                    success,
+                    failure,
+                }))
+            }
+            Some(Body::Select(select)) => Some(object_result::Result::Select(SelectResultRaw {
+                raw_data: select.into(),
+            })),
+            None => None,
+        };
+
+        ObjectResult { header, result }
+    }
+}
+
+pub fn build_err_result(err: &impl ErrorExt) -> ObjectResult {
+    ObjectResultBuilder::new()
+        .status_code(err.status_code() as u32)
+        .err_msg(err.to_string())
+        .build()
+}
+
+#[derive(Debug)]
+pub struct AdminResultBuilder {
+    version: u32,
+    code: u32,
+    err_msg: Option<String>,
+    mutate: Option<(Success, Failure)>,
+}
+
+impl AdminResultBuilder {
+    pub fn status_code(mut self, code: u32) -> Self {
+        self.code = code;
+        self
+    }
+
+    pub fn err_msg(mut self, err_msg: String) -> Self {
+        self.err_msg = Some(err_msg);
+        self
+    }
+
+    pub fn mutate_result(mut self, success: u32, failure: u32) -> Self {
+        self.mutate = Some((success, failure));
+        self
+    }
+
+    pub fn build(self) -> AdminResult {
+        let header = Some(ResultHeader {
+            version: self.version,
+            code: self.code,
+            err_msg: self.err_msg.unwrap_or_default(),
+        });
+
+        let result = if let Some((success, failure)) = self.mutate {
+            Some(admin_result::Result::Mutate(MutateResult {
+                success,
+                failure,
+            }))
+        } else {
+            None
+        };
+
+        AdminResult { header, result }
+    }
+}
+
+impl Default for AdminResultBuilder {
+    fn default() -> Self {
+        Self {
+            version: PROTOCOL_VERSION,
+            code: 0,
+            err_msg: None,
+            mutate: None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use common_error::status_code::StatusCode;
+
+    use super::*;
+    use crate::error::UnknownColumnDataTypeSnafu;
+    use crate::v1::{object_result, MutateResult};
+
+    #[test]
+    fn test_object_result_builder() {
+        let obj_result = ObjectResultBuilder::new()
+            .version(101)
+            .status_code(500)
+            .err_msg("Failed to read this file!".to_string())
+            .mutate_result(100, 20)
+            .build();
+        let header = obj_result.header.unwrap();
+        assert_eq!(101, header.version);
+        assert_eq!(500, header.code);
+        assert_eq!("Failed to read this file!", header.err_msg);
+
+        let result = obj_result.result.unwrap();
+        assert_eq!(
+            object_result::Result::Mutate(MutateResult {
+                success: 100,
+                failure: 20,
+            }),
+            result
+        );
+    }
+
+    #[test]
+    fn test_build_err_result() {
+        let err = UnknownColumnDataTypeSnafu { datatype: 1 }.build();
+        let err_result = build_err_result(&err);
+        let header = err_result.header.unwrap();
+        let result = err_result.result;
+
+        assert_eq!(PROTOCOL_VERSION, header.version);
+        assert_eq!(StatusCode::InvalidArguments as u32, header.code);
+        assert!(result.is_none());
+    }
+}