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