struct gbAlignInfo gbAlignGet(struct gbSelect* select,
                              struct gbSelect* prevSelect)
/* Build files to align in the work directory.  If this is not a full release,
 * or there is no previously aligned release, prevSelect should be NULL.
 */
{
struct gbAlignInfo alignInfo;

gbVerbEnter(1, "gbAlignGet: %s", gbSelectDesc(select));
if (prevSelect != NULL)
    prevSelect->orgCats = select->orgCats;

/* load the required entry data */
gbReleaseLoadProcessed(select);
if (prevSelect != NULL)
    {
    gbReleaseLoadProcessed(prevSelect);
    gbReleaseLoadAligned(prevSelect);
    }

/* select entries to align */
gbVerbEnter(2, "selecting seqs to align");
alignInfo = gbAlignFindNeedAligned(select, prevSelect);
gbVerbLeave(2, "selecting seqs to align");

if (alignInfo.migrate.accTotalCnt > 0)
    gbVerbMsg(1, "gbAlignGet: %d %s entries, %d alignments will be migrated",
              alignInfo.migrate.accTotalCnt, gbFmtSelect(select->type),
              alignInfo.migrate.recTotalCnt);

/* create fasta with sequences to align if not empty */
if (alignInfo.align.accTotalCnt > 0)
    {
    gbVerbMsg(1, "gbAlignGet: %d %s sequences will be align",
              alignInfo.align.accTotalCnt, gbFmtSelect(select->type));
    copySelectedFasta(select);
    }

/* leave calling cards */
if (select->orgCats & GB_NATIVE)
    markAligns(select, GB_NATIVE);
if (select->orgCats & GB_XENO)
    markAligns(select, GB_XENO);

/* print before releasing memory */
gbVerbLeave(1, "gbAlignGet: %s", gbSelectDesc(select));

/* unload entries to free memory */
gbReleaseUnload(select->release);
if (prevSelect != NULL)
    gbReleaseUnload(prevSelect->release);
return alignInfo;
}
void processMetaData(struct sqlConnection *conn, struct gbSelect* select,
                     struct gbStatusTbl* statusTbl, char* tmpDir)
/* Parse and load the metadata */
{
struct gbUpdate* update;

gbVerbEnter(3, "processing metadata");
gbMetaDataInit(conn, select->release->srcDb, &gOptions, 
               gGbdbGenBank, tmpDir);

for (update = select->release->updates; update != NULL; update = update->next)
    {
    if (update->selectProc)
        {
        select->update = update;
        parseUpdateMetaData(conn, select, statusTbl);
        }
    }
select->update = NULL;
gbVerbLeave(3, "processing metadata");
if (!(gOptions.flags & DBLOAD_INITIAL))
    {
    gbMetaDataUpdateChgGenes(conn, select, statusTbl, tmpDir);
    loadMetaData(conn);
    }
}
void loadAligns(struct sqlConnection *conn)
/* load pending alignments */
{
gbVerbEnter(3, "load alignments");
gbAlignDataDbLoad(conn);
gbVerbLeave(3, "load alignments");
}
void loadMetaData(struct sqlConnection *conn)
/* load the metadata into the database */
{
gbVerbEnter(3, "loading metadata");
gbMetaDataDbLoad(conn);
gbVerbLeave(3, "loading metadata");
}
void checkMrnaPartition(struct gbSelect* select)
/* Check an mRNA partition.  For genbank, check all ESTs against
 * this mRNA partation. */
{
struct hashCookie cookie;
struct hashEl* hel;

gbReleaseLoadProcessed(select);
struct gbSelect* prevSelect = gbProcessedGetPrevRel(select);
if (prevSelect != NULL)
    gbReleaseLoadProcessed(prevSelect);

gbVerbEnter(2, "checking %s", gbSelectDesc(select));
cookie = hashFirst(select->release->entryTbl);
while ((hel = hashNext(&cookie)) != NULL)
    checkOrgCat(hel->val, prevSelect);
gbVerbLeave(2, "checking %s", gbSelectDesc(select));
if (select->release->srcDb == GB_GENBANK)
    checkEstPartitions(select->release);

gbReleaseUnload(select->release);
if (prevSelect != NULL)
    {
    gbReleaseUnload(prevSelect->release);
    freeMem(prevSelect);
    }
}
void deleteOutdated(struct sqlConnection *conn, struct gbSelect* select,
                    struct gbStatusTbl* statusTbl, char* tmpDir)
