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

Minor refactoring to db_column

Browse Source 
Typedef'd an enum
Renamed a column detail variable
Added debug query print
This commit is contained in:
Craig Williams
2020-09-23 13:06:45 +01:00
parent 02d11c75b2
commit f15017501c
3 changed files with 86 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
src/db_column.c
View File

@@ -7,7 +7,7 @@
#include "db_column.h" #include "db_column.h"
size_t columnTypeToByteSize(enum e_column_type type) size_t columnTypeToByteSize(e_column_type type)
{ {
switch(type) { switch(type) {
case TYPE_BOOL: case TYPE_BOOL:
@@ -48,7 +48,7 @@ size_t columnTypeToByteSize(enum e_column_type type)
return sizeof(char *); return sizeof(char *);
} }
enum e_column_type simplifyFieldType(enum enum_field_types sql_type, int is_unsigned) e_column_type simplifyFieldType(enum enum_field_types sql_type, int is_unsigned)
{ {
switch(sql_type) { switch(sql_type) {
case MYSQL_TYPE_TINY: case MYSQL_TYPE_TINY:
@@ -110,6 +110,51 @@ enum e_column_type simplifyFieldType(enum enum_field_types sql_type, int is_unsi
} }
struct column_data_t *initEmptyColumn(e_column_type type, int nullable, const char *name,
size_t name_len)
{
struct column_data_t *col;
if (name_len == 0) {
name_len = strlen(name);
}
col = (struct column_data_t *)malloc(sizeof(struct column_data_t));
if (col == NULL) {
fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
return 0;
}
memset(col, 0, sizeof(struct column_data_t));
col->name_len = name_len;
col->name = (char*)malloc(col->name_len + 1);
if (col->name == NULL) {
fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
free(col);
return 0;
}
memcpy(col->name, name, col->name_len);
*(col->name + col->name_len) = '\0';
col->type = type;
col->type_bytes = columnTypeToByteSize(col->type);
col->n_values = 0;
col->hasPointers = col->type == TYPE_STRING
|| col->type == TYPE_BLOB
|| col->type == TYPE_RAW;
col->isUnsigned = col->type == TYPE_UINT8
|| col->type == TYPE_UINT16
|| col->type == TYPE_UINT32
|| col->type == TYPE_UINT64;
col->isNullable = nullable > 0;
col->isBlob = type == TYPE_BLOB;
col->isTimestamp = type == TYPE_TIMESTAMP;
return col;
}
struct column_data_t *columnFromResult(struct stored_conn_t *sconn, MYSQL_RES *result, struct column_data_t *columnFromResult(struct stored_conn_t *sconn, MYSQL_RES *result,
uint64_t num_rows) uint64_t num_rows)
{ {
@@ -125,39 +170,19 @@ struct column_data_t *columnFromResult(struct stored_conn_t *sconn, MYSQL_RES *r
return 0; return 0;
} }
col = (struct column_data_t *)malloc(sizeof(struct column_data_t)); col = initEmptyColumn(
if (col == NULL) { simplifyFieldType(field->type, (field->flags & UNSIGNED_FLAG) > 0),
fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno)); (field->flags & NOT_NULL_FLAG) == 0,
return 0; field->name,
} field->name_length
memset(col, 0, sizeof(struct column_data_t)); );
col->name_size = field->name_length; if (col == 0 || num_rows == 0) {
col->name = (char*)malloc(field->name_length + 1);
if (col->name == NULL) {
fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
free(col);
return 0;
}
memcpy(col->name, field->name, col->name_size);
*(col->name + col->name_size) = '\0';
col->type = simplifyFieldType(field->type, (field->flags & UNSIGNED_FLAG) > 0);
col->type_bytes = columnTypeToByteSize(col->type);
col->n_values = num_rows;
col->hasPointers = col->type == TYPE_STRING
|| col->type == TYPE_BLOB
|| col->type == TYPE_RAW;
col->isNullable = (field->flags & NOT_NULL_FLAG) == 0;
col->isBlob = (field->flags & BLOB_FLAG) > 0;
col->isTimestamp = (field->flags & TIMESTAMP_FLAG) > 0;
if (num_rows == 0) {
return col; return col;
} }
col->n_values = num_rows;
col->data.vptr = malloc(col->type_bytes * num_rows); col->data.vptr = malloc(col->type_bytes * num_rows);
if (col->data.vptr == NULL) { if (col->data.vptr == NULL) {
fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno)); fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
@@ -168,23 +193,23 @@ struct column_data_t *columnFromResult(struct stored_conn_t *sconn, MYSQL_RES *r
memset(col->data.vptr, 0, col->type_bytes * num_rows); memset(col->data.vptr, 0, col->type_bytes * num_rows);
if (col->hasPointers) { if (col->hasPointers) {
col->data_sizes = (size_t *)malloc(sizeof(size_t) * num_rows); col->data_lens = (size_t *)malloc(sizeof(size_t) * num_rows);
if (col->data_sizes == NULL) { if (col->data_lens == NULL) {
fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno)); fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
free(col->data.vptr); free(col->data.vptr);
free(col->name); free(col->name);
free(col); free(col);
return 0; return 0;
} }
memset(col->data_sizes, 0, sizeof(size_t) * num_rows); memset(col->data_lens, 0, sizeof(size_t) * num_rows);
} }
if (col->isNullable) { if (col->isNullable) {
col->nulls = malloc(num_rows / 8 + 1); col->nulls = malloc(num_rows / 8 + 1);
if (col->nulls == NULL) { if (col->nulls == NULL) {
fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno)); fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
if (col->data_sizes) { if (col->data_lens) {
free(col->data_sizes); free(col->data_lens);
} }
free(col->data.vptr); free(col->data.vptr);
free(col->name); free(col->name);
@@ -207,8 +232,8 @@ void freeColumn(struct column_data_t *col)
} }
} }
free(col->data_sizes); free(col->data_lens);
col->data_sizes = 0; col->data_lens = 0;
} }
if (col->data.vptr) { if (col->data.vptr) {
@@ -242,6 +267,10 @@ int setColumnValue(struct column_data_t *col, uint64_t row, const char *value, s
return 0; return 0;
} }
if (value_size == 0) {
value_size = strlen(value);
}
switch(col->type) { switch(col->type) {
case TYPE_BOOL: case TYPE_BOOL:
{ {
@@ -319,8 +348,8 @@ int setColumnValue(struct column_data_t *col, uint64_t row, const char *value, s
return -1; return -1;
} }
memcpy(*(col->data.ptr_str + row), value, value_size); memcpy(*(col->data.ptr_str + row), value, value_size);
*(*(col->data.ptr_str + row) + value_size) = 0; *(*(col->data.ptr_str + row) + value_size) = '\0';
*(col->data_sizes + row) = value_size; *(col->data_lens + row) = value_size;
break; break;
} }
} }

