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 ); }