/* delete outdated alignments and metadata from the database. */
{
gbVerbEnter(3, "delete outdated");

/* first the alignments */
gbVerbMsg(4, "delete outdated alignments");
gbAlignDataDeleteOutdated(gDatabase, conn, select, statusTbl, &gOptions, tmpDir);

/* now drop metadata entries */
gbVerbMsg(4, "delete outdated metadata");
gbMetaDataDeleteOutdated(conn, select, statusTbl, &gOptions, tmpDir);

/* Now it's safe to drop deleted entries from the database status table. */
gbVerbMsg(4, "delete outdated gbStatus");
gbStatusTblRemoveDeleted(statusTbl, conn);

/* orphaned now become new */
statusTbl->newList = slCat(statusTbl->newList, statusTbl->orphanList);
statusTbl->orphanList = NULL;
statusTbl->numNew += statusTbl->numOrphan;
statusTbl->numOrphan = 0;

gbVerbLeave(3, "delete outdated");
}
void loadMgcStatus(struct sqlConnection *conn, char *mgcStatusTab, char *statusTblName)
/* load the mgcStatus or mgcFullStatus tables, return name loaded */
{
struct lineFile* inLf;
FILE *outFh;
char tmpFile[PATH_LEN];
gbVerbEnter(2, "loading %s", statusTblName);

/* uncompress to tmp file */
safef(tmpFile, sizeof(tmpFile), "%s/mgcStatus.%s.%d.tmp", workDir,
      getHost(), getpid());
inLf = gzLineFileOpen(mgcStatusTab);
outFh = gzMustOpen(tmpFile, "w");

while (mgcStatusTblCopyRow(inLf, outFh))
    continue;

gzClose(&outFh);
gzLineFileClose(&inLf);

mgcStatusTblCreate(conn, statusTblName);

sqlLoadTabFile(conn, tmpFile, statusTblName, SQL_TAB_FILE_ON_SERVER);
unlink(tmpFile);

gbVerbLeave(2, "loading %s", statusTblName);
}
struct metaDataTbls* chkMetaDataTbls(struct gbSelect* select,
                                     struct sqlConnection* conn,
                                     boolean checkExtSeqRecs,
                                     unsigned descOrgCats,
                                     char* gbdbMapToCurrent)
/* load the metadata tables do basic validatation.  descOrgCats are
 * orgCats that should have descriptions. */
{
struct metaDataTbls* metaDataTbls;

gbVerbEnter(1, "load and check metadata tables: %s", gbSelectDesc(select));

metaDataTbls = metaDataTblsNew();

/* order is important here to allow checking between tables */
loadGbCdnaInfoData(metaDataTbls, select, conn);
if (select->release->srcDb == GB_REFSEQ)
    {
    /* must load before seq data due to protein checks */
    loadRefSeqStatus(metaDataTbls, conn);
    loadRefLink(metaDataTbls, conn);
    }
loadSeqData(metaDataTbls, select, conn, checkExtSeqRecs, gbdbMapToCurrent);
loadGbStatus(metaDataTbls, select, descOrgCats, conn);

gbVerbLeave(1, "load and check metadata tables: %s", gbSelectDesc(select));
return metaDataTbls;
}
예제 #9
0
void migratePsls(struct migrateAligns* migrate, unsigned pslFileType,
                 struct gbEntryCnts* counts, FILE* outPslFh)
