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

struct taxonNode *taxonNodeCommaIn(char **pS, struct taxonNode *ret)/* Create a taxonNode out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new taxonNode */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->taxon = sqlUnsignedComma(&s);ret->parent = sqlUnsignedComma(&s);ret->rank = sqlStringComma(&s);ret->emblcode = sqlStringComma(&s);ret->division = sqlUnsignedComma(&s);ret->inheritedDiv = sqlUnsignedComma(&s);ret->geneticCode = sqlUnsignedComma(&s);ret->inheritedGC = sqlUnsignedComma(&s);ret->mitoGeneticCode = sqlUnsignedComma(&s);ret->inheritedMitoGC = sqlUnsignedComma(&s);ret->GenBankHidden = sqlUnsignedComma(&s);ret->notSequenced = sqlUnsignedComma(&s);ret->comments = sqlStringComma(&s);*pS = s;return ret;}

struct snp125CodingCoordless *snp125CodingCoordlessCommaIn(char **pS, struct snp125CodingCoordless *ret)/* Create a snp125CodingCoordless out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new snp125CodingCoordless */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->name = sqlStringComma(&s);ret->transcript = sqlStringComma(&s);ret->frame = sqlEnumComma(&s, values_frame, &valhash_frame);ret->alleleCount = sqlSignedComma(&s);{int i;s = sqlEatChar(s, '{');AllocArray(ret->funcCodes, ret->alleleCount);for (i=0; i<ret->alleleCount; ++i)    {    ret->funcCodes[i] = sqlUnsignedComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');}{int i;s = sqlEatChar(s, '{');AllocArray(ret->alleles, ret->alleleCount);for (i=0; i<ret->alleleCount; ++i)    {    ret->alleles[i] = sqlStringComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');}{int i;s = sqlEatChar(s, '{');AllocArray(ret->codons, ret->alleleCount);for (i=0; i<ret->alleleCount; ++i)    {    ret->codons[i] = sqlStringComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');}{int i;s = sqlEatChar(s, '{');AllocArray(ret->peptides, ret->alleleCount);for (i=0; i<ret->alleleCount; ++i)    {    ret->peptides[i] = sqlStringComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');}*pS = s;return ret;}

struct recombRate *recombRateCommaIn(char **pS, struct recombRate *ret)/* Create a recombRate out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new recombRate */{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->decodeAvg = sqlFloatComma(&s);ret->decodeFemale = sqlFloatComma(&s);ret->decodeMale = sqlFloatComma(&s);ret->marshfieldAvg = sqlFloatComma(&s);ret->marshfieldFemale = sqlFloatComma(&s);ret->marshfieldMale = sqlFloatComma(&s);ret->genethonAvg = sqlFloatComma(&s);ret->genethonFemale = sqlFloatComma(&s);ret->genethonMale = sqlFloatComma(&s);*pS = s;return ret;}

struct imageClone *imageCloneCommaIn(char **pS, struct imageClone *ret)/* Create a imageClone out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new imageClone */{char *s = *pS;int i;if (ret == NULL)    AllocVar(ret);ret->id = sqlUnsignedComma(&s);ret->library = sqlStringComma(&s);ret->plateNum = sqlUnsignedComma(&s);ret->row = sqlStringComma(&s);ret->column = sqlUnsignedComma(&s);ret->libId = sqlUnsignedComma(&s);ret->organism = sqlStringComma(&s);ret->numGenbank = sqlSignedComma(&s);s = sqlEatChar(s, '{');AllocArray(ret->genbankIds, ret->numGenbank);for (i=0; i<ret->numGenbank; ++i)    {    ret->genbankIds[i] = sqlStringComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');*pS = s;return ret;}

struct rmskOut2 *rmskOut2CommaIn(char **pS, struct rmskOut2 *ret)/* Create a rmskOut2 out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new rmskOut2 */{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 = sqlUnsignedComma(&s);ret->repLeft = sqlSignedComma(&s);ret->id = sqlUnsignedComma(&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 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 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 submission *submissionCommaIn(char **pS, struct submission *ret)/* Create a submission out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new submission */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->id = sqlStringComma(&s);ret->host = sqlStringComma(&s);ret->cpuTime = sqlFloatComma(&s);ret->submitTime = sqlUnsignedComma(&s);ret->startTime = sqlUnsignedComma(&s);ret->endTime = sqlUnsignedComma(&s);ret->status = sqlSignedComma(&s);ret->gotStatus = sqlUnsignedComma(&s);ret->submitError = sqlUnsignedComma(&s);ret->inQueue = sqlUnsignedComma(&s);ret->queueError = sqlUnsignedComma(&s);ret->trackingError = sqlUnsignedComma(&s);ret->running = sqlUnsignedComma(&s);ret->crashed = sqlUnsignedComma(&s);ret->slow = sqlUnsignedComma(&s);ret->hung = sqlUnsignedComma(&s);ret->ranOk = sqlUnsignedComma(&s);ret->errFile = sqlStringComma(&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 tigrOperon *tigrOperonCommaIn(char **pS, struct tigrOperon *ret)/* Create a tigrOperon out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new tigrOperon */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->name = sqlStringComma(&s);ret->size = sqlUnsignedComma(&s);{int i;s = sqlEatChar(s, '{');AllocArray(ret->genes, ret->size);for (i=0; i<ret->size; ++i)    {    ret->genes[i] = sqlStringComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');}ret->info = sqlStringComma(&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 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 cnpSharp *cnpSharpCommaIn(char **pS, struct cnpSharp *ret)/* Create a cnpSharp out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new cnpSharp */{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->variationType = sqlStringComma(&s);ret->cytoName = sqlStringComma(&s);ret->cytoStrain = sqlStringComma(&s);ret->dupPercent = sqlFloatComma(&s);ret->repeatsPercent = sqlFloatComma(&s);ret->LINEpercent = sqlFloatComma(&s);ret->SINEpercent = sqlFloatComma(&s);ret->LTRpercent = sqlFloatComma(&s);ret->DNApercent = sqlFloatComma(&s);ret->diseaseSpotsPercent = sqlFloatComma(&s);*pS = s;return ret;}

struct wiggle *wiggleCommaIn(char **pS, struct wiggle *ret)/* Create a wiggle out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new wiggle */{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->span = sqlUnsignedComma(&s);ret->count = sqlUnsignedComma(&s);ret->offset = sqlUnsignedComma(&s);ret->file = sqlStringComma(&s);ret->lowerLimit = sqlDoubleComma(&s);ret->dataRange = sqlDoubleComma(&s);ret->validCount = sqlUnsignedComma(&s);ret->sumData = sqlDoubleComma(&s);ret->sumSquares = sqlDoubleComma(&s);*pS = s;return ret;}

struct simpleRepeat *simpleRepeatCommaIn(char **pS, struct simpleRepeat *ret)/* Create a simpleRepeat out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new simpleRepeat */{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->period = sqlUnsignedComma(&s);ret->copyNum = sqlFloatComma(&s);ret->consensusSize = sqlUnsignedComma(&s);ret->perMatch = sqlUnsignedComma(&s);ret->perIndel = sqlUnsignedComma(&s);ret->score = sqlUnsignedComma(&s);ret->A = sqlUnsignedComma(&s);ret->C = sqlUnsignedComma(&s);ret->G = sqlUnsignedComma(&s);ret->T = sqlUnsignedComma(&s);ret->entropy = sqlFloatComma(&s);ret->sequence = sqlStringComma(&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 cutter *cutterCommaIn(char **pS, struct cutter *ret)/* Create a cutter out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new cutter */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->name = sqlStringComma(&s);ret->size = sqlUnsignedComma(&s);ret->matchSize = sqlUnsignedComma(&s);ret->seq = sqlStringComma(&s);ret->cut = sqlUnsignedComma(&s);ret->overhang = sqlSignedComma(&s);ret->palindromic = sqlUnsignedComma(&s);ret->semicolon = sqlUnsignedComma(&s);ret->numSciz = sqlUnsignedComma(&s);{int i;s = sqlEatChar(s, '{');AllocArray(ret->scizs, ret->numSciz);for (i=0; i<ret->numSciz; ++i)    {    ret->scizs[i] = sqlStringComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');}ret->numCompanies = sqlUnsignedComma(&s);{int i;s = sqlEatChar(s, '{');AllocArray(ret->companies, ret->numCompanies);for (i=0; i<ret->numCompanies; ++i)    {    ret->companies[i] = sqlCharComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');}ret->numRefs = sqlUnsignedComma(&s);{int i;s = sqlEatChar(s, '{');AllocArray(ret->refs, ret->numRefs);for (i=0; i<ret->numRefs; ++i)    {    ret->refs[i] = sqlUnsignedComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');}*pS = s;return ret;}

struct pgSiftPred *pgSiftPredCommaIn(char **pS, struct pgSiftPred *ret)/* Create a pgSiftPred out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new pgSiftPred */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->chrom = sqlStringComma(&s);ret->chromStart = needMem(sizeof(unsigned));*(ret->chromStart) = sqlUnsignedComma(&s);ret->chromEnd = needMem(sizeof(unsigned));*(ret->chromEnd) = sqlUnsignedComma(&s);ret->prediction = sqlStringComma(&s);ret->geneId = sqlStringComma(&s);ret->geneName = sqlStringComma(&s);ret->geneDesc = sqlStringComma(&s);ret->protFamDesc = sqlStringComma(&s);ret->omimDisease = sqlStringComma(&s);ret->aveAlleleFreq = sqlStringComma(&s);ret->ceuAlleleFreq = sqlStringComma(&s);*pS = s;return ret;}

struct tableStatus *tableStatusCommaIn(char **pS, struct tableStatus *ret)/* Create a tableStatus out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new tableStatus */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->name = sqlStringComma(&s);ret->type = sqlStringComma(&s);ret->rowFormat = sqlStringComma(&s);ret->rows = sqlUnsignedComma(&s);ret->aveRowLength = sqlUnsignedComma(&s);ret->dataLength = sqlLongLongComma(&s);ret->maxDataLength = sqlLongLongComma(&s);ret->indexLength = sqlLongLongComma(&s);ret->dataFree = sqlLongLongComma(&s);ret->autoIncrement = sqlStringComma(&s);ret->createTime = sqlStringComma(&s);ret->updateTime = sqlStringComma(&s);ret->checkTime = sqlStringComma(&s);ret->createOptions = sqlStringComma(&s);ret->comment = sqlStringComma(&s);*pS = s;return ret;}

struct cdsSpec *cdsSpecCommaIn(char **pS, struct cdsSpec *ret)/* Create a cdsSpec out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new cdsSpec */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->id = sqlStringComma(&s);ret->cds = sqlStringComma(&s);*pS = s;return ret;}

struct transRegCodeCondition *transRegCodeConditionCommaIn(char **pS, struct transRegCodeCondition *ret)/* Create a transRegCodeCondition out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new transRegCodeCondition */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->name = sqlStringComma(&s);ret->growthCondition = sqlStringComma(&s);*pS = s;return ret;}

struct kgAlias *kgAliasCommaIn(char **pS, struct kgAlias *ret)/* Create a kgAlias out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new kgAlias */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->kgID = sqlStringComma(&s);ret->alias = sqlStringComma(&s);*pS = s;return ret;}

struct pepPred *pepPredCommaIn(char **pS, struct pepPred *ret)/* Create a pepPred out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new pepPred */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->name = sqlStringComma(&s);ret->seq = sqlStringComma(&s);*pS = s;return ret;}

struct fbSynonym *fbSynonymCommaIn(char **pS, struct fbSynonym *ret)/* Create a fbSynonym out of a comma separated string. * This will fill in ret if non-null, otherwise will * return a new fbSynonym */{    char *s = *pS;    if (ret == NULL)        AllocVar(ret);    ret->geneId = sqlStringComma(&s);    ret->name = sqlStringComma(&s);    *pS = s;    return ret;}

struct geneTree *geneTreeCommaIn(char **pS, struct geneTree *ret)/* Create a geneTree out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new geneTree */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->name = sqlStringComma(&s);ret->tree = sqlStringComma(&s);*pS = s;return ret;}

struct wgEncodeGencodePdb *wgEncodeGencodePdbCommaIn(char **pS, struct wgEncodeGencodePdb *ret)/* Create a wgEncodeGencodePdb out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new wgEncodeGencodePdb */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->transcriptId = sqlStringComma(&s);ret->pdbId = sqlStringComma(&s);*pS = s;return ret;}

struct sangerGeneToWBGeneID *sangerGeneToWBGeneIDCommaIn(char **pS, struct sangerGeneToWBGeneID *ret)/* Create a sangerGeneToWBGeneID out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new sangerGeneToWBGeneID */{char *s = *pS;if (ret == NULL)    AllocVar(ret);ret->sangerGene = sqlStringComma(&s);ret->WBGeneID = sqlStringComma(&s);*pS = s;return ret;}

struct splice *spliceCommaIn(char **pS, struct splice *ret)/* Create a splice out of a comma separated string.  * This will fill in ret if non-null, otherwise will * return a new splice */{char *s = *pS;int i;if (ret == NULL)    AllocVar(ret);ret->tName = sqlStringComma(&s);ret->tStart = sqlSignedComma(&s);ret->tEnd = sqlSignedComma(&s);ret->name = sqlStringComma(&s);ret->type = sqlSignedComma(&s);sqlFixedStringComma(&s, ret->strand, sizeof(ret->strand));ret->agxId = sqlSignedComma(&s);ret->vCount = sqlSignedComma(&s);s = sqlEatChar(s, '{');AllocArray(ret->vPositions, ret->vCount);for (i=0; i<ret->vCount; ++i)    {    ret->vPositions[i] = sqlSignedComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');s = sqlEatChar(s, '{');AllocArray(ret->vTypes, ret->vCount);for (i=0; i<ret->vCount; ++i)    {    ret->vTypes[i] = sqlUnsignedComma(&s);    }s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');ret->pathCount = sqlSignedComma(&s);s = sqlEatChar(s, '{');for (i=0; i<ret->pathCount; ++i)    {    s = sqlEatChar(s, '{');    if(s[0] != '}')        slSafeAddHead(&ret->paths, pathCommaIn(&s,NULL));    s = sqlEatChar(s, '}');    s = sqlEatChar(s, ',');    }slReverse(&ret->paths);s = sqlEatChar(s, '}');s = sqlEatChar(s, ',');*pS = s;return ret;}