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

Removed db helpers from modb (3 of 3)

Browse Source
This commit is contained in:
Craig Williams
2020-10-09 10:09:31 +01:00
parent 3b35c27811
commit 24b4cff430
6 changed files with 305 additions and 391 deletions
Download Patch File Download Diff File Expand all files Collapse all files

404
src/modb_accounting.c
View File

@@ -92,6 +92,8 @@ int64_t modbUserCreate(stored_conn *sconn, modb_ref *modb,
unsigned int id, const char *user_name, const char *email) unsigned int id, const char *user_name, const char *email)
{ {
str_builder *sb; str_builder *sb;
char *table;
size_t table_len;
char *qry; char *qry;
size_t qry_len; size_t qry_len;
uint64_t qry_ret; uint64_t qry_ret;
@@ -99,15 +101,19 @@ int64_t modbUserCreate(stored_conn *sconn, modb_ref *modb,
if ((sb = strbld_create()) == 0) { if ((sb = strbld_create()) == 0) {
return -1; return -1;
} }
modbTableName(&table, &table_len, modb, USERS_TABLE, strlen(USERS_TABLE));
strbld_str(sb, "INSERT INTO ", 0); strbld_str(sb, "INSERT INTO ", 0);
modbTableName_sb(sb, modb, USERS_TABLE, strlen(USERS_TABLE), '`'); escapeTableName_sb(sb, table, table_len);
strbld_str(sb, " (`id`, `username`, `email`) VALUES(", 0); strbld_str(sb, " (`id`, `username`, `email`) VALUES (", 0);
db_value_sb(sb, TYPE_UINT32, 1, id); db_value_sb(sb, TYPE_UINT32, 1, id);
strbld_str(sb, ", ", 0); strbld_char(sb, ',');
db_value_sb(sb, TYPE_STRING, 1, user_name); db_value_sb(sb, TYPE_STRING, 1, user_name);
strbld_str(sb, ", ", 0); strbld_char(sb, ',');
db_value_sb(sb, TYPE_STRING, 1, email); db_value_sb(sb, TYPE_STRING, 1, email);
strbld_char(sb, ')'); strbld_char(sb, ')');
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;
} }
@@ -121,104 +127,94 @@ int64_t modbUserUpdate(stored_conn *sconn, modb_ref *modb, unsigned int id,
const char *username, const char *email) const char *username, const char *email)
{ {
str_builder *sb; str_builder *sb;
char *qry; char *table, *set;
size_t qry_len; size_t table_len, set_len;
uint64_t qry_ret; int64_t qry_ret;
if ((sb = strbld_create()) == 0) { if ((sb = strbld_create()) == 0) {
return 0; return 0;
} }
strbld_str(sb, "UPDATE ", 0); columnSetValueStr_sb(sb, "id", TYPE_ID, 1, id);
modbTableName_sb(sb, modb, USERS_TABLE, strlen(USERS_TABLE), '`');
strbld_str(sb, " SET `id` = ", 0);
db_value_sb(sb, TYPE_UINT32, 1, id);
if (username != 0) { if (username != 0) {
strbld_str(sb, ", `username` = ", 0); strbld_char(sb, ',');
db_value_sb(sb, TYPE_STRING, 1, username); columnSetValueStr_sb(sb, "username", TYPE_STRING, 1, username);
} }
if (email != 0) { if (email != 0) {
strbld_str(sb, "`email` = ", 0); strbld_char(sb, ',');
db_value_sb(sb, TYPE_STRING, 1, email); columnSetValueStr_sb(sb, "email", TYPE_STRING, 1, email);
} }
if (strbld_finalize_or_destroy(&sb, &set, &set_len) != 0) {
strbld_str(sb, " WHERE `id` = ", 0);
db_value_sb(sb, TYPE_UINT32, 1, id);
if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) {
return 0; return 0;
} }
qry_ret = simpleQuery(sconn, qry, qry_len); modbTableName(&table, &table_len, modb, USERS_TABLE, strlen(USERS_TABLE));
free(qry); qry_ret = updateQuery(sconn, table, table_len, set, set_len, where(0, "id", EQ, TYPE_ID, 1, id));
modbFreeTableName(&table);
// Query failed free(set);
if (qry_ret == (uint64_t)-1) {
return 0;
}
return 1; return qry_ret;
} }
int modbUserDelete(stored_conn *sconn, modb_ref *modb, unsigned int id) int modbUserDelete(stored_conn *sconn, modb_ref *modb, unsigned int id)
{ {
int qry_ret;
char *table; char *table;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, USERS_TABLE, STR_LEN(USERS_TABLE), 0)) == 0) { modbTableName(&table, &table_len, modb, USERS_TABLE, STR_LEN(USERS_TABLE));
return 0; qry_ret = softDeleteByIdQuery(sconn, table, table_len, "id", id);
} modbFreeTableName(&table);
qry_ret = softDeleteByIdQuery(sconn, table, "id", id); return (int)qry_ret;
free(table);
return qry_ret;
} }
int modbUserDestroy(stored_conn *sconn, modb_ref *modb, unsigned int id) int modbUserDestroy(stored_conn *sconn, modb_ref *modb, unsigned int id)
{ {
int qry_ret;
char *table; char *table;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, USERS_TABLE, STR_LEN(USERS_TABLE), 0)) == 0) { modbTableName(&table, &table_len, modb, USERS_TABLE, STR_LEN(USERS_TABLE));
return 0; qry_ret = deleteByIdQuery(sconn, table, table_len, "id", id);
} modbFreeTableName(&table);
qry_ret = deleteByIdQuery(sconn, table, "id", id); return (int)qry_ret;
free(table);
return qry_ret;
} }
int modbFetchUserGroupIds(stored_conn *sconn, modb_ref *modb, int modbFetchUserGroupIds(stored_conn *sconn, modb_ref *modb,
struct user_t *user, int with_deleted) struct user_t *user, int with_deleted)
{ {
char *g_table, *ug_table;
size_t g_len, ug_len;
char *qry; char *qry;
size_t qry_len; size_t qry_len;
uint64_t qry_ret; uint64_t qry_ret;
str_builder *sb; str_builder *sb;
where_builder *wb; where_builder *wb;
char *table;
column_data **col_data; column_data **col_data;
size_t n_cols; size_t n_cols;
if ((sb = strbld_create()) == 0) { if ((sb = strbld_create()) == 0) {
return -errno; return -1;
} }
strbld_str(sb, "SELECT `group_id` FROM ", 0); modbTableName(&g_table, &g_len, modb, GROUPS_TABLE, STR_LEN(GROUPS_TABLE));
modbTableName_sb(sb, modb, USER_GROUPS_TABLE, strlen(USER_GROUPS_TABLE), '`'); modbTableName(&ug_table, &ug_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
strbld_char(sb, ' ');
modbJoin_sb(sb, modb, "LEFT", 4, 1, strbld_str(sb, "SELECT ", 0);
GROUPS_TABLE, strlen(GROUPS_TABLE), "id", 2, escapeColumnName_sb(sb, 0, 0, "group_id", 0);
USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), "group_id", 8); strbld_str(sb, " FROM ", 0);
strbld_str(sb, " WHERE ", 0); escapeTableName_sb(sb, ug_table, ug_len);
joinStr_sb(sb, " LEFT", 5, 1, g_table, g_len, "id", 2, ug_table, ug_len, "group_id", 8);
wb = where(0, "user_id", EQ, TYPE_ID, 1, user->id); wb = where(0, "user_id", EQ, TYPE_ID, 1, user->id);
if (!with_deleted) { if (!with_deleted) {
table = modbTableName(modb, GROUPS_TABLE, STR_LEN(GROUPS_TABLE), 0); wb = whereAnd(wb, where(g_table, "deleted", IS_NULL, TYPE_RAW, 0));
wb = whereAnd(wb, where(table, "deleted", IS_NULL, TYPE_RAW, 0));
free(table);
} }
compileWhereBuilder_sb(wb, sb, 1); compileWhereBuilder_sb(sb, wb, 1);
modbFreeTableName(&g_table);
modbFreeTableName(&ug_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;
} }
@@ -271,6 +267,78 @@ int modbFetchUserGroups(stored_conn *sconn, modb_ref *modb, struct user_t *user,
} }
int modbSyncUserGroups(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, size_t n_groups, unsigned int *group_ids)
{
char *table;
size_t table_len;
int64_t qry_ret;
modbTableName(&table, &table_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
qry_ret = syncIdMap(sconn, table, table_len, "user_id", "group_id", user_id, n_groups, group_ids);
modbFreeTableName(&table);
return (int)qry_ret;
}
int modbSyncUserGroups_va(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, size_t n_groups, ...)
{
va_list args;
char *table;
size_t table_len;
int64_t qry_ret;
va_start(args, n_groups);
modbTableName(&table, &table_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
qry_ret = syncIdMap_va(sconn, table, table_len, "user_id", "group_id", user_id, n_groups, args);
modbFreeTableName(&table);
va_end(args);
return (int)qry_ret;
}
int modbIsLinked_User_Group(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, unsigned int group_id)
{
char *table;
size_t table_len;
int64_t qry_ret;
modbTableName(&table, &table_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
qry_ret = hasIdMap(sconn, table, table_len, "user_id", "group_id", user_id, group_id);
modbFreeTableName(&table);
return (int)qry_ret;
}
int modbLink_User_Group(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, unsigned int group_id)
{
char *table;
size_t table_len;
int64_t qry_ret;
modbTableName(&table, &table_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
qry_ret = hasIdMap(sconn, table, table_len, "user_id", "group_id", user_id, group_id);
modbFreeTableName(&table);
return (int)qry_ret;
}
int modbUnlink_User_Group(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, unsigned int group_id)
{
char *table;
size_t table_len;
int64_t qry_ret;
modbTableName(&table, &table_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
qry_ret = hasIdMap(sconn, table, table_len, "user_id", "group_id", user_id, group_id);
modbFreeTableName(&table);
return (int)qry_ret;
}
// ##### GROUPS // ##### GROUPS
int modbGroupById(stored_conn *sconn, modb_ref *modb, unsigned int id, int with_members, int modbGroupById(stored_conn *sconn, modb_ref *modb, unsigned int id, int with_members,
struct group_t **group) struct group_t **group)
@@ -278,7 +346,7 @@ int modbGroupById(stored_conn *sconn, modb_ref *modb, unsigned int id, int with_
where_builder *wb = 0; where_builder *wb = 0;
int res; int res;
wb = where(0, "id", EQ, TYPE_UINT32, 1, id); wb = where(0, "id", EQ, TYPE_ID, 1, id);
res = doScalarGroupsQuery(sconn, modb, wb, with_members, group); res = doScalarGroupsQuery(sconn, modb, wb, with_members, group);
freeWhereBuilder(&wb); freeWhereBuilder(&wb);
@@ -332,6 +400,8 @@ int64_t modbGroupCreate(stored_conn *sconn, modb_ref *modb,
unsigned int id, const char *name) unsigned int id, const char *name)
{ {
str_builder *sb; str_builder *sb;
char *table;
size_t table_len;
char *qry; char *qry;
size_t qry_len; size_t qry_len;
uint64_t qry_ret; uint64_t qry_ret;
@@ -339,13 +409,17 @@ int64_t modbGroupCreate(stored_conn *sconn, modb_ref *modb,
if ((sb = strbld_create()) == 0) { if ((sb = strbld_create()) == 0) {
return -1; return -1;
} }
modbTableName(&table, &table_len, modb, GROUPS_TABLE, strlen(GROUPS_TABLE));
strbld_str(sb, "INSERT INTO ", 0); strbld_str(sb, "INSERT INTO ", 0);
modbTableName_sb(sb, modb, GROUPS_TABLE, strlen(GROUPS_TABLE), '`'); escapeTableName_sb(sb, table, table_len);
strbld_str(sb, " (`id`, `name`) VALUES(", 0); strbld_str(sb, " (`id`, `name`) VALUES (", 0);
db_value_sb(sb, TYPE_UINT32, 1, id); db_value_sb(sb, TYPE_ID, 1, id);
strbld_str(sb, ", ", 0); strbld_char(sb, ',');
db_value_sb(sb, TYPE_STRING, 1, name); db_value_sb(sb, TYPE_STRING, 1, name);
strbld_char(sb, ')'); strbld_char(sb, ')');
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;
} }
@@ -359,101 +433,92 @@ int64_t modbGroupUpdate(stored_conn *sconn, modb_ref *modb, unsigned int id,
const char *name) const char *name)
{ {
str_builder *sb; str_builder *sb;
char *qry; char *table, *set;
size_t qry_len; size_t table_len, set_len;
uint64_t qry_ret; int64_t qry_ret;
if ((sb = strbld_create()) == 0) { if ((sb = strbld_create()) == 0) {
return 0; return 0;
} }
strbld_str(sb, "UPDATE ", 0); columnSetValueStr_sb(sb, "id", TYPE_ID, 1, id);
modbTableName_sb(sb, modb, GROUPS_TABLE, strlen(GROUPS_TABLE), '`'); if (name != 0) {
strbld_str(sb, " SET `id` = ", 0); strbld_char(sb, ',');
db_value_sb(sb, TYPE_UINT32, 1, id); columnSetValueStr_sb(sb, "name", TYPE_STRING, 1, name);
if (name == 0) {
strbld_str(sb, ", `name` = ", 0);
db_value_sb(sb, TYPE_STRING, 1, name);
} }
if (strbld_finalize_or_destroy(&sb, &set, &set_len) != 0) {
strbld_str(sb, " WHERE ", 0);
strbld_str(sb, "`id` = ", 0);
db_value_sb(sb, TYPE_UINT32, 1, id);
if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) {
return 0; return 0;
} }
qry_ret = simpleQuery(sconn, qry, qry_len); modbTableName(&table, &table_len, modb, GROUPS_TABLE, strlen(GROUPS_TABLE));
free(qry); qry_ret = updateQuery(sconn, table, table_len, set, set_len, where(0, "id", EQ, TYPE_ID, 1, id));
modbFreeTableName(&table);
// Query failed free(set);
if (qry_ret == (uint64_t)-1) {
return 0;
}
return 1; return qry_ret;
} }
int modbGroupDelete(stored_conn *sconn, modb_ref *modb, unsigned int id) int modbGroupDelete(stored_conn *sconn, modb_ref *modb, unsigned int id)
{ {
int qry_ret;
char *table; char *table;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, GROUPS_TABLE, STR_LEN(GROUPS_TABLE), 0)) == 0) { modbTableName(&table, &table_len, modb, GROUPS_TABLE, STR_LEN(GROUPS_TABLE));
return 0; qry_ret = softDeleteByIdQuery(sconn, table, table_len, "id", id);
} modbFreeTableName(&table);
qry_ret = softDeleteByIdQuery(sconn, table, "id", id); return (int)qry_ret;
free(table);
return qry_ret;
} }
int modbGroupDestroy(stored_conn *sconn, modb_ref *modb, unsigned int id) int modbGroupDestroy(stored_conn *sconn, modb_ref *modb, unsigned int id)
{ {
int qry_ret;
char *table; char *table;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, GROUPS_TABLE, STR_LEN(GROUPS_TABLE), 0)) == 0) { modbTableName(&table, &table_len, modb, GROUPS_TABLE, STR_LEN(GROUPS_TABLE));
return 0; qry_ret = deleteByIdQuery(sconn, table, table_len, "id", id);
} modbFreeTableName(&table);
qry_ret = deleteByIdQuery(sconn, table, "id", id); return (int)qry_ret;
free(table);
return qry_ret;
} }
int modbFetchGroupUserIds(stored_conn *sconn, modb_ref *modb, struct group_t *group, int modbFetchGroupUserIds(stored_conn *sconn, modb_ref *modb, struct group_t *group,
int with_deleted) int with_deleted)
{ {
char *u_table, *ug_table;
size_t u_len, ug_len;
char *qry; char *qry;
size_t qry_len; size_t qry_len;
uint64_t qry_ret; uint64_t qry_ret;
str_builder *sb; str_builder *sb;
where_builder *wb; where_builder *wb;
char *table;
column_data **col_data; column_data **col_data;
size_t n_cols; size_t n_cols;
if ((sb = strbld_create()) == 0) { if ((sb = strbld_create()) == 0) {
return -errno; return -1;
} }
strbld_str(sb, "SELECT `user_id` FROM ", 0); modbTableName(&u_table, &u_len, modb, USERS_TABLE, STR_LEN(USERS_TABLE));
modbTableName_sb(sb, modb, USER_GROUPS_TABLE, strlen(USER_GROUPS_TABLE), '`'); modbTableName(&ug_table, &ug_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
strbld_char(sb, ' ');
modbJoin_sb(sb, modb, "LEFT", 4, 1, strbld_str(sb, "SELECT ", 0);
USERS_TABLE, strlen(USERS_TABLE), "id", 2, escapeColumnName_sb(sb, 0, 0, "user_id", 0);
USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), "user_id", 8); strbld_str(sb, " FROM ", 0);
strbld_str(sb, " WHERE ", 0); escapeTableName_sb(sb, ug_table, ug_len);
joinStr_sb(sb, " LEFT", 5, 1, u_table, u_len, "id", 2, ug_table, ug_len, "user_id", 8);
wb = where(0, "group_id", EQ, TYPE_ID, 1, group->id); wb = where(0, "group_id", EQ, TYPE_ID, 1, group->id);
if (!with_deleted) { if (!with_deleted) {
table = modbTableName(modb, USERS_TABLE, STR_LEN(USERS_TABLE), 0); wb = whereAnd(wb, where(u_table, "deleted", IS_NULL, TYPE_RAW, 0));
wb = whereAnd(wb, where(table, "deleted", IS_NULL, TYPE_RAW, 0));
free(table);
} }
compileWhereBuilder_sb(wb, sb, 1); compileWhereBuilder_sb(sb, wb, 1);
modbFreeTableName(&u_table);
modbFreeTableName(&ug_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;
} }
@@ -510,117 +575,72 @@ int modbFetchGroupUsers(stored_conn *sconn, modb_ref *modb, struct group_t *grou
// ##### USER<->GROUP RELATIONS // ##### USER<->GROUP RELATIONS
int modbSyncGroupsUser(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, size_t n_groups, unsigned int *group_ids)
{
int qry_ret;
char *table;
if ((table = modbTableName(modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), 0)) == 0) {
return 0;
}
qry_ret = syncIdMap(sconn, table, "user_id", "group_id", user_id, n_groups, group_ids);
free(table);
return qry_ret;
}
int modbSyncUserGroups_va(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, size_t n_groups, ...)
{
va_list args;
int qry_ret;
char *table;
if ((table = modbTableName(modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), 0)) == 0) {
return 0;
}
va_start(args, n_groups);
qry_ret = syncIdMap_va(sconn, table, "user_id", "group_id", user_id, n_groups, args);
va_end(args);
free(table);
return qry_ret;
}
int modbSyncGroupUsers(stored_conn *sconn, modb_ref *modb, int modbSyncGroupUsers(stored_conn *sconn, modb_ref *modb,
unsigned int group_id, size_t n_users, unsigned int *user_ids) unsigned int group_id, size_t n_users, unsigned int *user_ids)
{ {
int qry_ret;
char *table; char *table;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), 0)) == 0) { modbTableName(&table, &table_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
return 0; qry_ret = syncIdMap(sconn, table, table_len, "group_id", "user_id", group_id, n_users, user_ids);
} modbFreeTableName(&table);
qry_ret = syncIdMap(sconn, table, "group_id", "user_id", group_id, n_users, user_ids); return (int)qry_ret;
free(table);
return qry_ret;
} }
int modbSyncGroupUsers_va(stored_conn *sconn, modb_ref *modb, int modbSyncGroupUsers_va(stored_conn *sconn, modb_ref *modb,
unsigned int group_id, size_t n_users, ...) unsigned int group_id, size_t n_users, ...)
{ {
va_list args; va_list args;
int qry_ret;
char *table; char *table;
size_t table_len;
if ((table = modbTableName(modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), 0)) == 0) { int64_t qry_ret;
return 0;
}
va_start(args, n_users); va_start(args, n_users);
qry_ret = syncIdMap_va(sconn, table, "group_id", "user_id", group_id, n_users, args); modbTableName(&table, &table_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
qry_ret = syncIdMap_va(sconn, table, table_len, "group_id", "user_id", group_id, n_users, args);
modbFreeTableName(&table);
va_end(args); va_end(args);
free(table); return (int)qry_ret;
return qry_ret;
} }
int modbIsLinked_Group_User(stored_conn *sconn, modb_ref *modb, int modbIsLinked_Group_User(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, unsigned int group_id) unsigned int group_id, unsigned int user_id)
{ {
int qry_ret;
char *table; char *table;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), 0)) == 0) { modbTableName(&table, &table_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
return 0; qry_ret = hasIdMap(sconn, table, table_len, "group_id", "user_id", group_id, user_id);
} modbFreeTableName(&table);
qry_ret = hasIdMap(sconn, table, "group_id", "user_id", group_id, user_id); return (int)qry_ret;
free(table);
return qry_ret;
} }
int modbLink_Group_User(stored_conn *sconn, modb_ref *modb, int modbLink_Group_User(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, unsigned int group_id) unsigned int group_id, unsigned int user_id)
{ {
int qry_ret;
char *table; char *table;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), 0)) == 0) { modbTableName(&table, &table_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
return 0; qry_ret = addIdMap(sconn, table, table_len, "group_id", "user_id", group_id, user_id);
} modbFreeTableName(&table);
qry_ret = addIdMap(sconn, table, "group_id", "user_id", group_id, user_id); return (int)qry_ret;
free(table);
return qry_ret;
} }
int modbUnlink_Group_User(stored_conn *sconn, modb_ref *modb, int modbUnlink_Group_User(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, unsigned int group_id) unsigned int group_id, unsigned int user_id)
{ {
int qry_ret;
char *table; char *table;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), 0)) == 0) { modbTableName(&table, &table_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
return 0; qry_ret = addIdMap(sconn, table, table_len, "group_id", "user_id", group_id, user_id);
} modbFreeTableName(&table);
qry_ret = removeIdMap(sconn, table, "group_id", "user_id", group_id, user_id); return (int)qry_ret;
free(table);
return qry_ret;
} }

