R/rmodb
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Modifications to metadata and meta_ext handling

Browse Source
This commit is contained in:
Craig Williams
2020-11-09 12:41:21 +00:00
parent 0b7fd87036
commit f0e47fb9eb
5 changed files with 295 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/modb_database_p.c
View File

@@ -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, "

100
src/modb_metadata.c
View File

@@ -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);

9
src/modb_metadata.h
View File

@@ -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);

366
src/modb_metadata_ext.c
View File

@@ -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;
}
}
}

6
src/modb_metadata_ext.h
View File

@@ -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);