static void adjustSqlTableColumns(struct sqlConnection *conn, char *tableName, int bedSize)
/* Go through and drop columns to fit the file it the -trimSqlTable option is used. */
/* Otherwise the data is unloadable. */
{
struct slName *fieldNames = sqlFieldNames(conn, tableName);
int numFields = slCount(fieldNames);
if (! noBin)
numFields--; // subtract bin column if sql includes it
if (numFields != bedSize)
{
struct slName *oneName;
int i;
int start = 0;
if (!trimSqlTable || (bedSize > numFields))
errAbort(".sql table has wrong number of columns in the definition. Try -trimSqlTable");
slReverse(&fieldNames);
if (bedDetail)
{
fieldNames = fieldNames->next; /* skip description */
fieldNames = fieldNames->next; /* skip id */
}
for (oneName = fieldNames, i = start; (i < numFields - bedSize)
&& (oneName != NULL); i++, oneName = oneName->next)
{
char query[256];
safef(query, sizeof(query), "alter table %s drop column %s", tableName, oneName->name);
sqlUpdate(conn, query);
}
}
slFreeList(&fieldNames);
}
int encodePeakNumFields(char *db, char *trackName)
/* Just quickly count th number of fields. */
{
struct sqlConnection *conn = hAllocConn(db);
struct slName *fieldNames = sqlFieldNames(conn, trackName);
int numFields = slCount(fieldNames);
hFreeConn(&conn);
if (sameString(fieldNames->name, "bin"))
numFields--;
slFreeList(&fieldNames);
return numFields;
}
void checkFilename(struct sqlConnection *conn, char *table, struct hash *allBbiNames)
{
char buffer[10 * 1024];
char fileName[10 * 1024];
char oldSymlink[10 * 1024];
verbose(2, "checking for fileName field in table %s \n", table);
// see if this is even a bbi table
boolean bbiTable = FALSE;
struct slName *fnames = sqlFieldNames(conn, table);
if ((slCount(fnames) == 1) && (sameString(fnames->name, "fileName")))
bbiTable = TRUE;
slFreeList(&fnames);
if (!bbiTable)
return;
sqlSafef(buffer, sizeof buffer, "select fileName from %s limit 1", table);
if (sqlQuickQuery(conn, buffer, fileName, sizeof fileName) != NULL)
{
while(1) // loop to catch .bai as well as .bam
{
hashAdd(allBbiNames, fileName, NULL);
verbose(2,"got table.fileName %s\n", fileName);
// file exists
FILE *f = fopen(fileName, "r");
if (f == NULL)
{
warn("fileName %s from table %s can't be opened", fileName, table);
return;
}
else
fclose(f);
// check that the filename and object base match
char *base = strrchr(fileName, '/');
if (base == NULL)
{
warn("fileName %s in table %s not absolute path", fileName, table);
return;
}
else
{
base++;
char *dot = strchr(base, '.');
if (dot == NULL)
{
warn("fileName %s in table %s does not have suffix", fileName, table);
return;
}
else
{
char saveChar = *dot;
*dot = 0;
if (!sameString(table, base))
{
warn("fileName %s doesn't match table %s", base, table);
return;
}
*dot = saveChar;
}
}
// this file is really a symlink, so check its link target
ssize_t bufRead = readlink(fileName, oldSymlink, sizeof oldSymlink);
if (bufRead == -1)
{
errnoWarn("error reading symlink %s", fileName);
return;
}
else
{
oldSymlink[bufRead] = 0; // needs termination.
if (!fileExists(oldSymlink))
{
warn("symlink target %s does not exist!", oldSymlink);
return;
}
else
verbose(2,"got symlink %s\n", oldSymlink);
}
// check that the symlink and object base match
base = strrchr(oldSymlink, '/');
if (base == NULL)
{
warn("symlink %s in fileName %s not absolute path",oldSymlink, fileName);
return;
}
else
{
base++;
char *dot = strchr(base, '.');
if (dot == NULL)
{
warn("symlink %s in fileName %s does not have suffix", oldSymlink, fileName);
return;
}
else
{
char saveChar = *dot;
*dot = 0;
if (!sameString(table, base))
{
warn("symlink %s doesn't match table %s", base, table);
return;
}
*dot = saveChar;
}
}
/* Note "fileIndex" for .bai has been made obsolete
so we'll just hard-wire in the .bai support */
if (!endsWith(fileName, ".bam"))
break;
safecat(fileName, sizeof(fileName), ".bai");
}
}
}
void findToFixBedGraphLimits(char *input, char *output)
/* findToFixBedGraphLimits - Scan through ra file of bedGraphs and calculate limits.. */
{
struct lineFile *lf = lineFileOpen(input, TRUE);
FILE *f = mustOpen(output, "w");
struct slPair *el, *list;
while ((list = raNextRecordAsSlPairList(lf)) != NULL)
{
/* Find required fields for calcs. */
char *db = mustFindVal(list, "db", lf);
char *track = mustFindVal(list, "track", lf);
char *type = cloneString(mustFindVal(list, "type", lf));
/* Parse out type value, which should be "bedGraph 4" and put the 4 or whatever other number
* in dataFieldIndex. */
char *typeWords[3];
int typeWordCount = chopLine(type, typeWords);
if (typeWordCount != 2 || !sameString(typeWords[0], "bedGraph"))
errAbort("Not well formed bedGraph type line %d of %s", lf->lineIx, lf->fileName);
int dataFieldIndex = sqlUnsigned(typeWords[1]);
/* Figure out field corresponding to dataFieldIndex. */
struct sqlConnection *conn = sqlConnect(db);
struct slName *fieldList = sqlFieldNames(conn, track);
struct slName *pastBin = fieldList;
if (sameString(pastBin->name, "bin"))
pastBin = pastBin->next;
struct slName *fieldName = slElementFromIx(pastBin, dataFieldIndex - 1);
if (fieldName == NULL)
errAbort("%s doesn't have enough fields", track);
char *field = fieldName->name;
assert(sqlFieldIndex(conn, track, field) >= 0);
/* Print reassuring status message */
verbose(1, "%s.%s has %d elements. Data field is %s\n", db, track, sqlTableSize(conn, track), field);
/* Get min/max dataValues in fields. Do it ourselves rather than using SQL min/max because sometimes
* the data field is a name column.... */
char query[512];
safef(query, sizeof(query), "select %s from %s", field, track);
struct sqlResult *sr = sqlGetResult(conn, query);
char **row;
row = sqlNextRow(sr);
assert(row != NULL);
double val = sqlDouble(row[0]);
double minLimit = val, maxLimit = val;
while ((row = sqlNextRow(sr)) != 0)
{
double val = sqlDouble(row[0]);
if (val < minLimit) minLimit = val;
if (val > maxLimit) maxLimit = val;
}
sqlFreeResult(&sr);
verbose(1, " %g %g\n", minLimit, maxLimit);
/* Output original table plus new minLimit/maxLimit. */
for (el = list; el != NULL; el = el->next)
fprintf(f, "%s %s\n", el->name, (char *)el->val);
fprintf(f, "minLimit %g\n", minLimit);
fprintf(f, "maxLimit %g\n", maxLimit);
fprintf(f, "\n");
sqlDisconnect(&conn);
slFreeList(&fieldList);
slPairFreeValsAndList(&list);
}
lineFileClose(&lf);
carefulClose(&f);
}