/* Migrate selected PSL records */
{
char inPsl[PATH_LEN];
struct lineFile* inPslLf;
struct psl* psl;

gbAlignedGetPath(migrate->prevSelect, gPslFileGzExt[pslFileType], NULL, inPsl);

/* It's possible to end up here and not have a file if none of the sequences
 * aligned */
if (fileExists(inPsl))
    {
    gbVerbEnter(2, "migrating %ss from %s", gPslFileExt[pslFileType], inPsl);
    inPslLf = gzLineFileOpen(inPsl);
    while ((psl = pslNext(inPslLf)) != NULL)
        {
        migratePsl(migrate, pslFileType, counts, psl, inPsl, outPslFh);
        pslFree(&psl);
        }
    gzLineFileClose(&inPslLf);
    gbVerbLeave(2, "migrating %ss from %s", gPslFileExt[pslFileType], inPsl);
    }
}
void createMgcFailedEst(struct sqlConnection *conn)
/* create the mgcFailedEst table */
{
char sql[1024];
char tmpTbl[32];
tblBldGetTmpName(tmpTbl, sizeof(tmpTbl), MGC_FAILED_EST_TBL);

gbVerbEnter(2, "loading %s", tmpTbl);

tblBldRemakePslTable(conn, tmpTbl, "all_est");

/* insert a join by image id of the all_est table and mgcStatus rows having
 * failed status values, only getting 5' ESTs.  No acc in mgcStatus indicates
 * a imageClone id that has not be sequenced. */
safef(sql, sizeof(sql),
      "INSERT INTO %s"
      "  SELECT all_est.* FROM all_est,  mgcStatus_tmp, imageClone"
      "    WHERE (all_est.qName = imageClone.acc)"
      "      AND (imageClone.direction = '5')"
      "      AND (mgcStatus_tmp.imageId = imageClone.imageId)"
      "      AND (mgcStatus_tmp.acc = '')"
      "      AND (mgcStatus_tmp.state = %d)",
      tmpTbl, MGC_STATE_PROBLEM);
sqlUpdate(conn, sql);
gbVerbLeave(2, "loading %s", tmpTbl);
}
예제 #11
0
int main(int argc, char *argv[])
/* Process command line. */
{
char *database;

optionInit(&argc, argv, optionSpecs);
if (argc != 2)
    usage();
if (optionExists("gbdbCurrent"))
    {
    char* p;
    gGbdbMapToCurrent = optionVal("gbdbCurrent", NULL);
    /* trim trailing slashes */
    for (p = gGbdbMapToCurrent + (strlen(gGbdbMapToCurrent)-1);
         ((p > gGbdbMapToCurrent) && (*p == '/')); p--)
        *p = '\0';
    }
gbVerbInit(optionInt("verbose", 0));
if (gbVerbose >= 5)
    sqlMonitorEnable(JKSQL_TRACE);
database = argv[1];
gOptions = dbLoadOptionsParse(database);
testMode = optionExists("test");
gCheckExtSeqRecs = optionExists("checkExtSeqRecs");

gbVerbEnter(0, "gbSanity: begin: %s", database);
gbSanity(database);
gbVerbLeave(0, "gbSanity: completed: %d errors", errorCnt);
return ((errorCnt == 0) ? 0 : 1);
}
예제 #12
0
void migrateAligned(struct gbSelect* select, struct gbSelect* prevSelect,
                    struct gbAlignInfo* alignInfo, struct outputFiles* out,
                    struct recCounts* recCounts)
