自学教程：C++ sqlFixedStringComma函数代码示例

struct rmskOut *rmskOutCommaIn(char **pS, struct rmskOut *ret)/* Create a rmskOut out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new rmskOut */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->swScore = sqlUnsignedComma(&s);ret->milliDiv = sqlUnsignedComma(&s);ret->milliDel = sqlUnsignedComma(&s);ret->milliIns = sqlUnsignedComma(&s);ret->genoName = sqlStringComma(&s);ret->genoStart = sqlUnsignedComma(&s);ret->genoEnd = sqlUnsignedComma(&s);ret->genoLeft = sqlSignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->repName = sqlStringComma(&s);ret->repClass = sqlStringComma(&s);ret->repFamily = sqlStringComma(&s);ret->repStart = sqlSignedComma(&s);ret->repEnd = sqlSignedComma(&s);ret->repLeft = sqlSignedComma(&s);sqlFixedStringComma(&s, ret->id, sizeof(ret->id));*pS = s;return ret;}

struct hapmapPrimateAlleles *hapmapPrimateAllelesCommaIn(char **pS, struct hapmapPrimateAlleles *ret)/* Create a hapmapPrimateAlleles out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new hapmapPrimateAlleles */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlUnsignedComma(&s);ret->chromEnd = sqlUnsignedComma(&s);ret->name = sqlStringComma(&s);ret->score = sqlUnsignedComma(&s);sqlFixedStringComma(&s, &(ret->strand), sizeof(ret->strand));sqlFixedStringComma(&s, &(ret->refAllele), sizeof(ret->refAllele));sqlFixedStringComma(&s, &(ret->otherAllele), sizeof(ret->otherAllele));ret->chimpChrom = sqlStringComma(&s);ret->chimpPos = sqlUnsignedComma(&s);sqlFixedStringComma(&s, &(ret->chimpStrand), sizeof(ret->chimpStrand));ret->chimpAllele = sqlStringComma(&s);ret->chimpQual = sqlUnsignedComma(&s);ret->rhesusChrom = sqlStringComma(&s);ret->rhesusPos = sqlUnsignedComma(&s);sqlFixedStringComma(&s, &(ret->rhesusStrand), sizeof(ret->rhesusStrand));ret->rhesusAllele = sqlStringComma(&s);ret->rhesusQual = sqlUnsignedComma(&s);*pS = s;return ret;}

struct encodeHapMapAlleleFreq *encodeHapMapAlleleFreqCommaIn(char **pS, struct encodeHapMapAlleleFreq *ret)/* Create a encodeHapMapAlleleFreq out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new encodeHapMapAlleleFreq */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlUnsignedComma(&s);ret->chromEnd = sqlUnsignedComma(&s);ret->name = sqlStringComma(&s);ret->score = sqlUnsignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->center = sqlStringComma(&s);sqlFixedStringComma(&s, ret->refAllele, sizeof(ret->refAllele));sqlFixedStringComma(&s, ret->otherAllele, sizeof(ret->otherAllele));ret->refAlleleFreq = sqlFloatComma(&s);ret->otherAlleleFreq = sqlFloatComma(&s);ret->minorAlleleFreq = sqlFloatComma(&s);ret->totalCount = sqlUnsignedComma(&s);*pS = s;return ret;}

struct easyGene *easyGeneCommaIn(char **pS, struct easyGene *ret)/* Create a easyGene out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new easyGene */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlUnsignedComma(&s);ret->chromEnd = sqlUnsignedComma(&s);ret->name = sqlStringComma(&s);ret->score = sqlUnsignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->feat = sqlStringComma(&s);ret->R = sqlFloatComma(&s);ret->frame = sqlUnsignedComma(&s);ret->orf = sqlStringComma(&s);ret->startCodon = sqlStringComma(&s);ret->logOdds = sqlFloatComma(&s);ret->descriptor = sqlStringComma(&s);ret->swissProt = sqlStringComma(&s);sqlFixedStringComma(&s, ret->genbank, sizeof(ret->genbank));*pS = s;return ret;}

