Removed db helpers from modb (3 of 3)

src/modb_accounting.c

@@ -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), '`');
+  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;
+  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) {
     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) {
-    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) {
-    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;
   }
 
-  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 qry_ret;
   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 qry_ret;
   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);
+
+  return (int)qry_ret;
 }
 
-  qry_ret = deleteByIdQuery(sconn, table, "id", id);
-  free(table);
-
-  return 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(&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);
   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) {
     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), '`');
+  escapeTableName_sb(sb, table, table_len);
   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);
   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;
+  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) {
     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;
   }
 
-  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 qry_ret;
   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 qry_ret;
   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);
+
+  return (int)qry_ret;
 }
 
-  qry_ret = deleteByIdQuery(sconn, table, "id", id);
-  free(table);
-
-  return 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(&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);
   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) {
     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) {
+  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,
                           unsigned int group_id, size_t n_users, ...)
 {
   va_list args;
-  int qry_ret;
   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);
-  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 (int)qry_ret;
-
-  return 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) {
+  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,
-                        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) {
+  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,
-                          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) {
+  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;
 }

src/modb_accounting.h

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

src/modb_accounting_p.c

@@ -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_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);
   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(sb, wb, 0);
-    compileWhereBuilder_sb(wb, sb, 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_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);
   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(sb, wb, 0);
-    compileWhereBuilder_sb(wb, sb, 0);
   }
+
+  modbFreeTableName(&table);
   if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) {
     return -1;
   }

src/modb_database_p.c

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

src/modb_p.c

@@ -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);
-  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 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, 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)
 {
   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;
 }
+

src/modb_p.h

@@ -20,34 +20,9 @@
 #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 moveColumnBlobPointer(column_data *col, size_t row, int move,