/* Migrate existing aligned PSLs from an earlier release. */
{
int orgCatIdx = gbOrgCatIdx(select->orgCats);
struct gbUpdate* prevUpdateHold = prevSelect->update;
struct gbUpdate* prevUpdate;
struct migrateAligns migrate;
ZeroVar(&migrate);
migrate.select = select;
migrate.prevSelect = prevSelect;

/* traverse all updates in the previous release */
gbVerbEnter(1, "migrating alignments");
for (prevUpdate = prevSelect->release->updates; prevUpdate != NULL;
     prevUpdate = prevUpdate->next)
    {
    prevSelect->update = prevUpdate;
    migrateAlignedUpdate(prevSelect, &migrate, out, recCounts);
    }
prevSelect->update = prevUpdateHold;
recCountsSum(recCounts, &migrate.counts);
if (migrate.counts.pslCnts.recCnt[orgCatIdx] != alignInfo->migrate.recCnt[orgCatIdx])
    errAbort("expected to migrate %d %s PSLs, found %d",
             alignInfo->migrate.recCnt[orgCatIdx], gbOrgCatName(select->orgCats),
             migrate.counts.pslCnts.recCnt[orgCatIdx]);
gbVerbLeave(1, "migrating alignments");
}
void createMgcUnpickedEst(struct sqlConnection *conn)
/* create the mgcUnpickedEst table */
{
char sql[1024];
char tmpTbl[32];
tblBldGetTmpName(tmpTbl, sizeof(tmpTbl), MGC_UNPICKED_EST_TBL);

gbVerbEnter(2, "loading %s", tmpTbl);

tblBldRemakePslTable(conn, tmpTbl, "all_est");

/* insert a join by accession of the all_mrna table and mgcStatus rows not
 * full-length or inprogress status values.  No acc in mgcStatus indicates a
 * imageClone id that has not be sequenced. */
safef(sql, sizeof(sql),
      "INSERT INTO %s"
      "  SELECT all_est.* FROM all_est,  mgcStatus_tmp, imageClone"
      "    WHERE (all_est.qName = imageClone.acc)"
      "      AND (imageClone.direction = '5')"
      "      AND (mgcStatus_tmp.imageId = imageClone.imageId)"
      "      AND (mgcStatus_tmp.acc = '')"
      "      AND (mgcStatus_tmp.state = %d)",
      tmpTbl, MGC_STATE_UNPICKED);
sqlUpdate(conn, sql);
gbVerbLeave(2, "loading %s", tmpTbl);
}
void copySelectedFasta(struct gbSelect* select)
/* copy FASTA records that were selected for alignment, segregating by
 * native/xeno, and partitioning large files. */
{
char inFasta[PATH_LEN];
struct gbFa* inFa;
struct outFa* nativeFa = NULL;
struct outFa* xenoFa = NULL;
if (select->orgCats & GB_NATIVE)
    nativeFa = outFaNew(select, GB_NATIVE);
if (select->orgCats & GB_XENO)
    xenoFa = outFaNew(select, GB_XENO);

gbProcessedGetPath(select, "fa", inFasta);
gbVerbEnter(2, "copying from %s", inFasta);
inFa = gbFaOpen(inFasta, "r");

while (copyFastaRec(select, inFa, nativeFa, xenoFa))
    continue;

outFaFree(&nativeFa);
outFaFree(&xenoFa);
gbFaClose(&inFa);
gbVerbLeave(2, "copying from %s", inFasta);
}
void moveAll(char *srcDb, char* destDb)
/* Rename all gbLoadRna tables from database to another. */
{
struct slName *tables, *tbl;
struct sqlConnection *conn;
struct dyString* sqlCmd = dyStringNew(256);
char *sep;

gbVerbEnter(1, "moveAll");
conn = hAllocConn(srcDb);
gbLockDb(conn, srcDb);
gbLockDb(conn, destDb);

copyChromInfo(conn, destDb);

/* using one does rename atomically */
tables = getTableList(conn);
dyStringAppend(sqlCmd, "rename table");
sep = " "; /* before first table arg */
for (tbl = tables; tbl != NULL; tbl = tbl->next)
    {
    dyStringPrintf(sqlCmd, "%s%s to %s.%s",
                   sep,tbl->name, destDb, tbl->name);
    sep = ", "; /* before other table arg */
    }
sqlUpdate(conn, sqlCmd->string);
dyStringFree(&sqlCmd);
slFreeList(&tables);

gbUnlockDb(conn, destDb);
gbUnlockDb(conn, srcDb);
hFreeConn(&conn);
gbVerbLeave(1, "moveAll");
}
void copyAll(char *srcDb, char* destDb)
/* Copy all gbLoadRna tables from database to another. */
{
struct slName *tables, *tbl;
struct sqlConnection *conn;

gbVerbEnter(1, "copyAll");
conn = hAllocConn(srcDb);
gbLockDb(conn, srcDb);
gbLockDb(conn, destDb);

copyChromInfo(conn, destDb);

/* copy each table */
tables = getTableList(conn);
for (tbl = tables; tbl != NULL; tbl = tbl->next)
    {
    copyTable(conn, destDb, tbl->name, tbl->name);
    }
slFreeList(&tables);
gbUnlockDb(conn, destDb);
gbUnlockDb(conn, srcDb);
hFreeConn(&conn);
gbVerbLeave(1, "copyAll");
}
void cleanExtFileTable()
/* clean up extFile table if we change references for any seq */
{
struct sqlConnection *conn = hAllocConn(gDatabase);
gbVerbEnter(3, "cleaning extFileTbl");
extFileTblClean(conn, (gbVerbose >= 4));
gbVerbLeave(3, "cleaning extFileTbl");
hFreeConn(&conn);
}
void createMgcGenes(struct sqlConnection *conn)
/* create the mgcGenes table from the mgcFullMrna table */
{
char tmpGeneTbl[32], tmpMrnaTbl[32];
tblBldGetTmpName(tmpGeneTbl, sizeof(tmpGeneTbl), MGC_GENES_TBL);
tblBldGetTmpName(tmpMrnaTbl, sizeof(tmpMrnaTbl), MGC_FULL_MRNA_TBL);

gbVerbEnter(2, "loading %s", tmpGeneTbl);
tblBldGenePredFromPsl(conn, workDir, tmpMrnaTbl, tmpGeneTbl, stderr);
gbVerbLeave(2, "loading %s", tmpGeneTbl);
}
void mgcDropTables(char *database)
/* drop all MGC-related tables. */
{
struct sqlConnection *conn = hAllocConn(database);
gbVerbEnter(1, "droping MGC tables");

tblBldDropTables(conn, mgcFullTables, TBLBLD_REAL_TABLE|TBLBLD_TMP_TABLE|TBLBLD_OLD_TABLE);
tblBldDropTables(conn, mgcAllTables, TBLBLD_REAL_TABLE|TBLBLD_TMP_TABLE|TBLBLD_OLD_TABLE);

hFreeConn(&conn);
gbVerbLeave(1, "droping MGC tables");
}
void parseUpdateMetaData(struct sqlConnection *conn,
                         struct gbSelect* select, 
                         struct gbStatusTbl* statusTbl)
