static rc_t gather_statistic( statistic * data,
KDirectory *dir,
context *ctx )
{
VDBManager *my_manager;
/* because this tool is linked against the write-version
of vdb and kdb, there is no Read-Manager available... */
rc_t rc = VDBManagerMakeUpdate ( &my_manager, dir );
if ( rc != 0 )
LogErr( klogInt, rc, "VDBManagerMakeUpdate() failed\n" );
else
{
const VDatabase *my_database;
rc = VDBManagerOpenDBRead( my_manager, &my_database, NULL, "%s", ctx->src_path );
if ( rc != 0 )
LogErr( klogInt, rc, "VDBManagerOpenDBRead() failed\n" );
else
{
/* ******************************************************* */
rc = read_statistic_from_table( data, dir, ctx, my_database,
"PRIMARY_ALIGNMENT" );
/* ******************************************************* */
VDatabaseRelease( my_database );
}
VDBManagerRelease( my_manager );
}
return rc;
}
static rc_t report_ref_table( const VDBManager *vdb_mgr, const char * path, int64_t start, int64_t stop )
{
const VDatabase* db;
rc_t rc = VDBManagerOpenDBRead ( vdb_mgr, &db, NULL, "%s", path );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "cannot open vdb-database" );
}
else
{
const VTable* tb;
rc = VDatabaseOpenTableRead ( db, &tb, "REFERENCE" );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "cannot open REFERENCE-table" );
}
else
{
const VCursor *cur;
rc = VTableCreateCursorRead ( tb, &cur );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "cannot open REFERENCE-cursor" );
}
else
{
rc = report_ref_cursor( cur, start, stop );
VCursorRelease( cur );
}
VTableRelease ( tb );
}
VDatabaseRelease ( db );
}
return rc;
}
rc_t KeyRingDatabaseLoad ( struct KeyRingData* self, const struct KDirectory* dir, const char* path )
{
VDBManager* innerMgr;
rc_t rc = VDBManagerMakeUpdate( &innerMgr, (KDirectory*)dir );
if (rc == 0)
{
rc_t rc2;
const VDatabase* db;
rc = VDBManagerOpenDBRead(innerMgr, & db, NULL, "%s", path);
if (rc == 0)
{
rc = LoadProjects(&self->projects, db);
if (rc == 0)
rc = LoadObjects(&self->objects, db);
/*TODO: LoadKeys */
rc2 = VDatabaseRelease(db);
if (rc == 0)
rc = rc2;
}
rc2 = VDBManagerRelease(innerMgr);
if (rc == 0)
rc = rc2;
}
return rc;
}
rc_t prepare_ref_iter( prepare_ctx *ctx,
const VDBManager *vdb_mgr,
VSchema *vdb_schema,
const char * path,
BSTree * regions )
{
rc_t rc = prepare_db_table( ctx, vdb_mgr, vdb_schema, path );
if ( rc == 0 )
{
rc = prepare_reflist( ctx );
if( rc == 0 )
{
if ( ctx->reflist == NULL || count_ref_regions( regions ) == 0 )
{
/* the user has not specified a reference-range : use the whole file... */
rc = prepare_whole_file( ctx );
}
else
{
/* pick only the requested ranges... */
rc = foreach_ref_region( regions, prepare_region_cb, ctx );
}
}
if ( ctx->reflist != NULL )
{
ReferenceList_Release( ctx->reflist );
}
}
VTableRelease ( ctx->seq_tab );
VDatabaseRelease ( ctx->db );
return rc;
}
static rc_t RefSeq_WGS_open(RefSeq *const super, RefSeqMgr const *const mgr)
{
struct RefSeq_WGS *const self = &super->u.wgs;
VDatabase const *db;
rc_t rc = VDBManagerOpenDBRead(mgr->vmgr, &db, NULL, self->name);
if (db) {
char scheme[1024];
get_db_schema_info(db, sizeof(scheme), scheme);
if (strcmp(scheme, "NCBI:WGS:db:contig") == 0) {
VTable const *tbl;
rc = VDatabaseOpenTableRead(db, &tbl, "SEQUENCE");
if (tbl) {
rc = TableReaderWGS_MakeTable(&self->reader, mgr->vmgr, tbl,
mgr->reader_options, mgr->cache);
VTableRelease(tbl);
}
}
else {
rc = RC(rcAlign, rcTable, rcOpening, rcType, rcInvalid);
}
VDatabaseRelease(db);
}
return rc;
}
static
void SRA_DB_ReadCollectionWhack ( SRA_DB_ReadCollection * self, ctx_t ctx )
{
NGS_CursorRelease ( self -> curs, ctx );
SRA_ReadGroupInfoRelease ( self -> group_info, ctx );
VDatabaseRelease ( self -> db );
NGS_StringRelease ( self -> run_name, ctx );
}
static
rc_t RestoreReadMake ( RestoreRead **objp, const VTable *tbl, const VCursor* native_curs )
{
rc_t rc;
char name[]="PRIMARY_ALIGNMENT";
/* create the object */
RestoreRead *obj = malloc ( sizeof * obj );
memset(obj,0,sizeof * obj);
if ( obj == NULL )
{
*objp=0;
rc = RC ( rcXF, rcFunction, rcConstructing, rcMemory, rcExhausted );
}
else
{
rc = VCursorLinkedCursorGet(native_curs,name,&obj->curs);
if(rc == 0){
VCursorAddRef(obj->curs);
} else {
/* get at the parent database */
const VDatabase *db;
rc = VTableOpenParentRead ( tbl, & db );
if ( rc == 0 )
{
const VTable *patbl;
/* open the primary alignment table */
rc = VDatabaseOpenTableRead ( db, & patbl, name );
VDatabaseRelease ( db );
if ( rc == 0 )
{
/* create a cursor */
rc = VTableCreateCachedCursorRead( patbl, &obj->curs, 32*1024*1024UL );
VTableRelease ( patbl );
if ( rc == 0 )
{
/* add columns to cursor */
rc = VCursorAddColumn ( obj -> curs, & obj -> read_idx, "( INSDC:4na:bin ) READ" );
if ( rc == 0 )
{
rc = VCursorOpen ( obj -> curs );
if ( rc == 0 )
{
VCursorLinkedCursorSet( native_curs, name, obj->curs );
SUB_DEBUG( ( "SUB.Make in 'seq-restore-read.c'\n" ) );
* objp = obj;
return 0;
}
}
VCursorRelease ( obj -> curs );
}
}
}
free ( obj );
}
}
return rc;
}
void SequenceWhack(Sequence *self, bool commit) {
uint64_t dummyRows;
VDatabaseRelease(self->db);
if (self->tbl == NULL)
return;
(void)TableWriterSeq_Whack(self->tbl, commit, &dummyRows);
}
static rc_t report_ref_database( const VDBManager *vdb_mgr, VFSManager * vfs_mgr, const char * path, bool extended )
{
const VDatabase *db;
rc_t rc = VDBManagerOpenDBRead ( vdb_mgr, &db, NULL, "%s", path );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "VDBManagerOpenDBRead() failed" );
}
else
{
const ReferenceList * reflist;
uint32_t options = ( ereferencelist_usePrimaryIds | ereferencelist_useSecondaryIds | ereferencelist_useEvidenceIds );
rc = ReferenceList_MakeDatabase( &reflist, db, options, 0, NULL, 0 );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "ReferenceList_MakeDatabase() failed" );
}
else
{
uint32_t count;
rc = ReferenceList_Count( reflist, &count );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "ReferenceList_Count() failed" );
}
else
{
rc = KOutMsg( "this object uses %u references\n", count );
if ( rc == 0 )
{
uint32_t idx;
for ( idx = 0; idx < count && rc == 0; ++idx )
{
const ReferenceObj* ref_obj;
rc = ReferenceList_Get( reflist, &ref_obj, idx );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "ReferenceList_Get() failed" );
}
else
{
rc = report_ref_obj( vdb_mgr, vfs_mgr, path, idx, ref_obj, extended );
ReferenceObj_Release( ref_obj );
}
}
}
}
ReferenceList_Release( reflist );
}
VDatabaseRelease( db );
}
return rc;
}
void free_trans_ctx( trans_ctx * ctx )
{
if ( ctx->dir != NULL ) KDirectoryRelease( ctx->dir );
ctx->dir = NULL;
if ( ctx->vdb_mgr != NULL ) VDBManagerRelease( ctx->vdb_mgr );
ctx->vdb_mgr = NULL;
if ( ctx->db != NULL ) VDatabaseRelease ( ctx->db );
ctx->db = NULL;
if ( ctx->ref_list != NULL ) ReferenceList_Release( ctx->ref_list );
ctx->ref_list = NULL;
if ( ctx->almgr != NULL ) AlignMgrRelease ( ctx->almgr );
ctx->almgr = NULL;
}
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;
}
static
rc_t init_self( self_t *self, VTable const * const srctbl, char const column[] )
{
VDatabase const * db;
rc_t rc = VTableOpenParentRead( srctbl, &db );
if ( rc == 0 )
{
VTable const * tbl;
rc = VDatabaseOpenTableRead( db, &tbl, "SEQUENCE" );
VDatabaseRelease( db );
if ( rc == 0 )
{
bool has_column = does_table_have_column( tbl, column );
if ( !has_column )
VTableRelease( tbl );
else
{
VCursor const * curs;
#if CURSOR_CACHE_SIZE
rc = VTableCreateCachedCursorRead( tbl, &curs, CURSOR_CACHE_SIZE );
#else
rc = VTableCreateCursorRead( tbl, &curs );
#endif
VTableRelease( tbl );
if ( rc == 0 )
{
uint32_t col_idx;
rc = VCursorAddColumn( curs, &col_idx, "%s", column );
if ( rc == 0 )
{
rc = VCursorOpen( curs );
if ( rc == 0 )
{
self->curs = curs;
self->col_idx = col_idx;
return 0;
}
if ( GetRCObject( rc ) == (enum RCObject)rcColumn && GetRCState( rc ) == rcUndefined )
rc = 0;
}
VCursorRelease( curs );
}
}
}
}
return rc;
}
rc_t write_statistic_into_db( KDirectory *dir, statistic * data,
const KNamelist *schema_list, const char *src_path,
uint64_t * written, bool show_progress )
{
VDBManager *my_manager;
rc_t rc;
if ( written != NULL ) *written = 0;
rc = VDBManagerMakeUpdate ( &my_manager, dir );
if ( rc != 0 )
LogErr( klogInt, rc, "VDBManagerMakeUpdate() failed\n" );
else
{
VSchema * my_schema;
rc = make_schema( schema_list, my_manager, &my_schema );
if ( rc == 0 )
{
VDatabase *my_database;
rc = VDBManagerOpenDBUpdate( my_manager, &my_database,
my_schema, src_path );
if ( rc != 0 )
LogErr( klogInt, rc, "VDBManagerOpenDBUpdate() failed\n" );
else
{
VTable * my_table;
rc = VDatabaseCreateTable( my_database, &my_table,
"QUAL_STAT",
kcmOpen | kcmParents,
"QUAL_STAT" );
if ( rc !=0 )
LogErr( klogInt, rc, "VDatabaseCreateTable() failed\n" );
else
{
rc = write_statistic_cmn( my_table, data, written, show_progress );
VTableRelease( my_table );
}
VDatabaseRelease( my_database );
}
VSchemaRelease( my_schema );
}
VDBManagerRelease( my_manager );
}
return rc;
}
/* SetDatabase
* call it if you work with Database
*
* "path" [ IN ] - path to the database that is used to access it
*/
LIB_EXPORT rc_t CC ReportResetDatabase ( const char *path, const VDatabase *db )
{
rc_t rc = 0;
Report* self = NULL;
ReportGet(&self);
if ( self != NULL )
{
rc = VDatabaseAddRef ( db );
if ( rc == 0 )
{
VTableRelease ( self -> table ), self -> table = NULL;
VDatabaseRelease ( self -> db );
self -> db = db;
}
}
return rc;
}
/* SetTable
* call it if you work with Table
*
* "path" [ IN ] - path to the table that is used to access it
*/
LIB_EXPORT rc_t CC ReportResetTable ( const char *path, const VTable *tbl )
{
rc_t rc = 0;
Report* self = NULL;
ReportGet(&self);
if ( self != NULL )
{
rc = VTableAddRef ( tbl );
if ( rc == 0 )
{
VDatabaseRelease ( self -> db ), self -> db = NULL;
VTableRelease ( self -> table );
self -> table = tbl;
}
}
return rc;
}
static rc_t vdb_fastq_database( const p_dump_context ctx,
const VDBManager *mgr,
fastq_ctx * fctx )
{
const VDatabase * db;
VSchema *schema = NULL;
rc_t rc;
vdh_parse_schema( mgr, &schema, &(ctx->schema_list) );
rc = VDBManagerOpenDBRead( mgr, &db, schema, ctx->path );
DISP_RC( rc, "VDBManagerOpenDBRead() failed" );
if ( rc == 0 )
{
bool table_defined = ( ctx->table != NULL );
if ( !table_defined )
table_defined = vdh_take_this_table_from_db( ctx, db, "SEQUENCE" );
if ( table_defined )
{
const VTable * tbl;
rc = VDatabaseOpenTableRead( db, &tbl, ctx->table );
DISP_RC( rc, "VDatabaseOpenTableRead() failed" );
if ( rc == 0 )
{
rc = vdb_fastq_tbl( ctx, tbl, fctx );
VTableRelease( tbl );
}
}
else
{
LOGMSG( klogInfo, "opened as vdb-database, but no table found/defined" );
ctx->usage_requested = true;
}
VDatabaseRelease( db );
}
VSchemaRelease( schema );
return rc;
}
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 void CC qstats_whack(void *vp)
{
self_t *self = vp;
VTable *tbl;
writer_ctx_t ctx;
memset(&ctx, 0, sizeof(ctx));
ctx.alignMode = self->alignMode;
ctx.rc = OpenTableAndCursor(self->db, &tbl, &ctx.curs, self->alignMode ? 10 : 7);
VDatabaseRelease(self->db);
if (ctx.rc == 0) {
foreach_statistic(&self->stat, qstats_write, self);
VCursorRelease(ctx.curs);
if (ctx.rc == 0)
VTableReindex(tbl);
VTableRelease(tbl);
}
whack_statistic(&self->stat);
free(self);
}
static
rc_t open_RR_cursor( Read_Restorer * obj, const VTable *tbl, const VCursor* native_curs, const char * tablename )
{
rc_t rc = VCursorLinkedCursorGet( native_curs, tablename, &obj->curs );
if ( rc != 0 )
{
/* get at the parent database */
const VDatabase *db;
rc = VTableOpenParentRead ( tbl, & db );
if ( rc == 0 )
{
const VTable *patbl;
/* open the primary alignment table */
rc = VDatabaseOpenTableRead ( db, & patbl, tablename );
VDatabaseRelease ( db );
if ( rc == 0 )
{
/* create a cursor */
rc = VTableCreateCachedCursorRead( patbl, &obj->curs, 32*1024*1024UL );
/* rc = VTableCreateCursorRead( patbl, &obj->curs ); */
VTableRelease ( patbl );
if ( rc == 0 )
rc = VCursorLinkedCursorSet( native_curs, tablename, obj->curs );
}
}
}
if ( rc == 0 )
{
/* add columns to cursor */
rc = VCursorAddColumn ( obj -> curs, & obj -> read_idx, "( INSDC:4na:bin ) READ" );
if ( GetRCState(rc) == rcExists )
rc = 0;
if ( rc == 0 )
{
rc = VCursorOpen ( obj -> curs );
}
}
return rc;
}
void release_vdb_objects (
VDBManager const* mgr,
VDatabase const* db,
VTable const* table_ref,
VTable const* table_pa,
VCursor const* cursor_ref,
VCursor const* cursor_pa
)
{
/* TODO: process *Release-functions error return codes */
if ( cursor_pa)
VCursorRelease ( cursor_pa );
if ( cursor_ref )
VCursorRelease ( cursor_ref );
if ( table_pa )
VTableRelease ( table_pa );
if ( table_ref )
VTableRelease ( table_ref );
if ( db )
VDatabaseRelease ( db );
if ( mgr )
VDBManagerRelease ( mgr );
}
static rc_t CC ReportRelease ( void )
{
rc_t rc = 0;
Report *prev_report, *cur_report;
cur_report = report_singleton . ptr;
do
{
prev_report = cur_report;
cur_report = atomic_test_and_set_ptr ( & report_singleton, NULL, prev_report );
}
while ( cur_report != prev_report );
if ( cur_report != NULL )
{
/* cleanup */
VTableRelease ( cur_report -> table );
VDatabaseRelease ( cur_report -> db );
VDBManagerRelease ( cur_report -> mgr );
memset ( cur_report, 0, sizeof * cur_report );
}
return rc;
}
rc_t KeyRingDatabaseSave ( struct KeyRingData* self, struct KDirectory* wd, const char* path )
{
rc_t rc;
VDBManager* vdbMgr;
rc = VDBManagerMakeUpdate( &vdbMgr, wd );
if (rc == 0)
{
VSchema* schema;
rc = VDBManagerMakeSchema(vdbMgr, &schema);
if (rc == 0)
{
rc = VSchemaParseText ( schema, "keyring_schema", schema_text, string_measure(schema_text, NULL) );
if (rc == 0)
{ /* create a database */
VDatabase* db;
rc = VDBManagerCreateDB(vdbMgr, & db, schema, "keyring:KEYRING", kcmCreate | kcmMD5, path);
if (rc == 0)
{
rc_t rc2;
rc = SaveProjects(&self->projects, db);
if (rc == 0)
rc = SaveObjects(&self->objects, db);
/*TODO: SaveKeys */
rc2 = VDatabaseRelease(db);
if (rc == 0)
rc = rc2;
}
}
VSchemaRelease(schema);
}
VDBManagerRelease(vdbMgr);
}
return rc;
}
static rc_t qstats_trigger_make(const void *Self, const VXfactInfo *info, VFuncDesc *rslt,
const VFactoryParams *cp, const VFunctionParams *dp, bool alignMode)
{
rc_t rc = 0;
self_t *self = malloc(sizeof(*self));
if (self == NULL)
return RC(rcXF, rcFunction, rcConstructing, rcMemory, rcExhausted);
self->alignMode = no_algn_info;
rc = VTableOpenParentUpdate(info->tbl, &self->db);
if (rc == 0) {
rc = make_statistic(&self->stat, 7, no_algn_info);
if (rc == 0) {
rslt->self = self;
rslt->variant = vftIdDepRow;
rslt->whack = qstats_whack;
rslt->u.rf = qstats_trigger_impl;
return 0;
}
VDatabaseRelease(self->db);
}
return rc;
}
static rc_t ref_walker_walk_ref_range( struct ref_walker * self, ref_walker_data * rwd )
{
ReferenceIterator * ref_iter;
rc_t rc = AlignMgrMakeReferenceIterator ( self->amgr, &ref_iter, &self->cb_block, self->min_mapq ); /* align/iterator.h */
if ( rc == 0 )
{
/* construct the reference iterator */
uint32_t idx, count;
uint32_t reflist_options = ref_walker_make_reflist_options( self ); /* above */
Vector cur_id_vector;
VectorInit ( &cur_id_vector, 0, 12 );
rc = VNameListCount ( self->sources, &count );
for ( idx = 0; idx < count && rc == 0; ++idx )
{
const char * src_name = NULL;
rc = VNameListGet ( self->sources, idx, &src_name );
if ( rc == 0 && src_name != NULL )
{
const VDatabase *db;
rc = VDBManagerOpenDBRead ( self->vmgr, &db, self->vschema, "%s", src_name );
if ( rc == 0 )
{
const ReferenceList * ref_list;
rc = ReferenceList_MakeDatabase( &ref_list, db, reflist_options, 0, NULL, 0 );
if ( rc == 0 )
{
const ReferenceObj * ref_obj;
rc = ReferenceList_Find( ref_list, &ref_obj, rwd->ref_name, string_size( rwd->ref_name ) );
if ( rc == 0 )
{
INSDC_coord_len len;
rc = ReferenceObj_SeqLength( ref_obj, &len );
if ( rc == 0 )
{
if ( rwd->ref_start == 0 )
rwd->ref_start = 1;
if ( ( rwd->ref_end == 0 )||( rwd->ref_end > len + 1 ) )
rwd->ref_end = ( len - rwd->ref_start ) + 1;
if ( self->primary_alignments )
rc = ref_walker_add_iterator( self, rwd->ref_name, rwd->ref_start, rwd->ref_end, src_name,
&cur_id_vector, db, ref_obj, ref_iter, TBL_PRIM, primary_align_ids );
if ( rc == 0 && self->secondary_alignments )
rc = ref_walker_add_iterator( self, rwd->ref_name, rwd->ref_start, rwd->ref_end, src_name,
&cur_id_vector, db, ref_obj, ref_iter, TBL_SEC, secondary_align_ids );
if ( rc == 0 && self->evidence_alignments )
rc = ref_walker_add_iterator( self, rwd->ref_name, rwd->ref_start, rwd->ref_end, src_name,
&cur_id_vector, db, ref_obj, ref_iter, TBL_EV, evidence_align_ids );
}
ReferenceObj_Release( ref_obj );
}
ReferenceList_Release( ref_list );
}
VDatabaseRelease( db );
}
}
}
if ( rc == 0 )
{
/* walk the reference iterator */
struct ReferenceObj const * ref_obj;
rc = ReferenceIteratorNextReference( ref_iter, NULL, NULL, &ref_obj );
if ( rc == 0 && ref_obj != NULL )
{
if ( self->use_seq_name )
rc = ReferenceObj_Name( ref_obj, &rwd->ref_name );
else
rc = ReferenceObj_SeqId( ref_obj, &rwd->ref_name );
if ( rc == 0 )
{
INSDC_coord_zero first_pos;
INSDC_coord_len len;
rc_t rc_w = ReferenceIteratorNextWindow ( ref_iter, &first_pos, &len );
while ( rc == 0 && rc_w == 0 )
{
rc_t rc_p = ReferenceIteratorNextPos ( ref_iter, !self->no_skip );
if ( rc_p == 0 )
{
rc = ReferenceIteratorPosition ( ref_iter, &rwd->pos, &rwd->depth, &rwd->bin_ref_base );
if ( rwd->depth > 0 && rc == 0 )
{
rc_t rc_sg = 0;
rwd->ascii_ref_base = _4na_to_ascii( rwd->bin_ref_base, false );
if ( self->on_enter_ref_pos != NULL )
rc = self->on_enter_ref_pos( rwd );
while ( rc_sg == 0 && rc == 0 )
{
rc_sg = ReferenceIteratorNextSpotGroup ( ref_iter, &rwd->spot_group, &rwd->spot_group_len );
if ( rc_sg == 0 )
{
rc_t rc_pr = 0;
if ( self->on_enter_spot_group != NULL )
rc = self->on_enter_spot_group( rwd );
while ( rc == 0 && rc_pr == 0 )
{
const PlacementRecord * rec;
rc_pr = ReferenceIteratorNextPlacement ( ref_iter, &rec );
if ( rc_pr == 0 && self->on_alignment != NULL )
rc = ref_walker_walk_alignment( self, ref_iter, rec, rwd );
}
if ( self->on_exit_spot_group != NULL )
rc = self->on_exit_spot_group( rwd );
}
}
if ( self->on_exit_ref_pos != NULL )
rc = self->on_exit_ref_pos( rwd );
}
rc = Quitting();
}
}
}
}
}
/* free cur_id_vector */
ReferenceIteratorRelease ( ref_iter );
}
return rc;
}
rc_t run(const TestCase& test_case)
{
rc_t rc;
KDirectory * cur_dir;
const VDBManager * manager;
const VDatabase * database;
const VTable * table;
const VCursor * cursor;
uint32_t name_idx;
uint32_t name_range_idx;
rc = KDirectoryNativeDir( &cur_dir );
if ( rc != 0 )
LOGERR( klogInt, rc, "KDirectoryNativeDir() failed" );
else
{
rc = VDBManagerMakeRead ( &manager, cur_dir );
if ( rc != 0 )
LOGERR( klogInt, rc, "VDBManagerMakeRead() failed" );
else
{
rc = VDBManagerOpenDBRead( manager, &database, NULL, "%s", test_case.path );
if (rc != 0)
LOGERR( klogInt, rc, "VDBManagerOpenDBRead() failed" );
else
{
rc = VDatabaseOpenTableRead( database, &table, "%s", TABLE_NAME );
if ( rc != 0 )
LOGERR( klogInt, rc, "VDatabaseOpenTableRead() failed" );
else
{
rc = VTableCreateCursorRead( table, &cursor );
if ( rc != 0 )
LOGERR( klogInt, rc, "VTableCreateCursorRead() failed" );
else
{
/* add columns to cursor */
rc = VCursorAddColumn( cursor, &name_idx, "(utf8)NAME" );
if ( rc != 0 )
LOGERR( klogInt, rc, "VCursorAddColumn() failed" );
else
{
rc = VCursorAddColumn( cursor, &name_range_idx, "NAME_RANGE" );
if ( rc != 0 )
LOGERR( klogInt, rc, "VCursorAddColumn() failed" );
else
{
rc = VCursorOpen( cursor );
if (rc != 0)
LOGERR( klogInt, rc, "VCursorOpen() failed" );
else
rc = runChecks( test_case, cursor, name_idx, name_range_idx );
}
}
VCursorRelease( cursor );
}
VTableRelease( table );
}
VDatabaseRelease( database );
}
VDBManagerRelease( manager );
}
KDirectoryRelease( cur_dir );
}
return rc;
}
rc_t correct( const char * obj )
{
KDirectory * dir;
rc_t rc = KDirectoryNativeDir( &dir );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "creation of KDirectory failed" );
}
else
{
VDBManager * vdb_mgr;
rc = VDBManagerMakeUpdate ( &vdb_mgr, dir );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "creation of VDBManager failed" );
}
else
{
VDatabase * vdb_db;
rc = VDBManagerOpenDBUpdate ( vdb_mgr, &vdb_db, NULL, "%s", obj );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "vdb: open for update failed" );
}
else
{
KDatabase *kdb;
rc = VDatabaseOpenKDatabaseUpdate ( vdb_db, & kdb );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "kdb: open for update failed" );
}
else
{
if ( KDatabaseExists ( kdb, kptTable, CONSENSUS ) )
{
if ( KDatabaseExists ( kdb, kptTable, PULSE ) )
{
OUTMSG(( "table >%s< does already exist in >%s<\n", PULSE, obj ));
}
else
{
if ( KDatabaseExists ( kdb, kptTable, SEQUENCE ) )
{
rc = KDatabaseRenameTable ( kdb, true, SEQUENCE, PULSE );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "kdb: renaming table failed" );
}
else
{
OUTMSG(( "table >%s< renamed to >%s< in >%s<\n", SEQUENCE, PULSE, obj ));
}
if ( rc == 0 )
{
rc = KDatabaseAliasTable ( kdb, CONSENSUS, SEQUENCE );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "kdb: creating table-alias failed" );
}
else
{
OUTMSG(( "alias >%s< created for >%s< in >%s<\n", SEQUENCE, CONSENSUS, obj ));
}
}
}
}
}
else
{
OUTMSG(( "table >%s< does not exist in >%s<\n", CONSENSUS, obj ));
}
KDatabaseRelease ( kdb );
}
VDatabaseRelease( vdb_db );
}
VDBManagerRelease( vdb_mgr );
}
KDirectoryRelease( dir );
}
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;
}
inline rc_t Release () const throw ()
{ return VDatabaseRelease ( this ); }
static rc_t report_deletes_db( const VDBManager *vdb_mgr,
const char * path,
uint32_t min_len )
{
const VDatabase *db;
rc_t rc = VDBManagerOpenDBRead( vdb_mgr, &db, NULL, "%s", path );
if ( rc != 0 )
{
(void)PLOGERR( klogErr,
( klogInt, rc, "cannot open database $(db_name)", "db_name=%s", path ) );
}
else
{
const VTable *tab;
rc = VDatabaseOpenTableRead( db, &tab, "PRIMARY_ALIGNMENT" );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "cannot open table PRIMARY_ALIGNMENT" );
}
else
{
const VCursor *cur;
rc = VTableCreateCursorRead( tab, &cur );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "cannot open cursor on table PRIMARY_ALIGNMENT" );
}
else
{
uint32_t cigar_idx;
rc = VCursorAddColumn( cur, &cigar_idx, "CIGAR_SHORT" );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "cannot add CIGAR_SHORT to cursor" );
}
else
{
rc = VCursorOpen( cur );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "cannot open cursor" );
}
else
{
int64_t first;
uint64_t count;
rc = VCursorIdRange ( cur, cigar_idx, &first, &count );
if ( rc != 0 )
{
(void)LOGERR( klogErr, rc, "cannot detect row-range" );
}
else
{
rc = cigar_loop( cur, cigar_idx, first, count, min_len );
}
}
}
VCursorRelease( cur );
}
VTableRelease( tab );
}
VDatabaseRelease( db );
}
return rc;
}
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;
}
