static void get_meta_info( vdb_info_data * data, const KMetadata * meta )
{
const KMDataNode * node;
rc_t rc = KMetadataOpenNodeRead ( meta, &node, "schema" );
if ( rc == 0 )
{
size_t size;
rc = KMDataNodeReadAttr ( node, "name", data->schema_name, sizeof data->schema_name, &size );
if ( rc == 0 )
data->schema_name[ size ] = 0;
KMDataNodeRelease ( node );
}
rc = KMetadataOpenNodeRead ( meta, &node, "LOAD/timestamp" );
if ( rc == 0 )
{
rc = KMDataNodeReadAsU64 ( node, &data->ts.timestamp );
if ( rc == 0 )
{
KTime time_rec;
KTimeLocal ( &time_rec, data->ts.timestamp );
data->ts.year = time_rec.year;
data->ts.month = time_rec.month + 1;
data->ts.day = time_rec.day + 1;
data->ts.hour = time_rec.hour;
data->ts.minute= time_rec.minute;
}
KMDataNodeRelease ( node );
}
get_meta_event( meta, "SOFTWARE/formatter", &data->formatter );
get_meta_event( meta, "SOFTWARE/loader", &data->loader );
get_meta_event( meta, "SOFTWARE/update", &data->update );
}
static void get_meta_bam_hdr( vdb_info_bam_hdr * bam_hdr, const KMetadata * meta )
{
const KMDataNode * node;
rc_t rc = KMetadataOpenNodeRead ( meta, &node, "BAM_HEADER" );
bam_hdr -> present = ( rc == 0 );
if ( bam_hdr -> present )
{
bam_hdr->hdr_bytes = get_node_size( node );
if ( bam_hdr->hdr_bytes > 0 )
{
char * buffer = malloc( bam_hdr->hdr_bytes );
if ( buffer != NULL )
{
size_t num_read, remaining;
rc = KMDataNodeRead( node, 0, buffer, bam_hdr->hdr_bytes, &num_read, &remaining );
if ( rc == 0 )
{
parse_buffer( bam_hdr, buffer, bam_hdr->hdr_bytes );
}
free( buffer );
}
}
KMDataNodeRelease ( node );
}
}
static
bool KMetadataVersEqual ( const KMetadata *meta, const char *name, const char *vers )
{
bool equal = false;
const KMDataNode *node;
rc_t rc = KMetadataOpenNodeRead ( meta, & node, "SOFTWARE/loader" );
if ( rc == 0 )
{
size_t num_read;
char attr [ 256 ];
rc = KMDataNodeReadAttr ( node, "name", attr, sizeof attr, & num_read );
if ( rc == 0 )
{
if ( memcmp ( attr, name, strlen ( name ) ) == 0 )
{
if ( vers == NULL || vers [ 0 ] == 0 )
equal = true;
else
{
rc = KMDataNodeReadAttr ( node, "vers", attr, sizeof attr, & num_read );
if ( rc == 0 )
{
if ( memcmp ( attr, vers, strlen ( vers ) ) == 0 )
equal = true;
}
}
}
}
KMDataNodeRelease ( node );
}
return equal;
}
/* OpenIndexRead
* VOpenIndexRead
* open an index for read
*
* "idx" [ OUT ] - return parameter for newly opened index
*
* "name" [ IN ] - NUL terminated string in UTF-8 giving simple name of idx
*/
LIB_EXPORT rc_t CC VTableVOpenIndexRead ( const VTable *self,
struct KIndex const **idx, const char *name, va_list args )
{
rc_t rc;
KIdxType type;
uint32_t version;
const KMDataNode *node;
if ( self == NULL )
{
if ( idx == NULL )
return RC ( rcVDB, rcTable, rcOpening, rcParam, rcNull );
* idx = NULL;
return RC ( rcVDB, rcTable, rcOpening, rcSelf, rcNull );
}
/* open the requested index */
rc = KTableVOpenIndexRead ( self -> ktbl, idx, name, args );
if ( rc != 0 )
return rc;
/* get version and type */
rc = KIndexVersion ( * idx, & version );
if ( rc == 0 )
rc = KIndexType ( * idx, & type );
if ( rc != 0 )
return 0;
/* look for versions 2 or 3, type kitText or kitText with projection */
switch ( version )
{
case 2:
case 3:
switch ( type )
{
case kitText:
case kitText | kitProj:
break;
default:
return 0;
}
break;
default:
return 0;
}
/* look for a node in metadata for repairing maximum id */
rc = KMetadataOpenNodeRead ( self -> meta, & node, "/.seq/spot" );
if ( rc == 0 )
{
int64_t maxid;
rc = KMDataNodeReadAsI64 ( node, & maxid );
if ( rc == 0 )
KIndexSetMaxRowId ( * idx, maxid );
KMDataNodeRelease ( node );
}
return 0;
}
rc_t VDatabaseLoadSchema ( VDatabase *self )
{
/* try to get schema text */
const KMDataNode *node;
rc_t rc = KMetadataOpenNodeRead ( self -> meta, & node, "schema" );
if ( rc == 0 )
{
/* the node is probably within our 4K buffer,
but by using the callback mechanism we don't
have buffer or allocation issues. */
KMDataNodeSchemaFillData pb;
pb . node = node;
pb . pos = 0;
pb . add_v0 = false;
/* add in schema text. it is not mandatory, but it is
the design of the system to store object schema with
the object so that it is capable of standing alone */
rc = VSchemaParseTextCallback ( self -> schema,
"VDatabaseLoadSchema", KMDataNodeFillSchema, & pb );
if ( rc == 0 )
{
/* determine database type */
rc = KMDataNodeReadAttr ( node, "name",
pb . buff, sizeof pb . buff, & pb . pos );
if ( rc == 0 )
{
uint32_t type;
const SNameOverload *name;
/* find the sdb if possible */
self -> sdb = VSchemaFind ( self -> schema,
& name, & type, pb . buff, "VDatabaseLoadSchema", false );
/* the schema must be found in this case */
if ( self -> sdb == NULL || type != eDatabase )
{
self -> sdb = NULL;
rc = RC ( rcVDB, rcDatabase, rcLoading, rcSchema, rcCorrupt );
PLOGERR ( klogInt, ( klogInt, rc, "failed to establish database type from '$(expr)'",
"expr=%s", pb . buff ));
}
}
}
KMDataNodeRelease ( node );
}
else if ( GetRCState ( rc ) == rcNotFound )
{
/* the database may be under creation */
if ( ! self -> read_only )
rc = 0;
}
return rc;
}
static
bool KMetadataExists ( const KMetadata *meta, const char *path )
{
const KMDataNode *node;
rc_t rc = KMetadataOpenNodeRead ( meta, & node, "%s", path );
if ( rc != 0 )
return false;
KMDataNodeRelease ( node );
return true;
}
/* FillOutTableRead
* creates an empty cursor
* accesses metadata
*/
static rc_t ReadSpotSequence_v1(SRATable *self)
{
const KMDataNode *n;
rc_t rc = KMetadataOpenNodeRead(self->meta, &n, ".seq");
if (rc == 0)
{
rc = KMDataNodeReadAsU64(n, &self->spot_count);
KMDataNodeRelease(n);
}
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;
}
rc_t VPhysicalLoadMetadata ( VPhysical *self, VTypedecl *td, VSchema *schema )
{
/* capture fixed row length */
const KMDataNode *node;
rc_t rc = KMetadataOpenNodeRead ( self -> meta, & node, "row-len" );
if ( rc == 0 )
{
rc = KMDataNodeReadAsU32 ( node, & self -> fixed_len );
KMDataNodeRelease ( node );
if ( rc != 0 )
return rc;
}
/* look for "schema" root node */
rc = KMetadataOpenNodeRead ( self -> meta, & node, "schema" );
if ( rc == 0 )
return VPhysicalLoadSchema ( self, td, schema, node );
if ( GetRCState ( rc ) != rcNotFound )
return rc;
/* appears to be an older column */
self -> v01 = true;
/* look for "decoding" root node */
rc = KMetadataOpenNodeRead ( self -> meta, & node, "decoding" );
if ( rc == 0 )
return VPhysicalLoadV1Schema ( self, td, schema, node );
if ( GetRCState ( rc ) != rcNotFound )
return rc;
/* benign error for very old columns */
rc = RC ( rcVDB, rcColumn, rcLoading, rcSchema, rcNotFound );
DBGMSG(DBG_VDB, DBG_FLAG(DBG_VDB_VDB),
("VPhysicalLoadMetadata = %d\n", rc));
return rc;
}
static
bool KMetadataEmpty ( const KMetadata *meta, const char *path )
{
size_t num_read, remaining;
const KMDataNode *node;
rc_t rc = KMetadataOpenNodeRead ( meta, & node, "%s", path );
if ( rc != 0 )
return true;
rc = KMDataNodeRead ( node, 0, & num_read, 0, & num_read, & remaining );
KMDataNodeRelease ( node );
if ( rc == 0 && remaining != 0 )
return false;
return true;
}
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 extract_spotgroups_from_bam_hdr( VNamelist * spotgroups, input_database * id, const KMetadata * meta )
{
const KMDataNode * node;
rc_t rc = KMetadataOpenNodeRead( meta, &node, "BAM_HEADER" );
/* do not report if the node cannot be found, because this would produce an error message when a database does
not have this node, which can is OK */
if ( rc == 0 )
{
char buffer[ 4096 ];
rc = read_2_namelist( spotgroups, buffer, sizeof buffer,
read_from_metadata_node, write_to_namelist,
node, spotgroups );
KMDataNodeRelease( node );
}
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
bool KMetadataNumEqual ( const KMetadata *meta, const char *path, int64_t num )
{
const KMDataNode *node;
rc_t rc = KMetadataOpenNodeRead ( meta, & node, "%s", path );
if ( rc == 0 )
{
int64_t i;
rc = KMDataNodeReadAsI64 ( node, & i );
KMDataNodeRelease ( node );
if ( rc == 0 )
{
if ( i == num )
return true;
}
}
return false;
}
rc_t VTableLoadSchema ( VTable *self )
{
/* try to get schema text */
const KMDataNode *node;
rc_t rc = KMetadataOpenNodeRead ( self -> meta, & node, "schema" );
if ( rc == 0 )
{
rc = VTableLoadSchemaNode ( self, node );
KMDataNodeRelease ( node );
}
else if ( GetRCState ( rc ) == rcNotFound )
{
/* this is an older version. search schema
for a table having an untyped function */
rc = VTableFindType ( self );
}
return rc;
}
static
bool KMetadataStrEqual ( const KMetadata *meta, const char *path, const char *str )
{
const KMDataNode *node;
rc_t rc = KMetadataOpenNodeRead ( meta, & node, "%s", path );
if ( rc == 0 )
{
size_t num_read;
char buff [ 4096 ];
rc = KMDataNodeReadCString ( node, buff, sizeof buff, & num_read );
KMDataNodeRelease ( node );
if ( rc == 0 )
{
if ( strcmp ( buff, str ) == 0 )
return true;
}
}
return false;
}
/* HasStaticColumn - PRIVATE
* given a physical column name, report whether it exists
* and is ( currently ) static
* avail: 2.5
*/
LIB_EXPORT bool CC VTableHasStaticColumn ( const VTable *self, const char *name )
{
if ( self != NULL && name != NULL && name [ 0 ] != 0 )
{
/* a full check of this might include testing that the column
can be opened for read or write, but the API is purposely
vague on what this means.
currently the meaning of this ( PRIVATE ) API is whether
there is a metadata column entry with this name - period. */
const KMDataNode *node;
rc_t rc = KMetadataOpenNodeRead ( self -> meta, & node, "/col/%s", name );
if ( rc == 0 )
{
KMDataNodeRelease ( node );
return true;
}
}
return false;
}
/* OpenRead
* finish initialization on open for read
*/
static
rc_t VTableOpenRead ( VTable *self )
{
/* open metadata */
rc_t rc = KTableOpenMetadataRead ( self -> ktbl, & self -> meta );
if ( rc == 0 )
{
/* open "col" node, if present */
rc = KMetadataOpenNodeRead ( self -> meta, & self -> col_node, "col" );
if ( rc == 0 || GetRCState ( rc ) == rcNotFound )
{
/* fetch stored schema */
rc = VTableLoadSchema ( self );
if ( rc == 0 && self -> stbl == NULL )
rc = RC ( rcVDB, rcTable, rcOpening, rcSchema, rcNotFound );
}
}
DBGMSG(DBG_VDB, DBG_FLAG(DBG_VDB_VDB), ("VTableOpenRead = %d\n", rc));
return rc;
}
static rc_t extract_spotgroups_from_stats( VNamelist * spotgroups, input_database * id, const KMetadata * meta )
{
const KMDataNode * node;
rc_t rc = KMetadataOpenNodeRead( meta, &node, "STATS/SPOT_GROUP" );
if ( rc != 0 )
(void)PLOGERR( klogErr, ( klogErr, rc, "cannot open meta-node 'STATS/SPOT_GROUP' from '$(t)'", "t=%s", id->path ) );
else
{
KNamelist * node_childs;
rc = KMDataNodeListChildren( node, &node_childs );
if ( rc != 0 )
(void)PLOGERR( klogErr, ( klogErr, rc, "cannot list children of SPOT_GROUP-node in '$(t)'", "t=%s", id->path ) );
else
{
uint32_t n_count;
rc = KNamelistCount( node_childs, &n_count );
if ( rc == 0 && n_count > 0 )
{
uint32_t n_idx;
for ( n_idx = 0; n_idx < n_count && rc == 0; ++n_idx )
{
const char * spotgroup;
rc = KNamelistGet( node_childs, n_idx, &spotgroup );
if ( rc == 0 && spotgroup != NULL )
{
uint32_t found;
rc_t rc1 = VNamelistIndexOf( spotgroups, spotgroup, &found );
if ( GetRCState( rc1 ) == rcNotFound )
rc = VNamelistAppend( spotgroups, spotgroup );
}
}
}
KNamelistRelease( node_childs );
}
KMDataNodeRelease( node );
}
return rc;
}
static
bool KColumnTypeEqual ( const KTable *tbl, const char *col, const char *type )
{
/* TBD - this operation is expensive
should be addressed either by caching opened columns on table
or by introducing a path to open column metadata from table */
const KColumn *kcol;
rc_t rc = KTableOpenColumnRead ( tbl, & kcol, "%s", col );
if ( rc == 0 )
{
const KMetadata *meta;
rc = KColumnOpenMetadataRead ( kcol, & meta );
KColumnRelease ( kcol );
if ( rc == 0 )
{
/* this is a expected to be a v1 column
open its decoding node */
const KMDataNode *node;
rc = KMetadataOpenNodeRead ( meta, & node, "decoding" );
KMetadataRelease ( meta );
if ( rc == 0 )
{
/* read its type */
size_t size;
char type_expr [ 256 ];
rc = KMDataNodeReadAttr ( node, "type",
type_expr, sizeof type_expr, & size );
KMDataNodeRelease ( node );
if ( rc == 0 )
{
if ( memcmp ( type_expr, type, strlen ( type ) ) == 0 )
return true;
}
}
}
}
return false;
}
static rc_t copy_stray_metadata ( const KMetadata *src_meta, KMetadata *dst_meta,
const char * excluded_nodes,
const bool show_meta )
{
/* open root node */
const KMDataNode *src_root;
rc_t rc = KMetadataOpenNodeRead ( src_meta, & src_root, NULL );
DISP_RC( rc, "copy_stray_metadata:KMetadataOpenNodeRead() failed" );
if ( rc == 0 )
{
KMDataNode *dst_root;
rc = KMetadataOpenNodeUpdate ( dst_meta, & dst_root, NULL );
DISP_RC( rc, "copy_stray_metadata:KMetadataOpenNodeUpdate() failed" );
if ( rc == 0 )
{
/* treat the root node in a special way */
rc = copy_metadata_root ( src_root, dst_root, excluded_nodes, show_meta );
KMDataNodeRelease ( dst_root );
}
KMDataNodeRelease ( src_root );
}
return rc;
}
static rc_t get_schema_info(KMetadata const *const meta,
unsigned const bsz, char buffer[])
{
KMDataNode const *node;
rc_t rc = KMetadataOpenNodeRead(meta, &node, "schema");
if (rc == 0) {
size_t sz;
rc = KMDataNodeReadAttr(node, "name", buffer, bsz - 1, &sz);
KMDataNodeRelease(node);
if (rc == 0) {
buffer[sz] = '\0';
while (sz) {
--sz;
if (buffer[sz] == '#') {
buffer[sz] = '\0';
break;
}
}
}
}
return rc;
}
static void get_meta_event( const KMetadata * meta, const char * node_path, vdb_info_event * event )
{
const KMDataNode * node;
rc_t rc = KMetadataOpenNodeRead ( meta, &node, node_path );
if ( rc == 0 )
{
get_meta_attr( node, "name", event->name, sizeof event->name );
if ( event->name[ 0 ] == 0 )
get_meta_attr( node, "tool", event->name, sizeof event->name );
get_meta_attr( node, "vers", event->vers.s_vers, sizeof event->vers.s_vers );
split_vers( &event->vers );
get_meta_attr( node, "run", event->run_date.date, sizeof event->run_date.date );
split_date( &event->run_date );
get_meta_attr( node, "date", event->tool_date.date, sizeof event->tool_date.date );
if ( event->tool_date.date[ 0 ] == 0 )
get_meta_attr( node, "build", event->tool_date.date, sizeof event->tool_date.date );
split_date( &event->tool_date );
KMDataNodeRelease ( node );
}
}
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 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;
}
static
rc_t CC sra_meta_stats_update(sra_meta_stats_data* self,
const int64_t spot_id, const uint32_t spot_len,
const uint32_t bio_spot_len, const uint32_t cmp_spot_len,
bool has_grp, const char* grp, uint64_t grp_len)
{
rc_t rc = 0;
const uint32_t max_grp_qty = 10000;
assert(self != NULL);
rc = sra_meta_stats_node_group_update(&self->table, spot_id, spot_len, bio_spot_len, cmp_spot_len);
if( has_grp && self->grp_qty <= max_grp_qty && rc == 0 )
{
/* an empty group is considered default */
if( grp_len == 0 || grp == NULL || grp[0] == '\0' ||
(grp_len == 7 && strncasecmp("default", grp, grp_len) == 0 ) )
{
rc = sra_meta_stats_node_group_update(&self->dflt_grp, spot_id, spot_len, bio_spot_len, cmp_spot_len);
}
else
{
size_t i;
KMDataNode* n;
const KMDataNode *cn;
bool new_group, unsafe;
/* look for cached node */
if ( self->last_grp_name != NULL &&
self->last_grp_name_len == grp_len &&
strncmp(self->last_grp_name, grp, grp_len) == 0 )
{
return sra_meta_stats_node_group_update(&self->last_grp, spot_id, spot_len, bio_spot_len, cmp_spot_len);
}
/* release cached group */
sra_meta_stats_node_group_release(&self->last_grp);
/* realloc cached name */
if ( self->last_grp_name == NULL || grp_len >= self->last_grp_name_sz )
{
char *p = realloc ( self -> last_grp_name, grp_len + 1 );
if ( p == NULL )
return RC ( rcXF, rcFunction, rcExecuting, rcMemory, rcExhausted );
self -> last_grp_name = p;
self -> last_grp_name_sz = grp_len + 1;
}
/* sanitize name */
for ( unsafe = false, i = 0; i < grp_len; ++ i )
{
if ( ( self -> last_grp_name [ i ] = grp [ i ] ) == '/' )
{
unsafe = true;
self -> last_grp_name [ i ] = '\\';
}
}
self -> last_grp_name_len = i;
self -> last_grp_name [ i ] = 0;
/* look for new group */
new_group = true;
rc = KMetadataOpenNodeRead(self->meta, &cn, "STATS/SPOT_GROUP/%s", self->last_grp_name );
if ( rc == 0 )
{
new_group = false;
KMDataNodeRelease ( cn );
}
/* detect abusive quantity of nodes */
if ( new_group && ++self->grp_qty > max_grp_qty )
{
rc = KMetadataOpenNodeUpdate(self->meta, &n, "STATS");
if( rc == 0 )
{
sra_meta_stats_node_group_release(&self->dflt_grp);
KMDataNodeDropChild(n, "SPOT_GROUP");
KMDataNodeRelease(n);
free(self->last_grp_name);
self->last_grp_name = NULL;
}
return rc;
}
/* create new or cache existing group */
rc = KMetadataOpenNodeUpdate(self->meta, &n, "STATS/SPOT_GROUP/%s", self->last_grp_name );
if ( rc == 0 )
{
rc = sra_meta_stats_node_group_open(n, &self->last_grp, self->compressed);
if (rc == 0 && new_group) {
if (unsafe)
{
char value [ 512 ], *v = value;
if ( grp_len >= sizeof value )
v = malloc ( grp_len + 1 );
if ( v == NULL )
rc = RC ( rcXF, rcFunction, rcExecuting, rcMemory, rcExhausted );
else
{
rc = string_printf ( v, grp_len + 1, NULL, "%.*s", ( uint32_t ) grp_len, grp );
assert ( rc == 0 );
rc = KMDataNodeWriteAttr(n, "name", v);
if ( rc == 0 )
memcpy ( self->last_grp_name, grp, grp_len );
if ( v != value )
free ( v );
}
}
if ( rc == 0 )
rc = sra_meta_stats_node_group_update(&self->last_grp, 0, 0, 0, 0);
}
KMDataNodeRelease(n);
if( rc == 0 )
rc = sra_meta_stats_node_group_update(&self->last_grp, spot_id, spot_len, bio_spot_len, cmp_spot_len);
}
}
}
return rc;
}
/* ListPhysColumns
* avail: 2.4
*/
LIB_EXPORT rc_t CC VTableListPhysColumns ( const VTable *self, KNamelist **names )
{
rc_t rc;
if ( names == NULL )
rc = RC ( rcVDB, rcTable, rcListing, rcParam, rcNull );
else
{
* names = NULL;
if ( self == NULL )
rc = RC ( rcVDB, rcTable, rcListing, rcSelf, rcNull );
else
{
KNamelist *kcol_names;
rc = KTableListCol ( self -> ktbl, & kcol_names );
if ( rc == 0 )
{
uint32_t kcol_count;
rc = KNamelistCount ( kcol_names, & kcol_count );
if ( rc == 0 )
{
uint32_t scol_count = 0;
KNamelist *scol_names = NULL;
const KMDataNode *col_node = self -> col_node;
#if LAZY_OPEN_COL_NODE
if ( col_node == NULL )
{
rc = KMetadataOpenNodeRead ( self -> meta, & ( ( VTable* ) self ) -> col_node, "col" );
if ( rc == 0 || GetRCState ( rc ) != rcNotFound )
col_node = self -> col_node;
}
#endif
if ( col_node != NULL )
{
rc = KMDataNodeListChildren ( col_node, & scol_names );
if ( rc == 0 )
rc = KNamelistCount ( scol_names, & scol_count );
}
if ( rc == 0 )
{
VNamelist *vnames;
rc = VNamelistMake ( & vnames, kcol_count + scol_count );
if ( rc == 0 )
{
uint32_t i;
const char *name;
for ( i = 0; i < kcol_count && rc == 0; ++ i )
{
rc = KNamelistGet ( kcol_names, i, & name );
if ( rc == 0 )
rc = VNamelistAppend ( vnames, name );
}
for ( i = 0; i < scol_count && rc == 0; ++ i )
{
rc = KNamelistGet ( scol_names, i, & name );
if ( rc == 0 )
rc = VNamelistAppend ( vnames, name );
}
if ( rc == 0 )
{
rc = VNamelistToNamelist ( vnames, names );
if ( rc == 0 )
VNamelistReorder ( vnames, false );
}
}
VNamelistRelease ( vnames );
}
KNamelistRelease ( scol_names );
}
KNamelistRelease ( kcol_names );
}
}
}
return rc;
}
/* LoadSchema
* looks in metadata for stored schema
*/
static
rc_t CC VPhysicalLoadV1Schema ( VPhysical *self,
VTypedecl *td, VSchema *schema, const KMDataNode *node )
{
rc_t rc;
KMDataNodeSchemaFillData pb;
pb . node = node;
pb . pos = 0;
pb . add_v0 = true;
/* add stored declaration to cursor schema */
rc = VSchemaParseTextCallback ( schema,
"VPhysicalLoadV1Schema", KMDataNodeFillSchema, & pb );
if ( rc == 0 )
{
size_t size;
char type_expr [ 256 ];
/* retrieve and resolve "type" attribute */
rc = KMDataNodeReadAttr ( node, "type",
type_expr, sizeof type_expr, & size );
if ( rc == 0 )
rc = VSchemaResolveTypedecl ( schema, td, type_expr );
/* if a decoding schema exists */
if ( rc == 0 && pb . pos != 0 )
{
char sphysical_name [ 512 ];
/* preserve schema function expression */
size_t decoding_xsize;
char decoding_expr [ 256 ];
rc = KMDataNodeReadAttr ( node, "schema",
decoding_expr, sizeof decoding_expr, & decoding_xsize );
if ( rc == 0 )
{
/* look for "encoding" */
const KMDataNode *enc;
rc = KMetadataOpenNodeRead ( self -> meta, & enc, "encoding" );
if ( rc == 0 )
{
#if ALLOW_V1_UPDATE
if ( ! self -> read_only )
{
/* add stored declaration to cursor schema */
pb . node = enc;
pb . pos = 0;
pb . add_v0 = true;
rc = VSchemaParseTextCallback ( schema,
"VPhysicalLoadV1Schema", KMDataNodeFillSchema, & pb );
}
if ( rc == 0 )
#endif
{
/* preserve schema function expression */
size_t encoding_xsize;
char encoding_expr [ 256 ], enc_type [ 256 ];
rc = KMDataNodeReadAttr ( enc, "schema",
encoding_expr, sizeof encoding_expr, & encoding_xsize );
if ( rc == 0 )
{
rc = KMDataNodeReadAttr ( enc, "type",
enc_type, sizeof enc_type, & size );
}
if ( rc == 0 )
{
#if ALLOW_V1_UPDATE
if ( self -> read_only )
{
#endif
/* build sphysical name */
sprintf ( sphysical_name, "%s_only", decoding_expr );
/* build physical decl */
pb . pos = sprintf ( pb . buff, "version 1;"
"physical %s %s:phys#1"
"{decode{%s k=@;return %s(k);}}"
, type_expr
, sphysical_name
, enc_type
, decoding_expr
);
#if ALLOW_V1_UPDATE
}
else
{
/* strip off common namespace */
size_t i, ns_size;
string_match ( decoding_expr, decoding_xsize,
encoding_expr, encoding_xsize, -1, & ns_size );
if ( ns_size != 0 )
{
char *p = string_rchr ( decoding_expr, ns_size, ':' );
ns_size = ( p == NULL ) ? 0U : ( uint32_t ) ( p - decoding_expr ) + 1U;
}
/* build sphysical name */
sprintf ( sphysical_name, "%s_%s", decoding_expr, & encoding_expr [ ns_size ] );
for ( i = ns_size; sphysical_name [ i ] != 0; ++ i )
{
if ( sphysical_name [ i ] == ':' )
sphysical_name [ i ] = '_';
}
/* build physical decl */
pb . pos = sprintf ( pb . buff, "version 1;"
"physical %s %s:phys#1"
"{encode{return %s(@);}"
"decode{%s k=@;return %s(k);}}"
, type_expr
, sphysical_name
, encoding_expr
, enc_type
, decoding_expr
);
}
#endif
}
}
KMDataNodeRelease ( enc );
}
else if ( GetRCState ( rc ) == rcNotFound )
{
/* build sphysical name */
sprintf ( sphysical_name, "%s_only", decoding_expr );
/* build decode-only physical decl */
pb . pos = sprintf ( pb . buff, "version 1;"
"physical %s %s:phys#1"
"{decode{opaque k=@;return %s(k);}}"
, type_expr
, sphysical_name
, decoding_expr
);
rc = 0;
}
if ( rc == 0 )
{
/* parse synthesized schema into cursor VSchema */
rc = VSchemaParseText ( schema,
"VPhysicalLoadV1Schema", pb . buff, pb . pos );
if ( rc == 0 )
{
VTypedecl etd;
/* create a new expression object */
sprintf ( pb . buff, "%s:phys#1", sphysical_name );
rc = VSchemaImplicitPhysEncExpr ( schema, & etd,
& self -> enc, pb . buff, "VPhysicalLoadV1Schema" );
if ( rc != 0 )
{
PLOGERR ( klogInt, ( klogInt, rc, "failed to establish column type from '$(expr)'",
"expr=%s", pb . buff ));
}
else if ( self -> smbr != NULL && self -> smbr -> type == NULL )
{
/* back-patch schema */
( ( SPhysMember* ) self -> smbr ) -> type = self -> enc;
atomic32_inc ( & ( ( SExpression* ) self -> enc ) -> refcount );
}
}
}
}
}
}
KMDataNodeRelease ( node );
return rc;
}