18
src/db_column.h
View File

@@ -5,7 +5,8 @@
#include <mysql.h> #include <mysql.h>
#include "db_connection.h" #include "db_connection.h"
enum e_column_type { enum e_column_type_t {
TYPE_RAW,
TYPE_BOOL, TYPE_BOOL,
TYPE_INT8, TYPE_INT8,
TYPE_UINT8, TYPE_UINT8,
@@ -19,20 +20,21 @@ enum e_column_type {
TYPE_DOUBLE, TYPE_DOUBLE,
TYPE_STRING, TYPE_STRING,
TYPE_BLOB, TYPE_BLOB,
TYPE_TIMESTAMP, TYPE_TIMESTAMP
TYPE_RAW
}; };
typedef enum e_column_type_t e_column_type;
struct column_data_t { struct column_data_t {
char *name; char *name;
size_t name_size; size_t name_len;
enum e_column_type type; enum e_column_type_t type;
size_t type_bytes; size_t type_bytes;
size_t n_values; size_t n_values;
uint8_t hasPointers :1; uint8_t hasPointers :1;
uint8_t isUnsigned :1;
uint8_t isNullable :1; uint8_t isNullable :1;
uint8_t isBlob :1; uint8_t isBlob :1;
uint8_t isTimestamp :1; uint8_t isTimestamp :1;
@@ -57,7 +59,7 @@ struct column_data_t {
char **ptr_str; char **ptr_str;
} data; } data;
size_t *data_sizes; size_t *data_lens;
uint8_t *nulls; uint8_t *nulls;
}; };
@@ -81,13 +83,13 @@ static inline void columnRowClearNull(struct column_data_t *col, uint64_t row)
} }
} }
struct column_data_t *initEmptyColumn(e_column_type type, int nullable, const char *name,
size_t name_len);
struct column_data_t *columnFromResult(struct stored_conn_t *sconn, MYSQL_RES *result, struct column_data_t *columnFromResult(struct stored_conn_t *sconn, MYSQL_RES *result,
uint64_t num_rows); uint64_t num_rows);
void freeColumn(struct column_data_t *col); void freeColumn(struct column_data_t *col);
void freeColumns(struct column_data_t **col_data, size_t n_cols); void freeColumns(struct column_data_t **col_data, size_t n_cols);
int setColumnValue(struct column_data_t *col, uint64_t row, const char *value, size_t value_size); int setColumnValue(struct column_data_t *col, uint64_t row, const char *value, size_t value_size);
#endif // H__DB_COLUMN__ #endif // H__DB_COLUMN__