28
src/modb_accounting.h
View File

@@ -25,10 +25,24 @@ int64_t modbUserUpdate(stored_conn *sconn, modb_ref *modb, unsigned int id,
int modbUserDelete(stored_conn *sconn, modb_ref *modb, unsigned int id); int modbUserDelete(stored_conn *sconn, modb_ref *modb, unsigned int id);
int modbUserDestroy(stored_conn *sconn, modb_ref *modb, unsigned int id); int modbUserDestroy(stored_conn *sconn, modb_ref *modb, unsigned int id);
// MODB Users -> Groups
int modbFetchUserGroupIds(stored_conn *sconn, modb_ref *modb, int modbFetchUserGroupIds(stored_conn *sconn, modb_ref *modb,
struct user_t *user, int with_deleted); struct user_t *user, int with_deleted);
int modbFetchUserGroups(stored_conn *sconn, modb_ref *modb, struct user_t *user, int with_deleted); int modbFetchUserGroups(stored_conn *sconn, modb_ref *modb, struct user_t *user, int with_deleted);
int modbSyncUserGroups(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, size_t n_groups, unsigned int *group_id);
int modbSyncUserGroups_va(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, size_t n_groups, ...);
int modbIsLinked_User_Group(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, unsigned int group_id);
int modbLink_User_Group(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, unsigned int group_id);
int modbUnlink_User_Group(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, unsigned int group_id);
// MODB Groups // MODB Groups
int modbGroupById(stored_conn *sconn, modb_ref *modb, unsigned int id, int with_members, int modbGroupById(stored_conn *sconn, modb_ref *modb, unsigned int id, int with_members,
@@ -51,24 +65,18 @@ int modbFetchGroupUserIds(stored_conn *sconn, modb_ref *modb, struct group_t *gr
int modbFetchGroupUsers(stored_conn *sconn, modb_ref *modb, struct group_t *group, int modbFetchGroupUsers(stored_conn *sconn, modb_ref *modb, struct group_t *group,
int with_deleted); int with_deleted);
// MODB Groups -> Users
// MODB Users <-> Groups
int modbSyncUserGroups(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, size_t n_groups, unsigned int *group_id);
int modbSyncUserGroups_va(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, size_t n_groups, ...);
int modbSyncGroupUsers(stored_conn *sconn, modb_ref *modb, int modbSyncGroupUsers(stored_conn *sconn, modb_ref *modb,
unsigned int group_id, size_t n_users, unsigned int *user_id); unsigned int group_id, size_t n_users, unsigned int *user_id);
int modbSyncGroupUsers_va(stored_conn *sconn, modb_ref *modb, int modbSyncGroupUsers_va(stored_conn *sconn, modb_ref *modb,
unsigned int group_id, size_t n_users, ...); unsigned int group_id, size_t n_users, ...);
int modbIsLinked_Group_User(stored_conn *sconn, modb_ref *modb, int modbIsLinked_Group_User(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, unsigned int group_id); unsigned int group_id, unsigned int user_id);
int modbLink_Group_User(stored_conn *sconn, modb_ref *modb, int modbLink_Group_User(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, unsigned int group_id); unsigned int group_id, unsigned int user_id);
int modbUnlink_Group_User(stored_conn *sconn, modb_ref *modb, int modbUnlink_Group_User(stored_conn *sconn, modb_ref *modb,
unsigned int user_id, unsigned int group_id); unsigned int group_id, unsigned int user_id);
#endif // H__MODB_ACCOUNTING__ #endif // H__MODB_ACCOUNTING__

52
src/modb_accounting_p.c
View File

@@ -20,17 +20,17 @@ int tableRowsToUsers(column_data **col_data, size_t n_cols,
return 0; return 0;
} }
col_id = findColumn(col_data, n_cols, "id"); col_id = findColumnByName(col_data, n_cols, "id");
col_username = findColumn(col_data, n_cols, "username"); col_username = findColumnByName(col_data, n_cols, "username");
col_email = findColumn(col_data, n_cols, "email"); col_email = findColumnByName(col_data, n_cols, "email");
col_created = findColumn(col_data, n_cols, "created"); col_created = findColumnByName(col_data, n_cols, "created");
col_updated = findColumn(col_data, n_cols, "updated"); col_updated = findColumnByName(col_data, n_cols, "updated");
col_deleted = findColumn(col_data, n_cols, "deleted"); col_deleted = findColumnByName(col_data, n_cols, "deleted");
*users = (struct user_t **)malloc(sizeof(struct user_t *) * n_rows); *users = (struct user_t **)malloc(sizeof(struct user_t *) * n_rows);
if (*users == 0) { if (*users == 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 -1;
} }
memset(*users, 0, sizeof(struct user_t *) * n_rows); memset(*users, 0, sizeof(struct user_t *) * n_rows);
@@ -71,6 +71,8 @@ int tableRowsToUsers(column_data **col_data, size_t n_cols,
int doUsersQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb, int doUsersQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb,
struct user_t ***users, size_t *n_users) struct user_t ***users, size_t *n_users)
{ {
char *table;
size_t table_len;
char *qry; char *qry;
size_t qry_len; size_t qry_len;
uint64_t qry_ret; uint64_t qry_ret;
@@ -83,16 +85,19 @@ int doUsersQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb,
if ((sb = strbld_create()) == 0) { if ((sb = strbld_create()) == 0) {
return -errno; return -1;
} }
modbTableName(&table, &table_len, modb, USERS_TABLE, strlen(USERS_TABLE));
strbld_str(sb, "SELECT * FROM ", 0); strbld_str(sb, "SELECT * FROM ", 0);
modbTableName_sb(sb, modb, USERS_TABLE, strlen(USERS_TABLE), '`'); escapeTableName_sb(sb, table, table_len);
if (wb != 0) { if (wb != 0) {
strbld_str(sb, " WHERE ", 0); compileWhereBuilder_sb(sb, wb, 0);
compileWhereBuilder_sb(wb, sb, 0);
} }
modbFreeTableName(&table);
if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) { if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) {
return -errno; return -1;
} }
qry_ret = tableQuery(sconn, qry, qry_len, 0, &col_data, &n_cols); qry_ret = tableQuery(sconn, qry, qry_len, 0, &col_data, &n_cols);
@@ -158,16 +163,16 @@ int tableRowsToGroups(column_data **col_data, size_t n_cols,
return 0; return 0;
} }
col_id = findColumn(col_data, n_cols, "id"); col_id = findColumnByName(col_data, n_cols, "id");
col_name = findColumn(col_data, n_cols, "name"); col_name = findColumnByName(col_data, n_cols, "name");
col_created = findColumn(col_data, n_cols, "created"); col_created = findColumnByName(col_data, n_cols, "created");
col_updated = findColumn(col_data, n_cols, "updated"); col_updated = findColumnByName(col_data, n_cols, "updated");
col_deleted = findColumn(col_data, n_cols, "deleted"); col_deleted = findColumnByName(col_data, n_cols, "deleted");
*groups = (struct group_t **)malloc(sizeof(struct group_t *) * n_rows); *groups = (struct group_t **)malloc(sizeof(struct group_t *) * n_rows);
if (*groups == 0) { if (*groups == 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 -1;
} }
memset(*groups, 0, sizeof(struct group_t *) * n_rows); memset(*groups, 0, sizeof(struct group_t *) * n_rows);
@@ -202,6 +207,8 @@ int tableRowsToGroups(column_data **col_data, size_t n_cols,
int doGroupsQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb, int doGroupsQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb,
struct group_t ***groups, size_t *n_groups) struct group_t ***groups, size_t *n_groups)
{ {
char *table;
size_t table_len;
char *qry; char *qry;
size_t qry_len; size_t qry_len;
uint64_t qry_ret; uint64_t qry_ret;
@@ -216,12 +223,15 @@ int doGroupsQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb,
if ((sb = strbld_create()) == 0) { if ((sb = strbld_create()) == 0) {
return -1; return -1;
} }
modbTableName(&table, &table_len, modb, GROUPS_TABLE, strlen(GROUPS_TABLE));
strbld_str(sb, "SELECT * FROM ", 0); strbld_str(sb, "SELECT * FROM ", 0);
modbTableName_sb(sb, modb, GROUPS_TABLE, strlen(GROUPS_TABLE), '`'); escapeTableName_sb(sb, table, table_len);
if (wb != 0) { if (wb != 0) {
strbld_str(sb, " WHERE ", 0); compileWhereBuilder_sb(sb, wb, 0);
compileWhereBuilder_sb(wb, sb, 0);
} }
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;
} }

