src/hg/instinct/bioInt2/bioIntDb.h 1.1
1.1 2009/03/20 06:06:31 jsanborn
initial commit
Index: src/hg/instinct/bioInt2/bioIntDb.h
===================================================================
RCS file: src/hg/instinct/bioInt2/bioIntDb.h
diff -N src/hg/instinct/bioInt2/bioIntDb.h
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ src/hg/instinct/bioInt2/bioIntDb.h 20 Mar 2009 06:06:31 -0000 1.1
@@ -0,0 +1,1248 @@
+/* bioIntDb.h was originally generated by the autoSql program, which also
+ * generated bioIntDb.c and bioIntDb.sql. This header links the database and
+ * the RAM representation of objects. */
+
+#ifndef BIOINTDB_H
+#define BIOINTDB_H
+
+#include "jksql.h"
+#define PATHWAYS_NUM_COLS 3
+
+struct pathways
+/* Pathway List */
+ {
+ struct pathways *next; /* Next in singly linked list. */
+ unsigned id; /* Unique id */
+ char *name; /* Pathway name */
+ char *source; /* Pathway Source, i.e. KEGG, BioCarta */
+ };
+
+void pathwaysStaticLoad(char **row, struct pathways *ret);
+/* Load a row from pathways table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct pathways *pathwaysLoad(char **row);
+/* Load a pathways from row fetched with select * from pathways
+ * from database. Dispose of this with pathwaysFree(). */
+
+struct pathways *pathwaysLoadAll(char *fileName);
+/* Load all pathways from whitespace-separated file.
+ * Dispose of this with pathwaysFreeList(). */
+
+struct pathways *pathwaysLoadAllByChar(char *fileName, char chopper);
+/* Load all pathways from chopper separated file.
+ * Dispose of this with pathwaysFreeList(). */
+
+#define pathwaysLoadAllByTab(a) pathwaysLoadAllByChar(a, '\t');
+/* Load all pathways from tab separated file.
+ * Dispose of this with pathwaysFreeList(). */
+
+struct pathways *pathwaysLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all pathways from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with pathwaysFreeList(). */
+
+void pathwaysSaveToDb(struct sqlConnection *conn, struct pathways *el, char *tableName, int updateSize);
+/* Save pathways as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use pathwaysSaveToDbEscaped() */
+
+void pathwaysSaveToDbEscaped(struct sqlConnection *conn, struct pathways *el, char *tableName, int updateSize);
+/* Save pathways as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than pathwaysSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct pathways *pathwaysCommaIn(char **pS, struct pathways *ret);
+/* Create a pathways out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new pathways */
+
+void pathwaysFree(struct pathways **pEl);
+/* Free a single dynamically allocated pathways such as created
+ * with pathwaysLoad(). */
+
+void pathwaysFreeList(struct pathways **pList);
+/* Free a list of dynamically allocated pathways's */
+
+void pathwaysOutput(struct pathways *el, FILE *f, char sep, char lastSep);
+/* Print out pathways. Separate fields with sep. Follow last field with lastSep. */
+
+#define pathwaysTabOut(el,f) pathwaysOutput(el,f,'\t','\n');
+/* Print out pathways as a line in a tab-separated file. */
+
+#define pathwaysCommaOut(el,f) pathwaysOutput(el,f,',',',');
+/* Print out pathways as a comma separated list including final comma. */
+
+#define PATHWAYGENES_NUM_COLS 2
+
+struct pathwayGenes
+/* Pathway Genes */
+ {
+ struct pathwayGenes *next; /* Next in singly linked list. */
+ unsigned id; /* Unique id */
+ unsigned gene_id; /* Gene id */
+ };
+
+void pathwayGenesStaticLoad(char **row, struct pathwayGenes *ret);
+/* Load a row from pathwayGenes table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct pathwayGenes *pathwayGenesLoad(char **row);
+/* Load a pathwayGenes from row fetched with select * from pathwayGenes
+ * from database. Dispose of this with pathwayGenesFree(). */
+
+struct pathwayGenes *pathwayGenesLoadAll(char *fileName);
+/* Load all pathwayGenes from whitespace-separated file.
+ * Dispose of this with pathwayGenesFreeList(). */
+
+struct pathwayGenes *pathwayGenesLoadAllByChar(char *fileName, char chopper);
+/* Load all pathwayGenes from chopper separated file.
+ * Dispose of this with pathwayGenesFreeList(). */
+
+#define pathwayGenesLoadAllByTab(a) pathwayGenesLoadAllByChar(a, '\t');
+/* Load all pathwayGenes from tab separated file.
+ * Dispose of this with pathwayGenesFreeList(). */
+
+struct pathwayGenes *pathwayGenesLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all pathwayGenes from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with pathwayGenesFreeList(). */
+
+void pathwayGenesSaveToDb(struct sqlConnection *conn, struct pathwayGenes *el, char *tableName, int updateSize);
+/* Save pathwayGenes as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use pathwayGenesSaveToDbEscaped() */
+
+void pathwayGenesSaveToDbEscaped(struct sqlConnection *conn, struct pathwayGenes *el, char *tableName, int updateSize);
+/* Save pathwayGenes as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than pathwayGenesSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct pathwayGenes *pathwayGenesCommaIn(char **pS, struct pathwayGenes *ret);
+/* Create a pathwayGenes out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new pathwayGenes */
+
+void pathwayGenesFree(struct pathwayGenes **pEl);
+/* Free a single dynamically allocated pathwayGenes such as created
+ * with pathwayGenesLoad(). */
+
+void pathwayGenesFreeList(struct pathwayGenes **pList);
+/* Free a list of dynamically allocated pathwayGenes's */
+
+void pathwayGenesOutput(struct pathwayGenes *el, FILE *f, char sep, char lastSep);
+/* Print out pathwayGenes. Separate fields with sep. Follow last field with lastSep. */
+
+#define pathwayGenesTabOut(el,f) pathwayGenesOutput(el,f,'\t','\n');
+/* Print out pathwayGenes as a line in a tab-separated file. */
+
+#define pathwayGenesCommaOut(el,f) pathwayGenesOutput(el,f,',',',');
+/* Print out pathwayGenes as a comma separated list including final comma. */
+
+#define PATHWAYINFO_NUM_COLS 2
+
+struct pathwayInfo
+/* Pathway Information */
+ {
+ struct pathwayInfo *next; /* Next in singly linked list. */
+ unsigned id; /* Unique id */
+ char *description; /* Description of pathway */
+ };
+
+void pathwayInfoStaticLoad(char **row, struct pathwayInfo *ret);
+/* Load a row from pathwayInfo table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct pathwayInfo *pathwayInfoLoad(char **row);
+/* Load a pathwayInfo from row fetched with select * from pathwayInfo
+ * from database. Dispose of this with pathwayInfoFree(). */
+
+struct pathwayInfo *pathwayInfoLoadAll(char *fileName);
+/* Load all pathwayInfo from whitespace-separated file.
+ * Dispose of this with pathwayInfoFreeList(). */
+
+struct pathwayInfo *pathwayInfoLoadAllByChar(char *fileName, char chopper);
+/* Load all pathwayInfo from chopper separated file.
+ * Dispose of this with pathwayInfoFreeList(). */
+
+#define pathwayInfoLoadAllByTab(a) pathwayInfoLoadAllByChar(a, '\t');
+/* Load all pathwayInfo from tab separated file.
+ * Dispose of this with pathwayInfoFreeList(). */
+
+struct pathwayInfo *pathwayInfoLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all pathwayInfo from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with pathwayInfoFreeList(). */
+
+void pathwayInfoSaveToDb(struct sqlConnection *conn, struct pathwayInfo *el, char *tableName, int updateSize);
+/* Save pathwayInfo as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use pathwayInfoSaveToDbEscaped() */
+
+void pathwayInfoSaveToDbEscaped(struct sqlConnection *conn, struct pathwayInfo *el, char *tableName, int updateSize);
+/* Save pathwayInfo as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than pathwayInfoSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct pathwayInfo *pathwayInfoCommaIn(char **pS, struct pathwayInfo *ret);
+/* Create a pathwayInfo out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new pathwayInfo */
+
+void pathwayInfoFree(struct pathwayInfo **pEl);
+/* Free a single dynamically allocated pathwayInfo such as created
+ * with pathwayInfoLoad(). */
+
+void pathwayInfoFreeList(struct pathwayInfo **pList);
+/* Free a list of dynamically allocated pathwayInfo's */
+
+void pathwayInfoOutput(struct pathwayInfo *el, FILE *f, char sep, char lastSep);
+/* Print out pathwayInfo. Separate fields with sep. Follow last field with lastSep. */
+
+#define pathwayInfoTabOut(el,f) pathwayInfoOutput(el,f,'\t','\n');
+/* Print out pathwayInfo as a line in a tab-separated file. */
+
+#define pathwayInfoCommaOut(el,f) pathwayInfoOutput(el,f,',',',');
+/* Print out pathwayInfo as a comma separated list including final comma. */
+
+#define TISSUES_NUM_COLS 2
+
+struct tissues
+/* All available issues */
+ {
+ struct tissues *next; /* Next in singly linked list. */
+ unsigned id; /* Unique id */
+ char *name; /* Tissue Type */
+ };
+
+void tissuesStaticLoad(char **row, struct tissues *ret);
+/* Load a row from tissues table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct tissues *tissuesLoad(char **row);
+/* Load a tissues from row fetched with select * from tissues
+ * from database. Dispose of this with tissuesFree(). */
+
+struct tissues *tissuesLoadAll(char *fileName);
+/* Load all tissues from whitespace-separated file.
+ * Dispose of this with tissuesFreeList(). */
+
+struct tissues *tissuesLoadAllByChar(char *fileName, char chopper);
+/* Load all tissues from chopper separated file.
+ * Dispose of this with tissuesFreeList(). */
+
+#define tissuesLoadAllByTab(a) tissuesLoadAllByChar(a, '\t');
+/* Load all tissues from tab separated file.
+ * Dispose of this with tissuesFreeList(). */
+
+struct tissues *tissuesLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all tissues from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with tissuesFreeList(). */
+
+void tissuesSaveToDb(struct sqlConnection *conn, struct tissues *el, char *tableName, int updateSize);
+/* Save tissues as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use tissuesSaveToDbEscaped() */
+
+void tissuesSaveToDbEscaped(struct sqlConnection *conn, struct tissues *el, char *tableName, int updateSize);
+/* Save tissues as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than tissuesSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct tissues *tissuesCommaIn(char **pS, struct tissues *ret);
+/* Create a tissues out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new tissues */
+
+void tissuesFree(struct tissues **pEl);
+/* Free a single dynamically allocated tissues such as created
+ * with tissuesLoad(). */
+
+void tissuesFreeList(struct tissues **pList);
+/* Free a list of dynamically allocated tissues's */
+
+void tissuesOutput(struct tissues *el, FILE *f, char sep, char lastSep);
+/* Print out tissues. Separate fields with sep. Follow last field with lastSep. */
+
+#define tissuesTabOut(el,f) tissuesOutput(el,f,'\t','\n');
+/* Print out tissues as a line in a tab-separated file. */
+
+#define tissuesCommaOut(el,f) tissuesOutput(el,f,',',',');
+/* Print out tissues as a comma separated list including final comma. */
+
+#define DATATYPES_NUM_COLS 3
+
+struct dataTypes
+/* All available data types */
+ {
+ struct dataTypes *next; /* Next in singly linked list. */
+ unsigned id; /* Unique id */
+ char *format; /* Data Format */
+ char *name; /* Data type */
+ };
+
+void dataTypesStaticLoad(char **row, struct dataTypes *ret);
+/* Load a row from dataTypes table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct dataTypes *dataTypesLoad(char **row);
+/* Load a dataTypes from row fetched with select * from dataTypes
+ * from database. Dispose of this with dataTypesFree(). */
+
+struct dataTypes *dataTypesLoadAll(char *fileName);
+/* Load all dataTypes from whitespace-separated file.
+ * Dispose of this with dataTypesFreeList(). */
+
+struct dataTypes *dataTypesLoadAllByChar(char *fileName, char chopper);
+/* Load all dataTypes from chopper separated file.
+ * Dispose of this with dataTypesFreeList(). */
+
+#define dataTypesLoadAllByTab(a) dataTypesLoadAllByChar(a, '\t');
+/* Load all dataTypes from tab separated file.
+ * Dispose of this with dataTypesFreeList(). */
+
+struct dataTypes *dataTypesLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all dataTypes from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with dataTypesFreeList(). */
+
+void dataTypesSaveToDb(struct sqlConnection *conn, struct dataTypes *el, char *tableName, int updateSize);
+/* Save dataTypes as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use dataTypesSaveToDbEscaped() */
+
+void dataTypesSaveToDbEscaped(struct sqlConnection *conn, struct dataTypes *el, char *tableName, int updateSize);
+/* Save dataTypes as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than dataTypesSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct dataTypes *dataTypesCommaIn(char **pS, struct dataTypes *ret);
+/* Create a dataTypes out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new dataTypes */
+
+void dataTypesFree(struct dataTypes **pEl);
+/* Free a single dynamically allocated dataTypes such as created
+ * with dataTypesLoad(). */
+
+void dataTypesFreeList(struct dataTypes **pList);
+/* Free a list of dynamically allocated dataTypes's */
+
+void dataTypesOutput(struct dataTypes *el, FILE *f, char sep, char lastSep);
+/* Print out dataTypes. Separate fields with sep. Follow last field with lastSep. */
+
+#define dataTypesTabOut(el,f) dataTypesOutput(el,f,'\t','\n');
+/* Print out dataTypes as a line in a tab-separated file. */
+
+#define dataTypesCommaOut(el,f) dataTypesOutput(el,f,',',',');
+/* Print out dataTypes as a comma separated list including final comma. */
+
+#define DATASETS_NUM_COLS 8
+
+struct datasets
+/* All available datasets */
+ {
+ struct datasets *next; /* Next in singly linked list. */
+ unsigned id; /* Unique Id */
+ unsigned tissue_id; /* Numeric id denoting tissue type */
+ unsigned type_id; /* Type of genomics data */
+ unsigned num_samples; /* Number of samples in study */
+ char *name; /* Dataset name */
+ char *data_table; /* Array Data tablename */
+ char *probe_table; /* Probe tablename */
+ char *probe_to_gene_table; /* Probe to gene tablename */
+ };
+
+void datasetsStaticLoad(char **row, struct datasets *ret);
+/* Load a row from datasets table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct datasets *datasetsLoad(char **row);
+/* Load a datasets from row fetched with select * from datasets
+ * from database. Dispose of this with datasetsFree(). */
+
+struct datasets *datasetsLoadAll(char *fileName);
+/* Load all datasets from whitespace-separated file.
+ * Dispose of this with datasetsFreeList(). */
+
+struct datasets *datasetsLoadAllByChar(char *fileName, char chopper);
+/* Load all datasets from chopper separated file.
+ * Dispose of this with datasetsFreeList(). */
+
+#define datasetsLoadAllByTab(a) datasetsLoadAllByChar(a, '\t');
+/* Load all datasets from tab separated file.
+ * Dispose of this with datasetsFreeList(). */
+
+struct datasets *datasetsLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all datasets from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with datasetsFreeList(). */
+
+void datasetsSaveToDb(struct sqlConnection *conn, struct datasets *el, char *tableName, int updateSize);
+/* Save datasets as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use datasetsSaveToDbEscaped() */
+
+void datasetsSaveToDbEscaped(struct sqlConnection *conn, struct datasets *el, char *tableName, int updateSize);
+/* Save datasets as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than datasetsSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct datasets *datasetsCommaIn(char **pS, struct datasets *ret);
+/* Create a datasets out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new datasets */
+
+void datasetsFree(struct datasets **pEl);
+/* Free a single dynamically allocated datasets such as created
+ * with datasetsLoad(). */
+
+void datasetsFreeList(struct datasets **pList);
+/* Free a list of dynamically allocated datasets's */
+
+void datasetsOutput(struct datasets *el, FILE *f, char sep, char lastSep);
+/* Print out datasets. Separate fields with sep. Follow last field with lastSep. */
+
+#define datasetsTabOut(el,f) datasetsOutput(el,f,'\t','\n');
+/* Print out datasets as a line in a tab-separated file. */
+
+#define datasetsCommaOut(el,f) datasetsOutput(el,f,',',',');
+/* Print out datasets as a comma separated list including final comma. */
+
+#define GENELOOKUP_NUM_COLS 2
+
+struct geneLookup
+/* Lookup table linking knownGene */
+ {
+ struct geneLookup *next; /* Next in singly linked list. */
+ unsigned id; /* Unique Id */
+ char *kgId; /* Known Gene Id */
+ };
+
+void geneLookupStaticLoad(char **row, struct geneLookup *ret);
+/* Load a row from geneLookup table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct geneLookup *geneLookupLoad(char **row);
+/* Load a geneLookup from row fetched with select * from geneLookup
+ * from database. Dispose of this with geneLookupFree(). */
+
+struct geneLookup *geneLookupLoadAll(char *fileName);
+/* Load all geneLookup from whitespace-separated file.
+ * Dispose of this with geneLookupFreeList(). */
+
+struct geneLookup *geneLookupLoadAllByChar(char *fileName, char chopper);
+/* Load all geneLookup from chopper separated file.
+ * Dispose of this with geneLookupFreeList(). */
+
+#define geneLookupLoadAllByTab(a) geneLookupLoadAllByChar(a, '\t');
+/* Load all geneLookup from tab separated file.
+ * Dispose of this with geneLookupFreeList(). */
+
+struct geneLookup *geneLookupLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all geneLookup from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with geneLookupFreeList(). */
+
+void geneLookupSaveToDb(struct sqlConnection *conn, struct geneLookup *el, char *tableName, int updateSize);
+/* Save geneLookup as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use geneLookupSaveToDbEscaped() */
+
+void geneLookupSaveToDbEscaped(struct sqlConnection *conn, struct geneLookup *el, char *tableName, int updateSize);
+/* Save geneLookup as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than geneLookupSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct geneLookup *geneLookupCommaIn(char **pS, struct geneLookup *ret);
+/* Create a geneLookup out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new geneLookup */
+
+void geneLookupFree(struct geneLookup **pEl);
+/* Free a single dynamically allocated geneLookup such as created
+ * with geneLookupLoad(). */
+
+void geneLookupFreeList(struct geneLookup **pList);
+/* Free a list of dynamically allocated geneLookup's */
+
+void geneLookupOutput(struct geneLookup *el, FILE *f, char sep, char lastSep);
+/* Print out geneLookup. Separate fields with sep. Follow last field with lastSep. */
+
+#define geneLookupTabOut(el,f) geneLookupOutput(el,f,'\t','\n');
+/* Print out geneLookup as a line in a tab-separated file. */
+
+#define geneLookupCommaOut(el,f) geneLookupOutput(el,f,',',',');
+/* Print out geneLookup as a comma separated list including final comma. */
+
+#define PROBEINFO_NUM_COLS 5
+
+struct probeInfo
+/* Probe Information */
+ {
+ struct probeInfo *next; /* Next in singly linked list. */
+ unsigned id; /* Unique Id */
+ char *chrom; /* Chromosome */
+ unsigned start; /* Start Base */
+ unsigned stop; /* Stop Base */
+ char *name; /* Probe Name */
+ };
+
+void probeInfoStaticLoad(char **row, struct probeInfo *ret);
+/* Load a row from probeInfo table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct probeInfo *probeInfoLoad(char **row);
+/* Load a probeInfo from row fetched with select * from probeInfo
+ * from database. Dispose of this with probeInfoFree(). */
+
+struct probeInfo *probeInfoLoadAll(char *fileName);
+/* Load all probeInfo from whitespace-separated file.
+ * Dispose of this with probeInfoFreeList(). */
+
+struct probeInfo *probeInfoLoadAllByChar(char *fileName, char chopper);
+/* Load all probeInfo from chopper separated file.
+ * Dispose of this with probeInfoFreeList(). */
+
+#define probeInfoLoadAllByTab(a) probeInfoLoadAllByChar(a, '\t');
+/* Load all probeInfo from tab separated file.
+ * Dispose of this with probeInfoFreeList(). */
+
+struct probeInfo *probeInfoLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all probeInfo from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with probeInfoFreeList(). */
+
+void probeInfoSaveToDb(struct sqlConnection *conn, struct probeInfo *el, char *tableName, int updateSize);
+/* Save probeInfo as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use probeInfoSaveToDbEscaped() */
+
+void probeInfoSaveToDbEscaped(struct sqlConnection *conn, struct probeInfo *el, char *tableName, int updateSize);
+/* Save probeInfo as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than probeInfoSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct probeInfo *probeInfoCommaIn(char **pS, struct probeInfo *ret);
+/* Create a probeInfo out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new probeInfo */
+
+void probeInfoFree(struct probeInfo **pEl);
+/* Free a single dynamically allocated probeInfo such as created
+ * with probeInfoLoad(). */
+
+void probeInfoFreeList(struct probeInfo **pList);
+/* Free a list of dynamically allocated probeInfo's */
+
+void probeInfoOutput(struct probeInfo *el, FILE *f, char sep, char lastSep);
+/* Print out probeInfo. Separate fields with sep. Follow last field with lastSep. */
+
+#define probeInfoTabOut(el,f) probeInfoOutput(el,f,'\t','\n');
+/* Print out probeInfo as a line in a tab-separated file. */
+
+#define probeInfoCommaOut(el,f) probeInfoOutput(el,f,',',',');
+/* Print out probeInfo as a comma separated list including final comma. */
+
+#define PROBETOGENE_NUM_COLS 2
+
+struct probeToGene
+/* Lookup table linking probe id and gene id */
+ {
+ struct probeToGene *next; /* Next in singly linked list. */
+ unsigned probe_id; /* Probe Id */
+ unsigned gene_id; /* Gene Id */
+ };
+
+void probeToGeneStaticLoad(char **row, struct probeToGene *ret);
+/* Load a row from probeToGene table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct probeToGene *probeToGeneLoad(char **row);
+/* Load a probeToGene from row fetched with select * from probeToGene
+ * from database. Dispose of this with probeToGeneFree(). */
+
+struct probeToGene *probeToGeneLoadAll(char *fileName);
+/* Load all probeToGene from whitespace-separated file.
+ * Dispose of this with probeToGeneFreeList(). */
+
+struct probeToGene *probeToGeneLoadAllByChar(char *fileName, char chopper);
+/* Load all probeToGene from chopper separated file.
+ * Dispose of this with probeToGeneFreeList(). */
+
+#define probeToGeneLoadAllByTab(a) probeToGeneLoadAllByChar(a, '\t');
+/* Load all probeToGene from tab separated file.
+ * Dispose of this with probeToGeneFreeList(). */
+
+struct probeToGene *probeToGeneLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all probeToGene from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with probeToGeneFreeList(). */
+
+void probeToGeneSaveToDb(struct sqlConnection *conn, struct probeToGene *el, char *tableName, int updateSize);
+/* Save probeToGene as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use probeToGeneSaveToDbEscaped() */
+
+void probeToGeneSaveToDbEscaped(struct sqlConnection *conn, struct probeToGene *el, char *tableName, int updateSize);
+/* Save probeToGene as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than probeToGeneSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct probeToGene *probeToGeneCommaIn(char **pS, struct probeToGene *ret);
+/* Create a probeToGene out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new probeToGene */
+
+void probeToGeneFree(struct probeToGene **pEl);
+/* Free a single dynamically allocated probeToGene such as created
+ * with probeToGeneLoad(). */
+
+void probeToGeneFreeList(struct probeToGene **pList);
+/* Free a list of dynamically allocated probeToGene's */
+
+void probeToGeneOutput(struct probeToGene *el, FILE *f, char sep, char lastSep);
+/* Print out probeToGene. Separate fields with sep. Follow last field with lastSep. */
+
+#define probeToGeneTabOut(el,f) probeToGeneOutput(el,f,'\t','\n');
+/* Print out probeToGene as a line in a tab-separated file. */
+
+#define probeToGeneCommaOut(el,f) probeToGeneOutput(el,f,',',',');
+/* Print out probeToGene as a comma separated list including final comma. */
+
+#define PROBESAMPLEVAL_NUM_COLS 3
+
+struct probeSampleVal
+/* Probe values for single sample */
+ {
+ struct probeSampleVal *next; /* Next in singly linked list. */
+ unsigned probe_id; /* Probe Id */
+ unsigned sample_id; /* Sample Id */
+ float val; /* Exp Value */
+ };
+
+void probeSampleValStaticLoad(char **row, struct probeSampleVal *ret);
+/* Load a row from probeSampleVal table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct probeSampleVal *probeSampleValLoad(char **row);
+/* Load a probeSampleVal from row fetched with select * from probeSampleVal
+ * from database. Dispose of this with probeSampleValFree(). */
+
+struct probeSampleVal *probeSampleValLoadAll(char *fileName);
+/* Load all probeSampleVal from whitespace-separated file.
+ * Dispose of this with probeSampleValFreeList(). */
+
+struct probeSampleVal *probeSampleValLoadAllByChar(char *fileName, char chopper);
+/* Load all probeSampleVal from chopper separated file.
+ * Dispose of this with probeSampleValFreeList(). */
+
+#define probeSampleValLoadAllByTab(a) probeSampleValLoadAllByChar(a, '\t');
+/* Load all probeSampleVal from tab separated file.
+ * Dispose of this with probeSampleValFreeList(). */
+
+struct probeSampleVal *probeSampleValLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all probeSampleVal from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with probeSampleValFreeList(). */
+
+void probeSampleValSaveToDb(struct sqlConnection *conn, struct probeSampleVal *el, char *tableName, int updateSize);
+/* Save probeSampleVal as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use probeSampleValSaveToDbEscaped() */
+
+void probeSampleValSaveToDbEscaped(struct sqlConnection *conn, struct probeSampleVal *el, char *tableName, int updateSize);
+/* Save probeSampleVal as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than probeSampleValSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct probeSampleVal *probeSampleValCommaIn(char **pS, struct probeSampleVal *ret);
+/* Create a probeSampleVal out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new probeSampleVal */
+
+void probeSampleValFree(struct probeSampleVal **pEl);
+/* Free a single dynamically allocated probeSampleVal such as created
+ * with probeSampleValLoad(). */
+
+void probeSampleValFreeList(struct probeSampleVal **pList);
+/* Free a list of dynamically allocated probeSampleVal's */
+
+void probeSampleValOutput(struct probeSampleVal *el, FILE *f, char sep, char lastSep);
+/* Print out probeSampleVal. Separate fields with sep. Follow last field with lastSep. */
+
+#define probeSampleValTabOut(el,f) probeSampleValOutput(el,f,'\t','\n');
+/* Print out probeSampleVal as a line in a tab-separated file. */
+
+#define probeSampleValCommaOut(el,f) probeSampleValOutput(el,f,',',',');
+/* Print out probeSampleVal as a comma separated list including final comma. */
+
+#define PROBEVALS_NUM_COLS 3
+
+struct probeVals
+/* Probe values for all samples */
+ {
+ struct probeVals *next; /* Next in singly linked list. */
+ unsigned probe_id; /* Probe Id */
+ unsigned sample_count; /* Sample Count */
+ float *sample_data; /* Sample Data */
+ };
+
+struct probeVals *probeValsLoad(char **row);
+/* Load a probeVals from row fetched with select * from probeVals
+ * from database. Dispose of this with probeValsFree(). */
+
+struct probeVals *probeValsLoadAll(char *fileName);
+/* Load all probeVals from whitespace-separated file.
+ * Dispose of this with probeValsFreeList(). */
+
+struct probeVals *probeValsLoadAllByChar(char *fileName, char chopper);
+/* Load all probeVals from chopper separated file.
+ * Dispose of this with probeValsFreeList(). */
+
+#define probeValsLoadAllByTab(a) probeValsLoadAllByChar(a, '\t');
+/* Load all probeVals from tab separated file.
+ * Dispose of this with probeValsFreeList(). */
+
+struct probeVals *probeValsLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all probeVals from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with probeValsFreeList(). */
+
+void probeValsSaveToDb(struct sqlConnection *conn, struct probeVals *el, char *tableName, int updateSize);
+/* Save probeVals as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use probeValsSaveToDbEscaped() */
+
+void probeValsSaveToDbEscaped(struct sqlConnection *conn, struct probeVals *el, char *tableName, int updateSize);
+/* Save probeVals as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than probeValsSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct probeVals *probeValsCommaIn(char **pS, struct probeVals *ret);
+/* Create a probeVals out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new probeVals */
+
+void probeValsFree(struct probeVals **pEl);
+/* Free a single dynamically allocated probeVals such as created
+ * with probeValsLoad(). */
+
+void probeValsFreeList(struct probeVals **pList);
+/* Free a list of dynamically allocated probeVals's */
+
+void probeValsOutput(struct probeVals *el, FILE *f, char sep, char lastSep);
+/* Print out probeVals. Separate fields with sep. Follow last field with lastSep. */
+
+#define probeValsTabOut(el,f) probeValsOutput(el,f,'\t','\n');
+/* Print out probeVals as a line in a tab-separated file. */
+
+#define probeValsCommaOut(el,f) probeValsOutput(el,f,',',',');
+/* Print out probeVals as a comma separated list including final comma. */
+
+#define SAMPLES_NUM_COLS 7
+
+struct samples
+/* All sample info */
+ {
+ struct samples *next; /* Next in singly linked list. */
+ unsigned id; /* Unique Id */
+ char *name; /* Sample Name */
+ unsigned patient_id; /* Patient Id */
+ char *patient_name; /* Patient Name */
+ unsigned dataset_id; /* Dataset Id */
+ unsigned exp_id; /* Index in dataset -- for probeVals format */
+ unsigned tissue_id; /* Tissue Type Id */
+ };
+
+void samplesStaticLoad(char **row, struct samples *ret);
+/* Load a row from samples table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct samples *samplesLoad(char **row);
+/* Load a samples from row fetched with select * from samples
+ * from database. Dispose of this with samplesFree(). */
+
+struct samples *samplesLoadAll(char *fileName);
+/* Load all samples from whitespace-separated file.
+ * Dispose of this with samplesFreeList(). */
+
+struct samples *samplesLoadAllByChar(char *fileName, char chopper);
+/* Load all samples from chopper separated file.
+ * Dispose of this with samplesFreeList(). */
+
+#define samplesLoadAllByTab(a) samplesLoadAllByChar(a, '\t');
+/* Load all samples from tab separated file.
+ * Dispose of this with samplesFreeList(). */
+
+struct samples *samplesLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all samples from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with samplesFreeList(). */
+
+void samplesSaveToDb(struct sqlConnection *conn, struct samples *el, char *tableName, int updateSize);
+/* Save samples as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use samplesSaveToDbEscaped() */
+
+void samplesSaveToDbEscaped(struct sqlConnection *conn, struct samples *el, char *tableName, int updateSize);
+/* Save samples as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than samplesSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct samples *samplesCommaIn(char **pS, struct samples *ret);
+/* Create a samples out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new samples */
+
+void samplesFree(struct samples **pEl);
+/* Free a single dynamically allocated samples such as created
+ * with samplesLoad(). */
+
+void samplesFreeList(struct samples **pList);
+/* Free a list of dynamically allocated samples's */
+
+void samplesOutput(struct samples *el, FILE *f, char sep, char lastSep);
+/* Print out samples. Separate fields with sep. Follow last field with lastSep. */
+
+#define samplesTabOut(el,f) samplesOutput(el,f,'\t','\n');
+/* Print out samples as a line in a tab-separated file. */
+
+#define samplesCommaOut(el,f) samplesOutput(el,f,',',',');
+/* Print out samples as a comma separated list including final comma. */
+
+#define FEATURES_NUM_COLS 4
+
+struct features
+/* All Features */
+ {
+ struct features *next; /* Next in singly linked list. */
+ unsigned id; /* Unique Id */
+ char *name; /* Feature Name */
+ char *shortLabel; /* Short Label */
+ char *longLabel; /* Long Label */
+ };
+
+void featuresStaticLoad(char **row, struct features *ret);
+/* Load a row from features table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct features *featuresLoad(char **row);
+/* Load a features from row fetched with select * from features
+ * from database. Dispose of this with featuresFree(). */
+
+struct features *featuresLoadAll(char *fileName);
+/* Load all features from whitespace-separated file.
+ * Dispose of this with featuresFreeList(). */
+
+struct features *featuresLoadAllByChar(char *fileName, char chopper);
+/* Load all features from chopper separated file.
+ * Dispose of this with featuresFreeList(). */
+
+#define featuresLoadAllByTab(a) featuresLoadAllByChar(a, '\t');
+/* Load all features from tab separated file.
+ * Dispose of this with featuresFreeList(). */
+
+struct features *featuresLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all features from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with featuresFreeList(). */
+
+void featuresSaveToDb(struct sqlConnection *conn, struct features *el, char *tableName, int updateSize);
+/* Save features as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use featuresSaveToDbEscaped() */
+
+void featuresSaveToDbEscaped(struct sqlConnection *conn, struct features *el, char *tableName, int updateSize);
+/* Save features as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than featuresSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct features *featuresCommaIn(char **pS, struct features *ret);
+/* Create a features out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new features */
+
+void featuresFree(struct features **pEl);
+/* Free a single dynamically allocated features such as created
+ * with featuresLoad(). */
+
+void featuresFreeList(struct features **pList);
+/* Free a list of dynamically allocated features's */
+
+void featuresOutput(struct features *el, FILE *f, char sep, char lastSep);
+/* Print out features. Separate fields with sep. Follow last field with lastSep. */
+
+#define featuresTabOut(el,f) featuresOutput(el,f,'\t','\n');
+/* Print out features as a line in a tab-separated file. */
+
+#define featuresCommaOut(el,f) featuresOutput(el,f,',',',');
+/* Print out features as a comma separated list including final comma. */
+
+#define CLINICALDATA_NUM_COLS 4
+
+struct clinicalData
+/* All clinical data */
+ {
+ struct clinicalData *next; /* Next in singly linked list. */
+ unsigned sample_id; /* Sample Id */
+ unsigned feature_id; /* Feature Id */
+ double val; /* Value */
+ char *code; /* Coded Value */
+ };
+
+void clinicalDataStaticLoad(char **row, struct clinicalData *ret);
+/* Load a row from clinicalData table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct clinicalData *clinicalDataLoad(char **row);
+/* Load a clinicalData from row fetched with select * from clinicalData
+ * from database. Dispose of this with clinicalDataFree(). */
+
+struct clinicalData *clinicalDataLoadAll(char *fileName);
+/* Load all clinicalData from whitespace-separated file.
+ * Dispose of this with clinicalDataFreeList(). */
+
+struct clinicalData *clinicalDataLoadAllByChar(char *fileName, char chopper);
+/* Load all clinicalData from chopper separated file.
+ * Dispose of this with clinicalDataFreeList(). */
+
+#define clinicalDataLoadAllByTab(a) clinicalDataLoadAllByChar(a, '\t');
+/* Load all clinicalData from tab separated file.
+ * Dispose of this with clinicalDataFreeList(). */
+
+struct clinicalData *clinicalDataLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all clinicalData from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with clinicalDataFreeList(). */
+
+void clinicalDataSaveToDb(struct sqlConnection *conn, struct clinicalData *el, char *tableName, int updateSize);
+/* Save clinicalData as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use clinicalDataSaveToDbEscaped() */
+
+void clinicalDataSaveToDbEscaped(struct sqlConnection *conn, struct clinicalData *el, char *tableName, int updateSize);
+/* Save clinicalData as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than clinicalDataSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct clinicalData *clinicalDataCommaIn(char **pS, struct clinicalData *ret);
+/* Create a clinicalData out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new clinicalData */
+
+void clinicalDataFree(struct clinicalData **pEl);
+/* Free a single dynamically allocated clinicalData such as created
+ * with clinicalDataLoad(). */
+
+void clinicalDataFreeList(struct clinicalData **pList);
+/* Free a list of dynamically allocated clinicalData's */
+
+void clinicalDataOutput(struct clinicalData *el, FILE *f, char sep, char lastSep);
+/* Print out clinicalData. Separate fields with sep. Follow last field with lastSep. */
+
+#define clinicalDataTabOut(el,f) clinicalDataOutput(el,f,'\t','\n');
+/* Print out clinicalData as a line in a tab-separated file. */
+
+#define clinicalDataCommaOut(el,f) clinicalDataOutput(el,f,',',',');
+/* Print out clinicalData as a comma separated list including final comma. */
+
+#define ANALYSISFEATURES_NUM_COLS 2
+
+struct analysisFeatures
+/* All analysis features */
+ {
+ struct analysisFeatures *next; /* Next in singly linked list. */
+ unsigned feature_id; /* Feature Id */
+ char *feature_name; /* Feature Name */
+ };
+
+void analysisFeaturesStaticLoad(char **row, struct analysisFeatures *ret);
+/* Load a row from analysisFeatures table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct analysisFeatures *analysisFeaturesLoad(char **row);
+/* Load a analysisFeatures from row fetched with select * from analysisFeatures
+ * from database. Dispose of this with analysisFeaturesFree(). */
+
+struct analysisFeatures *analysisFeaturesLoadAll(char *fileName);
+/* Load all analysisFeatures from whitespace-separated file.
+ * Dispose of this with analysisFeaturesFreeList(). */
+
+struct analysisFeatures *analysisFeaturesLoadAllByChar(char *fileName, char chopper);
+/* Load all analysisFeatures from chopper separated file.
+ * Dispose of this with analysisFeaturesFreeList(). */
+
+#define analysisFeaturesLoadAllByTab(a) analysisFeaturesLoadAllByChar(a, '\t');
+/* Load all analysisFeatures from tab separated file.
+ * Dispose of this with analysisFeaturesFreeList(). */
+
+struct analysisFeatures *analysisFeaturesLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all analysisFeatures from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with analysisFeaturesFreeList(). */
+
+void analysisFeaturesSaveToDb(struct sqlConnection *conn, struct analysisFeatures *el, char *tableName, int updateSize);
+/* Save analysisFeatures as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use analysisFeaturesSaveToDbEscaped() */
+
+void analysisFeaturesSaveToDbEscaped(struct sqlConnection *conn, struct analysisFeatures *el, char *tableName, int updateSize);
+/* Save analysisFeatures as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than analysisFeaturesSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct analysisFeatures *analysisFeaturesCommaIn(char **pS, struct analysisFeatures *ret);
+/* Create a analysisFeatures out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new analysisFeatures */
+
+void analysisFeaturesFree(struct analysisFeatures **pEl);
+/* Free a single dynamically allocated analysisFeatures such as created
+ * with analysisFeaturesLoad(). */
+
+void analysisFeaturesFreeList(struct analysisFeatures **pList);
+/* Free a list of dynamically allocated analysisFeatures's */
+
+void analysisFeaturesOutput(struct analysisFeatures *el, FILE *f, char sep, char lastSep);
+/* Print out analysisFeatures. Separate fields with sep. Follow last field with lastSep. */
+
+#define analysisFeaturesTabOut(el,f) analysisFeaturesOutput(el,f,'\t','\n');
+/* Print out analysisFeatures as a line in a tab-separated file. */
+
+#define analysisFeaturesCommaOut(el,f) analysisFeaturesOutput(el,f,',',',');
+/* Print out analysisFeatures as a comma separated list including final comma. */
+
+#define ANALYSISVALS_NUM_COLS 4
+
+struct analysisVals
+/* All analysis vals */
+ {
+ struct analysisVals *next; /* Next in singly linked list. */
+ unsigned sample_id; /* Sample Id */
+ unsigned feature_id; /* Feature Id */
+ float val; /* Val */
+ float conf; /* Confidence */
+ };
+
+void analysisValsStaticLoad(char **row, struct analysisVals *ret);
+/* Load a row from analysisVals table into ret. The contents of ret will
+ * be replaced at the next call to this function. */
+
+struct analysisVals *analysisValsLoad(char **row);
+/* Load a analysisVals from row fetched with select * from analysisVals
+ * from database. Dispose of this with analysisValsFree(). */
+
+struct analysisVals *analysisValsLoadAll(char *fileName);
+/* Load all analysisVals from whitespace-separated file.
+ * Dispose of this with analysisValsFreeList(). */
+
+struct analysisVals *analysisValsLoadAllByChar(char *fileName, char chopper);
+/* Load all analysisVals from chopper separated file.
+ * Dispose of this with analysisValsFreeList(). */
+
+#define analysisValsLoadAllByTab(a) analysisValsLoadAllByChar(a, '\t');
+/* Load all analysisVals from tab separated file.
+ * Dispose of this with analysisValsFreeList(). */
+
+struct analysisVals *analysisValsLoadByQuery(struct sqlConnection *conn, char *query);
+/* Load all analysisVals from table that satisfy the query given.
+ * Where query is of the form 'select * from example where something=something'
+ * or 'select example.* from example, anotherTable where example.something =
+ * anotherTable.something'.
+ * Dispose of this with analysisValsFreeList(). */
+
+void analysisValsSaveToDb(struct sqlConnection *conn, struct analysisVals *el, char *tableName, int updateSize);
+/* Save analysisVals as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size
+ * of a string that would contain the entire query. Arrays of native types are
+ * converted to comma separated strings and loaded as such, User defined types are
+ * inserted as NULL. Note that strings must be escaped to allow insertion into the database.
+ * For example "autosql's features include" --> "autosql\'s features include"
+ * If worried about this use analysisValsSaveToDbEscaped() */
+
+void analysisValsSaveToDbEscaped(struct sqlConnection *conn, struct analysisVals *el, char *tableName, int updateSize);
+/* Save analysisVals as a row to the table specified by tableName.
+ * As blob fields may be arbitrary size updateSize specifies the approx size.
+ * of a string that would contain the entire query. Automatically
+ * escapes all simple strings (not arrays of string) but may be slower than analysisValsSaveToDb().
+ * For example automatically copies and converts:
+ * "autosql's features include" --> "autosql\'s features include"
+ * before inserting into database. */
+
+struct analysisVals *analysisValsCommaIn(char **pS, struct analysisVals *ret);
+/* Create a analysisVals out of a comma separated string.
+ * This will fill in ret if non-null, otherwise will
+ * return a new analysisVals */
+
+void analysisValsFree(struct analysisVals **pEl);
+/* Free a single dynamically allocated analysisVals such as created
+ * with analysisValsLoad(). */
+
+void analysisValsFreeList(struct analysisVals **pList);
+/* Free a list of dynamically allocated analysisVals's */
+
+void analysisValsOutput(struct analysisVals *el, FILE *f, char sep, char lastSep);
+/* Print out analysisVals. Separate fields with sep. Follow last field with lastSep. */
+
+#define analysisValsTabOut(el,f) analysisValsOutput(el,f,'\t','\n');
+/* Print out analysisVals as a line in a tab-separated file. */
+
+#define analysisValsCommaOut(el,f) analysisValsOutput(el,f,',',',');
+/* Print out analysisVals as a comma separated list including final comma. */
+
+/* -------------------------------- End autoSql Generated Code -------------------------------- */
+
+#endif /* BIOINTDB_H */
+