feat: frontend instance (#238)

* feat: frontend instance

* no need to carry column length in `Column` proto

* add more tests

* rebase develop

* create a new variant with already provisioned RecordBatches in Output

* resolve code review comments

* new frontend instance does not connect datanode grpc

* add more tests

* add more tests

* rebase develop

Co-authored-by: luofucong <luofucong@greptime.com>

src/datatypes/src/vectors/builder.rs

@@ -5,6 +5,8 @@ use common_time::datetime::DateTime;
 use common_time::timestamp::Timestamp;
 
 use crate::data_type::ConcreteDataType;
+use crate::error::{self, Result};
+use crate::prelude::ValueRef;
 use crate::scalars::ScalarVectorBuilder;
 use crate::value::Value;
 use crate::vectors::date::DateVectorBuilder;
@@ -160,6 +162,37 @@ impl VectorBuilder {
         }
     }
 
+    pub fn try_push_ref(&mut self, value: ValueRef) -> Result<()> {
+        match &mut *self {
+            VectorBuilder::Null(b) => {
+                if !value.is_null() {
+                    return error::CastTypeSnafu {
+                        msg: "unable to accept non-null value in NullVectorBuilder",
+                    }
+                    .fail();
+                }
+                *b += 1;
+                Ok(())
+            }
+            VectorBuilder::Boolean(b) => b.push_value_ref(value),
+            VectorBuilder::UInt8(b) => b.push_value_ref(value),
+            VectorBuilder::UInt16(b) => b.push_value_ref(value),
+            VectorBuilder::UInt32(b) => b.push_value_ref(value),
+            VectorBuilder::UInt64(b) => b.push_value_ref(value),
+            VectorBuilder::Int8(b) => b.push_value_ref(value),
+            VectorBuilder::Int16(b) => b.push_value_ref(value),
+            VectorBuilder::Int32(b) => b.push_value_ref(value),
+            VectorBuilder::Int64(b) => b.push_value_ref(value),
+            VectorBuilder::Float32(b) => b.push_value_ref(value),
+            VectorBuilder::Float64(b) => b.push_value_ref(value),
+            VectorBuilder::String(b) => b.push_value_ref(value),
+            VectorBuilder::Binary(b) => b.push_value_ref(value),
+            VectorBuilder::Date(b) => b.push_value_ref(value),
+            VectorBuilder::DateTime(b) => b.push_value_ref(value),
+            VectorBuilder::Timestamp(b) => b.push_value_ref(value),
+        }
+    }
+
     pub fn push_null(&mut self) {
         match self {
             VectorBuilder::Null(v) => *v += 1,
@@ -223,19 +256,37 @@ mod tests {
             for i in 0..10 {
                 builder.push(&Value::$Type(i));
             }
+            for i in 10..20 {
+                builder.try_push_ref(ValueRef::$Type(i)).unwrap();
+            }
             let vector = builder.finish();
 
-            for i in 0..10 {
+            for i in 0..20 {
                 assert_eq!(Value::$Type(i), vector.get(i as usize));
             }
 
             let mut builder = VectorBuilder::new(ConcreteDataType::$datatype());
             builder.push(&Value::Null);
             builder.push(&Value::$Type(100));
+            builder.try_push_ref(ValueRef::Null).unwrap();
+            builder.try_push_ref(ValueRef::$Type(101)).unwrap();
+
+            let result = builder.try_push_ref(ValueRef::Boolean(true));
+            assert!(result.is_err());
+            assert_eq!(
+                result.unwrap_err().to_string(),
+                format!(
+                    "Failed to cast value Boolean(true) to primitive type {}",
+                    stringify!($Type)
+                ),
+            );
+
             let vector = builder.finish();
 
             assert!(vector.is_null(0));
             assert_eq!(Value::$Type(100), vector.get(1));
+            assert!(vector.is_null(2));
+            assert_eq!(Value::$Type(101), vector.get(3));
         };
     }
 
@@ -244,8 +295,19 @@ mod tests {
         let mut builder = VectorBuilder::new(ConcreteDataType::null_datatype());
         assert_eq!(ConcreteDataType::null_datatype(), builder.data_type());
         builder.push(&Value::Null);
+
+        let result = builder.try_push_ref(ValueRef::Boolean(true));
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "unable to accept non-null value in NullVectorBuilder"
+        );
+
+        builder.try_push_ref(ValueRef::Null).unwrap();
+
         let vector = builder.finish();
         assert!(vector.is_null(0));
+        assert!(vector.is_null(1));
     }
 
     #[test]
@@ -267,13 +329,43 @@ mod tests {
         assert_eq!(data_type, builder.data_type());
 
         builder.push(&Value::Float32(OrderedFloat(1.0)));
+
+        let result = builder.try_push_ref(ValueRef::Boolean(true));
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Failed to cast value Boolean(true) to primitive type Float32"
+        );
+
+        builder
+            .try_push_ref(ValueRef::Float32(OrderedFloat(2.0)))
+            .unwrap();
+        builder.try_push_ref(ValueRef::Null).unwrap();
+
         let vector = builder.finish();
         assert_eq!(Value::Float32(OrderedFloat(1.0)), vector.get(0));
+        assert_eq!(Value::Float32(OrderedFloat(2.0)), vector.get(1));
+        assert_eq!(Value::Null, vector.get(2));
 
         let mut builder = VectorBuilder::new(ConcreteDataType::float64_datatype());
         builder.push(&Value::Float64(OrderedFloat(2.0)));
+
+        let result = builder.try_push_ref(ValueRef::Boolean(true));
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Failed to cast value Boolean(true) to primitive type Float64"
+        );
+
+        builder
+            .try_push_ref(ValueRef::Float64(OrderedFloat(3.0)))
+            .unwrap();
+        builder.try_push_ref(ValueRef::Null).unwrap();
+
         let vector = builder.finish();
         assert_eq!(Value::Float64(OrderedFloat(2.0)), vector.get(0));
