static boolean canIntersect(char *db, char *table)
/* Return true if table exists and is positional. */
{
if (isCustomTrack(table) && ctLookupName(table) != NULL)
return TRUE;
if (sameWord(table, WIKI_TRACK_TABLE))
return TRUE;
if (hTableOrSplitExists(db, table))
return isPositional(db, table);
return FALSE;
}
struct joinedTables *tjLoadFirst(struct region *regionList,
struct tableJoiner *tj, int totalFieldCount,
int totalKeyCount, int maxRowCount)
/* Load up first table in series of joined tables. This allocates
* field and key arrays big enough for all. */
{
struct joinedTables *joined = joinedTablesNew(totalFieldCount,
totalKeyCount, maxRowCount);
struct hash *idHash = NULL;
struct hTableInfo *hti = getHtiOnDb(tj->database, tj->table);
char *idField = getIdField(tj->database, curTrack, tj->table, hti);
if (idField != NULL)
idHash = identifierHash(tj->database, tj->table);
tjLoadSome(regionList, joined, 0, 0,
idField, idHash, NULL, NULL, tj,
isPositional(tj->database, tj->table), TRUE);
hashFree(&idHash);
return joined;
}
boolean canIntersect(char *db, char *table)
/* Return true if table exists and is positional. */
{
if (isCustomTrack(table) && ctLookupName(table) != NULL)
return TRUE;
if (isBamTable(table))
return TRUE;
if (isBigWigTable(table))
return TRUE;
if (isBigBed(database, table, curTrack, ctLookupName))
return TRUE;
if (isVcfTable(table, NULL))
return TRUE;
if (isHubTrack(table))
return TRUE;
if (sameWord(table, WIKI_TRACK_TABLE))
return TRUE;
if (hTableOrSplitExists(db, table))
return isPositional(db, table);
return FALSE;
}
static struct joinedTables *joinedTablesCreate( struct joiner *joiner,
char *primaryDb, char *primaryTable,
struct joinerDtf *fieldList, struct joinerDtf *filterTables,
int maxRowCount, struct region *regionList)
/* Create joinedTables structure from fields. */
{
struct tableJoiner *tj, *tjList = bundleFieldsIntoTables(fieldList, filterTables);
struct joinerPair *routeList = NULL, *route;
struct joinedTables *joined = NULL;
struct hash *tableHash = newHash(8);
int totalKeyCount = 0, totalFieldCount = 0;
int curKeyCount = 0, curFieldCount = 0;
struct joinerDtf *tableDtfs;
for (tj = tjList; tj != NULL; tj = tj->next)
{
char buf[256];
safef(buf, sizeof(buf), "%s.%s", tj->database, tj->table);
hashAdd(tableHash, buf, tj);
}
orderTables(&tjList, primaryDb, primaryTable);
tableDtfs = tableToDtfs(tjList);
routeList = joinerFindRouteThroughAll(joiner, tableDtfs);
if (routeList == NULL)
errAbort("Can't find route from %s to %s via all.joiner", primaryTable, tjList->next->table);
addOutKeys(tableHash, routeList, &tjList);
/* If first table is non-positional then it will lead to a lot
* of n/a's in later fields unless we treat the genome-wide. */
if (!isPositional(tjList->database, tjList->table))
regionList = getRegionsFullGenome();
/* Count up total fields and keys. */
for (tj = tjList; tj != NULL; tj = tj->next)
{
totalKeyCount += slCount(tj->keysOut);
totalFieldCount += slCount(tj->fieldList);
}
/* Do first table. This one uses identifier hash if any. */
{
joined = tjLoadFirst(regionList,
tjList, totalFieldCount, totalKeyCount, maxRowCount);
curKeyCount = slCount(tjList->keysOut);
curFieldCount = slCount(tjList->fieldList);
}
/* Follow routing list for rest. */
if (!sameString(tjList->database, routeList->a->database))
internalErr();
if (!sameString(tjList->table, routeList->a->table))
internalErr();
for (route = routeList; route != NULL; route = route->next)
{
struct tableJoiner *tj = findTableJoiner(tjList,
route->b->database, route->b->table);
struct joinerField *jfA = NULL, *jfB = NULL;
if (tj == NULL)
internalErr();
jfA = findJoinerField(route->identifier, route->a);
if (jfA == NULL)
{
internalErr();
}
jfB = findJoinerField(route->identifier, route->b);
if (jfB == NULL)
internalErr();
if (!tj->loaded)
{
int keyIx;
struct hash *keyHash = NULL;
keyIx = findDtfIndex(joined->keyList, route->a);
if (keyIx < 0)
internalErr();
keyHash = hashKeyField(joined, keyIx, jfA);
tjLoadSome(regionList, joined, curFieldCount, curKeyCount,
route->b->field, keyHash,
jfB->chopBefore, jfB->chopAfter,
tj, isPositional(tj->database, tj->table), FALSE);
curKeyCount += slCount(tj->keysOut);
curFieldCount += slCount(tj->fieldList);
hashFree(&keyHash);
}
}
joinerDtfFreeList(&tableDtfs);
hashFree(&tableHash);
tableJoinerFreeList(&tjList);
return joined;
}
