static void showTableFieldsCt(char *db, char *table, boolean withGetButton)
/* Put up html table with a check box for each field of custom
* track. */
{
struct customTrack *ct = ctLookupName(table);
char *type = ct->dbTrackType;
if (type == NULL)
type = ct->tdb->type;
struct sqlConnection *conn = hAllocConn(CUSTOM_TRASH);
struct asObject *asObj = asForTdb(conn, ct->tdb);
if (asObj)
{
struct slName *fieldList = NULL;
if (ct->dbTableName != NULL)
{
if (isVcfTable(table, NULL))
fieldList = vcfGetFields();
else
fieldList = sqlListFields(conn, ct->dbTableName);
}
if (fieldList == NULL)
fieldList = asColNames(asObj);
showTableFieldsOnList(db, table, asObj, fieldList, FALSE, withGetButton);
asObjectFree(&asObj);
slNameFreeList(&fieldList);
}
else
showBedTableFields(db, table, ct->fieldCount, withGetButton);
hFreeConn(&conn);
}
struct dataVector *bedGraphDataVector(char *table,
struct sqlConnection *conn, struct region *region)
/* Read in bedGraph as dataVector and return it. Filtering, subtrack merge
* and intersection are handled. */
{
struct dataVector *dv = NULL;
if (anySubtrackMerge(database, table))
dv = mergedWigDataVector(table, conn, region);
else
{
struct trackDb *tdb;
if (isCustomTrack(table))
{
struct customTrack *ct = ctLookupName(table);
tdb = ct->tdb;
conn = hAllocConn(CUSTOM_TRASH);
}
else
{
tdb = hTrackDbForTrack(database, table);
}
struct trackTable *tt1 = trackTableNew(tdb, table, conn);
dv = dataVectorFetchOneRegion(tt1, region, conn);
intersectDataVector(table, dv, region, conn);
if (isCustomTrack(table))
hFreeConn(&conn);
}
return dv;
}
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;
}
static char *vcfFileName(struct trackDb *tdb, struct sqlConnection *conn, char *table, char *chrom)
// Look up the vcf or vcfTabix file name, using CUSTOM_TRASH if necessary.
{
boolean isCt = isCustomTrack(table);
char *dbTable = table;
struct sqlConnection *dbConn = conn;
if (isCt)
{
dbConn = hAllocConn(CUSTOM_TRASH);
struct customTrack *ct = ctLookupName(table);
dbTable = ct->dbTableName;
}
char *fileName = bbiNameFromSettingOrTableChrom(tdb, dbConn, dbTable, chrom);
if (isCt)
hFreeConn(&dbConn);
return fileName;
}
char *bigFileNameFromCtOrHub(char *table, struct sqlConnection *conn)
/* If table is a custom track or hub track, return the bigDataUrl setting;
* otherwise return NULL. Do a freeMem on returned string when done. */
{
char *fileName = NULL;
if (isCustomTrack(table))
{
struct customTrack *ct = ctLookupName(table);
if (ct != NULL)
fileName = cloneString(trackDbSetting(ct->tdb, "bigDataUrl"));
}
else if (isHubTrack(table))
{
struct trackDb *tdb = hashFindVal(fullTableToTdbHash, table);
assert(tdb != NULL);
fileName = cloneString(trackDbSetting(tdb, "bigDataUrl"));
assert(fileName != NULL);
}
return fileName;
}
boolean isWiggle(char *db, char *table)
/* Return TRUE if db.table is a wiggle. */
{
boolean typeWiggle = FALSE;
if (db != NULL && table != NULL)
{
if (isCustomTrack(table))
{
struct customTrack *ct = ctLookupName(table);
if (ct != NULL && ct->wiggle)
typeWiggle = TRUE;
}
else
{
struct hTableInfo *hti = maybeGetHtiOnDb(db, table);
typeWiggle = (hti != NULL && HTI_IS_WIGGLE);
}
}
return(typeWiggle);
}
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 void makeCtOrderedCommaFieldList(struct joinerDtf *dtfList,
struct dyString *dy)
/* Make comma-separated field list in same order as fields are in
* custom track. */
{
char *track = dtfList->table;
struct customTrack *ct = ctLookupName(track);
char *type = ct->dbTrackType;
struct slName *fieldList = NULL;
if (startsWithWord("makeItems", type) || sameWord("bedDetail", type) || sameWord("pgSnp", type))
{
struct sqlConnection *conn = hAllocConn(CUSTOM_TRASH);
fieldList = sqlListFields(conn, ct->dbTableName);
hFreeConn(&conn);
}
else
{
fieldList = getBedFields(15);
}
makeOrderedCommaFieldList(fieldList, dtfList, dy);
slFreeList(&fieldList);
}
struct bed *getRegionAsBed(
char *db, char *table, /* Database and table. */
struct region *region, /* Region to get data for. */
char *filter, /* Filter to add to SQL where clause if any. */
struct hash *idHash, /* Restrict to id's in this hash if non-NULL. */
struct lm *lm, /* Where to allocate memory. */
int *retFieldCount) /* Number of fields. */
/* Return a bed list of all items in the given range in table.
* Cleanup result via lmCleanup(&lm) rather than bedFreeList. */
{
char *fields = NULL;
struct sqlResult *sr;
struct hTableInfo *hti;
struct bed *bedList=NULL, *bed;
char **row;
int fieldCount;
boolean isPsl, isGenePred, isBedWithBlocks;
boolean pslKnowIfProtein = FALSE, pslIsProtein = FALSE;
struct sqlConnection *conn = NULL;
char *dbTable = NULL;
if (isCustomTrack(table))
{
struct customTrack *ct = ctLookupName(table);
dbTable = ct->dbTableName;
conn = hAllocConn(CUSTOM_TRASH);
hti = hFindTableInfo(CUSTOM_TRASH, region->chrom, dbTable);
}
else
{
dbTable = table;
struct trackDb *tdb;
if(sameWord(db, database))
tdb = tdbForTrack(db, table, &fullTrackList);
else
tdb = hTrackDbForTrack(db, table);
conn = (tdb ? hAllocConnTrack(db, tdb) : hAllocConn(db));
hti = hFindTableInfo(db, region->chrom, table);
}
if (hti == NULL)
errAbort("Could not find table info for table %s.%s", db,table);
if (isWiggle(db, table))
{
bedList = getWiggleAsBed(db, table, region, filter, idHash, lm, conn);
fieldCount = 4;
}
else
{
bedSqlFieldsExceptForChrom(hti, &fieldCount, &fields);
isPsl = htiIsPsl(hti);
isGenePred = sameString("exonEnds", hti->endsSizesField);
isBedWithBlocks = (
(sameString("chromStarts", hti->startsField) ||
sameString("blockStarts", hti->startsField))
&& sameString("blockSizes", hti->endsSizesField));
/* All beds have at least chrom,start,end. We omit the chrom
* from the query since we already know it. */
sr = regionQuery(conn, dbTable, fields, region, TRUE, filter);
while (sr != NULL && (row = sqlNextRow(sr)) != NULL)
{
/* If have a name field apply hash filter. */
if (fieldCount >= 4 && idHash != NULL)
if (!hashLookup(idHash, row[2]))
continue;
bed = bedFromRow(region->chrom, row, fieldCount, isPsl, isGenePred,
isBedWithBlocks, &pslKnowIfProtein, &pslIsProtein, lm);
slAddHead(&bedList, bed);
}
freez(&fields);
sqlFreeResult(&sr);
slReverse(&bedList);
}
hFreeConn(&conn);
if (retFieldCount)
*retFieldCount = fieldCount;
return(bedList);
}
char *filterClause(char *db, char *table, char *chrom, char *extraClause)
/* Get filter clause (something to put after 'where')
* for table */
{
struct sqlConnection *conn = NULL;
char varPrefix[128];
int varPrefixSize, fieldNameSize;
struct hashEl *varList, *var;
struct dyString *dy = NULL;
boolean needAnd = FALSE;
char oldDb[128];
char dbTableBuf[256];
char explicitDb[128];
char splitTable[256];
char explicitDbTable[512];
/* Return just extraClause (which may be NULL) if no filter on us. */
if (! (anyFilter() && filteredOrLinked(db, table)))
return cloneString(extraClause);
safef(oldDb, sizeof(oldDb), "%s", db);
dbOverrideFromTable(dbTableBuf, &db, &table);
if (!sameString(oldDb, db))
safef(explicitDb, sizeof(explicitDb), "%s.", db);
else
explicitDb[0] = 0;
/* Cope with split table and/or custom tracks. */
if (isCustomTrack(table))
{
conn = hAllocConn(CUSTOM_TRASH);
struct customTrack *ct = ctLookupName(table);
safef(explicitDbTable, sizeof(explicitDbTable), "%s", ct->dbTableName);
}
else
{
conn = hAllocConn(db);
safef(splitTable, sizeof(splitTable), "%s_%s", chrom, table);
if (!sqlTableExists(conn, splitTable))
safef(splitTable, sizeof(splitTable), "%s", table);
safef(explicitDbTable, sizeof(explicitDbTable), "%s%s",
explicitDb, splitTable);
}
/* Get list of filter variables for this table. */
safef(varPrefix, sizeof(varPrefix), "%s%s.%s.", hgtaFilterVarPrefix, db, table);
varPrefixSize = strlen(varPrefix);
varList = cartFindPrefix(cart, varPrefix);
if (varList == NULL)
{
hFreeConn(&conn);
return cloneString(extraClause);
}
/* Create filter clause string, stepping through vars. */
dy = dyStringNew(0);
for (var = varList; var != NULL; var = var->next)
{
/* Parse variable name into field and type. */
char field[64], *s, *type;
s = var->name + varPrefixSize;
type = strchr(s, '.');
if (type == NULL)
internalErr();
fieldNameSize = type - s;
if (fieldNameSize >= sizeof(field))
internalErr();
memcpy(field, s, fieldNameSize);
field[fieldNameSize] = 0;
sqlCkId(field);
type += 1;
/* rawLogic and rawQuery are handled below;
* filterMaxOutputVar is not really a filter variable and is handled
* in wiggle.c. */
if (startsWith("raw", type) || sameString(filterMaxOutputVar, type))
continue;
/* Any other variables that are missing a name:
* <varPrefix>..<type>
* are illegal
*/
if (fieldNameSize < 1)
{
warn("Missing name in cart variable: %s\n", var->name);
continue;
}
if (sameString(type, filterDdVar))
{
char *patVar = filterPatternVarName(db, table, field);
struct slName *patList = cartOptionalSlNameList(cart, patVar);
normalizePatList(&patList);
if (slCount(patList) > 0)
{
char *ddVal = cartString(cart, var->name);
boolean neg = sameString(ddVal, ddOpMenu[1]);
char *fieldType = getSqlType(conn, explicitDbTable, field);
boolean needOr = FALSE;
if (needAnd) dyStringAppend(dy, " and ");
needAnd = TRUE;
if (neg) dyStringAppend(dy, "not ");
boolean composite = (slCount(patList) > 1);
if (composite || neg) dyStringAppendC(dy, '(');
struct slName *pat;
for (pat = patList; pat != NULL; pat = pat->next)
{
char *sqlPat = sqlLikeFromWild(pat->name);
if (needOr)
dyStringAppend(dy, " OR ");
needOr = TRUE;
if (isSqlSetType(fieldType))
{
sqlDyStringPrintfFrag(dy, "FIND_IN_SET('%s', %s.%s)>0 ",
sqlPat, explicitDbTable , field);
}
else
{
sqlDyStringPrintfFrag(dy, "%s.%s ", explicitDbTable, field);
if (sqlWildcardIn(sqlPat))
dyStringAppend(dy, "like ");
else
dyStringAppend(dy, "= ");
sqlDyStringPrintf(dy, "'%s'", sqlPat);
}
freez(&sqlPat);
}
if (composite || neg) dyStringAppendC(dy, ')');
}
}
else if (sameString(type, filterCmpVar))
{
char *patVar = filterPatternVarName(db, table, field);
char *pat = trimSpaces(cartOptionalString(cart, patVar));
char *cmpVal = cartString(cart, var->name);
if (cmpReal(pat, cmpVal))
{
if (needAnd) dyStringAppend(dy, " and ");
needAnd = TRUE;
if (sameString(cmpVal, "in range"))
{
char *words[2];
int wordCount;
char *dupe = cloneString(pat);
wordCount = chopString(dupe, ", \t\n", words, ArraySize(words));
if (wordCount < 2) /* Fake short input */
words[1] = "2000000000";
if (strchr(pat, '.')) /* Assume floating point */
{
double a = atof(words[0]), b = atof(words[1]);
sqlDyStringPrintfFrag(dy, "%s.%s >= %f && %s.%s <= %f",
explicitDbTable, field, a, explicitDbTable, field, b);
}
else
{
int a = atoi(words[0]), b = atoi(words[1]);
sqlDyStringPrintfFrag(dy, "%s.%s >= %d && %s.%s <= %d",
explicitDbTable, field, a, explicitDbTable, field, b);
}
freez(&dupe);
}
else
{
// cmpVal has been checked already above in cmpReal for legal values.
sqlDyStringPrintfFrag(dy, "%s.%s %-s ", explicitDbTable, field, cmpVal);
if (strchr(pat, '.')) /* Assume floating point. */
dyStringPrintf(dy, "%f", atof(pat));
else
dyStringPrintf(dy, "%d", atoi(pat));
}
}
}
}
/* Handle rawQuery if any */
{
char *varName;
char *logic, *query;
varName = filterFieldVarName(db, table, "", filterRawLogicVar);
logic = cartUsualString(cart, varName, logOpMenu[0]);
varName = filterFieldVarName(db, table, "", filterRawQueryVar);
query = trimSpaces(cartOptionalString(cart, varName));
if (query != NULL && query[0] != 0)
{
if (needAnd) dyStringPrintf(dy, " %s ", logic);
sqlSanityCheckWhere(query, dy);
}
}
/* Clean up and return */
hFreeConn(&conn);
hashElFreeList(&varList);
if (dy->stringSize == 0)
{
dyStringFree(&dy);
return cloneString(extraClause);
}
else
{
if (isNotEmpty(extraClause))
dyStringPrintf(dy, " and %s", extraClause);
return dyStringCannibalize(&dy);
}
}
static void filterControlsForTableCt(char *db, char *table)
/* Put up filter controls for a custom track. */
{
struct customTrack *ct = ctLookupName(table);
char *type = ct->dbTrackType;
puts("<TABLE BORDER=0>");
if (type != NULL && startsWithWord("maf", type))
{
stringFilterOption(db, table, "chrom", " AND ");
integerFilter(db, table, "chromStart", "chromStart", " AND ");
integerFilter(db, table, "chromEnd", "chromEnd", " AND ");
}
else if (type != NULL && (startsWithWord("makeItems", type) || sameWord("bedDetail", type) || sameWord("pgSnp", type)))
{
struct sqlConnection *conn = hAllocConn(CUSTOM_TRASH);
struct sqlFieldType *ftList = sqlListFieldsAndTypes(conn, ct->dbTableName);
printSqlFieldListAsControlTable(ftList, db, table, ct->tdb, FALSE);
hFreeConn(&conn);
}
else if (ct->wiggle || isBigWigTable(table))
{
if ((ct->tdb != NULL) && (ct->tdb != NULL))
{
double min, max;
wiggleMinMax(ct->tdb,&min,&max);
numericFilterWithLimits("ct", table, filterDataValueVar, filterDataValueVar,min,max,"");
hPrintf("<TR><TD COLSPAN=3 ALIGN=RIGHT> (dataValue range: [%g,%g]) "
"</TD></TR>\n", min, max);
}
else
{
numericFilter("ct", table, filterDataValueVar, filterDataValueVar,"");
}
}
else if (isBigBed(db, table, curTrack, ctLookupName))
{
struct sqlFieldType *ftList = bigBedListFieldsAndTypes(ct->tdb, NULL);
printSqlFieldListAsControlTable(ftList, db, table, ct->tdb, FALSE);
}
else if (isBamTable(table))
{
struct sqlFieldType *ftList = bamListFieldsAndTypes();
printSqlFieldListAsControlTable(ftList, db, table, ct->tdb, FALSE);
}
else if (isVcfTable(table, NULL))
{
struct sqlFieldType *ftList = vcfListFieldsAndTypes();
printSqlFieldListAsControlTable(ftList, db, table, ct->tdb, FALSE);
}
else
{
if (ct->fieldCount >= 3)
{
stringFilterOption(db, table, "chrom", " AND ");
integerFilter(db, table, "chromStart", "chromStart", " AND ");
integerFilter(db, table, "chromEnd", "chromEnd", " AND ");
}
if (ct->fieldCount >= 4)
{
stringFilterOption(db, table, "name", " AND ");
}
if (ct->fieldCount >= 5)
{
numericFilter(db, table, "score", "score", " AND ");
}
if (ct->fieldCount >= 6)
{
stringFilterOption(db, table, "strand", " AND ");
}
if (ct->fieldCount >= 8)
{
integerFilter(db, table, "thickStart", "thickStart", " AND ");
integerFilter(db, table, "thickEnd", "thickEnd", " AND ");
}
if (ct->fieldCount >= 12)
{
integerFilter(db, table, "blockCount", "blockCount", " AND ");
}
/* These are not bed fields, just extra constraints that we offer: */
if (ct->fieldCount >= 3)
{
integerFilter(db, table, "chromLength", "(chromEnd - chromStart)",
(ct->fieldCount >= 8) ? " AND " : "");
}
if (ct->fieldCount >= 8)
{
integerFilter( db, table, "thickLength", "(thickEnd - thickStart)", " AND ");
eqFilterOption(db, table, "compareStarts","chromStart","thickStart", " AND ");
eqFilterOption(db, table, "compareEnds", "chromEnd", "thickEnd", "");
}
}
puts("</TABLE>");
if (ct->wiggle || isBigWigTable(table) || isBamTable(table) || isVcfTable(table, NULL))
{
char *name;
hPrintf("<TABLE BORDER=0><TR><TD> Limit data output to: \n");
name = filterFieldVarName("ct", table, "_", filterMaxOutputVar);
cgiMakeDropList(name, maxOutMenu, maxOutMenuSize,
cartUsualString(cart, name, maxOutMenu[0]));
hPrintf(" lines</TD></TR></TABLE>\n");
}
hPrintf("<BR>\n");
cgiMakeButton(hgtaDoFilterSubmit, "submit");
hPrintf(" ");
cgiMakeButton(hgtaDoMainPage, "cancel");
}