[CUBVEC-8] Survey on adding Vector Type

src/compat/db_macro.c

@@ -349,6 +349,7 @@ db_value_domain_init (DB_VALUE * value, const DB_TYPE type, const int precision,
       break;
 
     case DB_TYPE_NULL:
+    case DB_TYPE_VIMKIM:
     case DB_TYPE_INTEGER:
     case DB_TYPE_BIGINT:
     case DB_TYPE_FLOAT:

src/compat/dbtype_def.h

@@ -722,14 +722,15 @@ extern "C"
     DB_TYPE_DATETIMETZ = 38,
     DB_TYPE_DATETIMELTZ = 39,
     DB_TYPE_JSON = 40,
+    DB_TYPE_VIMKIM = 41,
 
     /* aliases */
     DB_TYPE_LIST = DB_TYPE_SEQUENCE,
     DB_TYPE_SMALLINT = DB_TYPE_SHORT,	/* SQL SMALLINT */
     DB_TYPE_VARCHAR = DB_TYPE_STRING,	/* SQL CHAR(n) VARYING values */
     DB_TYPE_UTIME = DB_TYPE_TIMESTAMP,	/* SQL TIMESTAMP */
 
-    DB_TYPE_LAST = DB_TYPE_JSON
+    DB_TYPE_LAST = DB_TYPE_VIMKIM,
   } DB_TYPE;
 
   /* Domain information stored in DB_VALUE structures. */
@@ -1051,6 +1052,13 @@ extern "C"
     JSON_DOC *document;
   };
 
+  typedef struct db_vector DB_VECTOR;
+  struct db_vector
+  {
+    const float *buf;
+    int length;
+  };
+
   /* A union of all of the possible basic type values. This is used in the definition of the DB_VALUE which is the fundamental
    * structure used in passing data in and out of the db_ function layer.
    */
@@ -1082,6 +1090,7 @@ extern "C"
     DB_RESULTSET rset;
     DB_ENUM_ELEMENT enumeration;
     DB_JSON json;