11
src/db_query.c
View File

@@ -9,6 +9,10 @@
uint64_t simpleQuery(struct stored_conn_t *sconn, const char *qry, size_t qry_len) uint64_t simpleQuery(struct stored_conn_t *sconn, const char *qry, size_t qry_len)
{ {
#ifdef DEBUG
printf("QRY: %s\n", qry);
#endif
if (mysql_real_query(SQCONN(sconn), qry, qry_len) != 0) { if (mysql_real_query(SQCONN(sconn), qry, qry_len) != 0) {
fprintf( fprintf(
stderr, "[%d]mysql_real_query: (%d) %s\n", stderr, "[%d]mysql_real_query: (%d) %s\n",
@@ -138,7 +142,6 @@ uint64_t tableQuery(struct stored_conn_t *sconn, const char *qry, size_t qry_len
} }
int scalarInt(struct stored_conn_t *sconn, const char *qry, size_t qry_len, int default_value) int scalarInt(struct stored_conn_t *sconn, const char *qry, size_t qry_len, int default_value)
{ {
struct column_data_t **col_data; struct column_data_t **col_data;
@@ -243,15 +246,15 @@ char *scalarString(struct stored_conn_t *sconn, const char *qry, size_t qry_len,
if (n_rows > 0) { if (n_rows > 0) {
if (!((*col_data)->isNullable && columnRowIsNull(*col_data, 0))) { if (!((*col_data)->isNullable && columnRowIsNull(*col_data, 0))) {
retval = (char *)malloc((*col_data)->data_sizes[0] + 1); retval = (char *)malloc((*col_data)->data_lens[0] + 1);
if (retval == 0) { if (retval == 0) {
fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno)); fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
freeColumn(*col_data); freeColumn(*col_data);
free(col_data); free(col_data);
return NULL; return NULL;
} }
memcpy(retval, *((*col_data)->data.ptr_str), (*col_data)->data_sizes[0]); memcpy(retval, *((*col_data)->data.ptr_str), (*col_data)->data_lens[0]);
retval[(*col_data)->data_sizes[0]] = '\0'; retval[(*col_data)->data_lens[0]] = '\0';
} }
} }