static void handleStepLine(struct lineFile *lf, char *line, int firstWordSize,
boolean isVarStep, FILE *f)
/* Handle a line that starts with fixedStep or variableStep */
{
char *firstPair = skipLeadingSpaces(line + firstWordSize);
mustWrite(f, line, firstWordSize);
struct slPair *pair, *pairList = slPairFromString(firstPair);
boolean seenStep = FALSE, seenSpan = FALSE;
for (pair = pairList; pair != NULL; pair = pair->next)
{
if (gotStep && sameString(pair->name, "step"))
{
fprintf(f, " step=%d", step);
seenStep = TRUE;
}
else if (gotSpan && sameString(pair->name, "span"))
{
fprintf(f, " span=%d", span);
seenSpan = TRUE;
}
else
{
fprintf(f, " %s=%s", pair->name, (char *)pair->val);
}
}
if (gotStep && !seenStep)
{
if (isVarStep)
errAbort("%s isn't fixed step line %d, can't set step", lf->fileName, lf->lineIx);
fprintf(f, " step=%d", step);
}
if (gotSpan && !seenSpan)
fprintf(f, " span=%d", span);
fprintf(f, "\n");
}
static void checkOneSubGroups(char *compositeName,
struct trackDb *td, struct subGroupData *sgd)
{
char *subGroups = trackDbSetting(td, "subGroups");
verbose(2, " checkOne %s %s\n", compositeName, td->track);
if (subGroups && (sgd->nameHash == NULL))
{
errAbort("subTrack %s has groups not defined in parent %s\n",
td->track, compositeName);
}
else if (!subGroups && (sgd->nameHash != NULL))
{
errAbort("subtrack %s is missing subGroups defined in parent %s\n",
td->track, compositeName);
}
if (!subGroups && (sgd->nameHash == NULL))
return; /* nothing to do */
assert(sgd->nameHash != NULL);
struct slPair *slPair, *slPairList = slPairFromString(subGroups);
struct hash *foundHash = newHash(3);
for (slPair = slPairList; slPair; slPair = slPair->next)
{
struct hashEl *hel = hashLookup( sgd->nameHash, slPair->name);
if (hel == NULL)
errAbort("subtrack %s has subGroup (%s) not found in parent\n",
td->track, slPair->name);
struct hash *subHash = hel->val;
hashStore(foundHash, slPair->name);
if (hashLookup(subHash, slPair->val) == NULL)
{
errAbort("subtrack %s has subGroup (%s) with value (%s) not found in parent\n",
td->track, slPair->name, (char *)slPair->val);
}
}
struct hashCookie cookie = hashFirst(sgd->nameHash);
struct hashEl *hel;
while ((hel = hashNext(&cookie)) != NULL)
{
if (hashLookup(foundHash, hel->name) == NULL)
errAbort("subtrack %s is missing required subGroup %s\n",
td->track, hel->name);
}
}
void verticalSplitSqlTable(char *oldTab, char *oldAs, char *splitSpec, char *outDir)
/* verticalSplitSqlTable - Split a database table into two new related tables that share a field. */
{
struct asObject *as = asParseFile(oldAs);
if (as->next != NULL)
errAbort("%d records in %s, only 1 allowed\n", slCount(as), oldAs);
uglyf("Read %s from %s\n", as->name, oldAs);
/* Read fields from splitSpec, and make sure there are no extra. */
struct hash *ra = raReadSingle(splitSpec);
char *table1 = mustFindInSplitSpec("table1", ra, splitSpec);
char *fields1 = mustFindInSplitSpec("fields1", ra, splitSpec);
char *description1 = mustFindInSplitSpec("description1", ra, splitSpec);
char *table2 = mustFindInSplitSpec("table2", ra, splitSpec);
char *fields2 = mustFindInSplitSpec("fields2", ra, splitSpec);
char *description2 = mustFindInSplitSpec("description2", ra, splitSpec);
char *sharedKey = mustFindInSplitSpec("sharedKey", ra, splitSpec);
if (ra->elCount > 7)
errAbort("Extra fields in %s", splitSpec);
/* Convert this=that strings to lists of pairs. */
struct slPair *fieldList1 = slPairFromString(fields1);
struct slPair *fieldList2 = slPairFromString(fields2);
/* Do some more checks */
if (sameString(table1, table2))
errAbort("Error: table1 and table2 are the same (%s) in %s", table1, splitSpec);
checkSharedKeyInList(sharedKey, splitSpec, fields1, fieldList1);
checkSharedKeyInList(sharedKey, splitSpec, fields2, fieldList2);
struct asColumn *keyCol = asColumnFind(as, sharedKey);
if (keyCol == NULL)
errAbort("The sharedKey '%s' is not in %s", sharedKey, oldAs);
/* Make sure that all fields in splitSpec are actually in the oldAs file. */
checkFieldsInAs(fieldList1, splitSpec, as, oldAs);
checkFieldsInAs(fieldList2, splitSpec, as, oldAs);
/* Make sure that all old table fields are covered */
if (!partialOk)
{
struct hash *covered = hashNew(0);
struct slPair *field;
for (field = fieldList1; field != NULL; field = field->next)
hashAdd(covered, field->val, NULL);
for (field = fieldList2; field != NULL; field = field->next)
hashAdd(covered, field->val, NULL);
struct asColumn *col;
for (col = as->columnList; col != NULL; col = col->next)
{
if (!hashLookup(covered, col->name))
errAbort("Field %s in %s not output, use -partialOk flag if this is intentional",
col->name, oldAs);
}
}
/* Ok, input is checked, start on output.. */
if (lastChar(outDir) == '/')
trimLastChar(outDir);
makeDirsOnPath(outDir);
/* Output .as files. */
outputPartialAs(as, table1, fieldList1, description1, outDir);
outputPartialAs(as, table2, fieldList2, description2, outDir);
/* Output first split file - a straight up subset of columns. */
char path[PATH_LEN];
safef(path, sizeof(path), "%s/%s.tab", outDir, table1);
outputPartialTab(oldTab, as, fieldList1, path);
/* Output second split file */
char errPath[PATH_LEN];
safef(path, sizeof(path), "%s/%s.tab", outDir, table2);
safef(errPath, sizeof(path), "%s/mergeErrs.txt", outDir);
outputUniqueOnSharedKey(oldTab, as, keyCol, fieldList2, path, errPath);
}
