rc_t copy_database_meta ( const VDatabase *src_db, VDatabase *dst_db,
const char * excluded_nodes,
const bool show_meta )
{
const KMetadata *src_meta;
rc_t rc;
if ( src_db == NULL || dst_db == NULL )
return RC( rcExe, rcNoTarg, rcCopying, rcParam, rcNull );
/* it is OK if excluded_nodes is NULL */
rc = VDatabaseOpenMetadataRead ( src_db, & src_meta );
DISP_RC( rc, "copy_database_meta:VDatabaseOpenMetadataRead() failed" );
if ( rc == 0 )
{
KMetadata *dst_meta;
rc = VDatabaseOpenMetadataUpdate ( dst_db, & dst_meta );
DISP_RC( rc, "copy_database_meta:VDatabaseOpenMetadataUpdate() failed" );
if ( rc == 0 )
{
if ( show_meta )
KOutMsg( "+++copy current db-metadata\n" );
rc = copy_stray_metadata ( src_meta, dst_meta, excluded_nodes,
show_meta );
if ( show_meta )
KOutMsg( "+++end of copy db-current metadata\n" );
KMetadataRelease ( dst_meta );
}
KMetadataRelease ( src_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 rc_t bam_header(const VDatabase* db) {
rc_t rc = 0;
const char path[] = "BAM_HEADER";
const KMetadata* meta = NULL;
const KMDataNode* node = NULL;
char* buffer = NULL;
assert(db);
if (rc == 0) {
rc = VDatabaseOpenMetadataRead(db, &meta);
DISP_RC(rc, "while calling VDatabaseOpenMetadataRead");
}
if (rc == 0) {
rc = KMetadataOpenNodeRead(meta, &node, "%s", path);
if (GetRCState(rc) == rcNotFound)
{ rc = 0; }
else {
DISP_RC2(rc, path, "while calling KMetadataOpenNodeRead");
if (rc == 0) {
int i = 0;
size_t bsize = 0;
size_t size = 1024;
for (i = 0; i < 2; ++i) {
free(buffer);
bsize = size + 1;
buffer = malloc(bsize);
if (buffer == NULL) {
rc = RC(rcExe, rcStorage, rcAllocating,
rcMemory, rcExhausted);
}
else {
rc = KMDataNodeReadCString(node, buffer, bsize, &size);
if (rc == 0) {
break;
}
else if (i == 0
&& GetRCObject(rc) == (enum RCObject)rcBuffer
&& GetRCState (rc) == rcInsufficient)
{
rc = 0;
}
}
DISP_RC2(rc, path, "while calling KMDataNodeReadCString");
}
}
}
}
if (rc == 0 && buffer)
{ OUTMSG(("BAM_HEADER: {\n%s}\n\n", buffer)); }
DESTRUCT(KMDataNode, node);
DESTRUCT(KMetadata, meta);
free(buffer);
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 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 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 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;
}
/* OpenMetadataRead
* OpenMetadataUpdate
* opens metadata file
*
* "meta" [ OUT ] - return parameter for metadata
*/
inline rc_t OpenMetadata ( const KMetadata **meta ) const throw ()
{ return VDatabaseOpenMetadataRead ( this, meta ); }
