static rc_t prepare_db_table( prepare_ctx *ctx, const VDBManager *vdb_mgr, VSchema *vdb_schema, const char * path ) { rc_t rc; ctx->db = NULL; ctx->seq_tab = NULL; rc = VDBManagerOpenDBRead ( vdb_mgr, &ctx->db, vdb_schema, "%s", path ); if ( rc != 0 ) { rc = VDBManagerOpenTableRead ( vdb_mgr, &ctx->seq_tab, NULL, "%s", path ); if ( rc != 0 ) { PLOGERR( klogErr, ( klogErr, rc, "failed to open '$(path)'", "path=%s", path ) ); } else { ReportResetTable(path, ctx->seq_tab); } } else { rc = VDatabaseOpenTableRead( ctx->db, &ctx->seq_tab, "SEQUENCE" ); if ( rc != 0 ) { LOGERR( klogInt, rc, "VDatabaseOpenTableRead( SEQUENCE ) failed" ); } else { ReportResetDatabase( path, ctx->db ); } } return rc; }
LIB_EXPORT rc_t CC TableReaderRefSeq_MakePath(const TableReaderRefSeq** cself, const VDBManager* vmgr, const char* path, uint32_t options, size_t cache) { rc_t rc = 0; const VTable* tbl = NULL; if( vmgr == NULL || path == NULL ) { rc = RC(rcAlign, rcType, rcConstructing, rcParam, rcNull); } else if( (rc = VDBManagerOpenTableRead(vmgr, &tbl, NULL, "%s", path)) == 0 ) { rc = TableReaderRefSeq_MakeTable(cself, vmgr, tbl, options, cache); VTableRelease(tbl); } if( rc == 0 ) { /* ALIGN_DBG("table %s opened 0x%p", path, *cself); */ } else { ALIGN_DBGERRP("table for %s", rc, path); } return rc; }
CVDBTable::CVDBTable(const CVDBMgr& mgr, const string& acc_or_path, EMissing missing) : m_Name(acc_or_path) { *x_InitPtr() = 0; VSchema *schema; DECLARE_SDK_GUARD(); if ( rc_t rc = SRASchemaMake(&schema, mgr) ) { NCBI_THROW2(CSraException, eInitFailed, "Cannot make default SRA schema", rc); } string path = CVPath::ConvertAccOrSysPathToPOSIX(acc_or_path); if ( rc_t rc = VDBManagerOpenTableRead(mgr, x_InitPtr(), schema, "%.*s", int(path.size()), path.data()) ) { *x_InitPtr() = 0; VSchemaRelease(schema); if ( (GetRCObject(rc) == RCObject(rcDirectory) || GetRCObject(rc) == RCObject(rcPath)) && GetRCState(rc) == rcNotFound ) { // no SRA accession if ( missing != eMissing_Throw ) { return; } NCBI_THROW2_FMT(CSraException, eNotFoundTable, "Cannot open SRA table: "<<acc_or_path, rc); } else if ( GetRCObject(rc) == RCObject(rcDatabase) && GetRCState(rc) == rcIncorrect ) { // invalid SRA database NCBI_THROW2_FMT(CSraException, eDataError, "Cannot open SRA table: "<<acc_or_path, rc); } else { // other errors NCBI_THROW2_FMT(CSraException, eOtherError, "Cannot open SRA table: "<<acc_or_path, rc); } } VSchemaRelease(schema); }
static rc_t RefSeq_RefSeq_odd_open(RefSeq *const super, RefSeqMgr const *const mgr) { struct RefSeq_RefSeq *const self = &super->u.refSeq; VTable const *tbl; rc_t rc = VDBManagerOpenTableRead(mgr->vmgr, &tbl, NULL, "ncbi-acc:%s?vdb-ctx=refseq", self->name); if (tbl) { char scheme[1024]; get_tbl_schema_info(tbl, sizeof(scheme), scheme); if (strcmp(scheme, "NCBI:refseq:tbl:reference") == 0) { rc = TableReaderRefSeq_MakeTable(&self->reader, mgr->vmgr, tbl, mgr->reader_options, mgr->cache); } else { rc = RC(rcAlign, rcTable, rcOpening, rcType, rcInvalid); } VTableRelease(tbl); } return rc; }
static rc_t vdb_fastq_table( const p_dump_context ctx, const VDBManager *mgr, fastq_ctx * fctx ) { const VTable * tbl; VSchema * schema = NULL; rc_t rc; vdh_parse_schema( mgr, &schema, &(ctx->schema_list) ); rc = VDBManagerOpenTableRead( mgr, &tbl, schema, ctx->path ); DISP_RC( rc, "VDBManagerOpenTableRead() failed" ); if ( rc == 0 ) { rc = vdb_fastq_tbl( ctx, tbl, fctx ); VTableRelease( tbl ); } VSchemaRelease( schema ); 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 void get_species( char * buffer, size_t buffer_size, const VDatabase * db, const VDBManager *mgr ) { const VTable * tab; rc_t rc = VDatabaseOpenTableRead( db, &tab, "REFERENCE" ); if ( rc == 0 ) { char seq_id[ 1024 ]; seq_id[ 0 ] = 0; get_string_cell( seq_id, sizeof seq_id, tab, 1, "SEQ_ID" ); VTableRelease( tab ); if ( seq_id[ 0 ] != 0 ) { rc = VDBManagerOpenTableRead( mgr, &tab, NULL, "%s", seq_id ); if ( rc == 0 ) { get_string_cell( buffer, buffer_size, tab, 1, "DEF_LINE" ); VTableRelease( tab ); } } } }
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 static_read(void) { rc_t rc; VDBManager *vmgr; rc = VDBManagerMakeUpdate ( & vmgr, 0 ); if ( rc != 0 ) LOGERR ( klogInt, rc, "failed to make VDB manager" ); else { const VTable *vtbl; rc = VDBManagerOpenTableRead(vmgr, &vtbl, 0, table_path ); if ( rc != 0 ) { PLOGERR ( klogErr, (klogErr, rc, "failed to $(cmode) table '$(path)'" , "cmode=%s,path=%s" , "open" , table_path )); } else { const VCursor *curs; rc = VTableCreateCursorRead(vtbl, &curs); if (rc == 0) { uint32_t idx; rc = VCursorAddColumn(curs, &idx, "bar"); if (rc == 0) { rc = VCursorOpen(curs); if (rc == 0) { int i; for (i = 0; rc == 0 && i != 10; ++i) { rc = VCursorOpenRow(curs); if (rc == 0) { char buffer[1024]; uint32_t len; rc = VCursorRead(curs, idx, 8, buffer, sizeof(buffer), &len); assert(len == strlen(buff)); assert(memcmp(buff, buffer, len) == 0); } VCursorCloseRow(curs); } } else { PLOGERR ( klogErr, (klogErr, rc, "failed to $(cmode) cursor" , "cmode=open" )); } } else { PLOGERR ( klogErr, (klogErr, rc, "failed to add column $(col)" , "col=bar" )); } VCursorRelease(curs); } else { PLOGERR ( klogErr, (klogErr, rc, "failed to $(cmode) cursor" , "cmode=create" )); } VTableRelease(vtbl); } VDBManagerRelease(vmgr); } return rc; }
/* OpenRead * open an existing table * * "tbl" [ OUT ] - return parameter for table * * "spec" [ IN ] - NUL terminated UTF-8 string giving path * to table. */ static rc_t CC SRAMgrVOpenAltTableRead ( const SRAMgr *self, const SRATable **rslt, const char *altname, const char *spec, va_list args ) { rc_t rc; if ( rslt == NULL ) rc = RC ( rcSRA, rcTable, rcOpening, rcParam, rcNull ); else { if ( self == NULL ) rc = RC ( rcSRA, rcMgr, rcAccessing, rcSelf, rcNull ); else if ( spec == NULL ) rc = RC ( rcSRA, rcTable, rcOpening, rcName, rcNull ); else if ( spec [ 0 ] == 0 ) rc = RC ( rcSRA, rcTable, rcOpening, rcName, rcEmpty ); else { char path [ 4096 ]; rc = ResolveTablePath ( self, path, sizeof path, spec, args ); if ( rc == 0 ) { SRATable *tbl = calloc ( 1, sizeof *tbl ); if ( tbl == NULL ) rc = RC ( rcSRA, rcTable, rcConstructing, rcMemory, rcExhausted ); else { VSchema *schema = NULL; rc = VDBManagerMakeSRASchema(self -> vmgr, & schema); if ( rc == 0 ) { rc = VDBManagerOpenTableRead ( self -> vmgr, & tbl -> vtbl, schema, path ); if ( rc != 0 && GetRCObject ( rc ) == rcTable && GetRCState ( rc ) == rcIncorrect ) { const VDatabase *db; rc_t rc2 = VDBManagerOpenDBRead ( self -> vmgr, & db, schema, path ); if ( rc2 == 0 ) { rc2 = VDatabaseOpenTableRead ( db, & tbl -> vtbl, altname ); if ( rc2 == 0 ) rc = 0; VDatabaseRelease ( db ); } } VSchemaRelease(schema); if ( rc == 0 ) { rc = VTableOpenMetadataRead ( tbl -> vtbl, & tbl -> meta ); if ( rc == 0 ) { rc = KMetadataVersion ( tbl -> meta, & tbl -> metavers ); if ( rc == 0 ) { rc = VTableCreateCursorRead ( tbl -> vtbl, & tbl -> curs ); if ( rc == 0 ) { tbl -> mgr = SRAMgrAttach ( self ); tbl -> mode = self -> mode; tbl -> read_only = true; KRefcountInit ( & tbl -> refcount, 1, "SRATable", "OpenTableRead", path ); rc = SRATableFillOut ( tbl, false ); if ( rc == 0 ) { * rslt = tbl; return 0; } } } } } } SRATableWhack ( tbl ); } } } * rslt = NULL; } return rc; }
rc_t matcher_execute( matcher* self, const p_matcher_input in ) { VSchema * dflt_schema; const VTable * src_table; rc_t rc; if ( self == NULL ) return RC( rcExe, rcNoTarg, rcResolving, rcSelf, rcNull ); if ( in->manager == NULL || in->add_schemas == NULL || in->cfg == NULL || in->columns == NULL || in->src_path == NULL || in->dst_path == NULL || in->dst_tabname == NULL ) return RC( rcExe, rcNoTarg, rcResolving, rcParam, rcNull ); rc = matcher_build_column_vector( self, in->columns ); if ( rc != 0 ) return rc; rc = matcher_exclude_columns( self, in->excluded_columns ); if ( rc != 0 ) return rc; rc = helper_parse_schema( in->manager, &dflt_schema, in->add_schemas ); if ( rc != 0 ) return rc; rc = VDBManagerOpenTableRead( in->manager, &src_table, dflt_schema, "%s", in->src_path ); if ( rc == 0 ) { const VSchema * src_schema; rc = VTableOpenSchema ( src_table, &src_schema ); if ( rc == 0 ) { rc = matcher_read_src_types( self, src_table, src_schema ); if ( rc == 0 ) { if ( in->legacy_schema != NULL ) rc = VSchemaParseFile ( dflt_schema, "%s", in->legacy_schema ); if ( rc == 0 ) { VTable * dst_table; KCreateMode cmode = kcmParents; const VSchema * dst_schema = src_schema; if ( in->legacy_schema != NULL ) dst_schema = dflt_schema; if ( in->force_unlock ) VDBManagerUnlock ( in->manager, "%s", in->dst_path ); if ( in->force_kcmInit ) cmode |= kcmInit; else cmode |= kcmCreate; rc = VDBManagerCreateTable( in->manager, &dst_table, dst_schema, in->dst_tabname, cmode, "%s", in->dst_path ); if ( rc == 0 ) { rc = matcher_read_dst_types( self, dst_table, dst_schema ); if ( rc == 0 ) { rc = matcher_make_type_matrix( self ); if ( rc == 0 ) rc = matcher_match_matrix( self, src_schema, in->cfg ); } VTableRelease( dst_table ); if ( !(in->force_kcmInit) ) KDirectoryRemove ( in->dir, true, "%s", in->dst_path ); } } } VSchemaRelease( src_schema ); } VTableRelease( src_table ); } VSchemaRelease( dflt_schema ); return rc; }
/* open_table */ static rc_t open_src_table ( const vtblcp_parms *pb, const VDBManager *mgr, const VSchema *schema, const VTable **tblp ) { return VDBManagerOpenTableRead ( mgr, tblp, schema, pb -> src_path ); }