33
src/modb_database_p.c
View File

@@ -151,6 +151,8 @@ void connectionUnuseMODB(stored_conn *sconn)
uint64_t createMODBTable(stored_conn *sconn, modb_ref *modb, const char *suffix, size_t suffix_len, uint64_t createMODBTable(stored_conn *sconn, modb_ref *modb, const char *suffix, size_t suffix_len,
const char *table_def, size_t table_def_len) const char *table_def, size_t table_def_len)
{ {
char *table;
size_t table_len;
char *qry; char *qry;
uint64_t res; uint64_t res;
size_t qry_len; size_t qry_len;
@@ -159,10 +161,14 @@ uint64_t createMODBTable(stored_conn *sconn, modb_ref *modb, const char *suffix,
if ((sb = strbld_create()) == 0) { if ((sb = strbld_create()) == 0) {
return (uint64_t)-1; return (uint64_t)-1;
} }
modbTableName(&table, &table_len, modb, suffix, suffix_len);
strbld_str(sb, "CREATE TABLE ", 0); strbld_str(sb, "CREATE TABLE ", 0);
modbTableName_sb(sb, modb, suffix, suffix_len, '`'); escapeTableName_sb(sb, table, table_len);
strbld_char(sb, ' '); strbld_char(sb, ' ');
strbld_str(sb, table_def, table_def_len); strbld_str(sb, table_def, table_def_len);
modbFreeTableName(&table);
if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) { if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) {
return (uint64_t)-1; return (uint64_t)-1;
} }
@@ -181,12 +187,15 @@ int MODBTableExists(stored_conn *sconn, modb_ref *modb, const char *suffix, size
int retval = 0; int retval = 0;
if ((sb = strbld_create()) == 0) { if ((sb = strbld_create()) == 0) {
return -errno; return -1;
} }
strbld_str(sb, "SHOW TABLES LIKE ", 0);
modbTableName_sb(sb, modb, suffix, suffix_len, '\''); strbld_str(sb, "SHOW TABLES LIKE '", 0);
modbTableName_sb(sb, modb, suffix, suffix_len);
strbld_char(sb, '\'');
if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) { if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) {
return -errno; return -1;
} }
res = scalarString(sconn, qry, qry_len, "Z"); res = scalarString(sconn, qry, qry_len, "Z");
@@ -216,6 +225,8 @@ int MODBTableExists(stored_conn *sconn, modb_ref *modb, const char *suffix, size
uint64_t destroyMODBTable(stored_conn *sconn, modb_ref *modb, const char *suffix, size_t suffix_len) uint64_t destroyMODBTable(stored_conn *sconn, modb_ref *modb, const char *suffix, size_t suffix_len)
{ {
char *table;
size_t table_len;
char *qry; char *qry;
uint64_t res; uint64_t res;
size_t qry_len; size_t qry_len;
@@ -224,8 +235,12 @@ uint64_t destroyMODBTable(stored_conn *sconn, modb_ref *modb, const char *suffix
if ((sb = strbld_create()) == 0) { if ((sb = strbld_create()) == 0) {
return (uint64_t)-1; return (uint64_t)-1;
} }
modbTableName(&table, &table_len, modb, suffix, suffix_len);
strbld_str(sb, "DROP TABLE IF EXISTS ", 0); strbld_str(sb, "DROP TABLE IF EXISTS ", 0);
modbTableName_sb(sb, modb, suffix, suffix_len, '`'); escapeTableName_sb(sb, table, table_len);
modbFreeTableName(&table);
if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) { if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) {
return (uint64_t)-1; return (uint64_t)-1;
} }
@@ -257,6 +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, "
"`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, "
@@ -273,7 +289,7 @@ uint64_t createObjectsTable(stored_conn *sconn, modb_ref *modb)
OBJECTS_TABLE, STR_LEN(OBJECTS_TABLE), OBJECTS_TABLE, STR_LEN(OBJECTS_TABLE),
"(" "("
"`mdo_id` INT UNSIGNED NOT NULL, " "`mdo_id` INT UNSIGNED NOT NULL, "
"`object` MEDIUMBLOB NOT NULL, " "`object` MEDIUMBLOB NULL, "
"PRIMARY KEY (`mdo_id`)" "PRIMARY KEY (`mdo_id`)"
")", 0 ")", 0
); );
@@ -355,7 +371,8 @@ uint64_t createMetaExtTable(stored_conn *sconn, modb_ref *modb,
strbld_str(sb, "(" strbld_str(sb, "("
"`mdo_id` INT UNSIGNED NOT NULL", 0); "`mdo_id` INT UNSIGNED NOT NULL", 0);
for (size_t c = 0; c < cols; c++) { for (size_t c = 0; c < cols; c++) {
createColumn_sb(sb, *(col_data + c)); strbld_str(sb, ", ", 2);
columnCreateStr_sb(sb, *(col_data + c));
} }
strbld_str(sb, ", INDEX (`mdo_id`)" strbld_str(sb, ", INDEX (`mdo_id`)"
")", 0); ")", 0);

148
src/modb_p.c
View File

@@ -5,155 +5,38 @@
#include "modb_p.h" #include "modb_p.h"
#include "strext.h" #include "strext.h"
char *modbTableName(modb_ref *modb, const char *suffix, size_t suffix_len, char encap) char *modbTableName(char **name, size_t *len, modb_ref *modb, const char *suffix, size_t suffix_len)
{ {
str_builder *sb; str_builder *sb;
char *str;
size_t len;
if ((sb = strbld_create()) == 0) { if ((sb = strbld_create()) == 0) {
return 0; return 0;
} }
modbTableName_sb(sb, modb, suffix, suffix_len);
modbTableName_sb(sb, modb, suffix, suffix_len, encap); if (strbld_finalize_or_destroy(&sb, name, len) != 0) {
if (strbld_finalize_or_destroy(&sb, &str, &len) != 0) {
return 0; return 0;
} }
return str; return *name;
} }
void modbTableName_sb(str_builder *sb, modb_ref *modb, const char *suffix, size_t suffix_len)
void modbTableName_sb(str_builder *sb, modb_ref *modb, const char *suffix, size_t suffix_len,
char encap)
{ {
if (encap != 0) {
strbld_char(sb, encap);
}
strbld_str(sb, modb->name, modb->name_len); strbld_str(sb, modb->name, modb->name_len);
strbld_str(sb, suffix, suffix_len); strbld_str(sb, suffix, suffix_len);
if (encap != 0) {
strbld_char(sb, encap);
}
} }
void modbFreeTableName(char **name)
char *modbJoin(modb_ref *modb,
const char *join, size_t join_len, int equals,
const char *tableA, size_t tableA_len, const char *colA, size_t colA_len,
const char *tableB, size_t tableB_len, const char *colB, size_t colB_len)
{ {
str_builder *sb; if (*name != 0) {
char *str; free(*name);
size_t len; *name = 0;
if ((sb = strbld_create()) == 0) {
return 0;
} }
modbJoin_sb(sb, modb,
join, join_len, equals,
tableA, tableA_len, colA, colA_len,
tableB, tableB_len, colB, colB_len);
if (strbld_finalize_or_destroy(&sb, &str, &len) != 0) {
return 0;
}
return str;
}
void modbJoin_sb(str_builder *sb, modb_ref *modb,
const char *join, size_t join_len, int equals,
const char *tableA, size_t tableA_len, const char *colA, size_t colA_len,
const char *tableB, size_t tableB_len, const char *colB, size_t colB_len)
{
strbld_str(sb, join, join_len);
strbld_str(sb, " JOIN ", 6);
modbTableName_sb(sb, modb, tableA, tableA_len, '`');
strbld_str(sb, " ON ", 4);
modbColumnName_sb(sb, modb, tableA, tableA_len, colA, colA_len);
strbld_str(sb, (equals ? " = " : " != "), (equals ? 3 : 4));
modbColumnName_sb(sb, modb, tableB, tableB_len, colB, colB_len);
}
char *modbColumnName(modb_ref *modb,
const char *table, size_t table_len,
const char *column, size_t column_len)
{
str_builder *sb;
char *str;
size_t len;
if ((sb = strbld_create()) == 0) {
return 0;
}
modbColumnName_sb(sb, modb, table, table_len, column, column_len);
if (strbld_finalize_or_destroy(&sb, &str, &len) != 0) {
return 0;
}
return str;
}
void modbColumnName_sb(str_builder *sb, modb_ref *modb,
const char *table, size_t table_len,
const char *column, size_t column_len)
{
if (table != 0) {
modbTableName_sb(sb, modb, table, table_len, '`');
strbld_char(sb, '.');
}
strbld_char(sb, '`');
strbld_str(sb, column, column_len);
strbld_char(sb, '`');
}
char *modbColumnNameAs(modb_ref *modb,
const char *table, size_t table_len,
const char *column, size_t column_len,
const char *as_column, size_t as_column_len)
{
str_builder *sb;
char *str;
size_t len;
if ((sb = strbld_create()) == 0) {
return 0;
}
modbColumnNameAs_sb(sb, modb, table, table_len, column, column_len, as_column, as_column_len);
if (strbld_finalize_or_destroy(&sb, &str, &len) != 0) {
return 0;
}
return str;
}
void modbColumnNameAs_sb(str_builder *sb, modb_ref *modb,
const char *table, size_t table_len,
const char *column, size_t column_len,
const char *as_column, size_t as_column_len)
{
if (table != 0) {
modbTableName_sb(sb, modb, table, table_len, '`');
strbld_char(sb, '.');
}
strbld_char(sb, '`');
strbld_str(sb, column, column_len);
strbld_char(sb, '`');
strbld_str(sb, " AS ", 4);
strbld_char(sb, '`');
strbld_str(sb, as_column, as_column_len);
strbld_char(sb, '`');
} }
int moveColumnStrPointer(column_data *col, size_t row, int move, char **target, size_t *target_len) int moveColumnStrPointer(column_data *col, size_t row, int move, char **target, size_t *target_len)
{ {
if (columnRowIsNull(col, row)) { if (columnRowIsNull(col, row)) {
return 0; return -1;
} }
if (move) { if (move) {
@@ -163,17 +46,17 @@ int moveColumnStrPointer(column_data *col, size_t row, int move, char **target,
*(col->data_lens + row) = 0; *(col->data_lens + row) = 0;
} else { } else {
if (strmemcpy(*(col->data.ptr_str + row), *(col->data_lens + row), target, target_len) != 0) { if (strmemcpy(*(col->data.ptr_str + row), *(col->data_lens + row), target, target_len) != 0) {
return -1; return 0;
} }
} }
return 0; return 1;
} }
int moveColumnBlobPointer(column_data *col, size_t row, int move, int moveColumnBlobPointer(column_data *col, size_t row, int move,
char **target, size_t *target_len) char **target, size_t *target_len)
{ {
if (columnRowIsNull(col, row)) { if (columnRowIsNull(col, row)) {
return 0; return -1;
} }
if (move) { if (move) {
@@ -185,12 +68,13 @@ int moveColumnBlobPointer(column_data *col, size_t row, int move,
*target = (char *)malloc(*(col->data_lens + row)); *target = (char *)malloc(*(col->data_lens + row));
if (*target == 0) { if (*target == 0) {
fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno)); fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
return -1; return 0;
} }
memcpy(*target, *(col->data.ptr_blob + row), *(col->data_lens + row)); memcpy(*target, *(col->data.ptr_blob + row), *(col->data_lens + row));
*target_len = *(col->data_lens + row); *target_len = *(col->data_lens + row);
} }
return 0; return 1;
} }

31
src/modb_p.h
View File

@@ -20,34 +20,9 @@
#define META_EXT_TABLE "_meta_ext" #define META_EXT_TABLE "_meta_ext"
char *modbTableName(modb_ref *modb, const char *suffix, size_t suffix_len, char encap); char *modbTableName(char **name, size_t *len, modb_ref *modb, const char *suffix, size_t suffix_len);
void modbTableName_sb(str_builder *sb, modb_ref *modb, const char *suffix, size_t suffix_len, void modbFreeTableName(char **name);
char encap); void modbTableName_sb(str_builder *sb, modb_ref *modb, const char *suffix, size_t suffix_len);
char *modbJoin(modb_ref *modb,
const char *join, size_t join_len, int equals,
const char *tableA, size_t tableA_len, const char *colA, size_t colA_len,
const char *tableB, size_t tableB_len, const char *colB, size_t colB_len);
void modbJoin_sb(str_builder *sb, modb_ref *modb,
const char *join, size_t join_len, int equals,
const char *tableA, size_t tableA_len, const char *colA, size_t colA_len,
const char *tableB, size_t tableB_len, const char *colB, size_t colB_len);
char *modbColumnName(modb_ref *modb,
const char *table, size_t table_len,
const char *column, size_t column_len);
void modbColumnName_sb(str_builder *sb, modb_ref *modb,
const char *table, size_t table_len,
const char *column, size_t column_len);
char *modbColumnNameAs(modb_ref *modb,
const char *table, size_t table_len,
const char *column, size_t column_len,
const char *as_column, size_t as_column_len);
void modbColumnNameAs_sb(str_builder *sb, modb_ref *modb,
const char *table, size_t table_len,
const char *column, size_t column_len,
const char *as_column, size_t as_column_len);
int moveColumnStrPointer(column_data *col, size_t row, int move, char **target, size_t *target_len); int moveColumnStrPointer(column_data *col, size_t row, int move, char **target, size_t *target_len);
int moveColumnBlobPointer(column_data *col, size_t row, int move, int moveColumnBlobPointer(column_data *col, size_t row, int move,