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); }