struct genePred *getPredsFromBeds(char *file, char *table, char *db)
{
struct sqlConnection *conn = hAllocConn(db);
struct lineFile *lf = lineFileOpen(file, TRUE);
char *words[5000];
int wordsRead;
struct genePred *list = NULL;
while( (wordsRead = lineFileChopNext(lf, words, sizeof(words)/sizeof(char *)) ))
{
if (wordsRead != 4)
errAbort("file '%s' must be bed4. Line %d has %d fields",
file, lf->lineIx, wordsRead);
char where[10 * 1024];
sqlSafefFrag(where, sizeof where,
"name = '%s' and chrom='%s' and txStart = %d and txEnd = %d",
words[3], words[0], sqlUnsigned(words[1]), sqlUnsigned(words[2]));
//printf("table %s where %s\n",table,where);
struct genePredReader *reader = genePredReaderQuery( conn, table, where);
struct genePred *pred;
while ((pred = genePredReaderNext(reader)) != NULL)
slAddHead(&list, pred);
genePredReaderFree(&reader);
}
hFreeConn(&conn);
if (list != NULL)
slReverse(&list);
return list;
}
void getChromSizes(char *database, struct hash **retHash,
struct chromSizes **retList)
/* Return hash of chromSizes. Also calculates size without
* gaps. */
{
struct sqlConnection *conn = hAllocConn(database);
struct chromInfo *ci, *ciList = getAllChromInfo(database);
struct sqlResult *sr;
char **row;
struct chromSizes *cs, *csList = NULL;
struct hash *hash = newHash(8);
int rowOffset;
for (ci = ciList; ci != NULL; ci = ci->next)
{
AllocVar(cs);
hashAddSaveName(hash, ci->chrom, cs, &cs->name);
slAddHead(&csList, cs);
cs->totalSize = ci->size;
sr = hChromQuery(conn, "gold", ci->chrom, NULL, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
struct agpFrag frag;
agpFragStaticLoad(row + rowOffset, &frag);
cs->seqSize += frag.chromEnd - frag.chromStart;
}
sqlFreeResult(&sr);
}
hFreeConn(&conn);
slReverse(&csList);
*retHash = hash;
*retList = csList;
}
void loadDatabase()
{
struct sqlConnection *conn = hAllocConn();
FILE *f = mustOpen("ContigLocusIdCondense.tab", "r");
hgLoadTabFile(conn, ".", "ContigLocusIdCondense", &f);
hFreeConn(&conn);
}
void lfRetroGene(struct track *tg)
/* Load the items in one custom track - just move beds in
* window... */
{
struct linkedFeatures *lfList = NULL, *lf;
struct ucscRetroInfo *pg = NULL, *list = NULL;
struct sqlConnection *conn = hAllocConn(database);
struct sqlResult *sr;
char **row;
int rowOffset;
int colCount ;
sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd, NULL, &rowOffset);
colCount = sqlCountColumns(sr);
while ((row = sqlNextRow(sr)) != NULL)
{
//if (colCount == 56)
// pg = retroMrnaInfo56Load(row+rowOffset);
//else
pg = ucscRetroInfoLoad(row+rowOffset);
slAddHead(&list, pg);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
for (pg = list; pg != NULL; pg = pg->next)
{
lf = lfFromRetroGene(pg);
lf->grayIx = 9;
slReverse(&lf->components);
slAddHead(&lfList,lf);
}
tg->items = lfList;
}
struct hash *storeBacs(char *tableName)
/* store BAC coords in a hash */
{
struct hash *ret = NULL;
char query[512];
struct sqlConnection *conn = hAllocConn();
struct sqlResult *sr;
char **row;
struct coords *cel = NULL;
verbose(1, "creating BAC hash...\n");
ret = newHash(0);
sqlSafef(query, sizeof(query),
"select name, chrom, chromStart, chromEnd from %s", tableName);
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
AllocVar(cel);
cel->chrom = cloneString(row[1]);
cel->start = sqlUnsigned(row[2]);
cel->end = sqlUnsigned(row[3]);
hashAdd(ret, cloneString(row[0]), cel);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
return ret;
}
void createSnpHash(char *snpTable)
/* load the snps into global snpHash */
{
char query[512];
struct sqlConnection *conn = hAllocConn();
struct sqlResult *sr;
char **row;
struct coords *coordsInstance = NULL;
int count = 0;
snpHash = newHash(0);
safef(query, sizeof(query), "select chrom, chromStart, chromEnd, name from %s", snpTable);
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
count++;
AllocVar(coordsInstance);
coordsInstance->chrom = cloneString(row[0]);
coordsInstance->start = sqlUnsigned(row[1]);
coordsInstance->end = sqlUnsigned(row[2]);
hashAdd(snpHash, cloneString(row[3]), coordsInstance);
}
verbose(1, "%d elements in snpHash\n", count);
sqlFreeResult(&sr);
hFreeConn(&conn);
}
struct hash *readFasta(char *chromName)
/* read moltype from chrN_fasta into hash. */
/* Read again for random */
/* Also called to create the chrN_multi hash. */
{
char query[512];
struct sqlConnection *conn = hAllocConn();
struct sqlResult *sr;
char **row;
char fastaTableName[64];
struct hash *newChromHash = NULL;
char *adjustedChromName = cloneString(chromName);
char *randomSubstring = NULL;
newChromHash = newHash(0);
randomSubstring = strstr(chromName, "random");
if (randomSubstring != NULL)
stripString(adjustedChromName, "_random");
safef(fastaTableName, ArraySize(fastaTableName), "%s_snpFasta", adjustedChromName);
if(!hTableExistsDb(snpDb, fastaTableName))
errAbort("can't get table %s\n", fastaTableName);
safef(query, sizeof(query), "select rsId, molType from %s", fastaTableName);
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
/* could check for duplicates here */
hashAdd(newChromHash, cloneString(row[0]), cloneString(row[1]));
sqlFreeResult(&sr);
hFreeConn(&conn);
return newChromHash;
}
void fakeChromLinkage(char *database, char *chrom, FILE *f)
/* Generate fake linkage data for one chromosome */
{
int size = hdbChromSize(database, chrom);
int stepSize = 5000000;
int pos;
uglyf("faking %s %d\n", chrom, size);
struct sqlConnection *conn = hAllocConn();
for (pos=0; pos<size; pos += stepSize)
{
int rowOffset = 0;
char query[512];
sqlSafef(query, sizeof(query), "select name from stsMap where chrom='%s' and chromStart >= %d && chromStart < %d", chrom, pos, pos+stepSize);
struct sqlResult *sr = sqlGetResult(conn, query);
char **row = sqlNextRow(sr);
if (row != NULL)
{
double x;
if (rand()%250 == 0)
{
x = 3.5 + (double)rand()/RAND_MAX;
}
else
{
x = (double)rand() / RAND_MAX + 0.001;
x = log(x) + 1;
if (x < -1)
x = -1;
}
fprintf(f, "%s\t%f\n", row[0], x);
}
sqlFreeResult(&sr);
}
hFreeConn(&conn);
}
void getExceptions()
{
char query[512];
struct sqlConnection *conn = hAllocConn();
struct sqlResult *sr;
char **row;
int start = 0;
int end = 0;
sqlSafef(query, sizeof(query), "select * from snp126Exceptions where chrom = 'chrX' and chromEnd < 2709520");
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
fprintf(exceptionFileHandle, "chrY\t%s\t%s\t%s\t%s\n", row[1], row[2], row[3], row[4]);
sqlFreeResult(&sr);
sqlSafef(query, sizeof(query), "select * from snp126Exceptions where chrom = 'chrX' and chromEnd > 154584237");
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
start = sqlUnsigned(row[1]);
end = sqlUnsigned(row[2]);
start = start - 97140800;
end = end - 97140800;
fprintf(exceptionFileHandle, "chrY\t%d\t%d\t%s\t%s\n", start, end, row[3], row[4]);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
}
struct hash *loadContigs(char *contigGroup)
/* hash all ctg IDs that match contigGroup */
{
struct hash *ret;
char query[512];
struct sqlConnection *conn = hAllocConn();
struct sqlResult *sr;
char **row;
int count = 0;
ret = newHash(0);
verbose(1, "getting contigs...\n");
sqlSafef(query, sizeof(query), "select contig_acc, group_term from ContigInfo");
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
if (!sameString(row[1], contigGroup)) continue;
hashAdd(ret, cloneString(row[0]), NULL);
count++;
}
sqlFreeResult(&sr);
hFreeConn(&conn);
verbose(1, "contigs found = %d\n", count);
return ret;
}
void filterSNPs()
/* read all rows, relevant columns of ContigLocusId into memory. */
/* Write out rows where ctg_id is in our hash. */
{
char query[512];
struct sqlConnection *conn = hAllocConn();
struct sqlResult *sr;
char **row;
struct hashEl *el1;
FILE *f;
f = hgCreateTabFile(".", "ContigLocusIdFilter");
sqlSafef(query, sizeof(query), "select snp_id, contig_acc, fxn_class, mrna_acc, protein_acc from ContigLocusId");
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
el1 = hashLookup(contigHash,row[1]);
if (el1 != NULL)
{
fprintf(f, "%s\t%s\t%s\t%s\t%s\n", row[0], row[1], row[2], row[3], row[4]);
}
}
sqlFreeResult(&sr);
hFreeConn(&conn);
carefulClose(&f);
}
void readSnps()
/* put all coords in coordHash */
{
char query[512];
struct sqlConnection *conn = hAllocConn();
struct sqlResult *sr;
char **row;
struct hashEl *helCoord, *helName = NULL;
struct coords *cel = NULL;
coordHash = newHash(18);
verbose(1, "creating hash...\n");
safef(query, sizeof(query), "select name, chrom, chromStart, chromEnd from snp125");
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
/* store all coords */
AllocVar(cel);
cel->chrom = cloneString(row[1]);
cel->start = sqlUnsigned(row[2]);
cel->end = sqlUnsigned(row[3]);
hashAdd(coordHash, cloneString(row[0]), cel);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
}
static void showTableFieldsCt(char *db, char *table, boolean withGetButton)
/* Put up html table with a check box for each field of custom
* track. */
{
struct customTrack *ct = ctLookupName(table);
char *type = ct->dbTrackType;
if (type == NULL)
type = ct->tdb->type;
struct sqlConnection *conn = hAllocConn(CUSTOM_TRASH);
struct asObject *asObj = asForTdb(conn, ct->tdb);
if (asObj)
{
struct slName *fieldList = NULL;
if (ct->dbTableName != NULL)
{
if (isVcfTable(table, NULL))
fieldList = vcfGetFields();
else
fieldList = sqlListFields(conn, ct->dbTableName);
}
if (fieldList == NULL)
fieldList = asColNames(asObj);
showTableFieldsOnList(db, table, asObj, fieldList, FALSE, withGetButton);
asObjectFree(&asObj);
slNameFreeList(&fieldList);
}
else
showBedTableFields(db, table, ct->fieldCount, withGetButton);
hFreeConn(&conn);
}
static void showTableFieldsDb(char *db, char *rootTable, boolean withGetButton)
/* Put up a little html table with a check box, name, and hopefully
* a description for each field in SQL rootTable. */
{
struct sqlConnection *conn = NULL;
if (!trackHubDatabase(database))
conn = hAllocConn(db);
struct trackDb *tdb = findTdbForTable(db, curTrack, rootTable, ctLookupName);
struct asObject *asObj = asForTable(conn, rootTable);
boolean showItemRgb = FALSE;
showItemRgb=bedItemRgb(tdb); /* should we expect itemRgb instead of "reserved" */
struct slName *fieldList;
if (isBigBed(database, rootTable, curTrack, ctLookupName))
fieldList = bigBedGetFields(rootTable, conn);
else if (isBamTable(rootTable))
fieldList = bamGetFields();
else if (isVcfTable(rootTable, NULL))
fieldList = vcfGetFields();
else
{
char *table = chromTable(conn, rootTable);
fieldList = sqlListFields(conn, table);
freez(&table);
}
showTableFieldsOnList(db, rootTable, asObj, fieldList, showItemRgb, withGetButton);
hFreeConn(&conn);
}
/* query the list of gene names from the frames table */
struct slName *queryNames(char *dbName, char *frameTable, char *org)
{
struct sqlConnection *conn = hAllocConn();
struct slName *list = NULL;
char query[1024];
struct sqlResult *sr = NULL;
char **row;
if (onlyChrom != NULL)
sqlSafef(query, sizeof query,
"select distinct(name) from %s where src='%s' and chrom='%s'\n",
frameTable, org, onlyChrom);
else
sqlSafef(query, sizeof query,
"select distinct(name) from %s where src='%s'\n",
frameTable, org);
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
int len = strlen(row[0]);
struct slName *sn = needMem(sizeof(*sn)+len);
strcpy(sn->name, row[0]);
slAddHead(&list, sn);
}
sr = sqlGetResult(conn, query);
sqlFreeResult(&sr);
hFreeConn(&conn);
return list;
}
static void goldLoad(struct track *tg)
/* Load up golden path from database table to track items. */
{
struct sqlConnection *conn = hAllocConn(database);
struct sqlResult *sr = NULL;
char **row;
struct agpFrag *fragList = NULL, *frag;
struct agpGap *gapList = NULL, *gap;
int rowOffset;
/* Get the frags and load into tg->items. */
sr = hRangeQuery(conn, "gold", chromName, winStart, winEnd, NULL, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
frag = agpFragLoad(row+rowOffset);
slAddHead(&fragList, frag);
}
slSort(&fragList, cmpAgpFrag);
sqlFreeResult(&sr);
tg->items = fragList;
/* Get the gaps into tg->customPt. */
sr = hRangeQuery(conn, "gap", chromName, winStart, winEnd, NULL, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
gap = agpGapLoad(row+rowOffset);
slAddHead(&gapList, gap);
}
slReverse(&gapList);
sqlFreeResult(&sr);
tg->customPt = gapList;
hFreeConn(&conn);
}
struct hash *createFunctionHash()
{
struct hash *ret;
char query[512];
struct sqlConnection *conn = hAllocConn();
struct sqlResult *sr;
char **row;
char *snpString = NULL;
char *functionString = NULL;
verbose(1, "building function hash...\n");
ret = newHash(18);
sqlSafef(query, sizeof(query), "select snp_id, fxn_class from ContigLocusIdCondense");
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
snpString = cloneString(row[0]);
functionString = cloneString(row[1]);
// hashAdd(ret, snpString, (void *)(&functionString));
hashAdd(ret, snpString, functionString);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
return ret;
}
void cgapSageLoadItems(struct track *tg)
/* This function loads the beds in the current window into a linkedFeatures list. */
/* Each bed entry may turn into multiple linkedFeatures because one is made for */
/* each library at a given tag (bed). */
{
struct linkedFeatures *itemList = NULL;
struct sqlConnection *conn = hAllocConn(database);
struct hash *libHash = libTissueHash(conn);
struct hash *libTotHash = getTotTagsHashFromTable(conn);
struct sqlResult *sr = NULL;
char **row;
int rowOffset;
sr = hOrderedRangeQuery(conn, tg->table, chromName, winStart, winEnd,
NULL, &rowOffset);
if ((winEnd - winStart) > CGAP_SAGE_DENSE_GOVERNOR)
tg->visibility = tvDense;
while ((row = sqlNextRow(sr)) != NULL)
{
struct cgapSage *tag = cgapSageLoad(row+rowOffset);
struct linkedFeatures *oneLfList = cgapSageToLinkedFeatures(tag, libHash, libTotHash, tg->visibility);
itemList = slCat(oneLfList, itemList);
}
slReverse(&itemList);
sqlFreeResult(&sr);
hFreeConn(&conn);
tg->items = itemList;
}
void recreateDatabaseTable(char *chromName)
/* create a new chrN_snpTmp table with new definition */
{
struct sqlConnection *conn = hAllocConn();
char tableName[64];
char *createString =
"CREATE TABLE %s (\n"
" snp_id int(11) not null,\n"
" chromStart int(11) not null,\n"
" chromEnd int(11) not null,\n"
" loc_type tinyint(4) not null,\n"
" class varchar(255) not null,\n"
" orientation tinyint(4) not null,\n"
" molType varchar(255) not null,\n"
" fxn_class varchar(255) not null,\n"
" validation_status tinyint(4) not null,\n"
" avHet float not null, \n"
" avHetSE float not null, \n"
" allele blob,\n"
" refUCSC blob,\n"
" refUCSCReverseComp blob,\n"
" observed blob,\n"
" weight int\n"
");\n";
struct dyString *dy = newDyString(1024);
safef(tableName, ArraySize(tableName), "%s_snpTmp", chromName);
dyStringPrintf(dy, createString, tableName);
sqlRemakeTable(conn, tableName, dy->string);
dyStringFree(&dy);
hFreeConn(&conn);
}
struct snpSimple *readSnpsFromChrom(char *tableName, char *chrom)
/* Slurp in the snpSimple rows for one chrom */
/* strict option is used to check size */
{
struct snpSimple *list=NULL, *el;
char query[512];
struct sqlConnection *conn = hAllocConn();
struct sqlResult *sr;
char **row;
int start = 0;
int end = 0;
sqlSafef(query, sizeof(query),
"select name, chromStart, strand, observed, chrom, chromEnd, class, locType from %s", tableName);
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
if (!sameString(row[4], chrom)) continue;
if (!sameString(row[6], "single")) continue;
if (!sameString(row[7], "exact")) continue;
start = sqlUnsigned(row[1]);
end = sqlUnsigned(row[5]);
if (strict && end != start + 1) continue;
el = snpSimpleLoad(row);
slAddHead(&list,el);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
slReverse(&list); /* could possibly skip if it made much difference in speed. */
return list;
}
void gbReloadDelete(char *db, char *reloadList, struct dbLoadOptions* options,
char* workDir)
/* delete sequences that have been explictly requested for reloading */
{
struct sqlConnection *conn = hAllocConn(db);
char tmpDir[PATH_LEN];
struct sqlDeleter* deleter;
safef(tmpDir, sizeof(tmpDir), "%s/reload", workDir);
/* delete genbanks to reload */
deleter = buildReloadDeleter(reloadList, GB_GENBANK, tmpDir);
if (deleter != NULL)
{
deleteFromTables(db, conn, deleter, GB_GENBANK, options);
sqlDeleterFree(&deleter);
}
/* delete refseqs to reload */
deleter = buildReloadDeleter(reloadList, GB_REFSEQ, tmpDir);
if (deleter != NULL)
{
deleteFromTables(db, conn, deleter, GB_REFSEQ, options);
sqlDeleterFree(&deleter);
}
hFreeConn(&conn);
}
struct hash *getUniqueStringHash(char *columnName, char *tableName)
/* Read tableName. Store column as string, unique values only. */
/* Remove 'rs'. */
{
struct hash *ret;
char query[512];
struct sqlConnection *conn = hAllocConn();
struct sqlResult *sr;
char **row;
struct hashEl *helName = NULL;
int count = 0;
ret = newHash(18);
safef(query, sizeof(query), "select %s from %s", columnName, tableName);
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
stripString(row[0], "rs");
helName = hashLookup(ret, row[0]);
if (helName == NULL)
{
hashAdd(ret, cloneString(row[0]), NULL);
count++;
}
}
sqlFreeResult(&sr);
hFreeConn(&conn);
verbose(1, "%d unique %s in %s\n", count, columnName, tableName);
return ret;
}
struct hash *getBaseSnpData(char *tableName)
/* put all snpSubset elements in snpHash */
{
char query[512];
struct sqlConnection *conn = hAllocConn();
struct sqlResult *sr;
char **row;
struct snpSubset *subsetElement = NULL;
struct hash *ret = newHash(16);
int count = 0;
verbose(1, "get base snp data\n");
sqlSafef(query, sizeof(query),
"select chrom, chromStart, chromEnd, name, strand, refUCSC, observed from %s", tableName);
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
AllocVar(subsetElement);
subsetElement->chrom = cloneString(row[0]);
subsetElement->start = sqlUnsigned(row[1]);
subsetElement->end = sqlUnsigned(row[2]);
subsetElement->strand = cloneString(row[4]);
subsetElement->refUCSC = cloneString(row[5]);
subsetElement->observed = cloneString(row[6]);
hashAdd(ret, cloneString(row[3]), subsetElement);
count++;
}
sqlFreeResult(&sr);
hFreeConn(&conn);
verbose(1, "%d rows in hash\n", count);
return ret;
}
void recreateDatabaseTable(char *chromName)
/* create a new chrN_snpTmp table with new definition */
/* could use enum for loc_type here */
{
struct sqlConnection *conn = hAllocConn();
char tableName[64];
char *createString =
"CREATE TABLE %s (\n"
" snp_id int(11) not null,\n"
" ctg_id int(11) not null,\n"
" chromStart int(11) not null,\n"
" chromEnd int(11) not null,\n"
" loc_type tinyint(4) not null,\n"
" orientation tinyint(4) not null,\n"
" allele blob,\n"
" weight int\n"
");\n";
struct dyString *dy = newDyString(1024);
safef(tableName, ArraySize(tableName), "chr%s_snpTmp", chromName);
sqlDyStringPrintf(dy, createString, tableName);
sqlRemakeTable(conn, tableName, dy->string);
dyStringFree(&dy);
hFreeConn(&conn);
}
struct dataVector *bedGraphDataVector(char *table,
struct sqlConnection *conn, struct region *region)
/* Read in bedGraph as dataVector and return it. Filtering, subtrack merge
* and intersection are handled. */
{
struct dataVector *dv = NULL;
if (anySubtrackMerge(database, table))
dv = mergedWigDataVector(table, conn, region);
else
{
struct trackDb *tdb;
if (isCustomTrack(table))
{
struct customTrack *ct = ctLookupName(table);
tdb = ct->tdb;
conn = hAllocConn(CUSTOM_TRASH);
}
else
{
tdb = hTrackDbForTrack(database, table);
}
struct trackTable *tt1 = trackTableNew(tdb, table, conn);
dv = dataVectorFetchOneRegion(tt1, region, conn);
intersectDataVector(table, dv, region, conn);
if (isCustomTrack(table))
hFreeConn(&conn);
}
return dv;
}
struct slName *getChromListFromContigInfo(char *contigGroup)
/* get all chromNames that match contigGroup */
{
struct slName *ret = NULL;
struct slName *el = NULL;
char query[512];
struct sqlConnection *conn = hAllocConn();
struct sqlResult *sr;
char **row;
char chromName[64];
sqlSafef(query, sizeof(query), "select distinct(contig_chr) from ContigInfo where group_term = '%s' and contig_end != 0", contigGroup);
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
safef(chromName, sizeof(chromName), "%s", row[0]);
el = slNameNew(chromName);
slAddHead(&ret, el);
}
sqlFreeResult(&sr);
// not needed for canFam1
// safef(query, sizeof(query), "select distinct(contig_chr) from ContigInfo where group_term = '%s' and contig_end = 0", contigGroup);
// sr = sqlGetResult(conn, query);
// while ((row = sqlNextRow(sr)) != NULL)
// {
// safef(chromName, sizeof(chromName), "%s_random", row[0]);
// el = slNameNew(chromName);
// slAddHead(&ret, el);
// }
// sqlFreeResult(&sr);
hFreeConn(&conn);
return ret;
}
struct hash *storeHapmap(char *tableName)
/* store coords */
{
struct hash *ret = NULL;
char query[512];
struct sqlConnection *conn = hAllocConn();
struct sqlResult *sr;
char **row;
struct coords *coordItem = NULL;
ret = newHash(16);
sqlSafef(query, sizeof(query), "select name, chrom, chromStart, chromEnd from %s", tableName);
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
AllocVar(coordItem);
coordItem->chrom = cloneString(row[1]);
coordItem->start = sqlUnsigned(row[2]);
coordItem->end = sqlUnsigned(row[3]);
hashAdd(ret, cloneString(row[0]), coordItem);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
return ret;
}
struct table *getTables()
/* Get results from 'show tables' */
{
char query[512];
struct sqlConnection *conn = hAllocConn(database);
struct sqlResult *sr;
char **row;
int count = 0;
struct table *table, *list = NULL;
verbose(2, "show tables...\n");
sqlSafef(query, sizeof(query), "show tables");
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
count++;
// short-circuit
// if (count == 100) return list;
AllocVar(table);
table->name = cloneString(row[0]);
table->next = list;
list = table;
}
sqlFreeResult(&sr);
hFreeConn(&conn);
slReverse(&list); /* could possibly skip if it made much difference in speed. */
verbose(1, "%d tables found\n", count);
return list;
}
void scanGenes(char *chromName)
{
char query[512];
struct sqlConnection *conn = hAllocConn();
struct sqlResult *sr;
char **row;
struct hashEl *hel = NULL;
struct slName *snpPtr = NULL;
struct slName *snpList = NULL;
char *geneName = NULL;
sqlSafef(query, sizeof(query), "select name, txStart, txEnd from refGene where chrom = '%s'", chromName);
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
geneName = cloneString(row[0]);
snpList = readSnps(chromName, sqlUnsigned(row[1]), sqlUnsigned(row[2]));
for (snpPtr = snpList; snpPtr != NULL; snpPtr = snpPtr->next)
{
hel = hashLookup(contigHash, snpPtr->name);
if (hel == NULL)
verbose(1, "no function for %s\n", snpPtr->name);
else if (!sameString(hel->val, geneName))
verbose(1, "mismatch for %s: refGene = %s, mrna_acc = %s\n", snpPtr->name, geneName, hel->val);
}
}
sqlFreeResult(&sr);
hFreeConn(&conn);
}
void printBands(char *database, struct refLink *rl, FILE *f)
/* Print name of genes and bands it occurs on. */
{
struct sqlConnection *conn = hAllocConn(database);
struct sqlResult *sr;
char **row;
struct genePred *gp;
char query[512];
int count = 0;
struct dyString *bands = newDyString(0);
char band[64];
sprintf(query, "select * from refGene where name = '%s'", rl->mrnaAcc);
sr = sqlGetResult(conn, query);
while ((row = sqlNextRow(sr)) != NULL)
{
++count;
gp = genePredLoad(row);
if (hChromBand(database, gp->chrom, (gp->txStart + gp->txEnd)/2, band))
dyStringPrintf(bands, "%s,", band);
else
dyStringPrintf(bands, "n/a,");
}
if (count > 0)
fprintf(f, "%s\t%s\t%d\t%s\n", rl->name, rl->mrnaAcc, count, bands->string);
dyStringFree(&bands);
sqlFreeResult(&sr);
hFreeConn(&conn);
}
