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), METADATA_TABLE, STR_LEN(METADATA_TABLE),
"(" "("
"`mdo_id` INT UNSIGNED NOT NULL AUTO_INCREMENT, " "`mdo_id` INT UNSIGNED NOT NULL AUTO_INCREMENT, "
"`type` VARCHAR(255) NOT NULL, " // "`type` VARCHAR(255) NOT NULL, "
"`title` VARCHAR(255) NOT NULL, " "`title` VARCHAR(255) NOT NULL, "
"`owner_id` INT UNSIGNED NOT NULL, " "`owner_id` INT UNSIGNED NOT NULL, "
"`created` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, " "`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, int tableRowsToMetadataList(column_data **col_data, size_t n_cols,
struct metadata_t ***metadata_list, size_t *n_metadatas) 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; *col_created, *col_updated, *col_deleted;
size_t n_rows, idx; size_t n_rows, idx;
struct metadata_t *metadata; struct metadata_t *metadata;
column_data **ext_cols;
column_data *col;
n_rows = (*col_data)->n_values; n_rows = (*col_data)->n_values;
if (n_rows == 0) { 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_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_title = findColumnByName(col_data, n_cols, "title");
col_owner_id = findColumnByName(col_data, n_cols, "owner_id"); col_owner_id = findColumnByName(col_data, n_cols, "owner_id");
col_created = findColumnByName(col_data, n_cols, "created"); col_created = findColumnByName(col_data, n_cols, "created");
col_updated = findColumnByName(col_data, n_cols, "updated"); col_updated = findColumnByName(col_data, n_cols, "updated");
col_deleted = findColumnByName(col_data, n_cols, "deleted"); 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); *metadata_list = (struct metadata_t **)malloc(sizeof(struct metadata_t *) * n_rows);
if (*metadata_list == 0) { if (*metadata_list == 0) {
fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno)); fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
free(ext_cols);
return -errno; return -errno;
} }
memset(*metadata_list, 0, sizeof(struct metadata_t *) * n_rows); 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(); metadata = allocMetadata();
if (metadata == 0) { if (metadata == 0) {
freeMetadataList(metadata_list, idx - 1); freeMetadataList(metadata_list, idx - 1);
free(ext_cols);
return -1; return -1;
} }
metadata->id = *(col_id->data.ptr_uint32 + idx); metadata->id = *(col_id->data.ptr_uint32 + idx);
if (!moveColumnStrPointer(col_type, idx, 1, &metadata->type, &metadata->type_len)) { // if (!moveColumnStrPointer(col_type, idx, 1, &metadata->type, &metadata->type_len)) {
freeMetadataList(metadata_list, idx); // freeMetadataList(metadata_list, idx);
return -1; // return -1;
} // }
metadata->type_c = metadata->type; // metadata->type_c = metadata->type;
if (!moveColumnStrPointer(col_title, idx, 1, &metadata->title, &metadata->title_len)) { if (!moveColumnStrPointer(col_title, idx, 1, &metadata->title, &metadata->title_len)) {
freeMetadataList(metadata_list, idx); freeMetadataList(metadata_list, idx);
free(ext_cols);
return -1; return -1;
} }
metadata->title_c = metadata->title; 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); 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; *(*metadata_list + idx) = metadata;
} }
free(ext_cols);
*n_metadatas = n_rows; *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, int doMetadataListQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb,
struct metadata_t ***metadata_list, size_t *n_metadatas) struct metadata_t ***metadata_list, size_t *n_metadatas)
{ {
char *table; char *table, *ext_table;
size_t table_len; size_t table_len, ext_len;
char *qry; char *qry;
size_t qry_len; size_t qry_len;
uint64_t qry_ret; uint64_t qry_ret;
@@ -97,14 +124,17 @@ int doMetadataListQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb,
return -1; return -1;
} }
modbTableName(&table, &table_len, modb, METADATA_TABLE, strlen(METADATA_TABLE)); 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); strbld_str(sb, "SELECT * FROM ", 0);
escapeTableName_sb(sb, table, table_len); 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) { if (wb != 0) {
compileWhereBuilder_sb(sb, wb, 0); compileWhereBuilder_sb(sb, wb, 0);
} }
strbld_str(sb, " ORDER BY `updated` DESC, `created` DESC", 0); strbld_str(sb, " ORDER BY `updated` DESC, `created` DESC", 0);
modbFreeTableName(&ext_table);
modbFreeTableName(&table); modbFreeTableName(&table);
if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) { if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) {
return -1; return -1;
@@ -238,9 +268,13 @@ int modbMetadataById(stored_conn *sconn, modb_ref *modb, unsigned int id,
{ {
where_builder *wb = 0; where_builder *wb = 0;
int res; 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); res = doScalarMetadataListQuery(sconn, modb, wb, metadata);
free(table);
freeWhereBuilder(&wb); freeWhereBuilder(&wb);
return res; return res;
@@ -296,6 +330,12 @@ int modbMetadataListByGroupId(stored_conn *sconn, modb_ref *modb, unsigned int g
return res; 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, int modbMetadataList(stored_conn *sconn, modb_ref *modb, int with_deleted,
struct metadata_t ***metadata_list, size_t *n_metadatas) 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; size_t qry_len;
uint64_t qry_ret; uint64_t qry_ret;
if (metadata->type_c == 0) { // if (metadata->type_c == 0) {
metadata->type_c = metadata->type; // metadata->type_c = metadata->type;
} // }
if (metadata->title_c == 0) { if (metadata->title_c == 0) {
metadata->title_c = metadata->title; metadata->title_c = metadata->title;
} }
@@ -337,10 +377,11 @@ unsigned int modbMetadataCreate(stored_conn *sconn, modb_ref *modb,
strbld_str(sb, "INSERT INTO ", 0); strbld_str(sb, "INSERT INTO ", 0);
escapeTableName_sb(sb, table, table_len); 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); db_value_sb(sb, TYPE_ID, 1, metadata->id);
strbld_char(sb, ','); // strbld_char(sb, ',');
db_value_sb(sb, TYPE_STRING, 2, metadata->type_c, metadata->type_len); // db_value_sb(sb, TYPE_STRING, 2, metadata->type_c, metadata->type_len);
strbld_char(sb, ','); strbld_char(sb, ',');
db_value_sb(sb, TYPE_STRING, 2, metadata->title_c, metadata->title_len); db_value_sb(sb, TYPE_STRING, 2, metadata->title_c, metadata->title_len);
strbld_char(sb, ','); 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; size_t table_len, set_len;
int64_t qry_ret; int64_t qry_ret;
if (metadata->type_c == 0) { // if (metadata->type_c == 0) {
metadata->type_c = metadata->type; // metadata->type_c = metadata->type;
} // }
if (metadata->title_c == 0) { if (metadata->title_c == 0) {
metadata->title_c = metadata->title; 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) { if ((sb = strbld_create()) == 0) {
return 0; return 0;
} }
columnSetValueStr_sb(sb, "mdo_id", TYPE_ID, 1, id);
if (metadata->id != 0 && metadata->id != id) { if (metadata->id != 0 && metadata->id != id) {
strbld_char(sb, ','); strbld_char(sb, ',');
columnSetValueStr_sb(sb, "mdo_id", TYPE_ID, 1, metadata->id); columnSetValueStr_sb(sb, "mdo_id", TYPE_ID, 1, metadata->id);
} }
if (metadata->type_c != 0) { // if (metadata->type_c != 0) {
strbld_char(sb, ','); // strbld_char(sb, ',');
columnSetValueStr_sb(sb, "type", TYPE_STRING, 2, metadata->type_c, metadata->type_len); // columnSetValueStr_sb(sb, "type", TYPE_STRING, 2, metadata->type_c, metadata->type_len);
} // }
if (metadata->title_c != 0) { if (metadata->title_c != 0) {
strbld_char(sb, ','); strbld_char(sb, ',');
columnSetValueStr_sb(sb, "title", TYPE_STRING, 2, metadata->title_c, metadata->title_len); 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) { if (metadata->owner != 0) {
strbld_char(sb, ','); strbld_char(sb, ',');
columnSetValueStr_sb(sb, "owner_id", TYPE_ID, 1, metadata->owner->id); 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 { struct metadata_t {
unsigned int id; unsigned int id;
char *type; // char *type;
const char *type_c; // const char *type_c;
size_t type_len; // size_t type_len;
char *title; char *title;
const char *title_c; const char *title_c;
@@ -49,6 +49,9 @@ int modbMetadataListByGroupId(stored_conn *sconn, modb_ref *modb, unsigned int g
int with_deleted, int with_deleted,
struct metadata_t ***metadata_list, size_t *n_metadatas); 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, int modbMetadataList(stored_conn *sconn, modb_ref *modb, int with_deleted,
struct metadata_t ***metadata_list, size_t *n_metadatas); 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" #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 // ##### PRIVATE
int tableRowsToMetaExtList(column_data **col_data, size_t n_cols, int tableRowsToMetaExtList(column_data **col_data, size_t n_cols,
struct meta_ext_t ***ext_list, size_t *n_exts) struct meta_ext_t ***ext_list, size_t *n_exts)
{ {
column_data *col_id, *col; size_t n_rows, r_idx;
size_t n_rows, r_idx, c_idx, v_idx;
struct meta_ext_t *ext;
struct meta_ext_value_t *ext_value;
n_rows = (*col_data)->n_values; n_rows = (*col_data)->n_values;
if (n_rows == 0) { if (n_rows == 0) {
return 0; return 0;
} }
col_id = findColumnByName(col_data, n_cols, "mdo_id");
if ((*ext_list = allocMetaExtList(n_rows)) == 0) { if ((*ext_list = allocMetaExtList(n_rows)) == 0) {
fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno)); fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
return -errno; return -errno;
} }
for (r_idx = 0; r_idx < n_rows; r_idx++) { for (r_idx = 0; r_idx < n_rows; r_idx++) {
if ((ext = allocMetaExt()) == 0) { if (tableRowToMetaExt(col_data, n_cols, r_idx, (*ext_list) + r_idx) != 1) {
freeMetaExtList(ext_list, r_idx - 1); freeMetaExtList(ext_list, r_idx);
return -1; 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; *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++) { for (idx = 0; idx < meta_ext->n_values; idx++) {
ext_value = *(meta_ext->values + idx); ext_value = *(meta_ext->values + idx);
strbld_char(sb, ','); strbld_char(sb, ',');
switch(ext_value->type) { if (ext_value->is_null) {
case VTYPE_RAW: db_value_sb(sb, TYPE_RAW, 0);
db_value_sb(sb, TYPE_RAW, 2, ext_value->value.raw, ext_value->value_len); } else {
break; switch(ext_value->type) {
case VTYPE_BOOL: case VTYPE_RAW:
db_value_sb(sb, TYPE_BOOL, 1, ext_value->value.bool); if (ext_value->is_null) {
break; db_value_sb(sb, TYPE_RAW, 0);
case VTYPE_INT32: } else {
db_value_sb(sb, TYPE_INT32, 1, ext_value->value.int32); db_value_sb(sb, TYPE_RAW, 2, ext_value->value.raw, ext_value->value_len);
break; }
case VTYPE_DOUBLE: break;
db_value_sb(sb, TYPE_DOUBLE, 1, ext_value->value.dbl); case VTYPE_BOOL:
break; db_value_sb(sb, TYPE_BOOL, 1, ext_value->value.boolVal);
case VTYPE_STRING: break;
db_value_sb(sb, TYPE_STRING, 2, ext_value->value.str, ext_value->value_len); case VTYPE_INT32:
break; db_value_sb(sb, TYPE_INT32, 1, ext_value->value.int32);
case VTYPE_TIMESTAMP: break;
db_value_sb(sb, TYPE_TIMESTAMP, 1, ext_value->value.ts); case VTYPE_DOUBLE:
break; db_value_sb(sb, TYPE_DOUBLE, 1, ext_value->value.dbl);
case VTYPE_ID: break;
db_value_sb(sb, TYPE_ID, 1, ext_value->value.id); case VTYPE_STRING:
break; 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, ')'); 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; return qry_ret == 0 ? meta_ext->id : 0;
} }
int64_t modbMetaExtReplace(stored_conn *sconn, modb_ref *modb, unsigned int id, 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) struct meta_ext_t *meta_ext)
{ {
str_builder *sb; 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++) { for (idx = 0; idx < meta_ext->n_values; idx++) {
ext_value = *(meta_ext->values + idx); ext_value = *(meta_ext->values + idx);
strbld_char(sb, ','); strbld_char(sb, ',');
switch(ext_value->type) { if (ext_value->is_null) {
case VTYPE_RAW: columnSetValueStr_sb(sb, ext_value->key_c, TYPE_RAW, 0);
columnSetValueStr_sb( } else {
sb, ext_value->key_c, TYPE_RAW, 2, ext_value->value.raw, ext_value->value_len switch(ext_value->type) {
); case VTYPE_RAW:
break; columnSetValueStr_sb(
case VTYPE_BOOL: sb, ext_value->key_c, TYPE_RAW, 2, ext_value->value.raw, ext_value->value_len
columnSetValueStr_sb(sb, ext_value->key_c, TYPE_BOOL, 1, ext_value->value.bool); );
break; break;
case VTYPE_INT32: case VTYPE_BOOL:
columnSetValueStr_sb(sb, ext_value->key_c, TYPE_INT32, 1, ext_value->value.int32); columnSetValueStr_sb(sb, ext_value->key_c, TYPE_BOOL, 1, ext_value->value.boolVal);
break; break;
case VTYPE_DOUBLE: case VTYPE_INT32:
columnSetValueStr_sb(sb, ext_value->key_c, TYPE_DOUBLE, 1, ext_value->value.dbl); columnSetValueStr_sb(sb, ext_value->key_c, TYPE_INT32, 1, ext_value->value.int32);
break; break;
case VTYPE_STRING: case VTYPE_DOUBLE:
columnSetValueStr_sb( columnSetValueStr_sb(sb, ext_value->key_c, TYPE_DOUBLE, 1, ext_value->value.dbl);
sb, ext_value->key_c, TYPE_STRING, 2, ext_value->value.str, ext_value->value_len break;
); case VTYPE_STRING:
break; columnSetValueStr_sb(
case VTYPE_TIMESTAMP: sb, ext_value->key_c, TYPE_STRING, 2, ext_value->value.str, ext_value->value_len
columnSetValueStr_sb(sb, ext_value->key_c, TYPE_TIMESTAMP, 1, ext_value->value.ts); );
break; break;
case VTYPE_ID: case VTYPE_TIMESTAMP:
columnSetValueStr_sb(sb, ext_value->key_c, TYPE_ID, 1, ext_value->value.id); columnSetValueStr_sb(sb, ext_value->key_c, TYPE_TIMESTAMP, 1, ext_value->value.ts);
break; 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 { union {
void *raw; void *raw;
int bool; int boolVal;
int32_t int32; int32_t int32;
double dbl; double dbl;
char *str; char *str;
@@ -47,6 +47,10 @@ struct meta_ext_value_t {
uint32_t is_const :1; 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); struct meta_ext_t *allocMetaExt(void);
void freeMetaExt(struct meta_ext_t **meta_ext); void freeMetaExt(struct meta_ext_t **meta_ext);
struct meta_ext_t **allocMetaExtList(size_t n_meta_ext_list); struct meta_ext_t **allocMetaExtList(size_t n_meta_ext_list);