static struct visiMatch *matchGeneName(struct sqlConnection *conn,
char *symbol, struct hash *privateHash)
/* Return matching list if it's a gene symbol. */
{
struct visiMatch *matchList = NULL, *match;
struct slInt *imageList, *image;
char *sqlPat = sqlLikeFromWild(symbol);
if (sqlWildcardIn(sqlPat))
imageList = visiGeneSelectNamed(conn, sqlPat, vgsLike);
else
imageList = visiGeneSelectNamed(conn, sqlPat, vgsExact);
for (image = imageList; image != NULL; image = image->next)
{
char asciiId[16];
safef(asciiId, sizeof(asciiId), "%d", image->val);
if (!isPrivate(conn, privateHash, asciiId))
{
AllocVar(match);
match->imageId = image->val;
slAddHead(&matchList, match);
}
}
slReverse(&matchList);
return matchList;
}
void checkOneDependency(struct joiner *joiner,
struct joinerDependency *dep, struct sqlConnection *conn, char *dbName)
/* Check out one dependency in one database. */
{
char *tableToCheck = dep->table->table;
if (sqlWildcardIn(tableToCheck))
{
errAbort("Can't handle wildCards in dependency tables line %d of %s",
dep->lineIx, joiner->fileName);
}
if (slNameInList(dep->table->dbList, dbName)
&& sqlTableExists(conn, tableToCheck))
{
time_t tableTime = sqlTableUpdateTime(conn, tableToCheck);
struct joinerTable *dependsOn;
for (dependsOn = dep->dependsOnList; dependsOn != NULL;
dependsOn = dependsOn->next)
{
if (slNameInList(dependsOn->dbList, dbName))
{
if (!sqlTableExists(conn, dependsOn->table))
{
warn("Error: %s.%s doesn't exist line %d of %s",
dbName, dependsOn->table,
dep->lineIx, joiner->fileName);
}
else
{
time_t depTime = sqlTableUpdateTime(conn, dependsOn->table);
if (depTime > tableTime)
{
char *depStr = sqlUnixTimeToDate(&depTime, FALSE);
char *tableStr = sqlUnixTimeToDate(&tableTime, FALSE);
warn("Error: %s.%s updated after %s.%s line %d of %s",
dbName, dependsOn->table, dbName, tableToCheck,
dep->lineIx, joiner->fileName);
warn("\t%s vs. %s", depStr, tableStr);
freeMem(depStr);
freeMem(tableStr);
}
}
}
}
}
}
static void visiGeneMatchGene(struct visiSearcher *searcher,
struct sqlConnection *conn, struct slName *wordList)
/* Add images matching genes in wordList to searcher.
* The wordList can include wildcards. */
{
struct slName *word;
int wordIx;
for (word = wordList, wordIx=0; word != NULL; word = word->next, ++wordIx)
{
char *sqlPat = sqlLikeFromWild(word->name);
struct slInt *imageList;
if (sqlWildcardIn(sqlPat))
imageList = visiGeneSelectNamed(conn, sqlPat, vgsLike);
else
imageList = visiGeneSelectNamed(conn, sqlPat, vgsExact);
addImageListAndFree(searcher, imageList, wordIx, 1);
freez(&sqlPat);
}
}
static void addTablesLike(struct hash *hash, struct sqlConnection *conn,
char *spec)
/* Add tables like spec to hash. */
{
if (sqlWildcardIn(spec))
{
struct sqlResult *sr;
char query[512], **row;
safef(query, sizeof(query),
"show tables like '%s'", spec);
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
hashAdd(hash, row[0], NULL);
sqlFreeResult(&sr);
}
else
{
hashAdd(hash, spec, NULL);
}
}
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);
}
}