+        assert_eq!(Value::Float64(OrderedFloat(3.0)), vector.get(1));
+        assert_eq!(Value::Null, vector.get(2));
     }
 
     #[test]
@@ -283,8 +375,21 @@ mod tests {
         let mut builder = VectorBuilder::new(data_type.clone());
         assert_eq!(data_type, builder.data_type());
         builder.push(&Value::Binary(hello.into()));
+
+        let result = builder.try_push_ref(ValueRef::Boolean(true));
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Failed to cast value ref Boolean(true) to Binary"
+        );
+
+        builder.try_push_ref(ValueRef::Binary(b"world")).unwrap();
+        builder.try_push_ref(ValueRef::Null).unwrap();
+
         let vector = builder.finish();
         assert_eq!(Value::Binary(hello.into()), vector.get(0));
+        assert_eq!(ValueRef::Binary(b"world"), vector.get_ref(1));
+        assert_eq!(Value::Null, vector.get(2));
     }
 
     #[test]
@@ -294,8 +399,21 @@ mod tests {
         let mut builder = VectorBuilder::new(data_type.clone());
         assert_eq!(data_type, builder.data_type());
         builder.push(&Value::String(hello.into()));
+
+        let result = builder.try_push_ref(ValueRef::Boolean(true));
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Failed to cast value ref Boolean(true) to String"
+        );
+
+        builder.try_push_ref(ValueRef::String("world")).unwrap();
+        builder.try_push_ref(ValueRef::Null).unwrap();
+
         let vector = builder.finish();
         assert_eq!(Value::String(hello.into()), vector.get(0));
+        assert_eq!(ValueRef::String("world"), vector.get_ref(1));
+        assert_eq!(Value::Null, vector.get(2));
     }
 
     #[test]
@@ -304,10 +422,25 @@ mod tests {
         assert_eq!(ConcreteDataType::date_datatype(), builder.data_type());
         builder.push_null();
         builder.push(&Value::Date(Date::new(123)));
+
+        let result = builder.try_push_ref(ValueRef::Boolean(true));
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Failed to cast value ref Boolean(true) to Date"
+        );
+
+        builder
+            .try_push_ref(ValueRef::Date(Date::new(456)))
+            .unwrap();
+        builder.try_push_ref(ValueRef::Null).unwrap();
+
         let v = builder.finish();
         let v = v.as_any().downcast_ref::<DateVector>().unwrap();
         assert_eq!(Value::Null, v.get(0));
         assert_eq!(Value::Date(Date::new(123)), v.get(1));
