feat: add json data type (#4619)

* feat: add json type and vector

* fix: allow to create and insert json data

* feat: udf to query json as string

* refactor: remove JsonbValue and JsonVector

* feat: show json value as strings

* chore: make ci happy

* test: adunit test and sqlness test

* refactor: use binary as grpc value of json

* fix: use non-preserve-order jsonb

* test: revert changed test

* refactor: change udf get_by_path to jq

* chore: make ci happy

* fix: distinguish binary and json in proto

* chore: delete udf for future pr

* refactor: remove Value(Json)

* chore: follow review comments

* test: some tests and checks

* test: fix unit tests

* chore: follow review comments

* chore: corresponding changes to proto

* fix: change grpc and pgsql server behavior alongside with sqlness/crud tests

* chore: follow review comments

* feat: udf of conversions between json and strings, used for grpc server

* refactor: rename to_string to json_to_string

* test: add more sqlness test for json

* chore: thanks for review :)

* Apply suggestions from code review

---------

Co-authored-by: Weny Xu <wenymedia@gmail.com>

src/query/src/dist_plan/merge_scan.rs

@@ -156,20 +156,22 @@ impl MergeScanExec {
         query_ctx: QueryContextRef,
         target_partition: usize,
     ) -> Result<Self> {
-        let arrow_schema_without_metadata = Self::arrow_schema_without_metadata(arrow_schema);
+        // TODO(CookiePieWw): Initially we removed the metadata from the schema in #2000, but we have to
+        // keep it for #4619 to identify json type in src/datatypes/src/schema/column_schema.rs.
+        // Reconsider if it's possible to remove it.
+        let arrow_schema = Arc::new(arrow_schema.clone());
         let properties = PlanProperties::new(
-            EquivalenceProperties::new(arrow_schema_without_metadata.clone()),
+            EquivalenceProperties::new(arrow_schema.clone()),
             Partitioning::UnknownPartitioning(target_partition),
             ExecutionMode::Bounded,
         );
-        let schema_without_metadata =
-            Self::arrow_schema_to_schema(arrow_schema_without_metadata.clone())?;
+        let schema = Self::arrow_schema_to_schema(arrow_schema.clone())?;
         Ok(Self {
             table,
             regions,
             plan,
-            schema: schema_without_metadata,
-            arrow_schema: arrow_schema_without_metadata,
+            schema,
+            arrow_schema,
             region_query_handler,
             metric: ExecutionPlanMetricsSet::new(),
             sub_stage_metrics: Arc::default(),
@@ -288,20 +290,6 @@ impl MergeScanExec {
         }))
     }
 
-    fn arrow_schema_without_metadata(arrow_schema: &ArrowSchema) -> ArrowSchemaRef {
-        Arc::new(ArrowSchema::new(
-            arrow_schema
-                .fields()
-                .iter()
-                .map(|field| {
-                    let field = field.as_ref().clone();
-                    let field_without_metadata = field.with_metadata(Default::default());
-                    Arc::new(field_without_metadata)
-                })
-                .collect::<Vec<_>>(),
-        ))
-    }
-
     fn arrow_schema_to_schema(arrow_schema: ArrowSchemaRef) -> Result<SchemaRef> {
         let schema = Schema::try_from(arrow_schema).context(ConvertSchemaSnafu)?;
         Ok(Arc::new(schema))