+    DB_VECTOR vector;
   };
 
   /* This is the primary structure used for passing values in and out of the db_ function layer. Values are always tagged with

src/compat/dbtype_function.h

@@ -301,6 +301,8 @@ extern "C"
   extern bool db_is_json_value_type (DB_TYPE type);
   extern bool db_is_json_doc_type (DB_TYPE type);
 
+  extern const float *db_get_vimkim (const DB_VALUE * value);
+  extern int db_get_vimkim_size (const DB_VALUE * value);
   extern int db_get_int (const DB_VALUE * value);
   extern DB_C_SHORT db_get_short (const DB_VALUE * value);
   extern DB_BIGINT db_get_bigint (const DB_VALUE * value);
@@ -341,6 +343,7 @@ extern "C"
   extern JSON_DOC *db_get_json_document (const DB_VALUE * value);
 
   extern int db_make_null (DB_VALUE * value);
+  extern int db_make_vimkim (DB_VALUE * value, const float * buf, const int size);
   extern int db_make_int (DB_VALUE * value, const int num);
   extern int db_make_float (DB_VALUE * value, const DB_C_FLOAT num);
   extern int db_make_double (DB_VALUE * value, const DB_C_DOUBLE num);

src/compat/dbtype_function.i

@@ -26,6 +26,8 @@
 #if !defined (_NO_INLINE_DBTYPE_FUNCTION_)
 #include "porting_inline.hpp"
 
+STATIC_INLINE const float *db_get_vimkim (const DB_VALUE * value) __attribute__ ((ALWAYS_INLINE));
+STATIC_INLINE int db_get_vimkim_size (const DB_VALUE * value) __attribute__ ((ALWAYS_INLINE));
 STATIC_INLINE int db_get_int (const DB_VALUE * value) __attribute__ ((ALWAYS_INLINE));
 STATIC_INLINE DB_C_SHORT db_get_short (const DB_VALUE * value) __attribute__ ((ALWAYS_INLINE));
 STATIC_INLINE DB_BIGINT db_get_bigint (const DB_VALUE * value) __attribute__ ((ALWAYS_INLINE));
@@ -69,6 +71,7 @@ STATIC_INLINE int db_make_db_char (DB_VALUE * value, INTL_CODESET codeset, const
 				   const int size) __attribute__ ((ALWAYS_INLINE));
 
 STATIC_INLINE int db_make_null (DB_VALUE * value) __attribute__ ((ALWAYS_INLINE));
+STATIC_INLINE int db_make_vimkim (DB_VALUE * value, const float * buf, const int size) __attribute__ ((ALWAYS_INLINE));
 STATIC_INLINE int db_make_int (DB_VALUE * value, const int num) __attribute__ ((ALWAYS_INLINE));
 STATIC_INLINE int db_make_float (DB_VALUE * value, const DB_C_FLOAT num) __attribute__ ((ALWAYS_INLINE));
 STATIC_INLINE int db_make_double (DB_VALUE * value, const DB_C_DOUBLE num) __attribute__ ((ALWAYS_INLINE));
@@ -145,6 +148,40 @@ STATIC_INLINE DB_TYPE db_value_domain_type (const DB_VALUE * value) __attribute_
 #include <assert.h>
 #include "memory_cwrapper.h"
 
+/*
+ * db_get_vimkim() -
+ * return :
+ * value(in):
+ */
+const float *
+db_get_vimkim (const DB_VALUE * value)
+{
+#if defined (API_ACTIVE_CHECKS)
+  CHECK_1ARG_ZERO (value);
+#endif
+
+  assert (value->domain.general_info.type == DB_TYPE_VIMKIM);
+
+  return value->data.vector.buf;
+}
+
+/*
+ * db_get_vimkim() -
+ * return :
+ * value(in):
+ */
+int
+db_get_vimkim_size (const DB_VALUE * value)
+{
+#if defined (API_ACTIVE_CHECKS)
+  CHECK_1ARG_ZERO (value);
+#endif
+
+  assert (value->domain.general_info.type == DB_TYPE_VIMKIM);
+
+  return value->data.vector.length;
+}
+
 /*
  * db_get_int() -
  * return :
@@ -1044,6 +1081,29 @@ db_make_null (DB_VALUE * value)
   return NO_ERROR;
 }
 
+/*
+ * db_make_vimkim() -
+ * return :
+ * value(out) :
+ * num(in):
+ */
+int
+db_make_vimkim (DB_VALUE * value, const float *buf, const int size)
+{
+#if defined (API_ACTIVE_CHECKS)
+  CHECK_1ARG_ERROR (value);
+#endif
+
+  value->domain.general_info.type = DB_TYPE_VIMKIM;
+  value->data.vector.buf = buf;
+  value->data.vector.length = size;
+
+  value->domain.general_info.is_null = 0;
+  value->need_clear = false;
+
+  return NO_ERROR;
+}
+
 /*
  * db_make_int() -
  * return :

src/executables/csql_result_format.c

@@ -1471,6 +1471,30 @@ csql_db_value_as_string (DB_VALUE * value, int *length, const CSQL_ARGUMENT * cs
 	  len = strlen (result);
 	}
       break;
+    case DB_TYPE_VIMKIM:
+	{
+	  const float * vimkim = db_get_vimkim (value);
+	  const int vimkim_size = db_get_vimkim_size (value);
+
+
+	  std::ostringstream oss;
+	  oss << "[";
+
+	  // Add elements to the string stream
+	  for (int i = 0; i < vimkim_size; ++i) {
+	      if (i > 0) {
+		  oss << ", ";
+	      }
+	      oss << vimkim[i];
+	  }
+	  oss << "]";
+	  result = strdup(oss.str().c_str());
+	}
+      if (result)
+	{
+	  len = strlen (result);
+	}
+      break;
     case DB_TYPE_INTEGER:
       result =
 	bigint_to_string (db_get_int (value), default_int_profile.fieldwidth, default_int_profile.leadingzeros,

src/object/object_domain.c

@@ -7090,6 +7090,46 @@ tp_value_coerce_strict (const DB_VALUE * src, DB_VALUE * dest, const TP_DOMAIN *
   return err;
 }
 
+
+// Function to parse the string into a dynamically allocated float array
+float* parseFloatArray(const std::string& input, int& outSize) {
+    // Check if the input starts with '[' and ends with ']'
+    if (input.empty() || input.front() != '[' || input.back() != ']') {
+        outSize = 0;
+        return nullptr;
+    }
+
+    // Remove the square brackets
+    std::string content = input.substr(1, input.size() - 2);
+
+    // Use a stringstream to parse floats
+    std::stringstream ss(content);
+    std::vector<float> temp;
+
+    // Extract floats separated by commas
+    std::string item;
+    while (std::getline(ss, item, ',')) {
+        try {
+            // Trim whitespace and convert to float
+            temp.push_back(std::stof(item));
+        } catch (...) {
+            // Handle conversion errors (invalid input)
+            outSize = 0;
+            return nullptr;
+        }
+    }
+
+    // Allocate a dynamic array and copy values from the vector
+    outSize = temp.size();
+    float* result(new float[outSize]);
+    for (int i = 0; i < outSize; ++i) {
+        result[i] = temp[i];
+    }
+
+    return result;
+}
+
+
 /*
  * tp_value_coerce_internal - Coerce a value into one of another domain.
  *    return: error code
@@ -7529,6 +7569,24 @@ tp_value_cast_internal (const DB_VALUE * src, DB_VALUE * dest, const TP_DOMAIN *
 	}
       break;
 
+    case DB_TYPE_VIMKIM:
+      switch (original_type)
+	{
+	  case DB_TYPE_CHAR:
+	      {
+		const char *str = db_get_string(src);
+
+		int size;
+		auto farray = parseFloatArray(std::string(str), size);
+
+		db_make_vimkim(target, farray, (int)size);
+		break;
+	      }
+	  default:
+	    status = DOMAIN_INCOMPATIBLE;
+	    break;
+	}
+      break;
     case DB_TYPE_INTEGER:
       switch (original_type)
 	{