void doTest(struct sqlConnection *conn)
/* Put up a page to see what happens. */
{
char *s = NULL;
textOpen();
hPrintf("Doing test!\n");
s = filterClause("hg18", "knownGene", "chrX", NULL);
if (s != NULL)
hPrintf("%s\n", s);
else
hPrintf("%p\n", s);
}
struct bed *dbGetFilteredBedsOnRegions(struct sqlConnection *conn,
char *db, char *dbVarName, char *table, char *tableVarName,
struct region *regionList, struct lm *lm,
int *retFieldCount)
/* Get list of beds from database, in all regions, that pass filtering. */
{
/* A joining query may be required if the filter incorporates linked tables. */
struct hTableInfo *hti = getHti(db, table, conn);
struct slName *fieldList = getBedFieldSlNameList(hti, db, table);
struct joinerDtf *dtfList = NULL;
struct joinerDtf *filterTables = NULL;
boolean doJoin = joinRequired(db, table,
fieldList, &dtfList, &filterTables);
struct region *region;
struct bed *bedList = NULL;
char *idField = getIdField(db, curTrack, table, hti);
struct hash *idHash = identifierHash(db, table);
if (! doJoin)
{
for (region = regionList; region != NULL; region = region->next)
{
char *identifierFilter = identifierWhereClause(idField, idHash);
char *filter = filterClause(dbVarName, tableVarName, region->chrom, identifierFilter);
struct bed *bedListRegion = getRegionAsMergedBed(dbVarName, tableVarName,
region, filter, idHash, lm, retFieldCount);
struct bed *bed, *nextBed;
for (bed = bedListRegion; bed != NULL; bed = nextBed)
{
nextBed = bed->next;
slAddHead(&bedList, bed);
}
freez(&filter);
}
slReverse(&bedList);
}
else
{
struct joiner *joiner = allJoiner;
struct joinedTables *joined = joinedTablesCreate(joiner,
db, table, dtfList, filterTables, 1000000, regionList);
int bedFieldCount = hTableInfoBedFieldCount(hti);
if (retFieldCount != NULL)
*retFieldCount = bedFieldCount;
bedList = joinedTablesToBed(joined, hti, bedFieldCount, lm);
joinedTablesFree(&joined);
}
joinerDtfFreeList(&dtfList);
joinerDtfFreeList(&filterTables);
hashFree(&idHash);
return bedList;
}
static void wikiTrackFilteredBedOnRegion(
struct region *region, /* Region to get data from. */
struct hash *idHash, /* Hash of identifiers or NULL */
struct bedFilter *bf, /* Filter or NULL */
struct lm *lm, /* Local memory pool. */
struct bed **pBedList /* Output get's appended to this list */
)
/* Get the wikiTrack items passing filter on a single region. */
{
struct bed *bed;
int fieldCount = 6;
char query[512];
int rowOffset;
char **row;
struct sqlConnection *wikiConn = wikiConnect();
struct sqlResult *sr = NULL;
char where[512];
char *filter = filterClause(wikiDbName(), WIKI_TRACK_TABLE, region->chrom, NULL);
if (filter)
sqlSafefFrag(where, sizeof(where), "db='%s' AND %-s", database, filter);
else
sqlSafefFrag(where, sizeof(where), "db='%s'", database);
sqlSafef(query, sizeof(query), "select * from %s", WIKI_TRACK_TABLE);
sr = hRangeQuery(wikiConn, WIKI_TRACK_TABLE, region->chrom,
region->start, region->end, where, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
bed = bedLoadN(row+rowOffset, fieldCount);
if ((idHash == NULL || hashLookup(idHash, bed->name)) &&
(bf == NULL || bedFilterOne(bf, bed)))
{
struct bed *copy = lmCloneBed(bed, lm);
slAddHead(pBedList, copy);
}
}
sqlFreeResult(&sr);
wikiDisconnect(&wikiConn);
}
void tjLoadSome(struct region *regionList,
struct joinedTables *joined, int fieldOffset, int keyOffset,
char *idField, struct hash *idHash,
struct slName *chopBefore, struct slName *chopAfter,
struct tableJoiner *tj, boolean isPositional, boolean isFirst)
/* Load up rows. */
{
struct region *region;
struct dyString *sqlFields = dyStringNew(0);
struct joinerDtf *dtf;
struct slRef *ref;
struct joinerPair *jp;
int fieldCount = 0, keyCount = 0;
int idFieldIx = -1;
struct sqlConnection *conn = hAllocConn(tj->database);
char *identifierFilter = NULL;
char *filter;
boolean needUpdateFilter = FALSE;
struct joinedRow *jr;
if (isFirst)
identifierFilter = identifierWhereClause(idField, idHash);
filter = filterClause(tj->database, tj->table, regionList->chrom, identifierFilter);
/* Record combined filter. */
// Show only the SQL filter built from filter page options, not identifierFilter,
// because identifierFilter can get enormous (like 126kB for 12,500 rsIDs).
char *filterNoIds = filterClause(tj->database, tj->table, regionList->chrom, NULL);
if (filterNoIds != NULL)
{
if (joined->filter == NULL)
joined->filter = dyStringNew(0);
else
dyStringAppend(joined->filter, " AND ");
dyStringAppend(joined->filter, filterNoIds);
if (!isFirst)
{
needUpdateFilter = TRUE;
for (jr = joined->rowList; jr != NULL; jr = jr->next)
jr->hitThisTable = FALSE;
}
}
/* Create field spec for sql - first fields user will see, and
* second keys if any. */
for (dtf = tj->fieldList; dtf != NULL; dtf = dtf->next)
{
struct joinerDtf *dupe = joinerDtfClone(dtf);
slAddTail(&joined->fieldList, dupe);
dyStringAddList(sqlFields, dtf->field);
++fieldCount;
}
for (ref = tj->keysOut; ref != NULL; ref = ref->next)
{
struct joinerDtf *dupe;
jp = ref->val;
dupe = joinerDtfClone(jp->a);
slAddTail(&joined->keyList, dupe);
dyStringAddList(sqlFields, jp->a->field);
++keyCount;
}
if (idHash != NULL)
{
if (idField == NULL)
internalErr();
idFieldIx = fieldCount + keyCount;
dyStringAddList(sqlFields, idField);
}
for (region = regionList; region != NULL; region = region->next)
{
char **row;
/* We free at end of loop so we get new one for each chromosome. */
char *filter = filterClause(tj->database, tj->table, region->chrom, identifierFilter);
struct sqlResult *sr = regionQuery(conn, tj->table,
sqlFields->string, region, isPositional, filter);
while (sr != NULL && (row = sqlNextRow(sr)) != NULL)
{
if (idFieldIx < 0)
{
if (jrRowAdd(joined, row, fieldCount, keyCount) == NULL)
break;
}
else
{
char *id = row[idFieldIx];
if (isFirst)
{
if (hashLookup(idHash, id))
{
if (jrRowAdd(joined, row, fieldCount, keyCount) == NULL)
break;
}
}
else
{
struct hashEl *bucket;
id = chopKey(chopBefore, chopAfter, id);
for (bucket = hashLookup(idHash, id); bucket != NULL;
bucket = hashLookupNext(bucket))
{
jr = bucket->val;
jr->hitThisTable = TRUE;
jrRowExpand(joined, jr, row,
fieldOffset, fieldCount, keyOffset, keyCount);
}
}
}
}
sqlFreeResult(&sr);
freez(&filter);
if (!isPositional)
break;
}
if (isFirst)
slReverse(&joined->rowList);
if (needUpdateFilter)
{
for (jr = joined->rowList; jr != NULL; jr = jr->next)
{
jr->passedFilter &= jr->hitThisTable;
}
}
tj->loaded = TRUE;
hFreeConn(&conn);
}
