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