initialize generic sharding information from llmeta separately instead on relying on an alias to exist

Signed-off-by: Aakash Arayambeth <[email protected]>

Author: Aakash Arayambeth

bdb/bdb_api.h

@@ -2499,4 +2499,4 @@ void llmeta_collect_tablename_alias(void);
 int bdb_set_genshard(tran_type *, const char *, char *, int *);
 int bdb_clear_genshard(tran_type *, const char *, int *);
 int bdb_get_genshard(tran_type *, const char *, char **, int *, int *);
-
+int bdb_get_genshard_names(tran_type *t, char **names, int *num);

bdb/llmeta.c

@@ -11636,3 +11636,33 @@ int bdb_get_genshard(tran_type *tran, const char *table, char **str, int *size,
     return bdb_lite_exact_var_fetch_tran(llmeta_bdb_state, tran, key, (void **)str, size, bdberr);
 }
 
+struct llmeta_gen_shard_key {
+    int file_type;
+    char tablename[LLMETA_TBLLEN];
+};
+
+/* Fetch all generic shard names */
+int bdb_get_genshard_names(tran_type *t, char **names, int *num)
+{
+    union {
+        struct llmeta_gen_shard_key key;
+        uint8_t buf[LLMETA_IXLEN];
+    } * *shards;
+    int rc, n, bdberr;
+    llmetakey_t k;
+
+    k = htonl(LLMETA_GEN_SHARD);
+    rc = kv_get_keys(t, &k, sizeof(k), (void ***)&shards, &n, &bdberr);
+    if (rc || (n == 0)) {
+        *num = 0;
+        return rc;
+    }
+
+    for (int i = 0; i < n; ++i) {
+        names[i] = strdup(shards[i]->key.tablename);
+        free(shards[i]);
+    }
+    free(shards);
+    *num = n;
+    return rc;
+}

db/comdb2.c

@@ -208,7 +208,7 @@ static void *purge_old_files_thread(void *arg);
 static int lrllinecmp(char *lrlline, char *cmpto);
 static void ttrap(struct timer_parm *parm);
 int clear_temp_tables(void);
-
+int gen_shard_deserialize_shard(uint32_t *numdbs, char ***dbnames, uint32_t *numcols, char ***columns, char ***shardnames, char *serializedStr);
 pthread_key_t comdb2_open_key;
 
 /*---GLOBAL SETTINGS---*/
@@ -2294,6 +2294,79 @@ int llmeta_load_views(struct dbenv *dbenv, void *tran)
     return rc;
 }
 
+int llmeta_load_genshards(struct dbenv *dbenv, void *tran) {
+    int rc = 0;
+    int bdberr = 0;
+    /* allow as many generic sharded tables as regular tables (?) */
+    char *tablenames[MAX_NUM_TABLES];
+    char *shard_info = NULL;
+    char **dbnames = NULL, **columns = NULL, **shardnames = NULL;
+    int table_count = 0, size = 0;
+    uint32_t numdbs=0, numcols=0;
+    struct dbtable *db = NULL;
+    /* load the tables from the low level metatable */
+    if (bdb_get_genshard_names(tran, (char **)tablenames, &table_count)) {
+        logmsg(
+            LOGMSG_ERROR,
+            "couldn't load generic shard names from low level meta table (bdberr: %d)\n",
+            bdberr);
+        return 1;
+    }
+
+    for (int i = 0; i < table_count; i++) {
+        if (bdb_get_genshard(tran, tablenames[i], &shard_info, &size, &bdberr)) {
+            logmsg(LOGMSG_ERROR,
+                   "couldn't load view definition from low level meta table "
+                   "(bdberr: %d)\n",
+                   bdberr);
+            goto err;
+        }
+
+        if (gen_shard_deserialize_shard(&numdbs, &dbnames, &numcols, &columns, &shardnames, shard_info)) {
+            logmsg(LOGMSG_ERROR, "Failed to deserialize llmeta str for generic shard %s\n", tablenames[i]);
+        }
+
+        for(int i=0;i<numdbs;i++){
+            db = get_dbtable_by_name(shardnames[i]);
+            if (db) {
+                /*update the table object*/
+                db->numdbs = numdbs;
+                db->dbnames = dbnames;
+                db->numcols = numcols;
+                db->columns = columns;
+                db->shardnames = shardnames;
+            } else {
+                logmsg(LOGMSG_ERROR, "FAILED TO UPDATE GENERIC SHARDING METADATA FOR TABLE %s\n", tablenames[i]);
+            }
+        }
+    }
+    return rc;
+err:
+    for (int i = 0; i < table_count; i++) {
+        free(tablenames[i]);
+    }
+
+    if (dbnames) {
+        for(int i=0;i<numdbs;i++){
+            free(dbnames[i]);
+        }
+        free(dbnames);
+    }
+
+    if (columns) {
+        for(int i=0;i<numcols;i++){
+            free(columns[i]);
+        }
+    }
+
+    if (shardnames) {
+        for(int i=0;i<numdbs;i++) {
+            free(shardnames[i]);
+        }
+    }
+    return rc;
+}
+
 static inline int db_get_alias(void *tran, dbtable *tbl)
 {
     char *sqlalias = NULL;
@@ -2412,12 +2485,12 @@ static int llmeta_load_tables(struct dbenv *dbenv, void *tran)
         /* A shard of a partitioned table has the partition name as an alias.
          * Read the sharded table metadata. 
          */
-        if (tbl->sqlaliasname) {
+        /*if (tbl->sqlaliasname) {
             rc = gen_shard_update_inmem_db(tran, tbl, tbl->sqlaliasname);
             if (rc) {
                 logmsg(LOGMSG_USER, "NOT UPDATING SHARD METADATA FOR TABLE %s\n", tbl->tablename);
             }
-        }
+        }*/
         /* We only want to load older schema versions for ODH databases.  ODH
          * information is stored in the meta table (not the llmeta table), so
          * it's not loaded yet.
@@ -4225,6 +4298,13 @@ static int init(int argc, char **argv)
             return -1;
         }
 
+        if (llmeta_load_genshards(thedb, NULL)) {
+            logmsg(LOGMSG_FATAL, "could not load generic shards from the low level meta "
+                            "table\n");
+            unlock_schema_lk();
+            return -1;
+        }
+
         if (llmeta_load_timepart(thedb)) {
             logmsg(LOGMSG_ERROR, "could not load time partitions\n");
             unlock_schema_lk();