struct alleleFreqs *alleleFreqsCommaIn(char **pS, struct alleleFreqs *ret)/* Create a alleleFreqs out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new alleleFreqs */{char *s = *pS;int i;if (ret == NULL)    AllocVar(ret);ret->rsId = sqlStringComma(&s);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlSignedComma(&s);sqlFixedStringComma(&s, &(ret->strand), sizeof(ret->strand));ret->assembly = sqlStringComma(&s);ret->center = sqlStringComma(&s);ret->protLSID = sqlStringComma(&s);ret->assayLSID = sqlStringComma(&s);ret->panelLSID = sqlStringComma(&s);sqlFixedStringComma(&s, &(ret->majAllele), sizeof(ret->majAllele));ret->majCount = sqlSignedComma(&s);ret->majFreq = sqlFloatComma(&s);sqlFixedStringComma(&s, &(ret->minAllele), sizeof(ret->minAllele));ret->minCount = sqlSignedComma(&s);ret->minFreq = sqlFloatComma(&s);ret->total = sqlSignedComma(&s);*pS = s;return ret;}

struct hapmapAllelesCombined *hapmapAllelesCombinedCommaIn(char **pS, struct hapmapAllelesCombined *ret)/* Create a hapmapAllelesCombined out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new hapmapAllelesCombined */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlUnsignedComma(&s);ret->chromEnd = sqlUnsignedComma(&s);ret->name = sqlStringComma(&s);ret->score = sqlUnsignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->observed = sqlStringComma(&s);sqlFixedStringComma(&s, ret->allele1, sizeof(ret->allele1));ret->allele1CountCEU = sqlUnsignedComma(&s);ret->allele1CountCHB = sqlUnsignedComma(&s);ret->allele1CountJPT = sqlUnsignedComma(&s);ret->allele1CountYRI = sqlUnsignedComma(&s);ret->allele2 = sqlStringComma(&s);ret->allele2CountCEU = sqlUnsignedComma(&s);ret->allele2CountCHB = sqlUnsignedComma(&s);ret->allele2CountJPT = sqlUnsignedComma(&s);ret->allele2CountYRI = sqlUnsignedComma(&s);ret->heteroCountCEU = sqlUnsignedComma(&s);ret->heteroCountCHB = sqlUnsignedComma(&s);ret->heteroCountJPT = sqlUnsignedComma(&s);ret->heteroCountYRI = sqlUnsignedComma(&s);*pS = s;return ret;}

struct codeBlastScore *codeBlastScoreCommaIn(char **pS, struct codeBlastScore *ret)/* Create a codeBlastScore out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new codeBlastScore */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->qName = sqlStringComma(&s);sqlFixedStringComma(&s, ret->code, sizeof(ret->code));ret->evalue = sqlStringComma(&s);ret->GI = sqlUnsignedComma(&s);ret->PI = sqlFloatComma(&s);ret->length = sqlUnsignedComma(&s);ret->gap = sqlUnsignedComma(&s);ret->score = sqlUnsignedComma(&s);ret->seqstart = sqlUnsignedComma(&s);ret->seqend = sqlUnsignedComma(&s);sqlFixedStringComma(&s, ret->species, sizeof(ret->species));sqlFixedStringComma(&s, ret->product, sizeof(ret->product));sqlFixedStringComma(&s, ret->name, sizeof(ret->name));*pS = s;return ret;}

