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)
{
str_builder *sb;
char *table;
size_t table_len;
char *qry;
size_t qry_len;
uint64_t qry_ret;
@@ -99,15 +101,19 @@ int64_t modbUserCreate(stored_conn *sconn, modb_ref *modb,
if ((sb = strbld_create()) == 0) {
return -1;
}
modbTableName(&table, &table_len, modb, USERS_TABLE, strlen(USERS_TABLE));
strbld_str(sb, "INSERT INTO ", 0);
modbTableName_sb(sb, modb, USERS_TABLE, strlen(USERS_TABLE), '`');
strbld_str(sb, " (`id`, `username`, `email`) VALUES(", 0);
escapeTableName_sb(sb, table, table_len);
strbld_str(sb, " (`id`, `username`, `email`) VALUES (", 0);
db_value_sb(sb, TYPE_UINT32, 1, id);
strbld_str(sb, ", ", 0);
strbld_char(sb, ',');
db_value_sb(sb, TYPE_STRING, 1, user_name);
strbld_str(sb, ", ", 0);
strbld_char(sb, ',');
db_value_sb(sb, TYPE_STRING, 1, email);
strbld_char(sb, ')');
modbFreeTableName(&table);
if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) {
return -1;
}
@@ -121,104 +127,94 @@ int64_t modbUserUpdate(stored_conn *sconn, modb_ref *modb, unsigned int id,
const char *username, const char *email)
{
str_builder *sb;
char *qry;
size_t qry_len;
uint64_t qry_ret;
char *table, *set;
size_t table_len, set_len;
int64_t qry_ret;
if ((sb = strbld_create()) == 0) {
return 0;
}
strbld_str(sb, "UPDATE ", 0);
modbTableName_sb(sb, modb, USERS_TABLE, strlen(USERS_TABLE), '`');
strbld_str(sb, " SET `id` = ", 0);
db_value_sb(sb, TYPE_UINT32, 1, id);
columnSetValueStr_sb(sb, "id", TYPE_ID, 1, id);
if (username != 0) {
strbld_str(sb, ", `username` = ", 0);
db_value_sb(sb, TYPE_STRING, 1, username);
strbld_char(sb, ',');
columnSetValueStr_sb(sb, "username", TYPE_STRING, 1, username);
}
if (email != 0) {
strbld_str(sb, "`email` = ", 0);
db_value_sb(sb, TYPE_STRING, 1, email);
strbld_char(sb, ',');
columnSetValueStr_sb(sb, "email", TYPE_STRING, 1, email);
}
strbld_str(sb, " WHERE `id` = ", 0);
db_value_sb(sb, TYPE_UINT32, 1, id);
if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) {
if (strbld_finalize_or_destroy(&sb, &set, &set_len) != 0) {
return 0;
}
qry_ret = simpleQuery(sconn, qry, qry_len);
free(qry);
modbTableName(&table, &table_len, modb, USERS_TABLE, strlen(USERS_TABLE));
qry_ret = updateQuery(sconn, table, table_len, set, set_len, where(0, "id", EQ, TYPE_ID, 1, id));
modbFreeTableName(&table);
// Query failed
if (qry_ret == (uint64_t)-1) {
return 0;
}
free(set);
return 1;
return qry_ret;
}
int modbUserDelete(stored_conn *sconn, modb_ref *modb, unsigned int id)
{
int qry_ret;
char *table;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, USERS_TABLE, STR_LEN(USERS_TABLE), 0)) == 0) {
return 0;
}
modbTableName(&table, &table_len, modb, USERS_TABLE, STR_LEN(USERS_TABLE));
qry_ret = softDeleteByIdQuery(sconn, table, table_len, "id", id);
modbFreeTableName(&table);
qry_ret = softDeleteByIdQuery(sconn, table, "id", id);
free(table);
return qry_ret;
return (int)qry_ret;
}
int modbUserDestroy(stored_conn *sconn, modb_ref *modb, unsigned int id)
{
int qry_ret;
char *table;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, USERS_TABLE, STR_LEN(USERS_TABLE), 0)) == 0) {
return 0;
}
modbTableName(&table, &table_len, modb, USERS_TABLE, STR_LEN(USERS_TABLE));
qry_ret = deleteByIdQuery(sconn, table, table_len, "id", id);
modbFreeTableName(&table);
qry_ret = deleteByIdQuery(sconn, table, "id", id);
free(table);
return qry_ret;
return (int)qry_ret;
}
int modbFetchUserGroupIds(stored_conn *sconn, modb_ref *modb,
struct user_t *user, int with_deleted)
{
char *g_table, *ug_table;
size_t g_len, ug_len;
char *qry;
size_t qry_len;
uint64_t qry_ret;
str_builder *sb;
where_builder *wb;
char *table;
column_data **col_data;
size_t n_cols;
if ((sb = strbld_create()) == 0) {
return -errno;
return -1;
}
strbld_str(sb, "SELECT `group_id` FROM ", 0);
modbTableName_sb(sb, modb, USER_GROUPS_TABLE, strlen(USER_GROUPS_TABLE), '`');
strbld_char(sb, ' ');
modbJoin_sb(sb, modb, "LEFT", 4, 1,
GROUPS_TABLE, strlen(GROUPS_TABLE), "id", 2,
USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), "group_id", 8);
strbld_str(sb, " WHERE ", 0);
modbTableName(&g_table, &g_len, modb, GROUPS_TABLE, STR_LEN(GROUPS_TABLE));
modbTableName(&ug_table, &ug_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
strbld_str(sb, "SELECT ", 0);
escapeColumnName_sb(sb, 0, 0, "group_id", 0);
strbld_str(sb, " FROM ", 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);
if (!with_deleted) {
table = modbTableName(modb, GROUPS_TABLE, STR_LEN(GROUPS_TABLE), 0);
wb = whereAnd(wb, where(table, "deleted", IS_NULL, TYPE_RAW, 0));
free(table);
wb = whereAnd(wb, where(g_table, "deleted", IS_NULL, TYPE_RAW, 0));
}
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) {
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
int modbGroupById(stored_conn *sconn, modb_ref *modb, unsigned int id, int with_members,
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;
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);
freeWhereBuilder(&wb);
@@ -332,6 +400,8 @@ int64_t modbGroupCreate(stored_conn *sconn, modb_ref *modb,
unsigned int id, const char *name)
{
str_builder *sb;
char *table;
size_t table_len;
char *qry;
size_t qry_len;
uint64_t qry_ret;
@@ -339,13 +409,17 @@ int64_t modbGroupCreate(stored_conn *sconn, modb_ref *modb,
if ((sb = strbld_create()) == 0) {
return -1;
}
modbTableName(&table, &table_len, modb, GROUPS_TABLE, strlen(GROUPS_TABLE));
strbld_str(sb, "INSERT INTO ", 0);
modbTableName_sb(sb, modb, GROUPS_TABLE, strlen(GROUPS_TABLE), '`');
strbld_str(sb, " (`id`, `name`) VALUES(", 0);
db_value_sb(sb, TYPE_UINT32, 1, id);
strbld_str(sb, ", ", 0);
escapeTableName_sb(sb, table, table_len);
strbld_str(sb, " (`id`, `name`) VALUES (", 0);
db_value_sb(sb, TYPE_ID, 1, id);
strbld_char(sb, ',');
db_value_sb(sb, TYPE_STRING, 1, name);
strbld_char(sb, ')');
modbFreeTableName(&table);
if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) {
return -1;
}
@@ -359,101 +433,92 @@ int64_t modbGroupUpdate(stored_conn *sconn, modb_ref *modb, unsigned int id,
const char *name)
{
str_builder *sb;
char *qry;
size_t qry_len;
uint64_t qry_ret;
char *table, *set;
size_t table_len, set_len;
int64_t qry_ret;
if ((sb = strbld_create()) == 0) {
return 0;
}
strbld_str(sb, "UPDATE ", 0);
modbTableName_sb(sb, modb, GROUPS_TABLE, strlen(GROUPS_TABLE), '`');
strbld_str(sb, " SET `id` = ", 0);
db_value_sb(sb, TYPE_UINT32, 1, id);
if (name == 0) {
strbld_str(sb, ", `name` = ", 0);
db_value_sb(sb, TYPE_STRING, 1, name);
columnSetValueStr_sb(sb, "id", TYPE_ID, 1, id);
if (name != 0) {
strbld_char(sb, ',');
columnSetValueStr_sb(sb, "name", TYPE_STRING, 1, name);
}
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) {
if (strbld_finalize_or_destroy(&sb, &set, &set_len) != 0) {
return 0;
}
qry_ret = simpleQuery(sconn, qry, qry_len);
free(qry);
modbTableName(&table, &table_len, modb, GROUPS_TABLE, strlen(GROUPS_TABLE));
qry_ret = updateQuery(sconn, table, table_len, set, set_len, where(0, "id", EQ, TYPE_ID, 1, id));
modbFreeTableName(&table);
// Query failed
if (qry_ret == (uint64_t)-1) {
return 0;
}
free(set);
return 1;
return qry_ret;
}
int modbGroupDelete(stored_conn *sconn, modb_ref *modb, unsigned int id)
{
int qry_ret;
char *table;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, GROUPS_TABLE, STR_LEN(GROUPS_TABLE), 0)) == 0) {
return 0;
}
modbTableName(&table, &table_len, modb, GROUPS_TABLE, STR_LEN(GROUPS_TABLE));
qry_ret = softDeleteByIdQuery(sconn, table, table_len, "id", id);
modbFreeTableName(&table);
qry_ret = softDeleteByIdQuery(sconn, table, "id", id);
free(table);
return qry_ret;
return (int)qry_ret;
}
int modbGroupDestroy(stored_conn *sconn, modb_ref *modb, unsigned int id)
{
int qry_ret;
char *table;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, GROUPS_TABLE, STR_LEN(GROUPS_TABLE), 0)) == 0) {
return 0;
}
modbTableName(&table, &table_len, modb, GROUPS_TABLE, STR_LEN(GROUPS_TABLE));
qry_ret = deleteByIdQuery(sconn, table, table_len, "id", id);
modbFreeTableName(&table);
qry_ret = deleteByIdQuery(sconn, table, "id", id);
free(table);
return qry_ret;
return (int)qry_ret;
}
int modbFetchGroupUserIds(stored_conn *sconn, modb_ref *modb, struct group_t *group,
int with_deleted)
{
char *u_table, *ug_table;
size_t u_len, ug_len;
char *qry;
size_t qry_len;
uint64_t qry_ret;
str_builder *sb;
where_builder *wb;
char *table;
column_data **col_data;
size_t n_cols;
if ((sb = strbld_create()) == 0) {
return -errno;
return -1;
}
strbld_str(sb, "SELECT `user_id` FROM ", 0);
modbTableName_sb(sb, modb, USER_GROUPS_TABLE, strlen(USER_GROUPS_TABLE), '`');
strbld_char(sb, ' ');
modbJoin_sb(sb, modb, "LEFT", 4, 1,
USERS_TABLE, strlen(USERS_TABLE), "id", 2,
USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), "user_id", 8);
strbld_str(sb, " WHERE ", 0);
modbTableName(&u_table, &u_len, modb, USERS_TABLE, STR_LEN(USERS_TABLE));
modbTableName(&ug_table, &ug_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
strbld_str(sb, "SELECT ", 0);
escapeColumnName_sb(sb, 0, 0, "user_id", 0);
strbld_str(sb, " FROM ", 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);
if (!with_deleted) {
table = modbTableName(modb, USERS_TABLE, STR_LEN(USERS_TABLE), 0);
wb = whereAnd(wb, where(table, "deleted", IS_NULL, TYPE_RAW, 0));
free(table);
wb = whereAnd(wb, where(u_table, "deleted", IS_NULL, TYPE_RAW, 0));
}
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) {
return -1;
}
@@ -510,117 +575,72 @@ int modbFetchGroupUsers(stored_conn *sconn, modb_ref *modb, struct group_t *grou
// ##### 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,
unsigned int group_id, size_t n_users, unsigned int *user_ids)
{
int qry_ret;
char *table;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), 0)) == 0) {
return 0;
}
modbTableName(&table, &table_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
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);
free(table);
return qry_ret;
return (int)qry_ret;
}
int modbSyncGroupUsers_va(stored_conn *sconn, modb_ref *modb,
unsigned int group_id, size_t n_users, ...)
{
va_list args;
int qry_ret;
char *table;
if ((table = modbTableName(modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), 0)) == 0) {
return 0;
}
size_t table_len;
int64_t qry_ret;
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);
free(table);
return qry_ret;
return (int)qry_ret;
}
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;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), 0)) == 0) {
return 0;
}
modbTableName(&table, &table_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
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);
free(table);
return qry_ret;
return (int)qry_ret;
}
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;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), 0)) == 0) {
return 0;
}
modbTableName(&table, &table_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
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);
free(table);
return qry_ret;
return (int)qry_ret;
}
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;
size_t table_len;
int64_t qry_ret;
if ((table = modbTableName(modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE), 0)) == 0) {
return 0;
}
modbTableName(&table, &table_len, modb, USER_GROUPS_TABLE, STR_LEN(USER_GROUPS_TABLE));
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);
free(table);
return qry_ret;
return (int)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 modbUserDestroy(stored_conn *sconn, modb_ref *modb, unsigned int id);
// MODB Users -> Groups
int modbFetchUserGroupIds(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
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 with_deleted);
// 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, ...);
// MODB Groups -> Users
int modbSyncGroupUsers(stored_conn *sconn, modb_ref *modb,
unsigned int group_id, size_t n_users, unsigned int *user_id);
int modbSyncGroupUsers_va(stored_conn *sconn, modb_ref *modb,
unsigned int group_id, size_t n_users, ...);
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,
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,
unsigned int user_id, unsigned int group_id);
unsigned int group_id, unsigned int user_id);
#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;
}
col_id = findColumn(col_data, n_cols, "id");
col_username = findColumn(col_data, n_cols, "username");
col_email = findColumn(col_data, n_cols, "email");
col_created = findColumn(col_data, n_cols, "created");
col_updated = findColumn(col_data, n_cols, "updated");
col_deleted = findColumn(col_data, n_cols, "deleted");
col_id = findColumnByName(col_data, n_cols, "id");
col_username = findColumnByName(col_data, n_cols, "username");
col_email = findColumnByName(col_data, n_cols, "email");
col_created = findColumnByName(col_data, n_cols, "created");
col_updated = findColumnByName(col_data, n_cols, "updated");
col_deleted = findColumnByName(col_data, n_cols, "deleted");
*users = (struct user_t **)malloc(sizeof(struct user_t *) * n_rows);
if (*users == 0) {
fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
return -errno;
return -1;
}
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,
struct user_t ***users, size_t *n_users)
{
char *table;
size_t table_len;
char *qry;
size_t qry_len;
uint64_t qry_ret;
@@ -83,16 +85,19 @@ int doUsersQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb,
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);
modbTableName_sb(sb, modb, USERS_TABLE, strlen(USERS_TABLE), '`');
escapeTableName_sb(sb, table, table_len);
if (wb != 0) {
strbld_str(sb, " WHERE ", 0);
compileWhereBuilder_sb(wb, sb, 0);
compileWhereBuilder_sb(sb, wb, 0);
}
modbFreeTableName(&table);
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);
@@ -158,16 +163,16 @@ int tableRowsToGroups(column_data **col_data, size_t n_cols,
return 0;
}
col_id = findColumn(col_data, n_cols, "id");
col_name = findColumn(col_data, n_cols, "name");
col_created = findColumn(col_data, n_cols, "created");
col_updated = findColumn(col_data, n_cols, "updated");
col_deleted = findColumn(col_data, n_cols, "deleted");
col_id = findColumnByName(col_data, n_cols, "id");
col_name = findColumnByName(col_data, n_cols, "name");
col_created = findColumnByName(col_data, n_cols, "created");
col_updated = findColumnByName(col_data, n_cols, "updated");
col_deleted = findColumnByName(col_data, n_cols, "deleted");
*groups = (struct group_t **)malloc(sizeof(struct group_t *) * n_rows);
if (*groups == 0) {
fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
return -errno;
return -1;
}
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,
struct group_t ***groups, size_t *n_groups)
{
char *table;
size_t table_len;
char *qry;
size_t qry_len;
uint64_t qry_ret;
@@ -216,12 +223,15 @@ int doGroupsQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb,
if ((sb = strbld_create()) == 0) {
return -1;
}
modbTableName(&table, &table_len, modb, GROUPS_TABLE, strlen(GROUPS_TABLE));
strbld_str(sb, "SELECT * FROM ", 0);
modbTableName_sb(sb, modb, GROUPS_TABLE, strlen(GROUPS_TABLE), '`');
escapeTableName_sb(sb, table, table_len);
if (wb != 0) {
strbld_str(sb, " WHERE ", 0);
compileWhereBuilder_sb(wb, sb, 0);
compileWhereBuilder_sb(sb, wb, 0);
}
modbFreeTableName(&table);
if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) {
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,
const char *table_def, size_t table_def_len)
{
char *table;
size_t table_len;
char *qry;
uint64_t res;
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) {
return (uint64_t)-1;
}
modbTableName(&table, &table_len, modb, suffix, suffix_len);
strbld_str(sb, "CREATE TABLE ", 0);
modbTableName_sb(sb, modb, suffix, suffix_len, '`');
escapeTableName_sb(sb, table, table_len);
strbld_char(sb, ' ');
strbld_str(sb, table_def, table_def_len);
modbFreeTableName(&table);
if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) {
return (uint64_t)-1;
}
@@ -181,12 +187,15 @@ int MODBTableExists(stored_conn *sconn, modb_ref *modb, const char *suffix, size
int retval = 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) {
return -errno;
return -1;
}
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)
{
char *table;
size_t table_len;
char *qry;
uint64_t res;
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) {
return (uint64_t)-1;
}
modbTableName(&table, &table_len, modb, suffix, suffix_len);
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) {
return (uint64_t)-1;
}
@@ -257,6 +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, "
"`title` VARCHAR(255) NOT NULL, "
"`owner_id` INT UNSIGNED NOT NULL, "
"`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),
"("
"`mdo_id` INT UNSIGNED NOT NULL, "
"`object` MEDIUMBLOB NOT NULL, "
"`object` MEDIUMBLOB NULL, "
"PRIMARY KEY (`mdo_id`)"
")", 0
);
@@ -355,7 +371,8 @@ uint64_t createMetaExtTable(stored_conn *sconn, modb_ref *modb,
strbld_str(sb, "("
"`mdo_id` INT UNSIGNED NOT NULL", 0);
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`)"
")", 0);

148
src/modb_p.c
View File

@@ -5,155 +5,38 @@
#include "modb_p.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;
char *str;
size_t len;
if ((sb = strbld_create()) == 0) {
return 0;
}
modbTableName_sb(sb, modb, suffix, suffix_len, encap);
if (strbld_finalize_or_destroy(&sb, &str, &len) != 0) {
modbTableName_sb(sb, modb, suffix, suffix_len);
if (strbld_finalize_or_destroy(&sb, name, len) != 0) {
return 0;
}
return str;
return *name;
}
void modbTableName_sb(str_builder *sb, modb_ref *modb, const char *suffix, size_t suffix_len,
char encap)
void modbTableName_sb(str_builder *sb, modb_ref *modb, const char *suffix, size_t suffix_len)
{
if (encap != 0) {
strbld_char(sb, encap);
}
strbld_str(sb, modb->name, modb->name_len);
strbld_str(sb, suffix, suffix_len);
if (encap != 0) {
strbld_char(sb, encap);
}
}
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 modbFreeTableName(char **name)
{
str_builder *sb;
char *str;
size_t len;
if ((sb = strbld_create()) == 0) {
return 0;
if (*name != 0) {
free(*name);
*name = 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)
{
if (columnRowIsNull(col, row)) {
return 0;
return -1;
}
if (move) {
@@ -163,17 +46,17 @@ int moveColumnStrPointer(column_data *col, size_t row, int move, char **target,
*(col->data_lens + row) = 0;
} else {
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,
char **target, size_t *target_len)
{
if (columnRowIsNull(col, row)) {
return 0;
return -1;
}
if (move) {
@@ -185,12 +68,13 @@ int moveColumnBlobPointer(column_data *col, size_t row, int move,
*target = (char *)malloc(*(col->data_lens + row));
if (*target == 0) {
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));
*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"
char *modbTableName(modb_ref *modb, const char *suffix, size_t suffix_len, char encap);
void modbTableName_sb(str_builder *sb, modb_ref *modb, const char *suffix, size_t suffix_len,
char encap);
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);
char *modbTableName(char **name, size_t *len, modb_ref *modb, const char *suffix, size_t suffix_len);
void modbFreeTableName(char **name);
void modbTableName_sb(str_builder *sb, modb_ref *modb, const char *suffix, size_t suffix_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,