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