/* Parse metadata for changed and new entry for an update.  Done one
 * update at a time to allow reading the ra file in sequential order
 * (as there is one per update).  This doesn't load the mrna or seq
 * tables, but might add to the unique string tables. */
{
gbVerbEnter(4, "process metadata for %s", gbSelectDesc(select));
gbMetaDataProcess(conn, statusTbl, select);
gbUpdateClearSelectVer(select->update);
gbVerbLeave(4, "process metadata for %s", gbSelectDesc(select));
}
void chkMetaDataXRef(struct metaDataTbls* metaDataTbls)
/* Verify that data that is referenced in some tables is in all expected
 * tables.  Called after processing all indices */
{
struct metaData* md;

gbVerbEnter(1, "cross check metadata");

metaDataTblsFirst(metaDataTbls);
while ((md = metaDataTblsNext(metaDataTbls)) != NULL)
    checkXRef(md);
gbVerbLeave(1, "cross check metadata");
}
예제 #22
0
static void chkGbRelease(struct gbSelect* select,
                         struct metaDataTbls* metaDataTbls)
/* Check a partation of gbRelease */
{
gbVerbEnter(1, "check: %s", gbSelectDesc(select));
/* load required entry date */
gbReleaseLoadProcessed(select);
gbReleaseLoadAligned(select);

chkGbIndex(select, metaDataTbls);

/* unload entries to free memory */
gbReleaseUnload(select->release);
gbVerbLeave(1, "check: %s", gbSelectDesc(select));
}
예제 #23
0
static void chkAlignCounts(struct metaDataTbls* metaDataTbls,
                           char* dbTableDesc, unsigned typeFlags)
/* check alignment counts found in tables, also reset the counts
 * Type includes GB_NATIVE or GB_XENO. */
{
struct metaData* md;

gbVerbEnter(3, "chkAlignCounts %s", dbTableDesc);

/* Traverse all metadata entries, comparing number of alignments with
 * gbStatus. */
metaDataTblsFirst(metaDataTbls);
while ((md = metaDataTblsNext(metaDataTbls)) != NULL)
    chkAlignCount(md, metaDataTbls, dbTableDesc, typeFlags);
gbVerbLeave(3, "chkAlignCounts %s", dbTableDesc);
}
예제 #24
0
static void chkGenePredTable(struct gbSelect* select,
                             struct sqlConnection* conn,
                             char* table, boolean isRefFlat, 
                             struct metaDataTbls* metaDataTbls,
                             unsigned typeFlags)
/* Validate a genePred table.  Also count the number of genePreds for a
 * mrna.  If this is refFlat, also check the geneName.  Return numbner of
 * rows. */
{
gbVerbEnter(3, "chkGenePredTable %s", table);
if (!sqlTableExists(conn, table))
    gbError("no genePred table %s.%s", select->release->genome->database,
            table);
else
    chkGenePredRows(select, conn, table, isRefFlat, metaDataTbls, typeFlags);
gbVerbLeave(3, "chkGenePredTable %s", table);
}
void doLoadPartition(struct gbSelect* select)
/* Do work of syncing the database with the state in the genbank respository for
 * a given partition.  */
{
gbVerbEnter(2, "load for %s", gbSelectDesc(select));

/* load required entry date */
gbReleaseLoadProcessed(select);
gbReleaseLoadAligned(select);

databaseUpdate(select);

gbVerbLeave(2, "load for %s", gbSelectDesc(select));

/* unload entries to free memory */
gbReleaseUnload(select->release);
}
void dropAll(char *database)
/* Drop all gbLoadRna tables from database. */
{
struct slName *tables, *tbl;
struct sqlConnection *conn;

gbVerbEnter(1, "dropAll");
conn = hAllocConn(database);
gbLockDb(conn, NULL);

tables = getTableList(conn);
for (tbl = tables; tbl != NULL; tbl = tbl->next)
    sqlDropTable(conn, tbl->name);
slFreeList(&tables);
gbUnlockDb(conn, NULL);
hFreeConn(&conn);
gbVerbLeave(1, "dropAll");
}
void processUpdateAligns(struct sqlConnection *conn, struct gbSelect* select,
                         struct gbUpdate* update,
                         struct gbStatusTbl* statusTbl)