struct orthoAlleles *orthoAllelesCommaIn(char **pS, struct orthoAlleles *ret)/* Create a orthoAlleles out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new orthoAlleles */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlUnsignedComma(&s);ret->chromEnd = sqlUnsignedComma(&s);ret->name = sqlStringComma(&s);ret->score = sqlUnsignedComma(&s);sqlFixedStringComma(&s, &(ret->strand), sizeof(ret->strand));sqlFixedStringComma(&s, &(ret->allele1), sizeof(ret->allele1));ret->allele1Freq = sqlFloatComma(&s);ret->allele1Count = sqlUnsignedComma(&s);sqlFixedStringComma(&s, &(ret->allele2), sizeof(ret->allele2));ret->allele2Freq = sqlFloatComma(&s);ret->allele2Count = sqlUnsignedComma(&s);ret->ortho1Chrom = sqlStringComma(&s);ret->ortho1ChromStart = sqlUnsignedComma(&s);ret->ortho1ChromEnd = sqlUnsignedComma(&s);sqlFixedStringComma(&s, &(ret->ortho1Strand), sizeof(ret->ortho1Strand));ret->ortho1State = sqlStringComma(&s);ret->ortho2Chrom = sqlStringComma(&s);ret->ortho2ChromStart = sqlUnsignedComma(&s);ret->ortho2ChromEnd = sqlUnsignedComma(&s);sqlFixedStringComma(&s, &(ret->ortho2Strand), sizeof(ret->ortho2Strand));ret->ortho2State = sqlStringComma(&s);*pS = s;return ret;}

struct sangInsert *sangInsertCommaIn(char **pS, struct sangInsert *ret)/* Create a sangInsert out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new sangInsert */{char *s = *pS;int i;if (ret == NULL)    AllocVar(ret);sqlFixedStringComma(&s, ret->id, sizeof(ret->id));sqlFixedStringComma(&s, ret->name, sizeof(ret->name));*pS = s;return ret;}

struct ccdsNotes *ccdsNotesCommaIn(char **pS, struct ccdsNotes *ret)/* Create a ccdsNotes out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new ccdsNotes */{char *s = *pS;if (ret == NULL)    AllocVar(ret);sqlFixedStringComma(&s, ret->ccds, sizeof(ret->ccds));sqlFixedStringComma(&s, ret->createDate, sizeof(ret->createDate));ret->note = sqlStringComma(&s);*pS = s;return ret;}

struct dgvPlus *dgvPlusCommaIn(char **pS, struct dgvPlus *ret)/* Create a dgvPlus out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new dgvPlus */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlUnsignedComma(&s);ret->chromEnd = sqlUnsignedComma(&s);ret->name = sqlStringComma(&s);ret->score = sqlUnsignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->thickStart = sqlUnsignedComma(&s);ret->thickEnd = sqlUnsignedComma(&s);ret->itemRgb = sqlUnsignedComma(&s);ret->varType = sqlStringComma(&s);ret->reference = sqlStringComma(&s);ret->pubMedId = sqlUnsignedComma(&s);ret->method = sqlStringComma(&s);ret->platform = sqlStringComma(&s);ret->mergedVariants = sqlStringComma(&s);ret->supportingVariants = sqlStringComma(&s);ret->sampleSize = sqlUnsignedComma(&s);ret->observedGains = sqlUnsignedComma(&s);ret->observedLosses = sqlUnsignedComma(&s);ret->cohortDescription = sqlStringComma(&s);ret->genes = sqlStringComma(&s);ret->samples = sqlStringComma(&s);*pS = s;return ret;}

