コード例 #1
0
ファイル: refseq-mgr.c プロジェクト: ncbi/ncbi-vdb
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;
}
コード例 #2
0
ファイル: copy_meta.c プロジェクト: gconcepcion/sratoolkit
rc_t copy_table_meta ( const VTable *src_table, VTable *dst_table,
                       const char * excluded_nodes,
                       const bool show_meta, const bool schema_updated )
{
    const KMetadata *src_meta;
    rc_t rc;

    if ( src_table == NULL || dst_table == NULL )
        return RC( rcExe, rcNoTarg, rcCopying, rcParam, rcNull );
    /* it is OK if excluded_nodes is NULL */
    
    rc = VTableOpenMetadataRead ( src_table, & src_meta );
    DISP_RC( rc, "copy_table_meta:VTableOpenMetadataRead() failed" );
    if ( rc == 0 )
    {
        rc = copy_back_revisions ( src_meta, dst_table, show_meta );
        if ( rc == 0 )
        {
            KMetadata *dst_meta;
            rc = VTableOpenMetadataUpdate ( dst_table, & dst_meta );
            DISP_RC( rc, "copy_table_meta:VTableOpenMetadataUpdate() failed" );
            if ( rc == 0 )
            {
                if ( show_meta )
                    KOutMsg( "+++copy current metadata\n" );

                rc = copy_stray_metadata ( src_meta, dst_meta, excluded_nodes,
                                           show_meta );
                if ( show_meta )
                    KOutMsg( "+++end of copy current metadata\n" );

                /* enter a attribute "vdb-copy" under '/SOFTWARE/update'
                   *if the schema was updated ! */
                if ( rc == 0 && schema_updated )
                    rc = enter_schema_update( dst_meta, show_meta );

                /* enter a unconditional node under '/SOFTWARE/Copy'
                    <%TIMESTAMP%>
                        <Application date="%DATE%" name="vdb-copy" vers="%VERSION%"/>
                    </%TIMESTAMP%>
                */
                if ( rc == 0 )
                    rc = enter_vdbcopy_node( dst_meta, show_meta );

                KMetadataRelease ( dst_meta );
            }
        }
        KMetadataRelease ( src_meta );
    }
    return rc;
}
コード例 #3
0
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;
}
コード例 #4
0
ファイル: sam-hdr.c プロジェクト: DCGenomics/sra-tools
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;
}
コード例 #5
0
ファイル: vdb_info.c プロジェクト: genome-vendor/sra-sdk
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;
}
コード例 #6
0
ファイル: refseq-mgr.c プロジェクト: ncbi/ncbi-vdb
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;
}
コード例 #7
0
ファイル: align-info.c プロジェクト: mariux/sratoolkit
static rc_t qual_stats(const Params* prm, const VDatabase* db) {
    rc_t rc = 0;
    const char tblName[] = "SEQUENCE";
    const VTable* tbl = NULL;
    const KMetadata* meta = NULL;
    const KMDataNode* node = NULL;
    assert(prm && db);
    if (rc == 0) {
        rc = VDatabaseOpenTableRead(db, &tbl, tblName);
        DISP_RC2(rc, tblName, "while calling VDatabaseOpenTableRead");
    }
    if (rc == 0) {
        rc = VTableOpenMetadataRead(tbl, &meta);
        DISP_RC2(rc, tblName, "while calling VTableOpenMetadataRead");
    }
    if (rc == 0) {
        bool found = false;
        const char path[] = "STATS/QUALITY";
        rc = KMetadataOpenNodeRead(meta, &node, path);
        if (rc == 0)
        {   found = true; }
        else if (GetRCState(rc) == rcNotFound)
        {   rc = 0; }
        DISP_RC2(rc, path, "while calling KMetadataOpenNodeRead");
        if (found) {
            uint32_t i = 0;
            int nbr = 0;
            uint32_t count = 0;
            KNamelist* names = NULL;
            int* quals = NULL;
            if (rc == 0) {
                rc = KMDataNodeListChild(node, &names);
                DISP_RC2(rc, path, "while calling KMDataNodeListChild");
            }
            if (rc == 0) {
                rc = KNamelistCount(names, &count);
                DISP_RC2(rc, path, "while calling KNamelistCount");
                if (rc == 0 && count > 0) {
                    quals = calloc(count, sizeof *quals);
                    if (quals == NULL) {
                        rc = RC(rcExe,
                            rcStorage, rcAllocating, rcMemory, rcExhausted);
                    }
                }
            }
            for (i = 0; i < count && rc == 0; ++i) {
             /* uint64_t u = 0;
                const KMDataNode* n = NULL; */
                const char* nodeName = NULL;
                const char* name = NULL;
                rc = KNamelistGet(names, i, &nodeName);
                DISP_RC2(rc, path, "while calling KNamelistGet");
                if (rc)
                {   break; }
                name = nodeName;
             /* rc = KMDataNodeOpenNodeRead(node, &n, name);
                DISP_RC(rc, name);
                if (rc == 0) {
                    rc = KMDataNodeReadAsU64(n, &u);
                    DISP_RC(rc, name);
                } */
                if (rc == 0) {
                    char* c = strchr(name, '_');
                    if (c != NULL && *(c + 1) != '\0') {
                        name = c + 1;
                        if (sscanf(name, "%d", &quals[i]) != 1) {
                            rc = RC(rcExe,
                                rcNode, rcParsing, rcName, rcUnexpected);
                            PLOGERR(klogInt,
                                (klogInt, rc, "$(name)", "name=%s", nodeName));
                        }
                    }
                    /* OUTMSG(("QUALITY %s %lu\n", name, u)); */
                }
             /* DESTRUCT(KMDataNode, n); */
            }
            if (rc == 0 && count > 0)
            {   ksort(quals, count, sizeof *quals, sort_callback, NULL); }
            if (rc == 0) {
                OUTMSG(("%s", prm->dbPath));
            }
            for (i = 0, nbr = 0; i < count && rc == 0; ++i, ++nbr) {
                uint64_t u = 0;
                char name[64];
                const KMDataNode* n = NULL;
                sprintf(name, "PHRED_%d", quals[i]);
                rc = KMDataNodeOpenNodeRead(node, &n, name);
                DISP_RC(rc, name);
                if (rc == 0) {
                    rc = KMDataNodeReadAsU64(n, &u);
                    DISP_RC(rc, name);
                    if (rc == 0) {
                        while (nbr < quals[i]) {
                            OUTMSG(("\t0"));
                            ++nbr;
                        }
                        OUTMSG(("\t%lu", u));
                    /*  OUTMSG(("QUALITY %d %lu\n", quals[i], u)); */
                    }
                }
                DESTRUCT(KMDataNode, n);
            }
            while (rc == 0 && nbr <= 40) {
                OUTMSG(("\t0"));
                nbr++;
            }
            if (rc == 0) {
                OUTMSG(("\n"));
            }
            DESTRUCT(KNamelist, names);
        }
    }
    DESTRUCT(KMDataNode, node);
    DESTRUCT(KMetadata, meta);
    DESTRUCT(VTable, tbl);
    return rc;
}
コード例 #8
0
/* 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;
}