+        assert_eq!(ValueRef::Date(Date::new(456)), v.get_ref(2));
+        assert_eq!(ValueRef::Null, v.get_ref(3));
         assert_eq!(
             &arrow::datatypes::DataType::Date32,
             v.to_arrow_array().data_type()
@@ -320,10 +453,25 @@ mod tests {
         assert_eq!(ConcreteDataType::datetime_datatype(), builder.data_type());
         builder.push_null();
         builder.push(&Value::DateTime(DateTime::new(123)));
+
+        let result = builder.try_push_ref(ValueRef::Boolean(true));
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "Failed to cast value ref Boolean(true) to DateTime"
+        );
+
+        builder
+            .try_push_ref(ValueRef::DateTime(DateTime::new(456)))
+            .unwrap();
+        builder.try_push_ref(ValueRef::Null).unwrap();
+
         let v = builder.finish();
         let v = v.as_any().downcast_ref::<DateTimeVector>().unwrap();
         assert_eq!(Value::Null, v.get(0));
         assert_eq!(Value::DateTime(DateTime::new(123)), v.get(1));
+        assert_eq!(ValueRef::DateTime(DateTime::new(456)), v.get_ref(2));
+        assert_eq!(ValueRef::Null, v.get_ref(3));
         assert_eq!(
             &arrow::datatypes::DataType::Date64,
             v.to_arrow_array().data_type()

src/datatypes/src/vectors/list.rs

@@ -20,7 +20,7 @@ type ArrowListArray = ListArray<i32>;
 #[derive(Debug, Clone, PartialEq)]
 pub struct ListVector {
     array: ArrowListArray,
-    inner_data_type: ConcreteDataType,
+    inner_datatype: ConcreteDataType,
 }
 
 impl ListVector {
@@ -31,7 +31,7 @@ impl ListVector {
 
 impl Vector for ListVector {
     fn data_type(&self) -> ConcreteDataType {
-        ConcreteDataType::List(ListType::new(self.inner_data_type.clone()))
+        ConcreteDataType::List(ListType::new(self.inner_datatype.clone()))
     }
 
     fn vector_type_name(&self) -> String {
@@ -89,7 +89,7 @@ impl Vector for ListVector {
             .collect::<Vec<Value>>();
         Value::List(ListValue::new(
             Some(Box::new(values)),
-            self.inner_data_type.clone(),
+            self.inner_datatype.clone(),
         ))
     }
 
@@ -124,13 +124,13 @@ impl Serializable for ListVector {
 
 impl From<ArrowListArray> for ListVector {
     fn from(array: ArrowListArray) -> Self {
-        let inner_data_type = ConcreteDataType::from_arrow_type(match array.data_type() {
+        let inner_datatype = ConcreteDataType::from_arrow_type(match array.data_type() {
             ArrowDataType::List(field) => &field.data_type,
             _ => unreachable!(),
         });
         Self {
             array,
-            inner_data_type,
+            inner_datatype,
         }
     }
 }
@@ -234,7 +234,7 @@ impl MutableVector for ListVectorBuilder {
 
         let vector = ListVector {
             array,
-            inner_data_type: self.inner_type.clone(),
+            inner_datatype: self.inner_type.clone(),
         };
         Arc::new(vector)
     }
@@ -286,7 +286,7 @@ mod tests {
 
         let list_vector = ListVector {
             array: arrow_array.clone(),
-            inner_data_type: ConcreteDataType::int32_datatype(),
+            inner_datatype: ConcreteDataType::int32_datatype(),
         };
         assert_eq!(
             ConcreteDataType::List(ListType::new(ConcreteDataType::int32_datatype())),
@@ -374,7 +374,7 @@ mod tests {
 
         let list_vector = ListVector::try_from_arrow_array(array_ref).unwrap();
         assert_eq!(
-            "ListVector { array: ListArray[[1, 2, 3], None, [4, None, 6]], inner_data_type: UInt32(UInt32) }",
+            "ListVector { array: ListArray[[1, 2, 3], None, [4, None, 6]], inner_datatype: UInt32(UInt32) }",
             format!("{:?}", list_vector)
         );
     }