struct txCluster *txClusterCommaIn(char **pS, struct txCluster *ret)/* Create a txCluster out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new txCluster */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlSignedComma(&s);ret->chromEnd = sqlSignedComma(&s);ret->name = sqlStringComma(&s);ret->score = sqlSignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->txCount = sqlSignedComma(&s);{int i;s = sqlEatChar(s, '{');AllocArray(ret->txArray, ret->txCount);for (i=0; i<ret->txCount; ++i)    {    ret->txArray[i] = sqlStringComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');}*pS = s;return ret;}

struct dgv *dgvCommaIn(char **pS, struct dgv *ret)/* Create a dgv out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new dgv */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlUnsignedComma(&s);ret->chromEnd = sqlUnsignedComma(&s);ret->name = sqlStringComma(&s);ret->score = sqlUnsignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->thickStart = sqlUnsignedComma(&s);ret->thickEnd = sqlUnsignedComma(&s);ret->itemRgb = sqlUnsignedComma(&s);ret->landmark = sqlStringComma(&s);ret->varType = sqlStringComma(&s);ret->reference = sqlStringComma(&s);ret->pubMedId = sqlUnsignedComma(&s);ret->method = sqlStringComma(&s);ret->sample = sqlStringComma(&s);*pS = s;return ret;}

struct snoRNAs *snoRNAsCommaIn(char **pS, struct snoRNAs *ret)/* Create a snoRNAs out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new snoRNAs */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlUnsignedComma(&s);ret->chromEnd = sqlUnsignedComma(&s);ret->name = sqlStringComma(&s);ret->score = sqlUnsignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->snoScore = sqlFloatComma(&s);ret->targetList = sqlStringComma(&s);ret->orthologs = sqlStringComma(&s);ret->guideLen = sqlStringComma(&s);ret->guideStr = sqlStringComma(&s);ret->guideScore = sqlStringComma(&s);ret->cBox = sqlStringComma(&s);ret->dBox = sqlStringComma(&s);ret->cpBox = sqlStringComma(&s);ret->dpBox = sqlStringComma(&s);ret->hmmScore = sqlFloatComma(&s);ret->snoscanOutput = sqlStringComma(&s);*pS = s;return ret;}

struct MGIid *MGIidCommaIn(char **pS, struct MGIid *ret)/* Create a MGIid out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new MGIid */{char *s = *pS;int i;if (ret == NULL)    AllocVar(ret);sqlFixedStringComma(&s, ret->LLid, sizeof(ret->LLid));sqlFixedStringComma(&s, ret->MGIid, sizeof(ret->MGIid));sqlFixedStringComma(&s, ret->symbol, sizeof(ret->symbol));*pS = s;return ret;}

