int main(int argc, char *argv[]) { char *snpDb = NULL; char *oldTableName = NULL; char *newTableName = NULL; if (argc != 4) usage(); snpDb = argv[1]; hSetDb(snpDb); oldTableName = argv[2]; newTableName = argv[3]; /* check that tables exist */ if (!hTableExists(oldTableName)) errAbort("no %s table in %s\n", oldTableName, snpDb); if (!hTableExists(newTableName)) errAbort("no %s table in %s\n", newTableName, snpDb); if (!hTableExists("ContigLoc")) errAbort("no ContigLoc table in %s\n", snpDb); if (!hTableExists("MapInfo")) errAbort("no MapInfo table in %s\n", snpDb); processSnps(oldTableName, newTableName); return 0; }
int main(int argc, char *argv[]) { char *db = NULL; char *bacTableName = NULL; char *cnpTableName = NULL; char fileName[64]; char liftFileName[64]; char logFileName[64]; struct hash *bacHash = NULL; if (argc != 7) usage(); db = argv[1]; bacTableName = argv[2]; cnpTableName = argv[3]; safef(fileName, ArraySize(fileName), "%s", argv[4]); safef(liftFileName, ArraySize(liftFileName), "%s", argv[5]); safef(logFileName, ArraySize(logFileName), "%s", argv[6]); /* process args */ hSetDb(db); if (!hTableExists(bacTableName)) errAbort("no %s table in %s\n", bacTableName, db); if (!hTableExists(cnpTableName)) errAbort("no %s table in %s\n", cnpTableName, db); bacHash = storeBacs(bacTableName); processCnps(bacHash, cnpTableName, fileName, liftFileName, logFileName); return 0; }
int main(int argc, char *argv[]) /* get hapmapOrtho table from overall snpOrtho table */ /* hash in contents of hapmap table */ { char *database = NULL; char *hapmapTableName = NULL; char *snpOrthoTableName = NULL; struct hash *hapmapHash = NULL; if (argc != 4) usage(); database = argv[1]; hapmapTableName = argv[2]; snpOrthoTableName = argv[3]; hSetDb(database); if (!hTableExists(hapmapTableName)) errAbort("no %s table in %s\n", hapmapTableName, database); if (!hTableExists(snpOrthoTableName)) errAbort("no %s table in %s\n", snpOrthoTableName, database); hapmapHash = storeHapmap(hapmapTableName); processSnps(snpOrthoTableName, hapmapHash); return 0; }
int main(int argc, char *argv[]) /* read snpTable, output deletions that pass input filtering */ { struct slName *chromList = NULL; if (argc != 4) usage(); database = argv[1]; hSetDb(database); snpTable = argv[2]; if (!hTableExists(snpTable)) errAbort("no %s table\n", snpTable); exceptionsTable = argv[3]; if (!hTableExists(exceptionsTable)) errAbort("no %s table\n", exceptionsTable); verbose(1, "loading exceptions...\n"); getExceptions(); chromList = hAllChromNames(); outputFileHandle = mustOpen("deletions.tab", "w"); getDeletions(); carefulClose(&outputFileHandle); return 0; }
int main(int argc, char *argv[]) /* work with singly aligning SNPs only */ /* load oldTable subset into list */ /* load newTable subset into hash */ { char *snpDb = NULL; struct weightList *oldTableList = NULL; struct hash *newTableHash = NULL; char *oldTableName = NULL; char *newTableName = NULL; if (argc != 4) usage(); oneToOne = 0; oneToTwo = 0; oneToThree = 0; twoToTwo = 0; twoToOne = 0; twoToThree = 0; threeToThree = 0; threeToOne = 0; threeToTwo = 0; snpDb = argv[1]; hSetDb(snpDb); oldTableName = argv[2]; newTableName = argv[3]; // check that tables exist if (!hTableExists(oldTableName)) errAbort("no %s table in %s\n", oldTableName, snpDb); if (!hTableExists(newTableName)) errAbort("no %s table in %s\n", newTableName, snpDb); oldTableList = getTableList(oldTableName); newTableHash = getTableHash(newTableName); logFileHandle = mustOpen("snpCompareWeightLog.out", "w"); processSnps(oldTableList, newTableHash); carefulClose(&logFileHandle); countFileHandle = mustOpen("snpCompareWeightCounts.out", "w"); fprintf(countFileHandle, "oneToOne = %d\n", oneToOne); fprintf(countFileHandle, "oneToTwo = %d\n", oneToTwo); fprintf(countFileHandle, "oneToThree = %d\n", oneToThree); fprintf(countFileHandle, "twoToTwo = %d\n", twoToTwo); fprintf(countFileHandle, "twoToOne = %d\n", twoToOne); fprintf(countFileHandle, "twoToThree = %d\n", twoToThree); fprintf(countFileHandle, "threeToThree = %d\n", threeToThree); fprintf(countFileHandle, "threeToOne = %d\n", threeToOne); fprintf(countFileHandle, "threeToTwo = %d\n", threeToTwo); carefulClose(&countFileHandle); return 0; }
struct psl *getParentAligns(struct sqlConnection *conn, struct mappingInfo *mi, char **table) { struct ucscRetroInfo *pg = mi->pg; struct psl *pslList = NULL; char query[512]; if (startsWith("August",mi->geneSet)) { if (hTableExists(database, "augustusXAli")) { *table = cloneString( "augustusXAli"); pslList = loadPslRangeT(*table, mi->seqId, pg->gChrom, pg->gStart, pg->gEnd); } else if (hTableExists(database, "augustusX")) { struct sqlResult *sr; char **row; int targetSize = 0; *table = cloneString( "augustusX"); sqlSafef(query, sizeof(query), "select * from augustusX where chrom = '%s' and txEnd > %d and txStart < %d and name like '%s%%'", pg->gChrom, pg->gStart, pg->gEnd , mi->seqId ); sr = sqlGetResult(conn, query); if ((row = sqlNextRow(sr)) != NULL) { struct genePred *gp = genePredLoad(row+1); sqlSafef(query, sizeof(query), "select size from chromInfo where chrom = '%s' " , gp->chrom); sqlFreeResult(&sr); targetSize = sqlNeedQuickNum(conn, query) ; pslList = pslFromGenePred(gp, targetSize); } } } else if (hTableExists(database, "all_mrna")) { char parent[255]; char *dotPtr ; *table = cloneString( "all_mrna"); safef(parent, sizeof(parent), "%s",pg->name); /* strip off version and unique suffix when looking for parent gene*/ dotPtr = rStringIn(".",parent) ; if (dotPtr != NULL) *dotPtr = '\0'; pslList = loadPslRangeT(*table, mi->gbAcc, pg->gChrom, pg->gStart, pg->gEnd); if (pslList == NULL) { *table = cloneString( "refSeqAli"); pslList = loadPslRangeT(*table, mi->gbAcc, pg->gChrom, pg->gStart, pg->gEnd); } } else printf("no all_mrna table found<br>\n"); return pslList; }
int main(int argc, char *argv[]) /* hash subsnp_class and var_str from UniVariation */ /* read SNP for univar_id, lookup into univarHash */ /* store univarHash elements in snpHash */ /* read through chrN_snpTmp, rewrite with extensions to individual chrom tables */ { struct slName *chromList, *chromPtr; char tableName[64]; if (argc != 2) usage(); snpDb = argv[1]; hSetDb(snpDb); /* check for necessary tables */ if(!hTableExistsDb(snpDb, "SNP")) errAbort("missing SNP table"); if(!hTableExistsDb(snpDb, "UniVariation")) errAbort("missing UniVariation table"); chromList = hAllChromNamesDb(snpDb); errorFileHandle = mustOpen("snpClassAndObserved.errors", "w"); univarHash = getUnivarHash(); snpHash = getSNPHash(); for (chromPtr = chromList; chromPtr != NULL; chromPtr = chromPtr->next) { safef(tableName, ArraySize(tableName), "%s_snpTmp", chromPtr->name); if (!hTableExists(tableName)) continue; verbose(1, "chrom = %s\n", chromPtr->name); processSnps(chromPtr->name); } carefulClose(&errorFileHandle); for (chromPtr = chromList; chromPtr != NULL; chromPtr = chromPtr->next) { safef(tableName, ArraySize(tableName), "%s_snpTmp", chromPtr->name); if (!hTableExists(tableName)) continue; recreateDatabaseTable(chromPtr->name); verbose(1, "loading chrom = %s\n", chromPtr->name); loadDatabase(chromPtr->name); } return 0; }
struct consWiggle *wigMafWiggles(char *db, struct trackDb *tdb) /* get conservation wiggle table names and labels from trackDb setting, ignoring those where table doesn't exist */ { char *fields[20]; int fieldCt; int i; char *wigTable, *wigLabel; struct consWiggle *wig, *wigList = NULL; char *setting = trackDbSetting(tdb, CONS_WIGGLE); if (!setting) return NULL; fieldCt = chopLine(cloneString(setting), fields); for (i = 0; i < fieldCt; i += 3) { wigTable = fields[i]; if (hTableExists(db, wigTable)); { AllocVar(wig); wig->table = cloneString(wigTable); wigLabel = (i+1 == fieldCt ? DEFAULT_CONS_LABEL : fields[i+1]); wig->leftLabel = cloneString(wigLabel); wigLabel = (i+2 >= fieldCt ? wig->leftLabel : fields[i+2]); wig->uiLabel = cloneString(wigLabel); slAddTail(&wigList, wig); } } return wigList; }
char* lookupName( struct sqlConnection *conn , char *id) { char *name = cloneString(id); char infoTable[128]; safef(infoTable, sizeof(infoTable), "%sInfo","bdgpGene"); if (hTableExists(infoTable)) { struct sqlConnection *conn = hAllocConn(); char *symbol = NULL; char *ptr = strchr(name, '-'); char query[256]; char buf[64]; if (ptr != NULL) *ptr = 0; safef(query, sizeof(query), "select symbol from %s where bdgpName = '%s';", infoTable, name); symbol = sqlQuickQuery(conn, query, buf, sizeof(buf)); hFreeConn(&conn); if (symbol != NULL) { char *ptr = stringIn("{}", symbol); if (ptr != NULL) *ptr = 0; freeMem(name); name = cloneString(symbol); } } return(name); }
Color gbGeneColor(struct track *tg, void *item, struct hvGfx *hvg) /* Return color to draw gene in. */ { struct sqlConnection *conn = hAllocConn(database); struct sqlResult *sr; char query[512]; struct bed *bed = item; struct COG *COG=NULL; char *temparray[160]; char **row; if(hTableExists(database, "COG")) { sprintf(query, "select * from COG where name = '%s'", bed->name); sr = sqlGetResult(conn, query); if ((row = sqlNextRow(sr)) != NULL) COG = COGLoad(row); sqlFreeResult(&sr); hFreeConn(&conn); initializeColors(hvg); if(COG!=NULL) { chopString(COG->code, "," , temparray, 9999); return LLshadesOfCOGS[(temparray[0][0]-'A')]; } else return blackIndex(); } else { hFreeConn(&conn); return blackIndex(); } slFreeList(&bed); }
int main(int argc, char *argv[]) /* read snpTable, generate skinny sequence for chrom */ { char fileName[64]; FILE *f; struct dnaSeq *skinnySeq = NULL; if (argc != 5) usage(); database = argv[1]; hSetDb(database); chromName = argv[2]; snpTable = argv[4]; if (!hTableExists(snpTable)) errAbort("no %s table\n", snpTable); skinnySeq = getSkinnySeq(argv[3], chromName); stripChar(skinnySeq->dna, '-'); safef(fileName, ArraySize(fileName), "%s.skinny", chromName); f = mustOpen(fileName, "w"); // faWriteNext(f, chromName, skinnySeq->dna, strlen(skinnySeq->dna)); fprintf(f, ">%s\n", chromName); writeSeqWithBreaks(f, skinnySeq->dna, strlen(skinnySeq->dna), 50); carefulClose(&f); return 0; }
void orTable(char *database, Bits *acc, char *track, char *chrom, int chromSize, struct sqlConnection *conn) /* Or in table if it exists. Else do nothing. */ { char t[512], *s; char table[HDB_MAX_TABLE_STRING]; isolateTrackPartOfSpec(track, t); s = strrchr(t, '.'); if (s != NULL) { orFile(acc, track, chrom, chromSize); } else { boolean hasBin; int minFeatureSize = optionInt("minFeatureSize", 0); boolean isSplit = hFindSplitTable(database, chrom, t, table, &hasBin); boolean isFound = hTableExists(database, table); verbose(3,"orTable: db: %s isFound: %s isSplit: %s %s %s %s\n", database, isFound ? "TRUE" : "FALSE", isSplit ? "TRUE" : "FALSE", chrom, t, table ); if (isFound) fbOrTableBitsQueryMinSize(database, acc, track, chrom, chromSize, conn, where, TRUE, TRUE, minFeatureSize); } }
static boolean mrnaDescriptionsExists(struct section *section, struct sqlConnection *conn, char *geneId) /* Return TRUE if mrna on this one. */ { struct psl *list = NULL; if (hTableExists(sqlGetDatabase(conn), "all_mrna")) { struct sqlResult *sr; char **row; struct psl *psl; int rowOffset; char extra[64]; safef(extra, sizeof(extra), "strand='%c'", curGenePred->strand[0]); sr = hRangeQuery(conn, "all_mrna", curGeneChrom, curGeneStart, curGeneEnd, extra, &rowOffset); while ((row = sqlNextRow(sr)) != NULL) { psl = pslLoad(row+rowOffset); slAddHead(&list, psl); } slReverse(&list); section->items = list; } return slCount(list) > 0; }
int main(int argc, char *argv[]) /* Check args and call seqCheck. */ { if (argc != 2) usage(); database = argv[1]; // check for table existence if (!hTableExists(database, "seq")) errAbort("no seq table"); if (!hTableExists(database, "extFile")) errAbort("no extFile table"); seqCheck(); return 0; }
int main(int argc, char *argv[]) /* read snpTable, report positions with more than annotation */ { if (argc != 3) usage(); database = argv[1]; hSetDb(database); snpTable = argv[2]; if (!hTableExists(snpTable)) errAbort("no %s table\n", snpTable); // chromList = hAllChromNames(); // outputFileHandle = mustOpen("snpCheckCluster2.out", "w"); // for (chromPtr = chromList; chromPtr != NULL; chromPtr = chromPtr->next) // { // verbose(1, "chrom = %s\n", chromPtr->name); // getBinKeeper(chromPtr->name); // checkForClusters(chromPtr->name); // } // carefulClose(&outputFileHandle); outputFileHandle = mustOpen("snpCheckCluster2.chr22", "w"); getBinKeeper("chr22"); checkForClusters("chr22"); carefulClose(&outputFileHandle); return 0; }
static void loadCytoBandsIdeo(struct track *tg) /* Load up cytoBandIdeo from database table to track items. */ { if (tg->isBigBed) { struct lm *lm = lmInit(0); int start = 0; int end = hChromSize(database, chromName); struct bigBedInterval *bb, *bbList = bigBedSelectRange(tg, chromName, start, end, lm); char *bedRow[32]; char startBuf[16], endBuf[16]; for (bb = bbList; bb != NULL; bb = bb->next) { bigBedIntervalToRow(bb, chromName, startBuf, endBuf, bedRow, ArraySize(bedRow)); struct cytoBand *bed = cytoBandLoad(bedRow); slAddHead(&tg->items, bed); } slReverse(&tg->items); lmCleanup(&lm); return; } char query[256]; sqlSafef(query, sizeof(query), "select * from cytoBandIdeo where chrom like '%s'", chromName); if(hTableExists(database, "cytoBandIdeo")) bedLoadItemByQuery(tg, "cytoBandIdeo", query, (ItemLoader)cytoBandLoad); if(slCount(tg->items) == 0) { tg->limitedVisSet = TRUE; tg->limitedVis = tvHide; } }
int main(int argc, char *argv[]) /* read chrN_snpTmp, lookup in snpFasta, rewrite to individual chrom tables */ { struct slName *chromList, *chromPtr; char tableName[64]; if (argc != 2) usage(); snpDb = argv[1]; hSetDb(snpDb); chromList = hAllChromNamesDb(snpDb); if (chromList == NULL) { verbose(1, "couldn't get chrom info\n"); return 1; } errorFileHandle = mustOpen("snpSNP.errors", "w"); /* read into global hash */ verbose(1, "reading SNP table into hash...\n"); readSNP(); for (chromPtr = chromList; chromPtr != NULL; chromPtr = chromPtr->next) { safef(tableName, ArraySize(tableName), "%s_snpTmp", chromPtr->name); if (!hTableExists(tableName)) continue; verbose(1, "processing chrom = %s\n", chromPtr->name); processSnps(chromPtr->name); } carefulClose(&errorFileHandle); for (chromPtr = chromList; chromPtr != NULL; chromPtr = chromPtr->next) { safef(tableName, ArraySize(tableName), "%s_snpTmp", chromPtr->name); if (!hTableExists(tableName)) continue; recreateDatabaseTable(chromPtr->name); verbose(1, "loading chrom = %s\n", chromPtr->name); loadDatabase(chromPtr->name); } return 0; }
int main(int argc, char *argv[]) /* Read chromInfo into hash. */ /* Read ContigLocusIdCondense into hash. */ /* Recreate chrN_snpTmp, adding fxn_classes. */ { struct slName *chromList, *chromPtr; char tableName[64]; if (argc != 2) usage(); snpDb = argv[1]; hSetDb(snpDb); chromList = hAllChromNamesDb(snpDb); /* check for needed tables */ if(!hTableExistsDb(snpDb, "ContigLocusIdCondense")) errAbort("no ContigLocusIdCondense table in %s\n", snpDb); if(!hTableExistsDb(snpDb, "chromInfo")) errAbort("no chromInfo table in %s\n", snpDb); functionHash = createFunctionHash(); for (chromPtr = chromList; chromPtr != NULL; chromPtr = chromPtr->next) { safef(tableName, ArraySize(tableName), "%s_snpTmp", chromPtr->name); if (!hTableExists(tableName)) continue; verbose(1, "chrom = %s\n", chromPtr->name); addFunction(chromPtr->name); } for (chromPtr = chromList; chromPtr != NULL; chromPtr = chromPtr->next) { safef(tableName, ArraySize(tableName), "%s_snpTmp", chromPtr->name); if (!hTableExists(tableName)) continue; verbose(1, "loading chrom = %s\n", chromPtr->name); recreateDatabaseTable(chromPtr->name); loadDatabase(chromPtr->name); } return 0; }
void doFlyreg(struct trackDb *tdb, char *item) /* flyreg.org: Drosophila DNase I Footprint db. */ { struct dyString *query = newDyString(256); struct sqlConnection *conn = hAllocConn(database); struct sqlResult *sr = NULL; char **row; int start = cartInt(cart, "o"); int end = cartInt(cart, "t"); char fullTable[HDB_MAX_TABLE_STRING]; boolean hasBin = FALSE; char *motifTable = "flyregMotif"; struct dnaMotif *motif = NULL; boolean isVersion2 = sameString(tdb->table, "flyreg2"); genericHeader(tdb, item); if (!hFindSplitTable(database, seqName, tdb->table, fullTable, sizeof fullTable, &hasBin)) errAbort("track %s not found", tdb->table); sqlDyStringPrintf(query, "select * from %s where chrom = '%s' and ", fullTable, seqName); hAddBinToQuery(start, end, query); sqlDyStringPrintf(query, "chromStart = %d and name = '%s'", start, item); sr = sqlGetResult(conn, query->string); if ((row = sqlNextRow(sr)) != NULL) { struct flyreg2 fr; if (isVersion2) flyreg2StaticLoad(row+hasBin, &fr); else flyregStaticLoad(row+hasBin, (struct flyreg *)(&fr)); printf("<B>Factor:</B> %s<BR>\n", fr.name); printf("<B>Target:</B> %s<BR>\n", fr.target); if (isVersion2) printf("<B>Footprint ID:</B> %06d<BR>\n", fr.fpid); printf("<B>PubMed ID:</B> <A HREF=\""); printEntrezPubMedUidUrl(stdout, fr.pmid); printf("\" TARGET=_BLANK>%d</A><BR>\n", fr.pmid); bedPrintPos((struct bed *)(&fr), 3, tdb); if (hTableExists(database, motifTable)) { motif = loadDnaMotif(item, motifTable); if (motif != NULL) motifHitSection(NULL, motif); } } else errAbort("query returned no results: \"%s\"", query->string); dyStringFree(&query); sqlFreeResult(&sr); hFreeConn(&conn); if (motif != NULL) webNewSection("%s",tdb->longLabel); printTrackHtml(tdb); }
int main(int argc, char *argv[]) { char *snpDb = NULL; char *snpTableName = NULL; struct hashCookie cookie; char *chromName = NULL; if (argc != 3) usage(); snpDb = argv[1]; hSetDb(snpDb); snpTableName = argv[2]; /* check that tables exist */ if (!hTableExists(snpTableName)) errAbort("no %s table in %s\n", snpTableName, snpDb); if (!hTableExists("chromInfo")) errAbort("no chromInfo table in %s\n", snpDb); loadChroms(); getSnps(snpTableName); verbose(1, "creating tables...\n"); cookie = hashFirst(chromHash); while ((chromName = hashNextName(&cookie)) != NULL) createTable(chromName); verbose(1, "loading database...\n"); cookie = hashFirst(chromHash); while ((chromName = hashNextName(&cookie)) != NULL) { verbose(1, "chrom = %s\n", chromName); loadDatabase(chromName); } return 0; }
char *getRetroParentSymbol(struct ucscRetroInfo *r, char *parentName) { struct sqlConnection *conn = hAllocConn(database); char cond_str[512]; char *geneSymbol = NULL; if (r != NULL) { if (hTableExists(database, "kgXref") ) { sqlSafefFrag(cond_str, sizeof(cond_str), "kgID='%s'", parentName); geneSymbol = sqlGetField(database, "kgXref", "geneSymbol", cond_str); } if (hTableExists(database, "refLink") ) { sqlSafefFrag(cond_str, sizeof(cond_str), "mrnaAcc = '%s'", r->refSeq); geneSymbol = sqlGetField(database, "refLink", "name", cond_str); } } hFreeConn(&conn); return geneSymbol; }
int main(int argc, char *argv[]) /* hash snpFasta, read through chrN_snpTmp, rewrite with extensions to individual chrom tables */ { struct slName *chromList, *chromPtr; char tableName[64]; if (argc != 2) usage(); snpDb = argv[1]; hSetDb(snpDb); chromList = hAllChromNamesDb(snpDb); errorFileHandle = mustOpen("snpMoltype.errors", "w"); multiFastaHash = readFasta("chrMulti"); for (chromPtr = chromList; chromPtr != NULL; chromPtr = chromPtr->next) { safef(tableName, ArraySize(tableName), "%s_snpTmp", chromPtr->name); if (!hTableExists(tableName)) continue; verbose(1, "chrom = %s\n", chromPtr->name); chromFastaHash = readFasta(chromPtr->name); processSnps(chromPtr->name); } carefulClose(&errorFileHandle); for (chromPtr = chromList; chromPtr != NULL; chromPtr = chromPtr->next) { safef(tableName, ArraySize(tableName), "%s_snpTmp", chromPtr->name); if (!hTableExists(tableName)) continue; recreateDatabaseTable(chromPtr->name); verbose(1, "loading chrom = %s\n", chromPtr->name); loadDatabase(chromPtr->name); } return 0; }
static void pgSnpCodingDetail(struct vcfRecord *rec) /* Translate rec into pgSnp (with proper chrom name) and call Belinda's * coding effect predictor from pgSnp details. */ { char *genePredTable = "knownGene"; if (hTableExists(database, genePredTable)) { struct pgSnp *pgs = pgSnpFromVcfRecord(rec); if (!sameString(rec->chrom, seqName)) // rec->chrom might be missing "chr" prefix: pgs->chrom = seqName; printSeqCodDisplay(database, pgs, genePredTable); } }
static void loadCytoBandsIdeo(struct track *tg) /* Load up cytoBandIdeo from database table to track items. */ { char query[256]; sqlSafef(query, sizeof(query), "select * from cytoBandIdeo where chrom like '%s'", chromName); if(hTableExists(database, "cytoBandIdeo")) bedLoadItemByQuery(tg, "cytoBandIdeo", query, (ItemLoader)cytoBandLoad); if(slCount(tg->items) == 0) { tg->limitedVisSet = TRUE; tg->limitedVis = tvHide; } }
float aveSScoreForRegion(char *db, char *chrom, int chromStart, int chromEnd) { float currentSum = 0; int count = 0; float ave = 0; int sPos = 0; struct sample *sList=NULL, *s = NULL; char *tableName = optionVal("sampleTable", "hg15Mm3L"); struct sqlConnection *conn = hAllocConn(db); struct sqlResult *sr=NULL; char **row; char buff[256]; int rowOffset=0; safef(buff,sizeof(buff),"%s_%s",chrom, tableName); if(hTableExists(db, buff)) { sr = hRangeQuery(conn, tableName, chrom, chromStart, chromEnd, NULL, &rowOffset); while ((row = sqlNextRow(sr)) != NULL) { s = sampleLoad(row + rowOffset); slAddHead(&sList, s); } for(s = sList; s != NULL; s = s->next) { int i=0; for(i=0; i<s->sampleCount; i++) { sPos = s->chromStart + s->samplePosition[i]; if(sPos >= chromStart && sPos <= chromEnd) { currentSum += ((float) s->sampleHeight[i]) / 1000 * 8.0; count++; } } } sqlFreeResult(&sr); slFreeList(&sList); } hFreeConn(&conn); if(count > 0) ave = currentSum / count; else ave = -1; return ave; }
static void displayRetroDetails(struct sqlConnection *conn, struct mappingInfo *mi) /* display information from a retroXXXInfo table */ { struct ucscRetroInfo *pg = mi->pg; char query[256]; char orthoTable[128]; char orgDb[128]; char *org; if (mi->suffix != NULL && strlen(mi->suffix) > 0) safef(orthoTable, sizeof(orthoTable), "%s%sOrtho%s", mi->tblPre, mi->geneSet, mi->suffix); else safef(orthoTable, sizeof(orthoTable), "%s%sOrtho", mi->tblPre, mi->geneSet); printf("<TABLE class=\"transMap\">\n"); printf("<H3><A HREF=\"#orthology\">Break in Orthology:</A></H3>\n"); printf("<THEAD>\n"); printf("<TR><TH>Organism<TH>Score</TR>\n"); printf("</THEAD><TBODY>\n"); if (hTableExists(database, orthoTable)) { struct sqlResult *sr; char **row; sqlSafef(query, sizeof(query), "select * from %s where name = '%s' ", orthoTable, pg->name); sr = sqlGetResult(conn, query); while ((row = sqlNextRow(sr)) != NULL) { struct ucscRetroOrtho *puro = ucscRetroOrthoLoad(row); /* get substring after "net" prefix and convert first char to lower case then get organism name */ safecpy(orgDb, sizeof(orgDb), puro->db+3); orgDb[0] = tolower(orgDb[0]); org = hOrganism(orgDb); printf("<TR><TH>%s (%s) ", org, orgDb); printf("<TD>%d</TR>\n", puro->overlap); } sqlFreeResult(&sr); } else printf("<TR><TH>table %s not found </TR>", orthoTable); printf("</TBODY></TABLE>\n"); }
static struct slName *hgFindSpecNameList(char *db) /* Return the hgFindSpec table name(s) to use (based on trackDb name). */ { struct slName *trackDbList = hTrackDbList(); struct slName *specNameList = NULL; struct slName *tdbName; for (tdbName = trackDbList; tdbName != NULL; tdbName = tdbName->next) { char *subbed = replaceChars(tdbName->name, "trackDb", "hgFindSpec"); if (hTableExists(db, subbed)) slNameAddHead(&specNameList, subbed); freez(&subbed); } if (!specNameList) specNameList = slNameNew("hgFindSpec"); else slReverse(&specNameList); return specNameList; }
struct trackVersion *getTrackVersion(char *database, char *track) // Get most recent trackVersion for given track in given database { boolean trackVersionExists = !trackHubDatabase(database) && hTableExists("hgFixed", "trackVersion"); struct trackVersion *trackVersion = NULL; if (trackVersionExists) { char query[256]; struct sqlConnection *conn = hAllocConn(database); sqlSafef(query, sizeof(query), "select * from hgFixed.trackVersion where db = '%s' AND name = '%s' order by ix DESC limit 1", database, track); struct sqlResult *sr = sqlGetResult(conn, query); char **row; if ((row = sqlNextRow(sr)) != NULL) trackVersion = trackVersionLoad(row); sqlFreeResult(&sr); hFreeConn(&conn); } return trackVersion; }
char *getSwiss( struct sqlConnection *conn , char *id) { char *name = cloneString(id); char infoTable[128]; safef(infoTable, sizeof(infoTable), "sgdToSwissProt"); if (hTableExists(infoTable)) { struct sqlConnection *conn = hAllocConn(); char *symbol = NULL; //char *ptr = strchr(name, '-'); char query[256]; char buf[64]; //if (ptr != NULL) // *ptr = 0; sqlSafef(query, sizeof(query), "select value from %s where name = '%s';", infoTable, name); if ((symbol = sqlQuickQuery(conn, query, buf, sizeof(buf))) != NULL) name = symbol; hFreeConn(&conn); } return(name); }
int main(int argc, char *argv[]) { if (argc != 3) usage(); db = argv[1]; hSetDb(db); if (!hTableExists(argv[2])) { verbose(1, "can't find table %s\n", argv[2]); return 1; } errorFileHandle = mustOpen("hapmapValidate.error", "w"); complexFileHandle = mustOpen("hapmapValidate.complex", "w"); dynamicObserved = newDyString(32); hapmapValidate(argv[2]); carefulClose(&errorFileHandle); carefulClose(&complexFileHandle); return 0; }