/* Get alignements for an update.  */
{
select->update = update;
gbVerbEnter(4, "process alignments: %s", gbSelectDesc(select));

if (select->orgCats & GB_NATIVE)
    processUpdateAlignsForOrgCat(conn, select, GB_NATIVE, statusTbl);
if (select->orgCats & GB_XENO)
    processUpdateAlignsForOrgCat(conn, select, GB_XENO, statusTbl);

gbUpdateClearSelectVer(select->update);

gbVerbLeave(4, "process alignments: %s", gbSelectDesc(select));
select->update = NULL;
}
void mgcDbLoad(char *database, char *mgcStatusTabFile)
/* Load the database with the MGC tables. */
{
gbVerbEnter(1, "Loading MGC tables");
struct sqlConnection *conn = hAllocConn(database);
buildMgcTbls(conn, mgcStatusTabFile);
installMgcTbls(conn);

/*  Drop tables only on *OTHER* type of browser, in case switching */
tblBldDropTables(conn, ((allMgcTables) ? mgcFullOnlyTables : mgcAllOnlyTables), TBLBLD_REAL_TABLE);

/* Now get ride of old and do tmp as well, in case of switching browser
 * type */
tblBldDropTables(conn, mgcFullTables, TBLBLD_TMP_TABLE|TBLBLD_OLD_TABLE);
tblBldDropTables(conn, mgcAllTables, TBLBLD_TMP_TABLE|TBLBLD_OLD_TABLE);

hFreeConn(&conn);
gbVerbLeave(1, "Loading MGC tables");
}
예제 #29
0
void gbAlignInstall(struct gbSelect* select, struct gbSelect* prevSelect)
/* Install alignments, optionally migrating unchanged ones from a previous
 * release.  This does one update, accPrefix and either native or xeno */
{
char nativeAlignIdx[PATH_LEN], xenoAlignIdx[PATH_LEN];
struct gbAlignInfo alignInfo;

gbVerbEnter(1, "gbAlignInstall: %s", gbSelectDesc(select));

/* load required entry date */
gbReleaseLoadProcessed(select);
if (prevSelect != NULL)
    {
    gbReleaseLoadProcessed(prevSelect);
    gbReleaseLoadAligned(prevSelect);
    }

/* mark entries and updates to migrate or align */
alignInfo = gbAlignFindNeedAligned(select, prevSelect);

/* Process each category */
if (select->orgCats & GB_NATIVE)
    installOrgCatAligned(select, GB_NATIVE, prevSelect, &alignInfo,
                         nativeAlignIdx);
if (select->orgCats & GB_XENO)
    installOrgCatAligned(select, GB_XENO, prevSelect, &alignInfo,
                         xenoAlignIdx);

/* now indices can be renamed, not completely atomic, but good enough */
if (select->orgCats & GB_NATIVE)
    gbOutputRename(nativeAlignIdx, NULL);
if (select->orgCats & GB_XENO)
    gbOutputRename(xenoAlignIdx, NULL);

/* print message before memory is freed */
gbVerbLeave(1, "gbAlignInstall: %s", gbSelectDesc(select));

/* unload entries to free memory */
gbReleaseUnload(select->release);
if (prevSelect != NULL)
    gbReleaseUnload(prevSelect->release);
}
예제 #30
0
int chkAlignTables(char *db, struct gbSelect* select, struct sqlConnection* conn,
                   struct metaDataTbls* metaDataTbls, struct dbLoadOptions *options)
/* Verify all of the alignment-related. */
{
int cnt = 0;
if (gChromSizes == NULL)
    buildChromSizes(db);
gbVerbEnter(1, "validating alignment tables: %s", gbSelectDesc(select));
if (select->release->srcDb & GB_GENBANK)
    {
    chkGenBankAlignTables(select, conn, metaDataTbls, options);
    cnt++;
    }
if (select->release->srcDb & GB_REFSEQ)
    {
    chkRefSeqAlignTables(select, conn, metaDataTbls, options);
    cnt++;
    }
gbVerbLeave(1, "validated alignment tables: %s", gbSelectDesc(select));
return cnt;
}