static rc_t pacbio_meta_entry( ld_context *lctx, const char * toolname )
{
KMetadata* meta = NULL;
rc_t rc = VDatabaseOpenMetadataUpdate( lctx->database, &meta );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "Cannot open database-metadata" );
}
else
{
KMDataNode *node = NULL;
rc = KMetadataOpenNodeUpdate( meta, &node, "/" );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "Cannot open database-metadata-root" );
}
else
{
rc = KLoaderMeta_Write( node, toolname, __DATE__, "PacBio HDF5", PACBIO_LOAD_VERS );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "Cannot write pacbio metadata node" );
}
KMDataNodeRelease( node );
}
KMetadataRelease( meta );
}
return rc;
}
/* UseMetaRevision
* opens indicated revision of metadata
* all non-zero revisions are read-only
*/
LIB_EXPORT rc_t CC SRATableUseMetaRevision ( const SRATable *cself, uint32_t revision )
{
rc_t rc;
if ( cself == NULL )
rc = RC ( rcSRA, rcTable, rcUpdating, rcSelf, rcNull );
else if ( cself -> read_only == false )
rc = RC ( rcSRA, rcTable, rcUpdating, rcMetadata, rcBusy );
else
{
uint32_t cur;
rc = KMetadataRevision ( cself -> meta, & cur );
if ( rc == 0 && cur != revision )
{
SRATable *self = ( SRATable* ) cself;
const KMetadata *meta;
rc = KMetadataOpenRevision ( self -> meta, & meta, revision );
if ( rc == 0 )
{
KMetadataRelease ( self -> meta );
self -> meta = meta;
}
}
}
return rc;
}
static rc_t extract_spotgroups( VNamelist * spotgroups, input_files * ifs, bool from_stats )
{
rc_t rc = 0;
uint32_t i;
for ( i = 0; i < ifs->database_count && rc == 0; ++i )
{
input_database * id = VectorGet( &ifs->dbs, i );
if ( id != NULL )
{
if ( from_stats )
{
const VTable * tab;
rc = VDatabaseOpenTableRead( id->db, &tab, "SEQUENCE" );
if ( rc != 0 )
(void)PLOGERR( klogErr, ( klogErr, rc, "cannot open table SEQUENCE in '$(t)'", "t=%s", id->path ) );
else
{
const KMetadata * meta;
rc = VTableOpenMetadataRead( tab, &meta );
if ( rc != 0 )
(void)PLOGERR( klogErr, ( klogErr, rc, "cannot open metadata from '$(t)'", "t=%s", id->path ) );
else
{
if ( from_stats )
rc = extract_spotgroups_from_stats( spotgroups, id, meta );
KMetadataRelease( meta );
}
VTableRelease( tab );
}
}
else
{
const KMetadata * meta;
rc = VDatabaseOpenMetadataRead( id->db, &meta );
/* do not report if metadata cannot be found, because this would produce an error message when a database has
no metadata at all */
if ( rc == 0 )
{
rc = extract_spotgroups_from_bam_hdr( spotgroups, id, meta );
KMetadataRelease( meta );
}
}
}
}
return rc;
}
static rc_t copy_back_revisions ( const KMetadata *src_meta, VTable *dst_table,
const bool show_meta )
{
uint32_t max_revision, revision;
rc_t rc = KMetadataMaxRevision ( src_meta, &max_revision );
DISP_RC( rc, "copy_back_revisions:KMetadataMaxRevision() failed" );
if ( rc != 0 ) return rc;
if ( max_revision == 0 ) return rc;
for ( revision = 1; revision <= max_revision && rc == 0; ++revision )
{
const KMetadata *src_rev_meta;
if ( show_meta )
KOutMsg( "+++copy metadata rev. #%u:\n", revision );
rc = KMetadataOpenRevision ( src_meta, &src_rev_meta, revision );
DISP_RC( rc, "copy_back_revisions:KMetadataOpenRevision() failed" );
if ( rc == 0 )
{
KMetadata *dst_meta;
rc = VTableOpenMetadataUpdate ( dst_table, & dst_meta );
DISP_RC( rc, "copy_table_meta:VTableOpenMetadataUpdate() failed" );
if ( rc == 0 )
{
rc = copy_stray_metadata ( src_rev_meta, dst_meta, NULL, show_meta );
if ( rc == 0 )
{
rc = KMetadataCommit ( dst_meta );
DISP_RC( rc, "copy_back_revisions:KMetadataCommit() failed" );
if ( rc == 0 )
{
rc = KMetadataFreeze ( dst_meta );
DISP_RC( rc, "copy_back_revisions:KMetadataFreeze() failed" );
}
}
KMetadataRelease ( dst_meta );
}
KMetadataRelease ( src_rev_meta );
}
}
return rc;
}
static
void CC sra_meta_stats_whack( void *data )
{
sra_meta_stats_data *self = data;
sra_meta_stats_node_group_release(&self->table);
sra_meta_stats_node_group_release(&self->dflt_grp);
free(self->last_grp_name);
sra_meta_stats_node_group_release(&self->last_grp);
KMetadataRelease(self->meta);
free(self);
}
static rc_t get_tbl_schema_info(VTable const *const tbl,
unsigned const bsz, char buffer[])
{
KMetadata const *meta;
rc_t rc = VTableOpenMetadataRead(tbl, &meta);
buffer[0] = '\0';
if (rc == 0) rc = get_schema_info(meta, bsz, buffer);
KMetadataRelease(meta);
return rc;
}
static rc_t get_db_schema_info(VDatabase const *db,
unsigned const bsz, char buffer[])
{
KMetadata const *meta;
rc_t rc = VDatabaseOpenMetadataRead(db, &meta);
buffer[0] = '\0';
if (rc == 0) rc = get_schema_info(meta, bsz, buffer);
KMetadataRelease(meta);
return rc;
}
static
void CC stats_data_whack(void *const data)
{
stats_data_t *const self = data;
self->write_all(self);
KDataBufferWhack(&self->group);
KDataBufferWhack(&self->names);
KMetadataRelease(self->meta);
free(self);
}
void SRATableDestroy ( SRATable *self )
{
VectorWhack ( & self -> wcol, column_release, NULL );
VCursorRelease(self->curs);
KMetadataRelease ( self -> meta );
VTableRelease ( self -> vtbl );
SRAMgrSever ( self -> mgr );
memset(self, 0, sizeof *self);
free ( self );
}
rc_t AlignRefTableCursor(const VTable* table, const VCursor *native_curs, const VCursor** ref_cursor,const VTable **reftbl)
{
rc_t rc = 0;
char ref_tbl_name[512] = "REFERENCE";
const KMetadata* meta;
const VCursor *curs;
if( (rc = VTableOpenMetadataRead(table, &meta)) == 0 ) {
const KMDataNode* node;
if( (rc = KMetadataOpenNodeRead(meta, &node, "CONFIG/REF_TABLE")) == 0 ) {
size_t sz;
rc = KMDataNodeReadCString(node, ref_tbl_name, sizeof(ref_tbl_name), &sz);
ref_tbl_name[sz] = '\0';
KMDataNodeRelease(node);
}
KMetadataRelease(meta);
}
rc = VCursorLinkedCursorGet(native_curs,ref_tbl_name,&curs);
if(rc != 0){
const VDatabase *db;
const VTable *tbl;
/* get at the parent database */
rc = VTableOpenParentRead ( table, & db );
if(rc != 0) return rc;
/* open the table */
rc = VDatabaseOpenTableRead ( db, &tbl, ref_tbl_name);
VDatabaseRelease ( db );
if(rc != 0) return rc;
/* create a cursor */
rc = VTableCreateCachedCursorRead(tbl, &curs,256*1024*1024);
if(reftbl){
*reftbl = tbl;
} else {
VTableRelease(tbl);
}
if(rc != 0) return rc;
rc = VCursorPermitPostOpenAdd( curs );
if(rc != 0) return rc;
rc = VCursorOpen( curs );
if(rc != 0) return rc;
if(native_curs){
rc = VCursorLinkedCursorSet(native_curs,ref_tbl_name,curs);
}
if(rc != 0) return rc;
} else {
VCursorAddRef(curs);
}
*ref_cursor = curs;
return 0;
}
LIB_EXPORT rc_t CC TableWriterSeq_Whack(const TableWriterSeq* cself, bool commit, uint64_t* rows)
{
rc_t rc = 0;
if( cself != NULL ) {
TableWriterSeq* self = (TableWriterSeq*)cself;
VTable *vtbl;
TableReader_Whack(cself->tmpkey_reader);
if (commit && (rc = TableWriter_GetVTable(cself->base, &vtbl)) == 0 ) {
KMetadata* meta;
if ((rc = VTableOpenMetadataUpdate(vtbl, &meta)) == 0) {
KMDataNode* node = NULL;
if (cself->stats) {
if ((rc = KMetadataOpenNodeUpdate(meta, &node, "MATE_STATISTICS")) == 0) {
rc = TableWriterSeq_WriteStatistics(cself, node);
KMDataNodeRelease(node);
}
}
if ((rc = KMetadataOpenNodeUpdate(meta, &node, "unaligned")) == 0) {
KMDataNode *sub = NULL;
KMDataNodeOpenNodeUpdate(node, &sub, "first-unaligned");
KMDataNodeWriteB64(sub, &self->firstUnaligned);
KMDataNodeRelease(sub);
KMDataNodeOpenNodeUpdate(node, &sub, "first-half-aligned");
KMDataNodeWriteB64(sub, &self->firstHalfAligned);
KMDataNodeRelease(sub);
KMDataNodeRelease(node);
}
KMetadataRelease(meta);
}
}
rc = TableWriter_Whack(cself->base, commit && (rc == 0), rows);
KVectorRelease(cself->stats);
free(self->qual_buf);
free(self);
}
return rc;
}
/* Whack
*/
rc_t VTableWhack ( VTable *self )
{
KRefcountWhack ( & self -> refcount, "VTable" );
BSTreeWhack ( & self -> read_col_cache, VColumnRefWhack, NULL );
BSTreeWhack ( & self -> write_col_cache, VColumnRefWhack, NULL );
KMDataNodeRelease ( self -> col_node );
KMetadataRelease ( self -> meta );
KTableRelease ( self -> ktbl );
VSchemaRelease ( self -> schema );
VLinkerRelease ( self -> linker );
VDatabaseSever ( self -> db );
VDBManagerSever ( self -> mgr );
free ( self );
return 0;
}
static rc_t print_headers_from_metadata( const VDatabase * db, bool * recalc, const char * path )
{
const KMetadata * meta;
rc_t rc = VDatabaseOpenMetadataRead( db, &meta );
if ( rc != 0 )
(void)PLOGERR( klogErr, ( klogErr, rc, "cannot open metadata from '$(t)'", "t=%s", path ) );
else
{
const KMDataNode * node;
rc = KMetadataOpenNodeRead( meta, &node, "BAM_HEADER" );
if ( rc != 0 )
{
if ( GetRCState( rc ) == rcNotFound )
{
*recalc = true;
rc = 0;
}
else
(void)PLOGERR( klogErr, ( klogErr, rc, "cannot open meta-node 'BAM_HEADER' from '$(t)'", "t=%s", path ) );
}
else
{
size_t offset = 0, num_read, remaining = ~0;
char buffer[ 40960 ];
while ( rc == 0 && remaining > 0 )
{
rc = KMDataNodeRead( node, offset, buffer, sizeof( buffer ),
&num_read, &remaining );
if ( rc == 0 )
{
rc = KOutMsg( "%.*s", ( uint32_t )num_read, buffer );
offset += num_read;
}
}
if ( rc == 0 && buffer[ num_read - 1 ] != '\n' )
{
rc = KOutMsg( "\n" );
}
KMDataNodeRelease( node );
}
KMetadataRelease( meta );
}
return rc;
}
static
rc_t stats_data_make(stats_data_t **const pself,
VTable *const tbl,
bool has_spot_group,
bool compressed)
{
rc_t rc = 0;
stats_data_t *const self = calloc(1, sizeof(*self));
if (self) {
rc = stats_data_init(self, tbl, has_spot_group, compressed);
if (rc == 0) {
*pself = self;
return 0;
}
KMetadataRelease(self->meta);
free(self);
}
return RC(rcXF, rcFunction, rcConstructing, rcMemory, rcExhausted);
}
static rc_t vdb_info_db( vdb_info_data * data, VSchema * schema, const VDBManager *mgr )
{
const VDatabase * db;
rc_t rc = VDBManagerOpenDBRead( mgr, &db, schema, "%s", data->acc );
if ( rc == 0 )
{
const VTable * tab;
const KMetadata * meta = NULL;
rc_t rc1 = VDatabaseOpenTableRead( db, &tab, "SEQUENCE" );
if ( rc1 == 0 )
{
data->s_platform = get_platform( tab );
data->seq_rows = get_rowcount( tab );
VTableRelease( tab );
}
data->ref_rows = get_tab_row_count( db, "REFERENCE" );
data->prim_rows = get_tab_row_count( db, "PRIMARY_ALIGNMENT" );
data->sec_rows = get_tab_row_count( db, "SECONDARY_ALIGNMENT" );
data->ev_rows = get_tab_row_count( db, "EVIDENCE_ALIGNMENT" );
data->ev_int_rows = get_tab_row_count( db, "EVIDENCE_INTERVAL" );
data->consensus_rows = get_tab_row_count( db, "CONSENSUS" );
data->passes_rows = get_tab_row_count( db, "PASSES" );
data->metrics_rows = get_tab_row_count( db, "ZMW_METRICS" );
if ( data->ref_rows > 0 )
get_species( data->species, sizeof data->species, db, mgr );
rc = VDatabaseOpenMetadataRead ( db, &meta );
if ( rc == 0 )
{
get_meta_info( data, meta );
KMetadataRelease ( meta );
}
VDatabaseRelease( db );
}
return rc;
}
static rc_t vdb_info_tab( vdb_info_data * data, VSchema * schema, const VDBManager *mgr )
{
const VTable * tab;
rc_t rc = VDBManagerOpenTableRead( mgr, &tab, schema, "%s", data->acc );
if ( rc == 0 )
{
const KMetadata * meta = NULL;
data->s_platform = get_platform( tab );
data->seq_rows = get_rowcount( tab );
rc = VTableOpenMetadataRead ( tab, &meta );
if ( rc == 0 )
{
get_meta_info( data, meta );
KMetadataRelease ( meta );
}
VTableRelease( tab );
}
return rc;
}
static
bool KColumnTypeEqual ( const KTable *tbl, const char *col, const char *type )
{
/* TBD - this operation is expensive
should be addressed either by caching opened columns on table
or by introducing a path to open column metadata from table */
const KColumn *kcol;
rc_t rc = KTableOpenColumnRead ( tbl, & kcol, "%s", col );
if ( rc == 0 )
{
const KMetadata *meta;
rc = KColumnOpenMetadataRead ( kcol, & meta );
KColumnRelease ( kcol );
if ( rc == 0 )
{
/* this is a expected to be a v1 column
open its decoding node */
const KMDataNode *node;
rc = KMetadataOpenNodeRead ( meta, & node, "decoding" );
KMetadataRelease ( meta );
if ( rc == 0 )
{
/* read its type */
size_t size;
char type_expr [ 256 ];
rc = KMDataNodeReadAttr ( node, "type",
type_expr, sizeof type_expr, & size );
KMDataNodeRelease ( node );
if ( rc == 0 )
{
if ( memcmp ( type_expr, type, strlen ( type ) ) == 0 )
return true;
}
}
}
}
return false;
}
LIB_EXPORT rc_t CC TableWriterAlgn_Whack(const TableWriterAlgn* cself, bool commit, uint64_t* rows)
{
rc_t rc = 0;
if( cself != NULL ) {
VTable* vtbl;
TableReader_Whack(cself->tmpkey_reader);
if( (rc = TableWriter_GetVTable(cself->base, &vtbl)) == 0 ) {
KMetadata* meta;
if( (rc = VTableOpenMetadataUpdate(vtbl, &meta)) == 0 ) {
KMDataNode* node;
if( (rc = KMetadataOpenNodeUpdate(meta, &node, "CONFIG/REF_TABLE")) == 0 ) {
rc = KMDataNodeWriteCString(node, cself->ref_table_name);
KMDataNodeRelease(node);
}
KMetadataRelease(meta);
}
}
rc = TableWriter_Whack(cself->base, commit, rows);
free((TableWriterAlgn*)cself);
}
return rc;
}
static int AccessionType(VDBManager const *const mgr,
unsigned const N, char const accession[],
rc_t *const rc)
{
char scheme[1024];
bool isOdd = false;
scheme[0] = '\0';
{
KMetadata const *meta = NULL;
{
VDatabase const *db = NULL;
*rc = VDBManagerOpenDBRead(mgr, &db, NULL, "%.*s", (int)N, accession);
if (db) {
*rc = VDatabaseOpenMetadataRead(db, &meta);
VDatabaseRelease(db);
}
else {
VTable const *tbl = NULL;
*rc = VDBManagerOpenTableRead(mgr, &tbl, NULL, "%.*s", (int)N, accession);
if (tbl) {
*rc = VTableOpenMetadataRead(tbl, &meta);
VTableRelease(tbl);
}
else {
isOdd = true;
*rc = VDBManagerOpenTableRead(mgr, &tbl, NULL, "ncbi-acc:%.*s?vdb-ctx=refseq", (int)N, accession);
if (tbl) {
*rc = VTableOpenMetadataRead(tbl, &meta);
VTableRelease(tbl);
}
}
}
}
if (meta) {
KMDataNode const *node = NULL;
*rc = KMetadataOpenNodeRead(meta, &node, "schema");
KMetadataRelease(meta);
if (node) {
size_t sz = 0;
*rc = KMDataNodeReadAttr(node, "name", scheme, sizeof(scheme) - 1, &sz);
KMDataNodeRelease(node);
scheme[sz] = '\0';
while (sz) {
--sz;
if (scheme[sz] == '#') {
scheme[sz] = '\0';
break;
}
}
}
}
}
if (strcmp(scheme, "NCBI:WGS:db:contig") == 0)
return refSeqType_WGS;
if (strcmp(scheme, "NCBI:refseq:tbl:reference") == 0)
return isOdd ? refSeqType_RefSeq_odd : refSeqType_RefSeq;
return 0;
}
static
rc_t DB_Fini(const SParam* p, DB_Handle* h, bool drop)
{
rc_t rc = 0, rc2;
/* THIS FUNCTION MAKES NO ATTEMPT TO PRESERVE INITIAL ERROR CODES
EACH SUCCESSIVE ERROR OVERWRITES THE PREVIOUS CODE */
if( h != NULL ) {
PLOGMSG(klogInfo, (klogInfo, "Fini SEQUENCE", "severity=status"));
if( (rc2 = CGWriterSeq_Whack(h->wseq, !drop, NULL)) != 0 && !drop ) {
drop = true;
rc = rc2;
}
h->wseq = NULL;
h->reads = NULL;
PLOGMSG(klogInfo, (klogInfo, "Fini (PRI&SEC)_ALIGNMENT", "severity=status"));
if( (rc2 = CGWriterAlgn_Whack(h->walgn, !drop, NULL, NULL)) != 0 && !drop ) {
drop = true;
rc = rc2;
}
h->walgn = NULL;
h->mappings = NULL;
PLOGMSG(klogInfo, (klogInfo, "Fini EVIDENCE_INTERVAL", "severity=status"));
if( (rc2 = CGWriterEvdInt_Whack(h->wev_int, !drop, NULL)) != 0 && !drop ) {
drop = true;
rc = rc2;
}
h->wev_int = NULL;
h->ev_int = NULL;
PLOGMSG(klogInfo, (klogInfo, "Fini EVIDENCE_ALIGNMENT", "severity=status"));
if( (rc2 = CGWriterEvdDnbs_Whack(h->wev_dnb, !drop, NULL)) != 0 && !drop ) {
drop = true;
rc = rc2;
}
h->wev_dnb = NULL;
h->ev_dnb = NULL;
PLOGMSG(klogInfo, (klogInfo, "Fini calculating reference coverage", "severity=status"));
if( (rc2 = ReferenceMgr_Release(h->rmgr, !drop, NULL, drop ? false : true)) != 0 && !drop ) {
drop = true;
rc = rc2;
LOGERR(klogErr, rc, "Failed calculating reference coverage");
}
h->rmgr = NULL;
if( rc == 0 )
{
KMetadata* meta;
if( (rc = VDatabaseOpenMetadataUpdate(h->db, &meta)) == 0 ) {
KMDataNode *node;
if( (rc = KMetadataOpenNodeUpdate(meta, &node, "/")) == 0 ) {
if( (rc = KLoaderMeta_Write(node, p->argv0, __DATE__, "Complete Genomics", KAppVersion())) != 0 ) {
LOGERR(klogErr, rc, "Cannot update loader meta");
}
KMDataNodeRelease(node);
}
KMetadataRelease(meta);
}
}
PLOGMSG(klogInfo, (klogInfo, "Fini VDatabaseRelease", "severity=status"));
VDatabaseRelease(h->db);
h->db = NULL;
VSchemaRelease(h->schema);
h->schema = NULL;
if( drop || rc != 0 ) {
rc2 = VDBManagerDrop(h->mgr, kptDatabase, p->out);
if( GetRCState(rc2) == rcNotFound ) {
/* WHAT WOULD BE THE POINT OF RESETTING "rc" TO ZERO? */
rc = 0;
} else if( rc2 != 0 ) {
if ( rc == 0 )
rc = rc2;
PLOGERR(klogErr, (klogErr, rc2, "cannot drop db at '$(path)'", PLOG_S(path), p->out));
}
}
VDBManagerRelease(h->mgr);
h->mgr = NULL;
}
return rc;
}
rc_t KMain(int argc, char *argv[])
{
rc_t rc = 0;
Args* args = NULL;
const char* errmsg = NULL, *table_dir = NULL;
char accn[1024];
if( (rc = ArgsMakeAndHandle(&args, argc, argv, 1, MainArgs, MainArgsQty)) == 0 ) {
const char* blksz = NULL;
uint32_t count, dump = 0, gzip = 0;
if( (rc = ArgsParamCount(args, &count)) != 0 || count != 1 ) {
rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, count > 1 ? rcExcessive : rcInsufficient);
errmsg = "table";
} else if( (rc = ArgsOptionCount(args, MainArgs[eopt_BlockSize].name, &count)) != 0 || count > 1 ) {
rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive);
errmsg = MainArgs[eopt_BlockSize].name;
} else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_BlockSize].name, 0, (const void **)&blksz)) != 0 ) {
errmsg = MainArgs[eopt_BlockSize].name;
} else if( (rc = ArgsOptionCount(args, MainArgs[eopt_Accession].name, &count)) != 0 || count > 1 ) {
rc = rc ? rc : RC(rcExe, rcArgv, rcParsing, rcParam, rcExcessive);
errmsg = MainArgs[eopt_Accession].name;
} else if( count > 0 && (rc = ArgsOptionValue(args, MainArgs[eopt_Accession].name, 0, (const void **)&g_accession)) != 0 ) {
errmsg = MainArgs[eopt_Accession].name;
} else if( (rc = ArgsOptionCount(args, MainArgs[eopt_DumpIndex].name, &dump)) != 0 ) {
errmsg = MainArgs[eopt_DumpIndex].name;
} else if( (rc = ArgsOptionCount(args, MainArgs[eopt_noGzip].name, &gzip)) != 0 ) {
errmsg = MainArgs[eopt_noGzip].name;
}
while( rc == 0 ) {
long val = 0;
char* end = NULL;
if( blksz != NULL ) {
errno = 0;
val = strtol(blksz, &end, 10);
if( errno != 0 || blksz == end || *end != '\0' || val <= 0 ) {
rc = RC(rcExe, rcArgv, rcReading, rcParam, rcInvalid);
errmsg = MainArgs[eopt_BlockSize].name;
break;
} else if( val <= 128 || val > (1024 * 1024 * 1024) ) {
rc = RC(rcExe, rcArgv, rcValidating, rcParam, rcEmpty);
errmsg = "block size invalid";
break;
}
g_file_block_sz = val;
}
if( (rc = ArgsParamValue(args, 0, (const void **)&table_dir)) != 0 ) {
errmsg = "table";
break;
}
if( g_accession == NULL ) {
const char* p = strchr(table_dir, '/');
size_t l = 0;
g_accession = accn;
if( p == NULL ) {
p = strchr(table_dir, '\\');
}
strncpy(accn, p == NULL ? table_dir : p + 1, sizeof(accn) - 1);
if( accn[0] == '\0' ) {
rc = RC(rcExe, rcArgv, rcValidating, rcParam, rcEmpty);
errmsg = "accession";
}
l = strlen(accn);
if( accn[l - 1] == '/' || accn[l - 1] == '\\') {
accn[--l] = '\0';
}
if( strncmp(&accn[l - 9], ".lite.sra", 9) == 0 ) {
accn[l - 9] = '\0';
} else if( strncmp(&accn[l - 4], ".sra", 4) == 0 ) {
accn[l - 4] = '\0';
}
}
g_dump = dump > 0;
g_ungzip = gzip > 0;
break;
}
}
if( rc == 0 ) {
SRAMgr* smgr = NULL;
KDBManager* kmgr = NULL;
DEBUG_MSG(5, ("table %s, accession %s\n", table_dir, g_accession));
if( (rc = SRAMgrMakeUpdate(&smgr, NULL)) == 0 ) {
if( (rc = KDBManagerMakeUpdate(&kmgr, NULL)) == 0 ) {
bool relock = true;
if( (rc = KDBManagerUnlock(kmgr, table_dir)) != 0 ) {
relock = false;
rc = GetRCState(rc) == rcUnlocked ? 0 : rc;
} else {
PLOGMSG(klogInfo, (klogInfo, "Table $(p) locked, unlocking", PLOG_S(p), table_dir));
}
if( rc == 0 ) {
KTable* ktbl = NULL;
if( (rc = KDBManagerOpenTableUpdate(kmgr, &ktbl, table_dir)) == 0 ) {
KMetadata* meta = NULL;
if( (rc = KTableOpenMetadataUpdate(ktbl, &meta)) == 0 ) {
const SRATable* stbl = NULL;
if( (rc = SRAMgrOpenTableRead(smgr, &stbl, table_dir)) == 0 ) {
rc = MakeIndexes(stbl, ktbl, meta);
SRATableRelease(stbl);
}
}
KMetadataRelease(meta);
}
KTableRelease(ktbl);
}
if( rc == 0 && relock ) {
rc = KDBManagerLock(kmgr, table_dir);
}
KDBManagerRelease(kmgr);
}
SRAMgrRelease(smgr);
}
}
if( rc != 0 && rc != KLogLastErrorCode() ) {
if( errmsg ) {
Usage(args);
}
LOGERR(klogErr, rc, errmsg ? errmsg : "stop");
}
ArgsWhack(args);
return rc;
}
inline rc_t Release () const throw()
{ return KMetadataRelease ( this ); }
