From f0e47fb9eb406f7f45721ad046efb2a410aad358 Mon Sep 17 00:00:00 2001 From: avsdev-cw Date: Mon, 9 Nov 2020 12:41:21 +0000 Subject: [PATCH] Modifications to metadata and meta_ext handling --- src/modb_database_p.c | 2 +- src/modb_metadata.c | 100 ++++++++--- src/modb_metadata.h | 9 +- src/modb_metadata_ext.c | 366 ++++++++++++++++++++++------------------ src/modb_metadata_ext.h | 6 +- 5 files changed, 295 insertions(+), 188 deletions(-) diff --git a/src/modb_database_p.c b/src/modb_database_p.c index cb97e32..b55a47b 100644 --- a/src/modb_database_p.c +++ b/src/modb_database_p.c @@ -272,7 +272,7 @@ uint64_t createMetaTable(stored_conn *sconn, modb_ref *modb) METADATA_TABLE, STR_LEN(METADATA_TABLE), "(" "`mdo_id` INT UNSIGNED NOT NULL AUTO_INCREMENT, " - "`type` VARCHAR(255) NOT NULL, " +// "`type` VARCHAR(255) NOT NULL, " "`title` VARCHAR(255) NOT NULL, " "`owner_id` INT UNSIGNED NOT NULL, " "`created` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, " diff --git a/src/modb_metadata.c b/src/modb_metadata.c index e670c09..67377e6 100644 --- a/src/modb_metadata.c +++ b/src/modb_metadata.c @@ -14,10 +14,12 @@ int tableRowsToMetadataList(column_data **col_data, size_t n_cols, struct metadata_t ***metadata_list, size_t *n_metadatas) { - column_data *col_id, *col_type, *col_title, *col_owner_id, + column_data *col_id, *col_title, *col_owner_id, *col_created, *col_updated, *col_deleted; size_t n_rows, idx; struct metadata_t *metadata; + column_data **ext_cols; + column_data *col; n_rows = (*col_data)->n_values; if (n_rows == 0) { @@ -25,16 +27,32 @@ int tableRowsToMetadataList(column_data **col_data, size_t n_cols, } col_id = findColumnByName(col_data, n_cols, "mdo_id"); - col_type = findColumnByName(col_data, n_cols, "type"); + //col_type = findColumnByName(col_data, n_cols, "type"); col_title = findColumnByName(col_data, n_cols, "title"); col_owner_id = findColumnByName(col_data, n_cols, "owner_id"); col_created = findColumnByName(col_data, n_cols, "created"); col_updated = findColumnByName(col_data, n_cols, "updated"); col_deleted = findColumnByName(col_data, n_cols, "deleted"); + size_t n_ext_cols = 0; + ext_cols = malloc(n_cols * sizeof(column_data *)); + if (ext_cols == 0) { + fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno)); + return -1; + } + size_t tbl_len = STR_LEN(META_EXT_TABLE); + for (idx = 0; idx < n_cols; idx++) { + col = *(col_data + idx); + if (strncmp(col->table + (col->table_len - tbl_len), META_EXT_TABLE, tbl_len) == 0) { + *(ext_cols + n_ext_cols) = col; + n_ext_cols++; + } + } + *metadata_list = (struct metadata_t **)malloc(sizeof(struct metadata_t *) * n_rows); if (*metadata_list == 0) { fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno)); + free(ext_cols); return -errno; } memset(*metadata_list, 0, sizeof(struct metadata_t *) * n_rows); @@ -43,19 +61,21 @@ int tableRowsToMetadataList(column_data **col_data, size_t n_cols, metadata = allocMetadata(); if (metadata == 0) { freeMetadataList(metadata_list, idx - 1); + free(ext_cols); return -1; } metadata->id = *(col_id->data.ptr_uint32 + idx); - if (!moveColumnStrPointer(col_type, idx, 1, &metadata->type, &metadata->type_len)) { - freeMetadataList(metadata_list, idx); - return -1; - } - metadata->type_c = metadata->type; +// if (!moveColumnStrPointer(col_type, idx, 1, &metadata->type, &metadata->type_len)) { +// freeMetadataList(metadata_list, idx); +// return -1; +// } +// metadata->type_c = metadata->type; if (!moveColumnStrPointer(col_title, idx, 1, &metadata->title, &metadata->title_len)) { freeMetadataList(metadata_list, idx); + free(ext_cols); return -1; } metadata->title_c = metadata->title; @@ -70,8 +90,15 @@ int tableRowsToMetadataList(column_data **col_data, size_t n_cols, metadata->deleted_on = *(col_deleted->data.ptr_int64 + idx); } + if (tableRowToMetaExt(ext_cols, n_ext_cols, idx, &metadata->ext) != 1) { + freeMetadataList(metadata_list, idx); + free(ext_cols); + return -1; + } + *(*metadata_list + idx) = metadata; } + free(ext_cols); *n_metadatas = n_rows; @@ -80,8 +107,8 @@ int tableRowsToMetadataList(column_data **col_data, size_t n_cols, int doMetadataListQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb, struct metadata_t ***metadata_list, size_t *n_metadatas) { - char *table; - size_t table_len; + char *table, *ext_table; + size_t table_len, ext_len; char *qry; size_t qry_len; uint64_t qry_ret; @@ -97,14 +124,17 @@ int doMetadataListQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb, return -1; } modbTableName(&table, &table_len, modb, METADATA_TABLE, strlen(METADATA_TABLE)); + modbTableName(&ext_table, &ext_len, modb, META_EXT_TABLE, strlen(META_EXT_TABLE)); strbld_str(sb, "SELECT * FROM ", 0); escapeTableName_sb(sb, table, table_len); + joinStr_sb(sb, " LEFT", 5, 1, ext_table, ext_len, "mdo_id", 6, table, table_len, "mdo_id", 6); if (wb != 0) { compileWhereBuilder_sb(sb, wb, 0); } strbld_str(sb, " ORDER BY `updated` DESC, `created` DESC", 0); + modbFreeTableName(&ext_table); modbFreeTableName(&table); if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) { return -1; @@ -238,9 +268,13 @@ int modbMetadataById(stored_conn *sconn, modb_ref *modb, unsigned int id, { where_builder *wb = 0; int res; + char *table; + size_t table_len; - wb = where(0, "mdo_id", EQ, TYPE_ID, 1, id); + modbTableName(&table, &table_len, modb, METADATA_TABLE, strlen(METADATA_TABLE)); + wb = where(table, "mdo_id", EQ, TYPE_ID, 1, id); res = doScalarMetadataListQuery(sconn, modb, wb, metadata); + free(table); freeWhereBuilder(&wb); return res; @@ -296,6 +330,12 @@ int modbMetadataListByGroupId(stored_conn *sconn, modb_ref *modb, unsigned int g return res; } +int modbMetadataQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb, + struct metadata_t ***metadata_list, size_t *n_metadatas) +{ + return doMetadataListQuery(sconn, modb, wb, metadata_list, n_metadatas); +} + int modbMetadataList(stored_conn *sconn, modb_ref *modb, int with_deleted, struct metadata_t ***metadata_list, size_t *n_metadatas) { @@ -323,9 +363,9 @@ unsigned int modbMetadataCreate(stored_conn *sconn, modb_ref *modb, size_t qry_len; uint64_t qry_ret; - if (metadata->type_c == 0) { - metadata->type_c = metadata->type; - } +// if (metadata->type_c == 0) { +// metadata->type_c = metadata->type; +// } if (metadata->title_c == 0) { metadata->title_c = metadata->title; } @@ -337,10 +377,11 @@ unsigned int modbMetadataCreate(stored_conn *sconn, modb_ref *modb, strbld_str(sb, "INSERT INTO ", 0); escapeTableName_sb(sb, table, table_len); - strbld_str(sb, " (`mdo_id`, `type`, `title`, `owner_id`) VALUES (", 0); +// strbld_str(sb, " (`mdo_id`, `type`, `title`, `owner_id`) VALUES (", 0); + strbld_str(sb, " (`mdo_id`, `title`, `owner_id`) VALUES (", 0); db_value_sb(sb, TYPE_ID, 1, metadata->id); - strbld_char(sb, ','); - db_value_sb(sb, TYPE_STRING, 2, metadata->type_c, metadata->type_len); +// strbld_char(sb, ','); +// db_value_sb(sb, TYPE_STRING, 2, metadata->type_c, metadata->type_len); strbld_char(sb, ','); db_value_sb(sb, TYPE_STRING, 2, metadata->title_c, metadata->title_len); strbld_char(sb, ','); @@ -370,9 +411,9 @@ int64_t modbMetadataReplace(stored_conn *sconn, modb_ref *modb, unsigned int id, size_t table_len, set_len; int64_t qry_ret; - if (metadata->type_c == 0) { - metadata->type_c = metadata->type; - } +// if (metadata->type_c == 0) { +// metadata->type_c = metadata->type; +// } if (metadata->title_c == 0) { metadata->title_c = metadata->title; } @@ -380,18 +421,31 @@ int64_t modbMetadataReplace(stored_conn *sconn, modb_ref *modb, unsigned int id, if ((sb = strbld_create()) == 0) { return 0; } + columnSetValueStr_sb(sb, "mdo_id", TYPE_ID, 1, id); if (metadata->id != 0 && metadata->id != id) { strbld_char(sb, ','); columnSetValueStr_sb(sb, "mdo_id", TYPE_ID, 1, metadata->id); } - if (metadata->type_c != 0) { - strbld_char(sb, ','); - columnSetValueStr_sb(sb, "type", TYPE_STRING, 2, metadata->type_c, metadata->type_len); - } +// if (metadata->type_c != 0) { +// strbld_char(sb, ','); +// columnSetValueStr_sb(sb, "type", TYPE_STRING, 2, metadata->type_c, metadata->type_len); +// } if (metadata->title_c != 0) { strbld_char(sb, ','); columnSetValueStr_sb(sb, "title", TYPE_STRING, 2, metadata->title_c, metadata->title_len); } + if (metadata->created_on != 0) { + strbld_char(sb, ','); + columnSetValueStr_sb(sb, "created", TYPE_TIMESTAMP, 1, metadata->created_on); + } + if (metadata->updated_on != 0) { + strbld_char(sb, ','); + columnSetValueStr_sb(sb, "updated", TYPE_TIMESTAMP, 1, metadata->updated_on); + } + if (metadata->deleted_on != 0) { + strbld_char(sb, ','); + columnSetValueStr_sb(sb, "deleted", TYPE_TIMESTAMP, 1, metadata->deleted_on); + } if (metadata->owner != 0) { strbld_char(sb, ','); columnSetValueStr_sb(sb, "owner_id", TYPE_ID, 1, metadata->owner->id); diff --git a/src/modb_metadata.h b/src/modb_metadata.h index d3eec98..9f5b384 100644 --- a/src/modb_metadata.h +++ b/src/modb_metadata.h @@ -9,9 +9,9 @@ struct metadata_t { unsigned int id; - char *type; - const char *type_c; - size_t type_len; +// char *type; +// const char *type_c; +// size_t type_len; char *title; const char *title_c; @@ -49,6 +49,9 @@ int modbMetadataListByGroupId(stored_conn *sconn, modb_ref *modb, unsigned int g int with_deleted, struct metadata_t ***metadata_list, size_t *n_metadatas); +int modbMetadataQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb, + struct metadata_t ***metadata_list, size_t *n_metadatas); + int modbMetadataList(stored_conn *sconn, modb_ref *modb, int with_deleted, struct metadata_t ***metadata_list, size_t *n_metadatas); diff --git a/src/modb_metadata_ext.c b/src/modb_metadata_ext.c index 6db5dec..31cf604 100644 --- a/src/modb_metadata_ext.c +++ b/src/modb_metadata_ext.c @@ -8,134 +8,170 @@ #include "modb_p.h" +// ##### PUBLIC +int tableRowToMetaExt(column_data **col_data, size_t n_cols, size_t row_idx, + struct meta_ext_t **ext_ptr) +{ + column_data *col_id, *col; + size_t c_idx, v_idx; + struct meta_ext_t *ext; + struct meta_ext_value_t *ext_value; + + col_id = findColumnByName(col_data, n_cols, "mdo_id"); + + if ((ext = allocMetaExt()) == 0) { + fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno)); + return -errno; + } + *ext_ptr = ext; + + ext->id = *(col_id->data.ptr_uint32 + row_idx); + + if (n_cols > 0) { + if ((ext->values = allocMetaExtValues(n_cols - 1, 1)) == 0) { + freeMetaExt(ext_ptr); + return -1; + } + ext->n_values = n_cols - 1; + } + + for (c_idx = 0, v_idx = 0; c_idx < n_cols; c_idx++, v_idx++) { + col = *(col_data + c_idx); + if (col == col_id) { + v_idx--; + continue; + } + ext_value = *(ext->values + v_idx); + + if (strmemcpy(col->name, col->name_len, &ext_value->key, &ext_value->key_len) != 0) { + freeMetaExt(ext_ptr); + return -1; + } + ext_value->key_c = ext_value->key; + + switch(col->type) { + case TYPE_RAW: + ext_value->type = VTYPE_RAW; + break; + case TYPE_BOOL: + ext_value->type = VTYPE_BOOL; + break; + case TYPE_INT8: + case TYPE_UINT8: + case TYPE_INT16: + case TYPE_UINT16: + case TYPE_INT32: + case TYPE_FLOAT: + ext_value->type = VTYPE_INT32; + break; + case TYPE_UINT32: + case TYPE_INT64: + case TYPE_UINT64: + case TYPE_DOUBLE: + ext_value->type = VTYPE_DOUBLE; + break; + case TYPE_STRING: + ext_value->type = VTYPE_STRING; + break; + case TYPE_BLOB: + ext_value->type = VTYPE_RAW; + break; + case TYPE_TIMESTAMP: + ext_value->type = VTYPE_TIMESTAMP; + break; + case TYPE_ID: + ext_value->type = VTYPE_ID; + break; + } + + if (columnRowIsNull(col, row_idx)) { + ext_value->is_null = 1; + } else { + switch(col->type) { + case TYPE_RAW: + if (!moveColumnBlobPointer(col, row_idx, 1, (char **)&ext_value->value.raw, &ext_value->value_len)) { + freeMetaExt(ext_ptr); + return -1; + } + break; + case TYPE_BOOL: + ext_value->value.int32 = *(col->data.ptr_uint8 + row_idx); + break; + case TYPE_INT8: + ext_value->value.int32 = *(col->data.ptr_int8 + row_idx); + break; + case TYPE_UINT8: + ext_value->value.int32 = *(col->data.ptr_uint8 + row_idx); + break; + case TYPE_INT16: + ext_value->value.int32 = *(col->data.ptr_int16 + row_idx); + break; + case TYPE_UINT16: + ext_value->value.int32 = *(col->data.ptr_uint16 + row_idx); + break; + case TYPE_INT32: + ext_value->value.int32 = *(col->data.ptr_int32 + row_idx); + break; + case TYPE_UINT32: + ext_value->value.dbl = (double)*(col->data.ptr_uint32 + row_idx); + break; + case TYPE_INT64: + ext_value->value.dbl = (double)*(col->data.ptr_int64 + row_idx); + break; + case TYPE_UINT64: + ext_value->value.dbl = (double)*(col->data.ptr_uint64 + row_idx); + break; + case TYPE_FLOAT: + ext_value->value.dbl = (double)*(col->data.ptr_float + row_idx); + break; + case TYPE_DOUBLE: + ext_value->value.dbl = *(col->data.ptr_double + row_idx); + break; + case TYPE_STRING: + if (!moveColumnStrPointer(col, row_idx, 1, &ext_value->value.str, &ext_value->value_len)) { + freeMetaExt(ext_ptr); + return -1; + } + break; + case TYPE_BLOB: + if (!moveColumnBlobPointer(col, row_idx, 1, (char **)&ext_value->value.raw, &ext_value->value_len)) { + freeMetaExt(ext_ptr); + return -1; + } + break; + case TYPE_TIMESTAMP: + ext_value->value.ts = *(col->data.ptr_int64 + row_idx); + break; + case TYPE_ID: + ext_value->value.id = *(col->data.ptr_uint32 + row_idx); + break; + } + } + } + + return 1; +} // ##### PRIVATE int tableRowsToMetaExtList(column_data **col_data, size_t n_cols, struct meta_ext_t ***ext_list, size_t *n_exts) { - column_data *col_id, *col; - size_t n_rows, r_idx, c_idx, v_idx; - struct meta_ext_t *ext; - struct meta_ext_value_t *ext_value; + size_t n_rows, r_idx; n_rows = (*col_data)->n_values; if (n_rows == 0) { return 0; } - col_id = findColumnByName(col_data, n_cols, "mdo_id"); - if ((*ext_list = allocMetaExtList(n_rows)) == 0) { fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno)); return -errno; } for (r_idx = 0; r_idx < n_rows; r_idx++) { - if ((ext = allocMetaExt()) == 0) { - freeMetaExtList(ext_list, r_idx - 1); + if (tableRowToMetaExt(col_data, n_cols, r_idx, (*ext_list) + r_idx) != 1) { + freeMetaExtList(ext_list, r_idx); return -1; } - *((*ext_list) + r_idx) = ext; - - ext->id = *(col_id->data.ptr_uint32 + r_idx); - - if (n_cols > 0) { - if ((ext->values = allocMetaExtValues(n_cols - 1, 1)) == 0) { - freeMetaExtList(ext_list, r_idx); - return -1; - } - ext->n_values = n_cols - 1; - } - - for (c_idx = 0, v_idx = 0; c_idx < n_cols; c_idx++, v_idx++) { - col = *(col_data + c_idx); - if (col == col_id) { - v_idx--; - continue; - } - ext_value = *(ext->values + v_idx); - - if (strmemcpy(col->name, col->name_len, &ext_value->key, &ext_value->key_len) != 0) { - freeMetaExtList(ext_list, r_idx); - return -1; - } - ext_value->key_c = ext_value->key; - - switch(col->type) { - case TYPE_RAW: - ext_value->type = VTYPE_RAW; - if (!moveColumnBlobPointer(col, r_idx, 1, (char **)&ext_value->value.raw, &ext_value->value_len)) { - freeMetaExtList(ext_list, r_idx); - return -1; - } - break; - case TYPE_BOOL: - ext_value->type = VTYPE_BOOL; - ext_value->value.int32 = *(col->data.ptr_uint8 + r_idx); - break; - case TYPE_INT8: - ext_value->type = VTYPE_INT32; - ext_value->value.int32 = *(col->data.ptr_int8 + r_idx); - break; - case TYPE_UINT8: - ext_value->type = VTYPE_INT32; - ext_value->value.int32 = *(col->data.ptr_uint8 + r_idx); - break; - case TYPE_INT16: - ext_value->type = VTYPE_INT32; - ext_value->value.int32 = *(col->data.ptr_int16 + r_idx); - break; - case TYPE_UINT16: - ext_value->type = VTYPE_INT32; - ext_value->value.int32 = *(col->data.ptr_uint16 + r_idx); - break; - case TYPE_INT32: - ext_value->type = VTYPE_INT32; - ext_value->value.int32 = *(col->data.ptr_int32 + r_idx); - break; - case TYPE_UINT32: - ext_value->type = VTYPE_INT32; - ext_value->value.dbl = (double)*(col->data.ptr_uint32 + r_idx); - break; - case TYPE_INT64: - ext_value->type = VTYPE_INT32; - ext_value->value.dbl = (double)*(col->data.ptr_int64 + r_idx); - break; - case TYPE_UINT64: - ext_value->type = VTYPE_INT32; - ext_value->value.dbl = (double)*(col->data.ptr_uint64 + r_idx); - break; - case TYPE_FLOAT: - ext_value->type = VTYPE_INT32; - ext_value->value.dbl = (double)*(col->data.ptr_float + r_idx); - break; - case TYPE_DOUBLE: - ext_value->type = VTYPE_DOUBLE; - ext_value->value.dbl = *(col->data.ptr_double + r_idx); - break; - case TYPE_STRING: - ext_value->type = VTYPE_STRING; - if (!moveColumnStrPointer(col, r_idx, 1, &ext_value->value.str, &ext_value->value_len)) { - freeMetaExtList(ext_list, r_idx); - return -1; - } - break; - case TYPE_BLOB: - ext_value->type = VTYPE_RAW; - if (!moveColumnBlobPointer(col, r_idx, 1, (char **)&ext_value->value.raw, &ext_value->value_len)) { - freeMetaExtList(ext_list, r_idx); - return -1; - } - break; - case TYPE_TIMESTAMP: - ext_value->type = VTYPE_TIMESTAMP; - ext_value->value.ts = *(col->data.ptr_int64 + r_idx); - break; - case TYPE_ID: - ext_value->type = VTYPE_ID; - ext_value->value.id = *(col->data.ptr_uint32 + r_idx); - break; - } - } } *n_exts = n_rows; @@ -424,28 +460,36 @@ int64_t modbMetaExtCreate(stored_conn *sconn, modb_ref *modb, struct meta_ext_t for (idx = 0; idx < meta_ext->n_values; idx++) { ext_value = *(meta_ext->values + idx); strbld_char(sb, ','); - switch(ext_value->type) { - case VTYPE_RAW: - db_value_sb(sb, TYPE_RAW, 2, ext_value->value.raw, ext_value->value_len); - break; - case VTYPE_BOOL: - db_value_sb(sb, TYPE_BOOL, 1, ext_value->value.bool); - break; - case VTYPE_INT32: - db_value_sb(sb, TYPE_INT32, 1, ext_value->value.int32); - break; - case VTYPE_DOUBLE: - db_value_sb(sb, TYPE_DOUBLE, 1, ext_value->value.dbl); - break; - case VTYPE_STRING: - db_value_sb(sb, TYPE_STRING, 2, ext_value->value.str, ext_value->value_len); - break; - case VTYPE_TIMESTAMP: - db_value_sb(sb, TYPE_TIMESTAMP, 1, ext_value->value.ts); - break; - case VTYPE_ID: - db_value_sb(sb, TYPE_ID, 1, ext_value->value.id); - break; + if (ext_value->is_null) { + db_value_sb(sb, TYPE_RAW, 0); + } else { + switch(ext_value->type) { + case VTYPE_RAW: + if (ext_value->is_null) { + db_value_sb(sb, TYPE_RAW, 0); + } else { + db_value_sb(sb, TYPE_RAW, 2, ext_value->value.raw, ext_value->value_len); + } + break; + case VTYPE_BOOL: + db_value_sb(sb, TYPE_BOOL, 1, ext_value->value.boolVal); + break; + case VTYPE_INT32: + db_value_sb(sb, TYPE_INT32, 1, ext_value->value.int32); + break; + case VTYPE_DOUBLE: + db_value_sb(sb, TYPE_DOUBLE, 1, ext_value->value.dbl); + break; + case VTYPE_STRING: + db_value_sb(sb, TYPE_STRING, 2, ext_value->value.str, ext_value->value_len); + break; + case VTYPE_TIMESTAMP: + db_value_sb(sb, TYPE_TIMESTAMP, 1, ext_value->value.ts); + break; + case VTYPE_ID: + db_value_sb(sb, TYPE_ID, 1, ext_value->value.id); + break; + } } } strbld_char(sb, ')'); @@ -461,8 +505,6 @@ int64_t modbMetaExtCreate(stored_conn *sconn, modb_ref *modb, struct meta_ext_t return qry_ret == 0 ? meta_ext->id : 0; } int64_t modbMetaExtReplace(stored_conn *sconn, modb_ref *modb, unsigned int id, - struct meta_ext_t *meta_ext); -int64_t modbMetaExtUpdate(stored_conn *sconn, modb_ref *modb, unsigned int id, struct meta_ext_t *meta_ext) { str_builder *sb; @@ -480,32 +522,36 @@ int64_t modbMetaExtUpdate(stored_conn *sconn, modb_ref *modb, unsigned int id, for (idx = 0; idx < meta_ext->n_values; idx++) { ext_value = *(meta_ext->values + idx); strbld_char(sb, ','); - switch(ext_value->type) { - case VTYPE_RAW: - columnSetValueStr_sb( - sb, ext_value->key_c, TYPE_RAW, 2, ext_value->value.raw, ext_value->value_len - ); - break; - case VTYPE_BOOL: - columnSetValueStr_sb(sb, ext_value->key_c, TYPE_BOOL, 1, ext_value->value.bool); - break; - case VTYPE_INT32: - columnSetValueStr_sb(sb, ext_value->key_c, TYPE_INT32, 1, ext_value->value.int32); - break; - case VTYPE_DOUBLE: - columnSetValueStr_sb(sb, ext_value->key_c, TYPE_DOUBLE, 1, ext_value->value.dbl); - break; - case VTYPE_STRING: - columnSetValueStr_sb( - sb, ext_value->key_c, TYPE_STRING, 2, ext_value->value.str, ext_value->value_len - ); - break; - case VTYPE_TIMESTAMP: - columnSetValueStr_sb(sb, ext_value->key_c, TYPE_TIMESTAMP, 1, ext_value->value.ts); - break; - case VTYPE_ID: - columnSetValueStr_sb(sb, ext_value->key_c, TYPE_ID, 1, ext_value->value.id); - break; + if (ext_value->is_null) { + columnSetValueStr_sb(sb, ext_value->key_c, TYPE_RAW, 0); + } else { + switch(ext_value->type) { + case VTYPE_RAW: + columnSetValueStr_sb( + sb, ext_value->key_c, TYPE_RAW, 2, ext_value->value.raw, ext_value->value_len + ); + break; + case VTYPE_BOOL: + columnSetValueStr_sb(sb, ext_value->key_c, TYPE_BOOL, 1, ext_value->value.boolVal); + break; + case VTYPE_INT32: + columnSetValueStr_sb(sb, ext_value->key_c, TYPE_INT32, 1, ext_value->value.int32); + break; + case VTYPE_DOUBLE: + columnSetValueStr_sb(sb, ext_value->key_c, TYPE_DOUBLE, 1, ext_value->value.dbl); + break; + case VTYPE_STRING: + columnSetValueStr_sb( + sb, ext_value->key_c, TYPE_STRING, 2, ext_value->value.str, ext_value->value_len + ); + break; + case VTYPE_TIMESTAMP: + columnSetValueStr_sb(sb, ext_value->key_c, TYPE_TIMESTAMP, 1, ext_value->value.ts); + break; + case VTYPE_ID: + columnSetValueStr_sb(sb, ext_value->key_c, TYPE_ID, 1, ext_value->value.id); + break; + } } } diff --git a/src/modb_metadata_ext.h b/src/modb_metadata_ext.h index 2651ab1..a0029f7 100644 --- a/src/modb_metadata_ext.h +++ b/src/modb_metadata_ext.h @@ -33,7 +33,7 @@ struct meta_ext_value_t { union { void *raw; - int bool; + int boolVal; int32_t int32; double dbl; char *str; @@ -47,6 +47,10 @@ struct meta_ext_value_t { uint32_t is_const :1; }; + +int tableRowToMetaExt(column_data **col_data, size_t n_cols, size_t row_idx, + struct meta_ext_t **ext_ptr); + struct meta_ext_t *allocMetaExt(void); void freeMetaExt(struct meta_ext_t **meta_ext); struct meta_ext_t **allocMetaExtList(size_t n_meta_ext_list);