struct gtexGeneBed *gtexGeneBedCommaIn(char **pS, struct gtexGeneBed *ret)/* Create a gtexGeneBed out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new gtexGeneBed */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlUnsignedComma(&s);ret->chromEnd = sqlUnsignedComma(&s);ret->name = sqlStringComma(&s);ret->score = sqlUnsignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->geneId = sqlStringComma(&s);ret->geneType = sqlStringComma(&s);ret->expCount = sqlUnsignedComma(&s);{int i;s = sqlEatChar(s, '{');AllocArray(ret->expScores, ret->expCount);for (i=0; i<ret->expCount; ++i)    {    ret->expScores[i] = sqlFloatComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');}*pS = s;return ret;}

struct jaxQTL2 *jaxQTL2CommaIn(char **pS, struct jaxQTL2 *ret)/* Create a jaxQTL2 out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new jaxQTL2 */{char *s = *pS;int i;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlUnsignedComma(&s);ret->chromEnd = sqlUnsignedComma(&s);ret->name = sqlStringComma(&s);ret->score = sqlUnsignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->thickStart = sqlUnsignedComma(&s);ret->thickEnd = sqlUnsignedComma(&s);ret->marker = sqlStringComma(&s);ret->mgiID = sqlStringComma(&s);ret->description = sqlStringComma(&s);ret->cMscore = sqlFloatComma(&s);*pS = s;return ret;}

struct encodeStanfordPromoters *encodeStanfordPromotersCommaIn(char **pS, struct encodeStanfordPromoters *ret)/* Create a encodeStanfordPromoters out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new encodeStanfordPromoters */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlUnsignedComma(&s);ret->chromEnd = sqlUnsignedComma(&s);ret->name = sqlStringComma(&s);ret->score = sqlUnsignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->thickStart = sqlUnsignedComma(&s);ret->thickEnd = sqlUnsignedComma(&s);ret->reserved = sqlUnsignedComma(&s);ret->geneModel = sqlStringComma(&s);ret->description = sqlStringComma(&s);ret->lucA = sqlSignedComma(&s);ret->renA = sqlSignedComma(&s);ret->lucB = sqlSignedComma(&s);ret->renB = sqlSignedComma(&s);ret->avgRatio = sqlFloatComma(&s);ret->normRatio = sqlFloatComma(&s);ret->normLog2Ratio = sqlFloatComma(&s);*pS = s;return ret;}

struct tigrCmrGene *tigrCmrGeneCommaIn(char **pS, struct tigrCmrGene *ret)/* Create a tigrCmrGene out of a comma separated string. * This will fill in ret if non-null, otherwise will * return a new tigrCmrGene */{    char *s = *pS;    if (ret == NULL)        AllocVar(ret);    ret->bin = sqlSignedComma(&s);    ret->chrom = sqlStringComma(&s);    ret->chromStart = sqlUnsignedComma(&s);    ret->chromEnd = sqlUnsignedComma(&s);    ret->name = sqlStringComma(&s);    ret->score = sqlUnsignedComma(&s);    sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));    ret->tigrCommon = sqlStringComma(&s);    ret->tigrGene = sqlStringComma(&s);    ret->tigrECN = sqlStringComma(&s);    ret->primLocus = sqlStringComma(&s);    ret->tigrLength = sqlUnsignedComma(&s);    ret->tigrPepLength = sqlUnsignedComma(&s);    ret->tigrMainRole = sqlStringComma(&s);    ret->tigrSubRole = sqlStringComma(&s);    ret->swissProt = sqlStringComma(&s);    ret->genbank = sqlStringComma(&s);    ret->tigrMw = sqlFloatComma(&s);    ret->tigrPi = sqlFloatComma(&s);    ret->tigrGc = sqlFloatComma(&s);    ret->goTerm = sqlStringComma(&s);    *pS = s;    return ret;}

struct dbRIP *dbRIPCommaIn(char **pS, struct dbRIP *ret)/* Create a dbRIP out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new dbRIP */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlUnsignedComma(&s);ret->chromEnd = sqlUnsignedComma(&s);ret->name = sqlStringComma(&s);ret->score = sqlUnsignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->originalId = sqlStringComma(&s);ret->forwardPrimer = sqlStringComma(&s);ret->reversePrimer = sqlStringComma(&s);ret->polyClass = sqlStringComma(&s);ret->polyFamily = sqlStringComma(&s);ret->polySubfamily = sqlStringComma(&s);ret->polySeq = sqlStringComma(&s);ret->polySource = sqlStringComma(&s);ret->reference = sqlStringComma(&s);ret->ascertainingMethod = sqlStringComma(&s);ret->remarks = sqlStringComma(&s);ret->tm = sqlFloatComma(&s);ret->filledSize = sqlSignedComma(&s);ret->emptySize = sqlSignedComma(&s);ret->disease = sqlStringComma(&s);ret->genoRegion = sqlStringComma(&s);*pS = s;return ret;}

struct tfbsConsFactors *tfbsConsFactorsCommaIn(char **pS, struct tfbsConsFactors *ret)/* Create a tfbsConsFactors out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new tfbsConsFactors */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->name = sqlStringComma(&s);ret->ac = sqlStringComma(&s);sqlFixedStringComma(&s, ret->species, sizeof(ret->species));sqlFixedStringComma(&s, ret->factor, sizeof(ret->factor));sqlFixedStringComma(&s, ret->id, sizeof(ret->id));*pS = s;return ret;}

