feat: insert stmt support for map data type

WIP!

hybridse/include/codec/fe_schema_codec.h

@@ -18,10 +18,7 @@
 #define HYBRIDSE_INCLUDE_CODEC_FE_SCHEMA_CODEC_H_
 
 #include <cstring>
-#include <iostream>
-#include <map>
 #include <string>
-#include <vector>
 #include "vm/catalog.h"
 
 namespace hybridse {
@@ -56,7 +53,7 @@ class SchemaCodec {
             if (it->name().size() >= 128) {
                 return false;
             }
-            uint8_t name_size = (uint8_t)(it->name().size());
+            uint8_t name_size = static_cast<uint8_t>(it->name().size());
             memcpy(cbuffer, static_cast<const void*>(&name_size), 1);
             cbuffer += 1;
             memcpy(cbuffer, static_cast<const void*>(it->name().c_str()),
@@ -66,7 +63,7 @@ class SchemaCodec {
         return true;
     }
 
-    static bool Decode(const std::string& buf, vm::Schema* schema) {
+    static bool Decode(const std::string& buf, codec::Schema* schema) {
         if (schema == NULL) return false;
         if (buf.size() <= 0) return true;
         const char* buffer = buf.c_str();

hybridse/include/sdk/base_impl.h

@@ -30,13 +30,13 @@ typedef ::google::protobuf::RepeatedPtrField< ::hybridse::type::TableDef>
 
 class SchemaImpl : public Schema {
  public:
-    explicit SchemaImpl(const vm::Schema& schema);
+    explicit SchemaImpl(const codec::Schema& schema);
     SchemaImpl() {}
 
     ~SchemaImpl();
 
-    const vm::Schema& GetSchema() const { return schema_; }
-    inline void SetSchema(const vm::Schema& schema) { schema_ = schema; }
+    const codec::Schema& GetSchema() const { return schema_; }
+    inline void SetSchema(const codec::Schema& schema) { schema_ = schema; }
     int32_t GetColumnCnt() const;
 
     const std::string& GetColumnName(uint32_t index) const;
@@ -46,7 +46,7 @@ class SchemaImpl : public Schema {
     const bool IsConstant(uint32_t index) const;
 
  private:
-    vm::Schema schema_;
+    codec::Schema schema_;
 };
 
 class TableImpl : public Table {

hybridse/src/codegen/buf_ir_builder.cc

@@ -275,7 +275,7 @@ bool BufNativeIRBuilder::BuildGetStringField(uint32_t col_idx, uint32_t offset,
 
 BufNativeEncoderIRBuilder::BufNativeEncoderIRBuilder(CodeGenContextBase* ctx,
                                                      const std::map<uint32_t, NativeValue>* outputs,
-                                                     const vm::Schema* schema)
+                                                     const codec::Schema* schema)
     : ctx_(ctx),
       outputs_(outputs),
       schema_(schema),

hybridse/src/codegen/buf_ir_builder.h

@@ -25,15 +25,14 @@
 #include "codegen/row_ir_builder.h"
 #include "codegen/scope_var.h"
 #include "codegen/variable_ir_builder.h"
-#include "vm/catalog.h"
 
 namespace hybridse {
 namespace codegen {
 
 class BufNativeEncoderIRBuilder : public RowEncodeIRBuilder {
  public:
     BufNativeEncoderIRBuilder(CodeGenContextBase* ctx, const std::map<uint32_t, NativeValue>* outputs,
-                              const vm::Schema* schema);
+                              const codec::Schema* schema);
 
     ~BufNativeEncoderIRBuilder() override;
 
@@ -55,10 +54,6 @@ class BufNativeEncoderIRBuilder : public RowEncodeIRBuilder {
                               ::llvm::Value* str_addr_space, ::llvm::Value* str_body_offset, uint32_t str_field_idx,
                               ::llvm::Value** output);
 
-    // encode SQL map data type into row
-    base::Status AppendMapVal(const type::ColumnSchema& sc, llvm::Value* i8_ptr, uint32_t field_idx,
-                              const NativeValue& val, llvm::Value* str_addr_space, llvm::Value* str_body_offset,
-                              uint32_t str_field_idx, llvm::Value** next_str_body_offset);
     absl::StatusOr<llvm::Function*> GetOrBuildAppendMapFn(const type::ColumnSchema& sc) const;
 
     base::Status AppendHeader(::llvm::Value* i8_ptr, ::llvm::Value* size,
@@ -74,7 +69,7 @@ class BufNativeEncoderIRBuilder : public RowEncodeIRBuilder {
  private:
     CodeGenContextBase* ctx_;
     const std::map<uint32_t, NativeValue>* outputs_;
-    const vm::Schema* schema_;
+    const codec::Schema* schema_;
     uint32_t str_field_start_offset_;
     // n = offset_vec_[i] is
     //   schema_[i] is base type (except string): col encode offset in row

hybridse/src/codegen/insert_row_builder.cc

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2024 OpenMLDB authors
+ *
+ * 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.
+ */
+
+#include "codegen/insert_row_builder.h"
+
+#include "absl/status/status.h"
+
+namespace hybridse {
+namespace codegen {
+
+InsertRowBuilder::InsertRowBuilder(CodeGenContextBase* ctx, const codec::Schema* schema) : ctx_(ctx), schema_(schema) {}
+
+absl::StatusOr<std::shared_ptr<int8_t>> InsertRowBuilder::ComputeRow(absl::Span<const node::ExprNode*> values) {
+    return absl::OkStatus();
+}
+
+absl::StatusOr<llvm::Function*> InsertRowBuilder::BuildFn(absl::Span<const node::ExprNode*>) {
+    return absl::OkStatus();
+}
+
+// build the function that transform a single insert row values into encoded row
+absl::StatusOr<llvm::Function*> InsertRowBuilder::BuildEncodeFn() { return absl::OkStatus(); }
+}  // namespace codegen
+}  // namespace hybridse

hybridse/src/codegen/insert_row_builder.h

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2024 OpenMLDB authors
+ *
+ * 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.
+ */
+
+#ifndef HYBRIDSE_SRC_CODEGEN_INSERT_ROW_BUILDER_H_
+#define HYBRIDSE_SRC_CODEGEN_INSERT_ROW_BUILDER_H_
+
+#include <memory>
+
+#include "absl/status/statusor.h"
+#include "codec/fe_row_codec.h"
+#include "codegen/context.h"
+
+namespace hybridse {
+namespace codegen {
+
+class InsertRowBuilder {
+ public:
+    InsertRowBuilder(CodeGenContextBase* ctx, const codec::Schema* schema);
+
+    // compute the encoded row result for insert statement's single values expression list
+    //
+    // currently, expressions in insert values do not expect external source, so unsupported expressions
+    // will simply fail on resolving.
+    absl::StatusOr<std::shared_ptr<int8_t>> ComputeRow(absl::Span<const node::ExprNode*> values);
+
+ private:
+    // build the function the will output the row from single insert values
+    //
+    // the function is just equivalent to C: `int8* fn()`.
+    // BuildFn returns different function with different name on every invocation
+    absl::StatusOr<llvm::Function*> BuildFn(absl::Span<const node::ExprNode*>);
+
+    // build the function that transform a single insert row values into encoded row
+    absl::StatusOr<llvm::Function*> BuildEncodeFn();
+
+    CodeGenContextBase* ctx_;
+    const codec::Schema* schema_;
+};
+}  // namespace codegen
+}  // namespace hybridse
+#endif  // HYBRIDSE_SRC_CODEGEN_INSERT_ROW_BUILDER_H_

hybridse/src/sdk/base_impl.cc

@@ -24,7 +24,7 @@ namespace sdk {
 
 static const std::string EMPTY_STR;  // NOLINT
 
-SchemaImpl::SchemaImpl(const vm::Schema& schema) : schema_(schema) {}
+SchemaImpl::SchemaImpl(const codec::Schema& schema) : schema_(schema) {}
 
 SchemaImpl::~SchemaImpl() {}
 

src/codec/codec.cc

@@ -1152,5 +1152,15 @@ bool RowProject::Project(const int8_t* row_ptr, uint32_t size, int8_t** output_p
     return true;
 }
 
+bool ColumnSupportLegacyCodec(const openmldb::common::ColumnDesc& col_desc) {
+    auto dt = col_desc.data_type();
+    if (col_desc.has_schema()) {
+        dt = col_desc.schema().type();
+    }
+
+    return (dt >= openmldb::type::kBool && dt <= openmldb::type::kTimestamp) || dt == openmldb::type::kVarchar ||
+           dt == openmldb::type::kString;
+}
+
 }  // namespace codec
 }  // namespace openmldb

src/codec/codec.h

@@ -192,6 +192,8 @@ class RowView {
     std::vector<uint32_t> offset_vec_;
 };
 
+bool ColumnSupportLegacyCodec(const openmldb::common::ColumnDesc&);
+
 namespace v1 {
 
 inline int8_t GetAddrSpace(uint32_t size) {

src/sdk/sql_cluster_router.cc

@@ -524,6 +524,8 @@ bool SQLClusterRouter::GetMultiRowInsertInfo(const std::string& db, const std::s
         return false;
     }
     std::map<uint32_t, uint32_t> column_map;
+
+    bool insert_codegen = false;
     for (size_t j = 0; j < insert_stmt->columns_.size(); ++j) {
         const std::string& col_name = insert_stmt->columns_[j];
         bool find_flag = false;
@@ -535,6 +537,12 @@ bool SQLClusterRouter::GetMultiRowInsertInfo(const std::string& db, const std::s
                 }
                 column_map.insert(std::make_pair(i, j));
                 find_flag = true;
+
+                auto& col_desc = (*table_info)->column_desc(i);
+                if (!codec::ColumnSupportLegacyCodec(col_desc)) {
+                    insert_codegen = true;
+                }
+
                 break;
             }
         }