boolean checkMgcPicks(char *db, struct intronEv *iv)
/** Try to look up an mgc pick in this area. */
{
struct sqlConnection *conn = hAllocConn(db);
struct sqlResult *sr = NULL;
char **row;
int rowOffset = 0;
char *mgcTable = optionVal("mgcTable", "chuckMgcPicked");
char *mgcGenes = optionVal("mgcGenes", "chuckMgcGenes");
char *mgcAList = optionVal("mgcAList", "chuckMgcAList");
boolean foundSome = FALSE;
sr = hRangeQuery(conn, mgcTable, iv->chrom, iv->e1S, iv->e2E, NULL, &rowOffset);
if(sqlNextRow(sr) != NULL)
foundSome = TRUE;
sqlFreeResult(&sr);
if(foundSome == FALSE)
{
sr = hRangeQuery(conn, mgcGenes, iv->chrom, iv->e1S, iv->e2E, NULL, &rowOffset);
if(sqlNextRow(sr) != NULL)
foundSome = TRUE;
sqlFreeResult(&sr);
}
if(foundSome == FALSE)
{
sr = hRangeQuery(conn, mgcAList, iv->chrom, iv->e1S, iv->e2E, NULL, &rowOffset);
if(sqlNextRow(sr) != NULL)
foundSome = TRUE;
sqlFreeResult(&sr);
}
hFreeConn(&conn);
return foundSome;
}
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);
}
void loadGappedBed(struct track *tg)
/* Convert bed info in window to linked feature. */
{
struct sqlResult *sr;
char **row;
int rowOffset;
struct bed *bed;
struct linkedFeatures *lfList = NULL, *lf;
struct trackDb *tdb = tg->tdb;
int scoreMin = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMin", "0"));
int scoreMax = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMax", "1000"));
boolean useItemRgb = FALSE;
useItemRgb = bedItemRgb(tdb);
if (tg->isBigBed)
{ // avoid opening an unneeded db connection for bigBed; required not to use mysql for parallel fetch tracks
bigBedAddLinkedFeaturesFrom(tg, chromName, winStart, winEnd,
scoreMin, scoreMax, useItemRgb, 12, &lfList);
}
else
{
/* Use tg->tdb->track because subtracks inherit composite track's tdb
* by default, and the variable is named after the composite track. */
struct sqlConnection *conn = hAllocConn(database);
char *scoreFilterClause = getScoreFilterClause(cart, tg->tdb,NULL);
if (scoreFilterClause != NULL)
{
sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd,scoreFilterClause, &rowOffset);
freeMem(scoreFilterClause);
}
else
{
sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd, NULL, &rowOffset);
}
while ((row = sqlNextRow(sr)) != NULL)
{
bed = bedLoad12(row+rowOffset);
adjustBedScoreGrayLevel(tdb, bed, scoreMin, scoreMax);
lf = lfFromBedExtra(bed, scoreMin, scoreMax);
if (useItemRgb)
{
lf->extra = (void *)USE_ITEM_RGB; /* signal for coloring */
lf->filterColor=bed->itemRgb;
}
slAddHead(&lfList, lf);
bedFree(&bed);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
}
slReverse(&lfList);
if(tg->extraUiData)
filterBed(tg, &lfList);
slSort(&lfList, linkedFeaturesCmp);
tg->items = lfList;
}
void loadBed8(struct track *tg)
/* Convert bed 8 info in window to linked feature. */
{
struct bed *bed;
struct linkedFeatures *lfList = NULL, *lf;
struct trackDb *tdb = tg->tdb;
int scoreMin = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMin", "0"));
int scoreMax = atoi(trackDbSettingClosestToHomeOrDefault(tdb, "scoreMax", "1000"));
boolean useItemRgb = FALSE;
useItemRgb = bedItemRgb(tdb);
if (tg->isBigBed)
{ // avoid opening an unneeded db connection for bigBed; required not to use mysql for parallel fetch tracks
bigBedAddLinkedFeaturesFrom(tg, chromName, winStart, winEnd,
scoreMin, scoreMax, useItemRgb, 8, &lfList);
}
else
{
struct sqlConnection *conn = hAllocConn(database);
struct sqlResult *sr;
char **row;
int rowOffset;
char *scoreFilterClause = getScoreFilterClause(cart, tg->tdb,NULL);
if (scoreFilterClause != NULL)
{
sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd,scoreFilterClause, &rowOffset);
freeMem(scoreFilterClause);
}
else
{
sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd,
NULL, &rowOffset);
}
while ((row = sqlNextRow(sr)) != NULL)
{
bed = bedLoadN(row+rowOffset, 8);
lf = bedMungToLinkedFeatures(&bed, tdb, 8, scoreMin, scoreMax, useItemRgb);
slAddHead(&lfList, lf);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
}
slReverse(&lfList);
slSort(&lfList, linkedFeaturesCmp);
tg->items = lfList;
}
struct bed *wikiTrackGetBedRange(char *table, char *chromName,
int start, int end)
/* fetch wiki track items as simple bed 3 list in given range */
{
struct bed *bed, *bedList = NULL;
struct sqlConnection *wikiConn = wikiConnect();
struct sqlResult *sr;
char **row;
char where[256];
int rowOffset;
safef(where, ArraySize(where), "db='%s'", database);
sr = hRangeQuery(wikiConn, table, chromName, start, end, where, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
struct wikiTrack *item = wikiTrackLoad(row);
AllocVar(bed);
bed->chrom = cloneString(item->chrom);
bed->chromStart = item->chromStart;
bed->chromEnd = item->chromEnd;
slAddHead(&bedList, bed);
wikiTrackFree(&item);
}
sqlFreeResult(&sr);
wikiDisconnect(&wikiConn);
return bedList;
}
static double getSignalAt(char *table, struct bed *cluster)
/* Get (average) signal from table entries that overlap cluster */
{
struct sqlConnection *conn = hAllocConn(database);
int count = 0;
double sum = 0;
if (sqlTableExists(conn, table)) // Table might be withdrawn from data thrash
{
int rowOffset;
struct sqlResult *sr = hRangeQuery(conn, table, cluster->chrom, cluster->chromStart,
cluster->chromEnd, NULL, &rowOffset);
int signalCol = sqlFieldColumn(sr, "signalValue");
if (signalCol < 0)
internalErr();
char **row;
while ((row = sqlNextRow(sr)) != NULL)
{
count += 1;
sum += sqlDouble(row[signalCol]);
}
sqlFreeResult(&sr);
}
hFreeConn(&conn);
if (count > 0)
return sum/count;
else
return 0;
}
struct psl *loadPslsFromDb(struct sqlConnection *conn, int numTables, char **tables,
char *chrom, unsigned int chromStart, unsigned int chromEnd)
/* load up all of the psls that align on a given section of the database */
{
struct sqlResult *sr = NULL;
char **row = NULL;
int rowOffset = -100;
struct psl *pslList = NULL;
struct psl *psl = NULL;
int i=0;
/* for each table load up the relevant psls */
for(i = 0; i < numTables; i++)
{
sr = hRangeQuery(conn, tables[i], chrom, chromStart, chromEnd, NULL, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
psl = pslLoad(row+rowOffset);
slSafeAddHead(&pslList, psl);
if(weightMrna && (stringIn("refSeqAli",tables[i]) || stringIn("mrna", tables[i])))
{
psl = clonePsl(psl);
slSafeAddHead(&pslList, psl);
}
}
sqlFreeResult(&sr);
}
slReverse(&pslList);
return pslList;
}
char *altGraphId(struct sqlConnection *conn, struct genePred *gp)
/* Return altGraphId that overlaps most with genePred. */
{
int rowOffset;
struct sqlResult *sr;
char **row;
struct bed *bestBed = NULL;
int intersect, bestIntersect = 0;
char extra[64];
char *ret = NULL;
safef(extra, sizeof(extra), "strand='%s'", gp->strand);
sr = hRangeQuery(conn, "agxBed", gp->chrom, gp->txStart, gp->txEnd,
extra, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
struct bed *bed = bedLoad12(row+rowOffset);
intersect = gpBedBasesShared(gp, bed);
if (intersect > bestIntersect)
{
bestIntersect = intersect;
bestBed = bed;
}
else
bedFree(&bed);
}
if (bestBed != NULL)
{
ret = cloneString(bestBed->name);
bedFree(&bestBed);
}
return ret;
}
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;
}
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;
}
void loadRNAHybridization(struct track *tg)
/* Load the items in one custom track - just move beds in
* window... */
{
struct rnaHybridization *rnaHyb, *list = NULL;
struct sqlConnection *conn = hAllocConn(database);
struct sqlResult *sr;
char **row;
int rowOffset;
int minlengthSetting = cartUsualInt(cart, "rnaHybridization.minlength", 20);
int maxlengthSetting = cartUsualInt(cart, "rnaHybridization.maxlength", 20);
double gcSetting = (double)cartUsualInt(cart, "rnaHybridization.gc", 50) / 100;
int hideTrnaSetting = cartUsualBoolean(cart, "rnaHybridization.hideTrna", FALSE);
int showKnownTargetsSetting = cartUsualBoolean(cart, "rnaHybridization.showKnownTargets", TRUE);
sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd, NULL, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
rnaHyb = rnaHybridizationLoad(row);
if(rnaHyb->matchLength >= minlengthSetting
&& rnaHyb->matchLength <= maxlengthSetting
&& rnaHyb->gcContent >= gcSetting
&& !(hideTrnaSetting && strlen(rnaHyb->trnaTarget) > 0)
&& !(showKnownTargetsSetting && !rnaHyb->targetAnnotation))
slAddHead(&list, rnaHyb);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
slReverse(&list);
tg->items = list;
}
static void queryRange(struct sqlConnection *conn, char *table, struct chromRange *range)
/* query one range */
{
struct sqlResult *sr = hRangeQuery(conn, table, range->chrom,
range->start, range->end, NULL, NULL);
char **row;
while ((row = sqlNextRow(sr)) != NULL)
continue;
sqlFreeResult(&sr);
}
boolean coordOverlappedByTable(char *db, char *chrom, int start, int end, char *table)
/** Return TRUE if there is a record overlapping. */
{
struct sqlConnection *conn = hAllocConn(db);
struct sqlResult *sr = NULL;
char **row;
int rowOffset = 0;
boolean foundSome = FALSE;
sr = hRangeQuery(conn, table, chrom, start, end, NULL, &rowOffset);
if(sqlNextRow(sr) != NULL)
foundSome = TRUE;
sqlFreeResult(&sr);
hFreeConn(&conn);
return foundSome;
}
boolean loadMark2(struct sqlConnection *conn, char *table, char *chrom, unsigned start, unsigned end, double mark2[5][5][5])
// Load 2nd-order markov model from given table
{
boolean found = FALSE;
int rowOffset;
struct sqlResult *sr = hRangeQuery(conn, table, chrom, start, end, NULL, &rowOffset);
char **row;
// XXXX use "best" model instead of first if there are multiple (i.e. maximize overlap with start/end).
if((row = sqlNextRow(sr)) != NULL)
{
dnaMark2Deserialize(row[rowOffset + 3], mark2);
found = TRUE;
}
sqlFreeResult(&sr);
return found;
}
struct mafAli *mafLoadInRegion2(struct sqlConnection *conn,
struct sqlConnection *conn2, char *table, char *chrom,
int start, int end, char *file)
/* Return list of alignments in region. */
{
char **row;
unsigned int extFileId = 0;
struct mafAli *maf, *mafList = NULL;
struct mafFile *mf = NULL;
int rowOffset;
if (file != NULL)
mf = mafOpen(file);
struct sqlResult *sr = hRangeQuery(conn, table, chrom,
start, end, NULL, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
struct scoredRef ref;
scoredRefStaticLoad(row + rowOffset, &ref);
if ((file != NULL) && (ref.extFile != 0))
errAbort("expect extFile to be zero if file specified\n");
if ((file == NULL) && (ref.extFile == 0))
errAbort("expect extFile to be not zero or file specified\n");
if (ref.extFile != extFileId)
{
char *path = hExtFileNameC(conn2, "extFile", ref.extFile);
mafFileFree(&mf);
mf = mafOpen(path);
extFileId = ref.extFile;
}
lineFileSeek(mf->lf, ref.offset, SEEK_SET);
maf = mafNext(mf);
if (maf == NULL)
internalErr();
slAddHead(&mafList, maf);
}
sqlFreeResult(&sr);
mafFileFree(&mf);
slReverse(&mafList);
/* hRangeQuery may return items out-of-order when bin is used in the query,
* so sort here in order to avoid trouble at base-level view: */
slSort(&mafList, mafCmp);
return mafList;
}
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 pubsPslLoadItems(struct track *tg)
/* load only psl items from a single article */
{
// get articleId to filter on
char *articleId = cartOptionalString(cart, PUBSFILTERNAME);
if (articleId==NULL)
return;
struct sqlConnection *conn = hAllocConn(database);
char *dispLabel = pubsArticleDispId(tg, conn, articleId);
struct hash *idToSnip = pubsLookupSequences(tg, conn, articleId, TRUE);
struct hash *idToSeq = pubsLookupSequences(tg, conn, articleId, FALSE);
// change track label
char *oldLabel = tg->longLabel;
tg->longLabel = catTwoStrings("Individual matches for article ", dispLabel);
freeMem(oldLabel);
// filter and load items for this articleId
char where[256];
safef(where, sizeof(where), " articleId=%s ", articleId);
int rowOffset = 0;
struct sqlResult *sr = NULL;
sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd, where, &rowOffset);
struct linkedFeatures *lfList = NULL;
char **row = NULL;
while ((row = sqlNextRow(sr)) != NULL)
{
struct psl *psl = pslLoad(row+rowOffset);
slAddHead(&lfList, lfFromPsl(psl, TRUE));
char *shortSeq = hashFindVal(idToSeq, lfList->name);
char *snip = hashFindVal(idToSnip, lfList->name);
struct pubsExtra *extra = needMem(sizeof(struct pubsExtra));
extra->mouseOver=snip;
extra->label=shortSeq;
lfList->extra = extra;
}
sqlFreeResult(&sr);
slReverse(&lfList);
slSort(&lfList, linkedFeaturesCmp);
tg->items = lfList;
hFreeConn(&conn);
}
void loadWiki(struct track *tg)
/* Load the items in one custom track - just move beds in
* window... */
{
struct bed *bed, *list = NULL;
struct sqlConnection *conn = hAllocConn(database);
struct sqlResult *sr;
char **row;
int rowOffset;
sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd, NULL, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
bed = bedLoadN(row+rowOffset, 6);
freeMem(bed->name);
bed->name = malloc(MAX_WIKI_NAME);
snprintf(bed->name, MAX_WIKI_NAME, "%d-%d:%s", bed->chromStart, bed->chromEnd, bed->strand);
slAddHead(&list, bed);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
//slReverse(&list);
// add dummy links
AllocVar(bed);
bed->chrom = chromName;
bed->chromStart = winStart;
bed->chromEnd = winEnd;
bed->name = "Make new entry:+";
bed->strand[0] = '+';
bed->score = 100;
slAddHead(&list, bed);
AllocVar(bed);
bed->chrom = chromName;
bed->chromStart = winStart;
bed->chromEnd = winEnd;
bed->name = "Make new entry:-";
bed->strand[0] = '-';
bed->score = 100;
slAddHead(&list, bed);
tg->items = list;
}
void doQuery(char *database, char *table, char *chrom, int start, int end)
/* doQuery */
{
struct sqlConnection *conn = NULL;
struct sqlResult *sr = NULL;
char *empty = NULL;
int rowOffset = 0;
// char **row;
// int count = 0;
long startTime = 0;
long deltaTime = 0;
int i;
conn = sqlConnect(database);
// hSetDb(database);
for (i = 0; i < iterations; i++)
{
startTime = clock1000();
sr = hRangeQuery(conn, table, chrom, start, end, empty, &rowOffset);
deltaTime = clock1000() - startTime;
printf("time for hRangeQuery = %0.3fs\n", ((double)deltaTime)/1000.0);
end++;
sqlFreeResult(&sr);
sleep1000(500);
}
// startTime = clock1000();
// while ((row = sqlNextRow(sr)) != NULL)
// {
// count++;
// }
// printf("got %d rows\n", count);
// sqlFreeResult(&sr);
// deltaTime = clock1000() - startTime;
// printf("time for sqlFreeResult = %0.3fs\n", ((double)deltaTime)/1000.0);
// sqlDisconnect(&conn);
}
static void wikiTrackFilteredBedOnRegion(
struct region *region, /* Region to get data from. */
struct hash *idHash, /* Hash of identifiers or NULL */
struct bedFilter *bf, /* Filter or NULL */
struct lm *lm, /* Local memory pool. */
struct bed **pBedList /* Output get's appended to this list */
)
/* Get the wikiTrack items passing filter on a single region. */
{
struct bed *bed;
int fieldCount = 6;
char query[512];
int rowOffset;
char **row;
struct sqlConnection *wikiConn = wikiConnect();
struct sqlResult *sr = NULL;
char where[512];
char *filter = filterClause(wikiDbName(), WIKI_TRACK_TABLE, region->chrom, NULL);
if (filter)
sqlSafefFrag(where, sizeof(where), "db='%s' AND %-s", database, filter);
else
sqlSafefFrag(where, sizeof(where), "db='%s'", database);
sqlSafef(query, sizeof(query), "select * from %s", WIKI_TRACK_TABLE);
sr = hRangeQuery(wikiConn, WIKI_TRACK_TABLE, region->chrom,
region->start, region->end, where, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
bed = bedLoadN(row+rowOffset, fieldCount);
if ((idHash == NULL || hashLookup(idHash, bed->name)) &&
(bf == NULL || bedFilterOne(bf, bed)))
{
struct bed *copy = lmCloneBed(bed, lm);
slAddHead(pBedList, copy);
}
}
sqlFreeResult(&sr);
wikiDisconnect(&wikiConn);
}
void altGraphXLoadItems(struct track *tg)
/* Load the altGraphX data to a track. */
{
struct sqlConnection *conn = hAllocConn(database);
int rowOffSet;
char **row;
struct altGraphX *ag=NULL, *agList=NULL;
struct sqlResult *sr = hRangeQuery(conn, tg->table, chromName,
winStart, winEnd, NULL, &rowOffSet);
while((row = sqlNextRow(sr)) != NULL)
{
ag = altGraphXLoad(row + rowOffSet);
slAddHead(&agList, ag);
}
slReverse(&agList);
sqlFreeResult(&sr);
hFreeConn(&conn);
tg->items = agList;
}
static struct bed *loadMsBed(struct trackDb *tdb, char *table, char *chrom, uint start, uint end)
/* load every thing from a bed 15 table in the given range */
{
struct sqlConnection *conn = hAllocConnTrack(database, tdb);
struct sqlResult *sr;
char **row;
int rowOffset;
struct bed *bedList = NULL, *bed;
sr = hRangeQuery(conn, table, chrom, start, end, NULL, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
bed = bedLoadN(row+rowOffset, 15);
slAddHead(&bedList, bed);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
slReverse(&bedList);
return bedList;
}
static void encodePeakLoadItemsBoth(struct track *tg, struct customTrack *ct)
/* Load up an encodePeak table from the regular database or the customTrash one. */
{
char *db, *table;
struct sqlConnection *conn;
struct sqlResult *sr = NULL;
char **row;
char *filterConstraints = NULL;
int rowOffset;
struct linkedFeatures *lfList = NULL;
enum encodePeakType pt = 0;
int scoreMin = atoi(trackDbSettingClosestToHomeOrDefault(tg->tdb, "scoreMin", "0"));
int scoreMax = atoi(trackDbSettingClosestToHomeOrDefault(tg->tdb, "scoreMax", "1000"));
if (ct)
{
db = CUSTOM_TRASH;
table = ct->dbTableName;
}
else
{
db = database;
table = tg->tdb->table;
}
conn = hAllocConn(db);
pt = encodePeakInferTypeFromTable(db, table, tg->tdb->type);
tg->customInt = pt;
filterConstraints = encodePeakFilter(tg->tdb->track, tg->tdb, (ct!=NULL));
sr = hRangeQuery(conn, table, chromName, winStart, winEnd, filterConstraints, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
struct encodePeak *peak = encodePeakGeneralLoad(row + rowOffset, pt);
struct linkedFeatures *lf = lfFromEncodePeak((struct slList *)peak, tg->tdb, scoreMin, scoreMax);
if (lf)
slAddHead(&lfList, lf);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
slReverse(&lfList);
slSort(&lfList, linkedFeaturesCmp);
tg->items = lfList;
}
struct bed *loadBedFromTable(struct sqlConnection *conn, char *table,
char *chrom, int chromStart, int chromEnd)
/** Load all of the beds between chromstart and chromEnd */
{
struct sqlResult *sr = NULL;
char **row = NULL;
int rowOffset = -100;
struct bed *bedList = NULL;
struct bed *bed = NULL;
int i=0;
sr = hRangeQuery(conn, table, chrom, chromStart, chromEnd, NULL, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
bed = bedLoad(row+rowOffset);
slSafeAddHead(&bedList, bed);
}
sqlFreeResult(&sr);
slReverse(&bedList);
return bedList;
}
struct psl *loadPslFromTable(struct sqlConnection *conn, char *table,
char *chrom, int chromStart, int chromEnd)
/** Load all of the psls between chromstart and chromEnd */
{
struct sqlResult *sr = NULL;
char **row = NULL;
int rowOffset = -100;
struct psl *pslList = NULL;
struct psl *psl = NULL;
int i=0;
sr = hRangeQuery(conn, table, chrom, chromStart, chromEnd, NULL, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
psl = pslLoad(row+rowOffset);
slSafeAddHead(&pslList, psl);
}
sqlFreeResult(&sr);
slReverse(&pslList);
return pslList;
}
static void capAliTextOnTrack(struct mafAli *maf,
char *db, char *chrom,
char *track, boolean onlyCds)
/* Capitalize exons in alignment. */
{
int rowOffset;
struct sqlConnection *conn = sqlConnect(db);
struct mafComp *selfMc = maf->components, *mc;
int start = selfMc->start;
int end = start + selfMc->size;
struct sqlResult *sr = hRangeQuery(conn, track, chrom, start, end,
NULL, &rowOffset);
char **row;
while ((row = sqlNextRow(sr)) != NULL)
{
struct genePred *gp = genePredLoad(row+rowOffset);
int i;
for (i=0; i<gp->exonCount; ++i)
{
int s = gp->exonStarts[i];
int e = gp->exonEnds[i];
if (onlyCds)
{
if (s < gp->cdsStart) s = gp->cdsStart;
if (e > gp->cdsEnd) e = gp->cdsEnd;
}
if (s < start) s = start;
if (e > end) e = end;
if (findAliRange(selfMc->text, maf->textSize, s-start, e-start, &s, &e))
{
for (mc = maf->components; mc != NULL; mc = mc->next)
if (mc->text)
toUpperN(mc->text + s, e-s);
}
}
genePredFree(&gp);
}
sqlFreeResult(&sr);
sqlDisconnect(&conn);
}
struct pslReader *pslReaderRangeQuery(struct sqlConnection* conn,
char* table, char* chrom,
int start, int end,
char* extraWhere)
/* Create a new pslReader to read a chrom range in a database table. If
* extraWhere is not null, it is added as an additional where condition. It
* will determine if pslx columns are in the table. */
{
struct pslReader* pr;
int rowOffset;
AllocVar(pr);
pr->table = cloneString(table);
/* non-existant table will return null */
pr->sr = hRangeQuery(conn, table, chrom, start, end, extraWhere, &rowOffset);
if (pr->sr != NULL)
getTableInfo(pr);
assert(pr->rowOffset == rowOffset);
return pr;
}
struct genePredReader *genePredReaderRangeQuery(struct sqlConnection* conn,
char* table, char* chrom,
int start, int end,
char* extraWhere)
/* Create a new genePredReader to read a chrom range in a database table. If
* extraWhere is not null, it is added as an additional where condition. It
* will determine if extended genePred columns are in the table. */
{
struct genePredReader* gpr;
int rowOffset;
AllocVar(gpr);
gpr->table = cloneString(table);
/* non-existant table will return null */
gpr->sr = hRangeQuery(conn, table, chrom, start, end, extraWhere, &rowOffset);
if (gpr->sr != NULL)
buildResultFieldMap(gpr);
assert(gpr->rowOffset == rowOffset);
return gpr;
}
void loadBed6(struct track *tg)
/* Load the items in one custom track - just move beds in
* window... */
{
struct bed *bed, *list = NULL;
struct sqlConnection *conn = hAllocConn(database);
struct sqlResult *sr;
char **row;
int rowOffset;
sr = hRangeQuery(conn, tg->table, chromName, winStart, winEnd, NULL, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
bed = bedLoadN(row+rowOffset, 6);
slAddHead(&list, bed);
}
sqlFreeResult(&sr);
hFreeConn(&conn);
slReverse(&list);
tg->items = list;
}
static struct agpGap *loadAllGaps(struct sqlConnection *conn,
char *db, struct chromInfo *cInfoList)
/* fetch all gaps, returns list of gaps */
{
struct agpGap *gapList = NULL;
struct chromInfo *cInfo;
int gapCount = 0;
for (cInfo = cInfoList; cInfo; cInfo = cInfo->next)
{
char **row;
int rowOffset;
struct sqlResult *sr = hRangeQuery(conn, "gap", cInfo->chrom, 0,
cInfo->size, NULL, &rowOffset);
while ((row = sqlNextRow(sr)) != NULL)
{
struct agpGap *gap = agpGapLoad(row+rowOffset);
if (minGap)
{
if (gap->size >= minGap)
{
slAddHead(&gapList, gap);
++gapCount;
}
}
else
{
slAddHead(&gapList, gap);
++gapCount;
}
}
sqlFreeResult(&sr);
}
slSort(&gapList, bedCmp);
if (! insane)
gapSanityCheck(gapList);
verbose(2,"#\tfound %d gaps of size >= %d\n", gapCount, minGap);
return (gapList);
}