struct ccdsInfo *ccdsInfoCommaIn(char **pS, struct ccdsInfo *ret)/* Create a ccdsInfo out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new ccdsInfo */{char *s = *pS;char srcDbBuf[2];if (ret == NULL)    AllocVar(ret);sqlFixedStringComma(&s, ret->ccds, sizeof(ret->ccds));sqlFixedStringComma(&s, srcDbBuf, sizeof(srcDbBuf));sqlFixedStringComma(&s, ret->mrnaAcc, sizeof(ret->mrnaAcc));ret->srcDb = parseSrcDb(srcDbBuf, ret->mrnaAcc);sqlFixedStringComma(&s, ret->protAcc, sizeof(ret->protAcc));*pS = s;return ret;}

struct altProbe *altProbeCommaIn(char **pS, struct altProbe *ret)/* Create a altProbe out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new altProbe */{char *s = *pS;int i;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlSignedComma(&s);ret->chromEnd = sqlSignedComma(&s);ret->type = sqlSignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->name = sqlStringComma(&s);ret->maxCounts = sqlSignedComma(&s);ret->contProbeCount = sqlSignedComma(&s);s = sqlEatChar(s, '{');AllocArray(ret->contProbeSets, ret->contProbeCount);for (i=0; i<ret->contProbeCount; ++i)    {    ret->contProbeSets[i] = sqlStringComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');ret->alt1ProbeCount = sqlSignedComma(&s);s = sqlEatChar(s, '{');AllocArray(ret->alt1ProbeSets, ret->alt1ProbeCount);for (i=0; i<ret->alt1ProbeCount; ++i)    {    ret->alt1ProbeSets[i] = sqlStringComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');ret->alt2ProbeCount = sqlSignedComma(&s);s = sqlEatChar(s, '{');AllocArray(ret->alt2ProbeSets, ret->alt2ProbeCount);for (i=0; i<ret->alt2ProbeCount; ++i)    {    ret->alt2ProbeSets[i] = sqlStringComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');ret->transcriptCount = sqlSignedComma(&s);s = sqlEatChar(s, '{');AllocArray(ret->transcriptNames, ret->transcriptCount);for (i=0; i<ret->transcriptCount; ++i)    {    ret->transcriptNames[i] = sqlStringComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');*pS = s;return ret;}

struct pslWQueryID *pslWQueryIDCommaIn(char **pS, struct pslWQueryID *ret)/* Create a pslWQueryID out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new pslWQueryID */{char *s = *pS;int i;if (ret == NULL)    AllocVar(ret);ret->matches = sqlUnsignedComma(&s);ret->misMatches = sqlUnsignedComma(&s);ret->repMatches = sqlUnsignedComma(&s);ret->nCount = sqlUnsignedComma(&s);ret->qNumInsert = sqlUnsignedComma(&s);ret->qBaseInsert = sqlUnsignedComma(&s);ret->tNumInsert = sqlUnsignedComma(&s);ret->tBaseInsert = sqlUnsignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->qName = sqlStringComma(&s);ret->qSize = sqlUnsignedComma(&s);ret->qStart = sqlUnsignedComma(&s);ret->qEnd = sqlUnsignedComma(&s);ret->tName = sqlStringComma(&s);ret->tSize = sqlUnsignedComma(&s);ret->tStart = sqlUnsignedComma(&s);ret->tEnd = sqlUnsignedComma(&s);ret->blockCount = sqlUnsignedComma(&s);s = sqlEatChar(s, '{');AllocArray(ret->blockSizes, ret->blockCount);for (i=0; i<ret->blockCount; ++i)    {    ret->blockSizes[i] = sqlUnsignedComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');s = sqlEatChar(s, '{');AllocArray(ret->qStarts, ret->blockCount);for (i=0; i<ret->blockCount; ++i)    {    ret->qStarts[i] = sqlUnsignedComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');s = sqlEatChar(s, '{');AllocArray(ret->tStarts, ret->blockCount);for (i=0; i<ret->blockCount; ++i)    {    ret->tStarts[i] = sqlUnsignedComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');ret->queryID = sqlStringComma(&s);*pS = s;return ret;}

struct uniref *unirefCommaIn(char **pS, struct uniref *ret)/* Create a uniref out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new uniref */{char *s = *pS;if (ret == NULL)    AllocVar(ret);sqlFixedStringComma(&s, ret->entryId, sizeof(ret->entryId));sqlFixedStringComma(&s, ret->type, sizeof(ret->type));sqlFixedStringComma(&s, ret->upId, sizeof(ret->upId));sqlFixedStringComma(&s, ret->upAcc, sizeof(ret->upAcc));ret->org = sqlStringComma(&s);ret->tax = sqlSignedComma(&s);ret->len = sqlSignedComma(&s);*pS = s;return ret;}

struct mafSummary *mafSummaryCommaIn(char **pS, struct mafSummary *ret)/* Create a mafSummary out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new mafSummary */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlUnsignedComma(&s);ret->chromEnd = sqlUnsignedComma(&s);ret->src = sqlStringComma(&s);ret->score = sqlFloatComma(&s);sqlFixedStringComma(&s, ret->leftStatus, sizeof(ret->leftStatus));sqlFixedStringComma(&s, ret->rightStatus, sizeof(ret->rightStatus));*pS = s;return ret;}

struct transMapSrc *transMapSrcCommaIn(char **pS, struct transMapSrc *ret)/* Create a transMapSrc out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new transMapSrc */{char *s = *pS;if (ret == NULL)    AllocVar(ret);sqlFixedStringComma(&s, ret->db, sizeof(ret->db));ret->id = sqlStringComma(&s);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlUnsignedComma(&s);ret->chromEnd = sqlUnsignedComma(&s);sqlFixedStringComma(&s, &(ret->strand), sizeof(ret->strand));ret->ident = sqlFloatComma(&s);ret->aligned = sqlFloatComma(&s);*pS = s;return ret;}

struct affy10KDetails *affy10KDetailsCommaIn(char **pS, struct affy10KDetails *ret)/* Create a affy10KDetails out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new affy10KDetails */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->affyId = sqlStringComma(&s);ret->rsId = sqlStringComma(&s);ret->tscId = sqlStringComma(&s);sqlFixedStringComma(&s, ret->baseA, sizeof(ret->baseA));sqlFixedStringComma(&s, ret->baseB, sizeof(ret->baseB));sqlFixedStringComma(&s, ret->sequenceA, sizeof(ret->sequenceA));sqlFixedStringComma(&s, ret->sequenceB, sizeof(ret->sequenceB));sqlFixedStringComma(&s, ret->enzyme, sizeof(ret->enzyme));*pS = s;return ret;}

struct gsSeqInfo *gsSeqInfoCommaIn(char **pS, struct gsSeqInfo *ret)/* Create a gsSeqInfo out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new gsSeqInfo */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->acc = sqlStringComma(&s);sqlFixedStringComma(&s, ret->gi, sizeof(ret->gi));ret->size = sqlUnsignedComma(&s);ret->phase = sqlUnsignedComma(&s);sqlFixedStringComma(&s, ret->draft, sizeof(ret->draft));ret->chrom = sqlStringComma(&s);ret->lab = sqlStringComma(&s);ret->cloneName = sqlStringComma(&s);*pS = s;return ret;}

struct txEdgeBed *txEdgeBedCommaIn(char **pS, struct txEdgeBed *ret)/* Create a txEdgeBed out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new txEdgeBed */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = sqlSignedComma(&s);ret->chromEnd = sqlSignedComma(&s);ret->name = sqlStringComma(&s);ret->score = sqlSignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));sqlFixedStringComma(&s, ret->startType, sizeof(ret->startType));ret->type = sqlEnumComma(&s, values_type, &valhash_type);sqlFixedStringComma(&s, ret->endType, sizeof(ret->endType));*pS = s;return ret;}