struct encodePeak *encodePeakLoad(char **row) /* Load a encodePeak from row fetched with select * from encodePeak * from database. Dispose of this with encodePeakFree(). */ { struct encodePeak *ret; AllocVar(ret); ret->blockCount = sqlUnsigned(row[10]); ret->chrom = cloneString(row[0]); ret->chromStart = sqlUnsigned(row[1]); ret->chromEnd = sqlUnsigned(row[2]); ret->name = cloneString(row[3]); ret->score = sqlUnsigned(row[4]); safecpy(ret->strand, sizeof(ret->strand), row[5]); ret->signalValue = sqlFloat(row[6]); ret->pValue = sqlFloat(row[7]); ret->qValue = sqlFloat(row[8]); ret->peak = sqlSigned(row[9]); { int sizeOne; sqlUnsignedDynamicArray(row[11], &ret->blockSizes, &sizeOne); assert(sizeOne == ret->blockCount); } { int sizeOne; sqlUnsignedDynamicArray(row[12], &ret->blockStarts, &sizeOne); assert(sizeOne == ret->blockCount); } return ret; }
struct hgTranscript *hgTranscriptLoad(char **row) /* Load a hgTranscript from row fetched with select * from hgTranscript * from database. Dispose of this with hgTranscriptFree(). */ { struct hgTranscript *ret; int sizeOne; AllocVar(ret); ret->exonCount = sqlUnsigned(row[12]); ret->id = sqlUnsigned(row[0]); ret->name = cloneString(row[1]); ret->hgGene = sqlUnsigned(row[2]); ret->startBac = sqlUnsigned(row[3]); ret->startPos = sqlUnsigned(row[4]); ret->endBac = sqlUnsigned(row[5]); ret->endPos = sqlUnsigned(row[6]); ret->cdsStartBac = sqlUnsigned(row[7]); ret->cdsStartPos = sqlUnsigned(row[8]); ret->cdsEndBac = sqlUnsigned(row[9]); ret->cdsEndPos = sqlUnsigned(row[10]); ret->orientation = sqlSigned(row[11]); sqlUnsignedDynamicArray(row[13], &ret->exonStartBacs, &sizeOne); assert(sizeOne == ret->exonCount); sqlUnsignedDynamicArray(row[14], &ret->exonStartPos, &sizeOne); assert(sizeOne == ret->exonCount); sqlUnsignedDynamicArray(row[15], &ret->exonEndBacs, &sizeOne); assert(sizeOne == ret->exonCount); sqlUnsignedDynamicArray(row[16], &ret->exonEndPos, &sizeOne); assert(sizeOne == ret->exonCount); return ret; }
struct encodeErgeDNAseI *encodeErgeDNAseILoad(char **row) /* Load a encodeErgeDNAseI from row fetched with select * from encodeErgeDNAseI * from database. Dispose of this with encodeErgeDNAseIFree(). */ { struct encodeErgeDNAseI *ret; int sizeOne,i; char *s; AllocVar(ret); ret->blockCount = sqlUnsigned(row[9]); ret->chrom = cloneString(row[0]); ret->chromStart = sqlUnsigned(row[1]); ret->chromEnd = sqlUnsigned(row[2]); ret->name = cloneString(row[3]); ret->score = sqlUnsigned(row[4]); strcpy(ret->strand, row[5]); ret->thickStart = sqlUnsigned(row[6]); ret->thickEnd = sqlUnsigned(row[7]); ret->reserved = sqlUnsigned(row[8]); sqlUnsignedDynamicArray(row[10], &ret->blockSizes, &sizeOne); assert(sizeOne == ret->blockCount); sqlUnsignedDynamicArray(row[11], &ret->chromStarts, &sizeOne); assert(sizeOne == ret->blockCount); ret->Id = cloneString(row[12]); ret->color = cloneString(row[13]); return ret; }
struct fosEndPairs *fosEndPairsLoad(char **row) /* Load a fosEndPairs from row fetched with select * from fosEndPairs * from database. Dispose of this with fosEndPairsFree(). */ { struct fosEndPairs *ret; int sizeOne,i; char *s; AllocVar(ret); ret->lfCount = sqlUnsigned(row[8]); ret->bin = sqlSigned(row[0]); ret->chrom = cloneString(row[1]); ret->chromStart = sqlUnsigned(row[2]); ret->chromEnd = sqlUnsigned(row[3]); ret->name = cloneString(row[4]); ret->score = sqlUnsigned(row[5]); strcpy(ret->strand, row[6]); ret->pslTable = cloneString(row[7]); sqlUnsignedDynamicArray(row[9], &ret->lfStarts, &sizeOne); assert(sizeOne == ret->lfCount); sqlUnsignedDynamicArray(row[10], &ret->lfSizes, &sizeOne); assert(sizeOne == ret->lfCount); sqlStringDynamicArray(row[11], &ret->lfNames, &sizeOne); assert(sizeOne == ret->lfCount); return ret; }
struct psl *pslFromBigPsl( char *chrom, struct bigBedInterval *bb, unsigned chromSize, char **seq, char **cds) /* build a psl from a bigPsl */ { char *extra = cloneString(bb->rest); int numCols = 12 + 12 - 3; char *row[numCols]; int wordCount = chopByChar(extra, '\t', row, numCols); assert(wordCount == numCols); struct psl *psl; int ii; int sizeOne; AllocVar(psl); psl->qName = cloneString(row[0]); psl->strand[0] = *row[2]; if ((cds != NULL) && row[15] != NULL) *cds = cloneString(row[15]); if ((seq != NULL) && row[14] != NULL) *seq = cloneString(row[14]); psl->match = sqlUnsigned(row[17]); psl->misMatch = sqlUnsigned(row[18]); psl->repMatch = sqlUnsigned(row[19]); psl->nCount = sqlUnsigned(row[20]); psl->tName = chrom; psl->tStart = bb->start; psl->tEnd = bb->end; psl->tSize = chromSize; psl->blockCount = sqlSigned(row[6]); sqlUnsignedDynamicArray(row[7], &psl->blockSizes, &sizeOne); assert(sizeOne == psl->blockCount); sqlUnsignedDynamicArray(row[8], &psl->tStarts, &sizeOne); assert(sizeOne == psl->blockCount); psl->qStart = sqlSigned(row[9]); psl->qEnd = sqlSigned(row[10]); psl->strand[1] = *row[11]; psl->strand[1] = 0; psl->qSize = sqlSigned(row[12]); sqlUnsignedDynamicArray(row[13], &psl->qStarts, &sizeOne); assert(sizeOne == psl->blockCount); for(ii=0; ii < psl->blockCount; ii++) { psl->tStarts[ii] += psl->tStart; // psl->qStarts[ii] += psl->qStart; } return psl; }
struct cutter *cutterLoad(char **row) /* Load a cutter from row fetched with select * from cutter * from database. Dispose of this with cutterFree(). */ { struct cutter *ret; AllocVar(ret); ret->numSciz = sqlUnsigned(row[8]); ret->numCompanies = sqlUnsigned(row[10]); ret->numRefs = sqlUnsigned(row[12]); ret->name = cloneString(row[0]); ret->size = sqlUnsigned(row[1]); ret->matchSize = sqlUnsigned(row[2]); ret->seq = cloneString(row[3]); ret->cut = sqlUnsigned(row[4]); ret->overhang = sqlSigned(row[5]); ret->palindromic = sqlUnsigned(row[6]); ret->semicolon = sqlUnsigned(row[7]); { int sizeOne; sqlStringDynamicArray(row[9], &ret->scizs, &sizeOne); assert(sizeOne == ret->numSciz); } { int sizeOne; sqlCharDynamicArray(row[11], &ret->companies, &sizeOne); assert(sizeOne == ret->numCompanies); } { int sizeOne; sqlUnsignedDynamicArray(row[13], &ret->refs, &sizeOne); assert(sizeOne == ret->numRefs); } return ret; }
struct mrnaAli *mrnaAliLoad(char **row) /* Load a mrnaAli from row fetched with select * from mrnaAli * from database. Dispose of this with mrnaAliFree(). */ { struct mrnaAli *ret; int sizeOne,i; char *s; AllocVar(ret); ret->blockCount = sqlUnsigned(row[15]); ret->id = sqlUnsigned(row[0]); ret->readDir = sqlSigned(row[1]); ret->orientation = sqlSigned(row[2]); ret->hasIntrons = sqlUnsigned(row[3]); ret->isEst = sqlUnsigned(row[4]); ret->score = sqlSigned(row[5]); strcpy(ret->qAcc, row[6]); ret->qId = sqlUnsigned(row[7]); ret->qTotalSize = sqlUnsigned(row[8]); ret->qStart = sqlUnsigned(row[9]); ret->qEnd = sqlUnsigned(row[10]); ret->tStartBac = sqlUnsigned(row[11]); ret->tStartPos = sqlUnsigned(row[12]); ret->tEndBac = sqlUnsigned(row[13]); ret->tEndPos = sqlUnsigned(row[14]); sqlUnsignedDynamicArray(row[16], &ret->blockSizes, &sizeOne); assert(sizeOne == ret->blockCount); sqlUnsignedDynamicArray(row[17], &ret->qBlockStarts, &sizeOne); assert(sizeOne == ret->blockCount); sqlUnsignedDynamicArray(row[18], &ret->tBlockBacs, &sizeOne); assert(sizeOne == ret->blockCount); sqlUnsignedDynamicArray(row[19], &ret->tBlockStarts, &sizeOne); assert(sizeOne == ret->blockCount); sqlUshortDynamicArray(row[20], &ret->startGoods, &sizeOne); assert(sizeOne == ret->blockCount); sqlUshortDynamicArray(row[21], &ret->endGoods, &sizeOne); assert(sizeOne == ret->blockCount); return ret; }
struct encodePeak *encodePeakGeneralLoad(char **row, enum encodePeakType pt) /* Make a new encodePeak and return it. */ { struct encodePeak *peak; if (!pt) return NULL; if (pt == encodePeak) return encodePeakLoad(row); AllocVar(peak); peak->chrom = cloneString(row[0]); peak->chromStart = sqlUnsigned(row[1]); peak->chromEnd = sqlUnsigned(row[2]); peak->name = cloneString(row[3]); peak->score = sqlUnsigned(row[4]); peak->peak = -1; safecpy(peak->strand, sizeof(peak->strand), row[5]); if ((pt == broadPeak) || (pt == narrowPeak)) { peak->signalValue = sqlFloat(row[6]); peak->pValue = sqlFloat(row[7]); peak->qValue = sqlFloat(row[8]); if (pt == narrowPeak) peak->peak = sqlSigned(row[9]); } else /* must be gappedPeak */ { int sizeOne; peak->blockCount = sqlUnsigned(row[9]); sqlUnsignedDynamicArray(row[10], &peak->blockSizes, &sizeOne); assert(sizeOne == peak->blockCount); sqlUnsignedDynamicArray(row[11], &peak->blockStarts, &sizeOne); assert(sizeOne == peak->blockCount); peak->signalValue = sqlFloat(row[12]); peak->pValue = sqlFloat(row[13]); peak->qValue = sqlFloat(row[14]); } return peak; }
struct xAli *xAliLoad(char **row) /* Load a xAli from row fetched with select * from xAli * from database. Dispose of this with xAliFree(). */ { struct xAli *ret; int sizeOne; AllocVar(ret); ret->blockCount = sqlUnsigned(row[17]); ret->match = sqlUnsigned(row[0]); ret->misMatch = sqlUnsigned(row[1]); ret->repMatch = sqlUnsigned(row[2]); ret->nCount = sqlUnsigned(row[3]); ret->qNumInsert = sqlUnsigned(row[4]); ret->qBaseInsert = sqlSigned(row[5]); ret->tNumInsert = sqlUnsigned(row[6]); ret->tBaseInsert = sqlSigned(row[7]); strcpy(ret->strand, row[8]); ret->qName = cloneString(row[9]); ret->qSize = sqlUnsigned(row[10]); ret->qStart = sqlUnsigned(row[11]); ret->qEnd = sqlUnsigned(row[12]); ret->tName = cloneString(row[13]); ret->tSize = sqlUnsigned(row[14]); ret->tStart = sqlUnsigned(row[15]); ret->tEnd = sqlUnsigned(row[16]); sqlUnsignedDynamicArray(row[18], &ret->blockSizes, &sizeOne); assert(sizeOne == ret->blockCount); sqlUnsignedDynamicArray(row[19], &ret->qStarts, &sizeOne); assert(sizeOne == ret->blockCount); sqlUnsignedDynamicArray(row[20], &ret->tStarts, &sizeOne); assert(sizeOne == ret->blockCount); sqlStringDynamicArray(row[21], &ret->qSeq, &sizeOne); assert(sizeOne == ret->blockCount); sqlStringDynamicArray(row[22], &ret->tSeq, &sizeOne); assert(sizeOne == ret->blockCount); return ret; }
struct mrnaMisMatch *mrnaMisMatchLoad(char **row) /* Load a mrnaMisMatch from row fetched with select * from mrnaMisMatch * from database. Dispose of this with mrnaMisMatchFree(). */ { struct mrnaMisMatch *ret; AllocVar(ret); ret->misMatchCount = sqlSigned(row[3]); ret->snpCount = sqlSigned(row[9]); ret->name = cloneString(row[0]); ret->mrnaBase = row[1][0]; ret->mrnaLoc = sqlSigned(row[2]); ret->bases = cloneString(row[4]); { int sizeOne; sqlStringDynamicArray(row[5], &ret->chroms, &sizeOne); assert(sizeOne == ret->misMatchCount); } { int sizeOne; sqlUnsignedDynamicArray(row[6], &ret->tStarts, &sizeOne); assert(sizeOne == ret->misMatchCount); } ret->strands = cloneString(row[7]); { int sizeOne; sqlUnsignedDynamicArray(row[8], &ret->loci, &sizeOne); assert(sizeOne == ret->misMatchCount); } { int sizeOne; sqlStringDynamicArray(row[10], &ret->snps, &sizeOne); assert(sizeOne == ret->snpCount); } return ret; }
struct pslWQueryID *pslWQueryIDLoad(char **row) /* Load a pslWQueryID from row fetched with select * from pslWQueryID * from database. Dispose of this with pslWQueryIDFree(). */ { struct pslWQueryID *ret; int sizeOne,i; char *s; AllocVar(ret); ret->blockCount = sqlUnsigned(row[17]); ret->matches = sqlUnsigned(row[0]); ret->misMatches = sqlUnsigned(row[1]); ret->repMatches = sqlUnsigned(row[2]); ret->nCount = sqlUnsigned(row[3]); ret->qNumInsert = sqlUnsigned(row[4]); ret->qBaseInsert = sqlUnsigned(row[5]); ret->tNumInsert = sqlUnsigned(row[6]); ret->tBaseInsert = sqlUnsigned(row[7]); strcpy(ret->strand, row[8]); ret->qName = cloneString(row[9]); ret->qSize = sqlUnsigned(row[10]); ret->qStart = sqlUnsigned(row[11]); ret->qEnd = sqlUnsigned(row[12]); ret->tName = cloneString(row[13]); ret->tSize = sqlUnsigned(row[14]); ret->tStart = sqlUnsigned(row[15]); ret->tEnd = sqlUnsigned(row[16]); sqlUnsignedDynamicArray(row[18], &ret->blockSizes, &sizeOne); assert(sizeOne == ret->blockCount); sqlUnsignedDynamicArray(row[19], &ret->qStarts, &sizeOne); assert(sizeOne == ret->blockCount); sqlUnsignedDynamicArray(row[20], &ret->tStarts, &sizeOne); assert(sizeOne == ret->blockCount); ret->queryID = cloneString(row[21]); return ret; }
struct hgGene *hgGeneLoad(char **row) /* Load a hgGene from row fetched with select * from hgGene * from database. Dispose of this with hgGeneFree(). */ { struct hgGene *ret; int sizeOne; AllocVar(ret); ret->transcriptCount = sqlUnsigned(row[8]); ret->id = sqlUnsigned(row[0]); ret->name = cloneString(row[1]); ret->geneFinder = sqlUnsigned(row[2]); ret->startBac = sqlUnsigned(row[3]); ret->startPos = sqlUnsigned(row[4]); ret->endBac = sqlUnsigned(row[5]); ret->endPos = sqlUnsigned(row[6]); ret->orientation = sqlSigned(row[7]); sqlUnsignedDynamicArray(row[9], &ret->transcripts, &sizeOne); assert(sizeOne == ret->transcriptCount); return ret; }
void addElementInt(unsigned el, unsigned **array, unsigned *count) /* Add a new element to a array of elements */ { char *arrayCurr, arrayNew[MAX_ID_LIST]; int sizeOne, size; unsigned *uArray, **dArray; if (!inArrayInt(el, *array, *count)) { size = *count; arrayCurr = sqlUnsignedArrayToString(*array, *count); safef(arrayNew, ArraySize(arrayNew), "%s%d,", arrayCurr, el); size++; dArray = array; /* if (*count > 0) freeMem(dArray); */ sqlUnsignedDynamicArray(arrayNew, &uArray, &sizeOne); assert(sizeOne == size); *count = size; *array = uArray; } }
struct encodePeak *encodePeakLineFileLoad(char **row, enum encodePeakType pt, struct lineFile *lf) /* From a linefile line, load an encodePeak row. Errors outputted */ /* have line numbers, etc. Does more error checking as well. */ { struct encodePeak *peak; if (!pt) errAbort("Unknown peak type set for track"); AllocVar(peak); peak->chrom = cloneString(row[0]); peak->chromStart = lineFileNeedNum(lf, row, 1); peak->chromEnd = lineFileNeedNum(lf, row, 2); peak->peak = -1; if (peak->chromEnd < 1) lineFileAbort(lf, "chromEnd less than 1 (%d)", peak->chromEnd); if (peak->chromEnd < peak->chromStart) lineFileAbort(lf, "chromStart after chromEnd (%d > %d)", peak->chromStart, peak->chromEnd); peak->name = cloneString(row[3]); peak->score = lineFileNeedNum(lf, row, 4); safecpy(peak->strand, sizeof(peak->strand), row[5]); if (peak->strand[0] != '+' && peak->strand[0] != '-' && peak->strand[0] != '.') lineFileAbort(lf, "Expecting +, -, or . in strand"); if (pt != gappedPeak) /* deal with signalValue, pValue, qValue, and peak */ { peak->signalValue = (float)lineFileNeedDouble(lf, row, 6); peak->pValue = (float)lineFileNeedDouble(lf, row, 7); peak->qValue = (float)lineFileNeedDouble(lf, row, 8); if ((pt == narrowPeak) || (pt == encodePeak)) { peak->peak = lineFileNeedNum(lf, row, 9); if (peak->peak >= (int)peak->chromEnd) lineFileAbort(lf, "peak site past chromEnd (%d > %d)", peak->peak, peak->chromEnd); } } else /* must be gappedPeak */ /* deal with thickStart, thickEnd, itemRgb even though they're not used */ { int thickStart = lineFileNeedNum(lf, row, 6); int thickEnd = lineFileNeedNum(lf, row, 7); int itemRgb = 0; char *comma; /* Allow comma separated list of rgb values here */ comma = strchr(row[8], ','); if (comma) itemRgb = bedParseRgb(row[8]); else itemRgb = lineFileNeedNum(lf, row, 8); if ((thickStart != 0) || (thickEnd != 0) || (itemRgb != 0)) lineFileAbort(lf, "thickStart, thickEnd, and itemRgb columns not used in gappedPeak type, set all to 0"); } /* Deal with blocks */ if ((pt == gappedPeak) || (pt == encodePeak)) { int i, count; int lastEnd, lastStart; int blockCountIx, blockSizesIx, blockStartsIx; if (pt == gappedPeak) { blockCountIx = 9; blockSizesIx = 10; blockStartsIx = 11; } else { blockCountIx = 10; blockSizesIx = 11; blockStartsIx = 12; } peak->blockCount = lineFileNeedNum(lf, row, blockCountIx); sqlUnsignedDynamicArray(row[blockSizesIx], &peak->blockSizes, &count); if (count != peak->blockCount) lineFileAbort(lf, "expecting %d elements in array", peak->blockCount); sqlUnsignedDynamicArray(row[blockStartsIx], &peak->blockStarts, &count); if (count != peak->blockCount) lineFileAbort(lf, "expecting %d elements in array", peak->blockCount); // tell the user if they appear to be using absolute starts rather than // relative... easy to forget! Also check block order, coord ranges... lastStart = -1; lastEnd = 0; for (i=0; i < peak->blockCount; i++) { if (peak->blockStarts[i]+peak->chromStart >= peak->chromEnd) { if (peak->blockStarts[i] >= peak->chromStart) lineFileAbort(lf, "BED blockStarts offsets must be relative to chromStart, " "not absolute. Try subtracting chromStart from each offset " "in blockStarts."); else lineFileAbort(lf, "BED blockStarts[i]+chromStart must be less than chromEnd."); } lastStart = peak->blockStarts[i]; lastEnd = peak->chromStart + peak->blockStarts[i] + peak->blockSizes[i]; } if (peak->blockStarts[0] != 0) lineFileAbort(lf, "BED blocks must span chromStart to chromEnd. " "BED blockStarts[0] must be 0 (==%d) so that (chromStart + " "blockStarts[0]) equals chromStart.", peak->blockStarts[0]); i = peak->blockCount-1; if ((peak->chromStart + peak->blockStarts[i] + peak->blockSizes[i]) != peak->chromEnd) { lineFileAbort(lf, "BED blocks must span chromStart to chromEnd. (chromStart + " "blockStarts[last] + blockSizes[last]) must equal chromEnd."); } } if (pt == gappedPeak) /* deal with final three columns of a gappedPeak */ { peak->signalValue = (float)lineFileNeedDouble(lf, row, 12); peak->pValue = (float)lineFileNeedDouble(lf, row, 13); peak->qValue = (float)lineFileNeedDouble(lf, row, 14); } return peak; }