static
rc_t sra_meta_stats_make(sra_meta_stats_data** self, VTable* vtbl, bool has_spot_group, bool compressed)
{
rc_t rc = 0;
sra_meta_stats_data* data = calloc(1, sizeof(*data));
assert(self != NULL && vtbl != NULL);
if( data == NULL ) {
rc = RC(rcVDB, rcFunction, rcConstructing, rcMemory, rcExhausted);
} else if( (rc = VTableOpenMetadataUpdate(vtbl, &data->meta)) == 0 ) {
KMDataNode* node;
data->compressed = compressed;
if( (rc = KMetadataOpenNodeUpdate(data->meta, &node, "STATS/TABLE")) == 0 ) {
rc = sra_meta_stats_node_group_open(node, &data->table, compressed);
KMDataNodeRelease(node);
}
if( rc == 0 && has_spot_group ) {
if( (rc = KMetadataOpenNodeUpdate(data->meta, &node, "STATS/SPOT_GROUP/default")) == 0 ) {
rc = sra_meta_stats_node_group_open(node, &data->dflt_grp, compressed);
KMDataNodeRelease(node);
}
}
}
if( rc == 0 ) {
*self = data;
} else {
sra_meta_stats_whack(data);
}
return rc;
}
static rc_t group_stats_write(group_stats_t const *const self,
stats_data_t const *const parent,
char const strings[])
{
static char const namebase[] = "STATS/SPOT_GROUP/";
char namepath[sizeof(namebase) + 3]; /* sizeof(namebase) includes terminator */
char *const name = namepath + sizeof(namebase) - 1;
unsigned nodeid = self->node_name - 1;
KMDataNode *node;
rc_t rc;
memcpy(namepath, namebase, sizeof(namebase));
name[4] = '\0';
name[3] = nodeid % 26 + 'A'; nodeid /= 26;
name[2] = nodeid % 26 + 'A'; nodeid /= 26;
name[1] = nodeid % 26 + 'A'; nodeid /= 26;
name[0] = nodeid % 26 + 'A'; nodeid /= 26;
RC_THROW(KMetadataOpenNodeUpdate(parent->meta, &node, "%s", namepath));
rc = group_stats_write_1(self, parent,
self->name_len,
strings + self->name_offset,
node);
KMDataNodeRelease(node);
return rc;
}
static rc_t pacbio_meta_entry( ld_context *lctx, const char * toolname )
{
KMetadata* meta = NULL;
rc_t rc = VDatabaseOpenMetadataUpdate( lctx->database, &meta );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "Cannot open database-metadata" );
}
else
{
KMDataNode *node = NULL;
rc = KMetadataOpenNodeUpdate( meta, &node, "/" );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "Cannot open database-metadata-root" );
}
else
{
rc = KLoaderMeta_Write( node, toolname, __DATE__, "PacBio HDF5", PACBIO_LOAD_VERS );
if ( rc != 0 )
{
LOGERR( klogErr, rc, "Cannot write pacbio metadata node" );
}
KMDataNodeRelease( node );
}
KMetadataRelease( meta );
}
return rc;
}
static rc_t enter_vdbcopy_node( KMetadata *dst_meta, const bool show_meta )
{
rc_t rc;
KMDataNode *hist_node;
if ( show_meta )
KOutMsg( "--- entering Copy entry...\n" );
rc = KMetadataOpenNodeUpdate ( dst_meta, &hist_node, "HISTORY" );
DISP_RC( rc, "enter_vdbcopy_node:KMetadataOpenNodeUpdate('HISTORY') failed" );
if ( rc == 0 )
{
char event_name[ 32 ];
uint32_t index = get_child_count( hist_node ) + 1;
rc = string_printf ( event_name, sizeof( event_name ), NULL, "EVENT_%u", index );
DISP_RC( rc, "enter_vdbcopy_node:string_printf(EVENT_NR) failed" );
if ( rc == 0 )
{
KMDataNode *event_node;
rc = KMDataNodeOpenNodeUpdate ( hist_node, &event_node, event_name );
DISP_RC( rc, "enter_vdbcopy_node:KMDataNodeOpenNodeUpdate('EVENT_NR') failed" );
if ( rc == 0 )
{
rc = enter_date_name_vers( event_node );
KMDataNodeRelease ( event_node );
}
}
KMDataNodeRelease ( hist_node );
}
return rc;
}
LIB_EXPORT rc_t CC TableWriterSeq_Whack(const TableWriterSeq* cself, bool commit, uint64_t* rows)
{
rc_t rc = 0;
if( cself != NULL ) {
TableWriterSeq* self = (TableWriterSeq*)cself;
VTable *vtbl;
TableReader_Whack(cself->tmpkey_reader);
if (commit && (rc = TableWriter_GetVTable(cself->base, &vtbl)) == 0 ) {
KMetadata* meta;
if ((rc = VTableOpenMetadataUpdate(vtbl, &meta)) == 0) {
KMDataNode* node = NULL;
if (cself->stats) {
if ((rc = KMetadataOpenNodeUpdate(meta, &node, "MATE_STATISTICS")) == 0) {
rc = TableWriterSeq_WriteStatistics(cself, node);
KMDataNodeRelease(node);
}
}
if ((rc = KMetadataOpenNodeUpdate(meta, &node, "unaligned")) == 0) {
KMDataNode *sub = NULL;
KMDataNodeOpenNodeUpdate(node, &sub, "first-unaligned");
KMDataNodeWriteB64(sub, &self->firstUnaligned);
KMDataNodeRelease(sub);
KMDataNodeOpenNodeUpdate(node, &sub, "first-half-aligned");
KMDataNodeWriteB64(sub, &self->firstHalfAligned);
KMDataNodeRelease(sub);
KMDataNodeRelease(node);
}
KMetadataRelease(meta);
}
}
rc = TableWriter_Whack(cself->base, commit && (rc == 0), rows);
KVectorRelease(cself->stats);
free(self->qual_buf);
free(self);
}
return rc;
}
rc_t VTableCreateCursorWriteInt ( VTable *self, VCursor **cursp, KCreateMode mode, bool create_thread )
{
rc_t rc;
if ( cursp == NULL )
rc = RC ( rcVDB, rcCursor, rcCreating, rcParam, rcNull );
else
{
if ( self == NULL )
rc = RC ( rcVDB, rcTable, rcAccessing, rcSelf, rcNull );
else if ( self -> read_only )
rc = RC ( rcVDB, rcCursor, rcCreating, rcTable, rcReadonly );
#if VCURSOR_WRITE_MODES_SUPPORTED
#error "expecting kcmInsert mode only"
#else
else if ( mode != kcmInsert )
rc = RC ( rcVDB, rcCursor, rcCreating, rcMode, rcUnsupported );
#endif
else
{
VCursor *curs;
#if LAZY_OPEN_COL_NODE
if ( self -> col_node == NULL )
KMetadataOpenNodeUpdate ( self -> meta, & self -> col_node, "col" );
#endif
rc = VCursorMake ( & curs, self );
if ( rc == 0 )
{
rc = VCursorSupplementSchema ( curs );
#if VCURSOR_FLUSH_THREAD
if ( rc == 0 && create_thread )
{
rc = KLockMake ( & curs -> flush_lock );
if ( rc == 0 )
rc = KConditionMake ( & curs -> flush_cond );
if ( rc == 0 )
rc = KThreadMake ( & curs -> flush_thread, run_flush_thread, curs );
}
if(rc == 0)
rc = VCursorLaunchPagemapThread(curs);
#endif
if ( rc == 0 )
{
* cursp = curs;
return 0;
}
VCursorRelease ( curs );
}
}
* cursp = NULL;
}
return rc;
}
static rc_t group_stats_write_table(group_stats_t const *const self,
stats_data_t const *const parent)
{
KMDataNode *node;
rc_t rc;
RC_THROW(KMetadataOpenNodeUpdate(parent->meta, &node, "STATS/TABLE"));
rc = parent->write(self, node);
KMDataNodeRelease(node);
return rc;
}
static rc_t drop_all( KMetadata *dst_meta )
{
KMDataNode *dst_node;
rc_t rc = KMetadataOpenNodeUpdate ( dst_meta, & dst_node, NULL );
DISP_RC( rc, "drop_all:KMetadataOpenNodeUpdate() failed" );
if ( rc == 0 )
{
rc = KMDataNodeDropAll ( dst_node );
DISP_RC( rc, "drop_all:KMetadataDropAll() failed" );
KMDataNodeRelease ( dst_node );
}
return rc;
}
LIB_EXPORT rc_t CC SRATableVOpenMDataNodeUpdate ( SRATable *self, struct KMDataNode **node, const char *spec, va_list args ) {
rc_t rc;
char path[4096];
int n;
if (self == NULL)
return RC(RC_MODULE, RC_TARGET, rcOpening, rcSelf, rcNull);
if (spec == NULL)
return RC(RC_MODULE, RC_TARGET, rcOpening, rcParam, rcNull);
n = vsnprintf(path, sizeof(path), spec, args);
if (n >= sizeof(path))
return RC(RC_MODULE, RC_TARGET, rcOpening, rcName, rcTooLong);
rc = KMetadataOpenNodeUpdate(self->meta, node, "%s", path);
if (rc)
{
SRADBG(("failed to open table metadata node '%s' %R", path, rc));
}
return rc;
}
LIB_EXPORT rc_t CC TableWriterAlgn_Whack(const TableWriterAlgn* cself, bool commit, uint64_t* rows)
{
rc_t rc = 0;
if( cself != NULL ) {
VTable* vtbl;
TableReader_Whack(cself->tmpkey_reader);
if( (rc = TableWriter_GetVTable(cself->base, &vtbl)) == 0 ) {
KMetadata* meta;
if( (rc = VTableOpenMetadataUpdate(vtbl, &meta)) == 0 ) {
KMDataNode* node;
if( (rc = KMetadataOpenNodeUpdate(meta, &node, "CONFIG/REF_TABLE")) == 0 ) {
rc = KMDataNodeWriteCString(node, cself->ref_table_name);
KMDataNodeRelease(node);
}
KMetadataRelease(meta);
}
}
rc = TableWriter_Whack(cself->base, commit, rows);
free((TableWriterAlgn*)cself);
}
return rc;
}
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;
}
/* StoreSchema
*/
rc_t VDatabaseStoreSchema ( VDatabase *self )
{
/* open schema node */
KMDataNode *node;
rc_t rc = KMetadataOpenNodeUpdate ( self -> meta, & node, "schema" );
if ( rc == 0 )
{
size_t num_writ;
char expr [ 256 ];
rc = VSchemaToText ( self -> schema, expr, sizeof expr - 1, & num_writ,
"%N%V", self -> sdb -> name, self -> sdb -> version );
if ( rc != 0 )
LOGERR ( klogInt, rc, "failed to determine database schema" );
else
{
expr [ num_writ ] = 0;
rc = KMDataNodeWriteAttr ( node, "name", expr );
if ( rc != 0 )
PLOGERR (klogInt, ( klogInt, rc, "failed to write database type '$(expr)'", "expr=%s", expr ));
else
{
/* truncate existing schema */
rc = KMDataNodeWrite ( node, "", 0 );
if ( rc == 0 )
{
rc = VSchemaDump ( self -> schema, sdmCompact, expr,
( rc_t ( CC * ) ( void*, const void*, size_t ) ) KMDataNodeAppend, node );
}
if ( rc != 0 )
PLOGERR (klogInt, ( klogInt, rc, "failed to write database schema '$(expr)'", "expr=%s", expr ));
}
}
KMDataNodeRelease ( node );
}
return rc;
}
static rc_t enter_schema_update( KMetadata *dst_meta, const bool show_meta )
{
rc_t rc;
KMDataNode *sw_node;
if ( show_meta )
KOutMsg( "--- entering schema-update\n" );
rc = KMetadataOpenNodeUpdate ( dst_meta, &sw_node, "SOFTWARE" );
DISP_RC( rc, "enter_schema_update:KMetadataOpenNodeUpdate('SOFTWARE') failed" );
if ( rc == 0 )
{
KMDataNode *update_node;
rc = KMDataNodeOpenNodeUpdate ( sw_node, &update_node, "update" );
DISP_RC( rc, "enter_schema_update:KMDataNodeOpenNodeUpdate('update') failed" );
if ( rc == 0 )
{
rc = enter_date_name_vers( update_node );
KMDataNodeRelease ( update_node );
}
KMDataNodeRelease ( sw_node );
}
return rc;
}
/* StoreSchema
* stores schema definition in metadata
*
* <schema name="">...</schema>
*/
LIB_EXPORT rc_t VTableStoreSchema ( VTable *self )
{
/* open schema node */
KMDataNode *node;
rc_t rc = KMetadataOpenNodeUpdate ( self -> meta, & node, "schema" );
if ( rc == 0 )
{
size_t num_writ;
char expr [ 256 ];
rc = VSchemaToText ( self -> schema, expr, sizeof expr - 1, & num_writ,
"%N%V", self -> stbl -> name, self -> stbl -> version );
if ( rc != 0 )
LOGERR ( klogInt, rc, "failed to determine table schema" );
else
{
expr [ num_writ ] = 0;
/* if table has a default view declaration,
store the table information under a new attribute */
if ( self -> stbl -> dflt_view != NULL )
{
uint32_t type;
const SNameOverload *name;
const STable *view = VSchemaFind ( self -> schema, & name, & type,
self -> stbl -> dflt_view-> addr, __func__, false );
if ( view == NULL )
{
rc = RC ( rcVDB, rcTable, rcUpdating, rcSchema, rcNotFound );
PLOGERR ( klogInt, ( klogInt, rc, "failed to locate default view schema '$(expr)'",
"expr=%S", self -> stbl -> dflt_view ));
}
else
{
rc = KMDataNodeWriteAttr ( node, "table", expr );
if ( rc != 0 )
PLOGERR ( klogInt, ( klogInt, rc, "failed to write table type '$(expr)'", "expr=%s", expr ));
else
{
rc = VSchemaToText ( self -> schema, expr, sizeof expr - 1, & num_writ,
"%N%V", view -> name, view -> version );
if ( rc != 0 )
LOGERR ( klogInt, rc, "failed to determine table default view schema" );
else
expr [ num_writ ] = 0;
}
}
}
if ( rc == 0 )
{
rc = KMDataNodeWriteAttr ( node, "name", expr );
if ( rc != 0 )
PLOGERR ( klogInt, ( klogInt, rc, "failed to write table name '$(expr)'", "expr=%s", expr ));
}
if ( rc == 0 )
{
/* truncate existing schema */
rc = KMDataNodeWrite ( node, "", 0 );
if ( rc == 0 )
{
rc = VSchemaDump ( self -> schema, sdmCompact, expr,
( rc_t ( CC * ) ( void*, const void*, size_t ) ) KMDataNodeAppend, node );
}
if ( rc != 0 )
PLOGERR ( klogInt, ( klogInt, rc, "failed to write table schema '$(expr)'", "expr=%s", expr ));
}
}
KMDataNodeRelease ( node );
}
return rc;
}
/* OpenUpdate
* finish create operation
*/
static
rc_t VTableOpenUpdate ( VTable *self, const char *decl )
{
/* open metadata */
rc_t rc = KTableOpenMetadataUpdate ( self -> ktbl, & self -> meta );
if ( rc == 0 )
{
/* open "col" node */
rc = KMetadataOpenNodeUpdate ( self -> meta, & self -> col_node, "col" );
if ( rc == 0 )
{
/* fetch stored schema */
rc = VTableLoadSchema ( self );
if ( rc == 0 )
{
/* fetch requested schema */
const STable *stbl = self -> stbl;
if ( decl != NULL && decl [ 0 ] != 0 )
{
uint32_t type;
const SNameOverload *name;
if ( self -> db != NULL )
{
const STblMember *mbr = SDatabaseFind ( self -> db -> sdb,
self -> schema, & name, & type, decl, "VTableOpenUpdate" );
if ( mbr == NULL || type != eTblMember )
{
PLOGMSG ( klogWarn, ( klogWarn, "expression '$(expr)' is not a table member",
"expr=%s", decl ));
stbl = NULL;
}
else
{
stbl = mbr -> tbl;
assert ( stbl != NULL );
}
}
else
{
stbl = VSchemaFind ( self -> schema,
& name, & type, decl, "VTableOpenUpdate", true );
if ( stbl != NULL && type != eTable )
{
PLOGMSG ( klogWarn, ( klogWarn, "expression '$(expr)' is not a table",
"expr=%s", decl ));
stbl = NULL;
}
}
}
/* error if the two definitions differ */
if ( stbl != NULL && self -> stbl != NULL && stbl != self -> stbl )
rc = RC ( rcVDB, rcTable, rcOpening, rcSchema, rcIncorrect );
else if ( stbl == NULL && self -> stbl == NULL )
rc = RC ( rcVDB, rcTable, rcOpening, rcSchema, rcNotFound );
else if ( self -> stbl == NULL )
{
/* write schema to metadata */
self -> stbl = stbl;
rc = VTableStoreSchema ( self );
}
else if ( stbl != NULL )
{
/* use latest schema but don't overwrite in metadata */
self -> stbl = stbl;
}
}
}
}
DBGMSG(DBG_VDB, DBG_FLAG(DBG_VDB_VDB), ("VTableOpenUpdate = %d\n", rc));
return rc;
}
static
rc_t DB_Fini(const SParam* p, DB_Handle* h, bool drop)
{
rc_t rc = 0, rc2;
/* THIS FUNCTION MAKES NO ATTEMPT TO PRESERVE INITIAL ERROR CODES
EACH SUCCESSIVE ERROR OVERWRITES THE PREVIOUS CODE */
if( h != NULL ) {
PLOGMSG(klogInfo, (klogInfo, "Fini SEQUENCE", "severity=status"));
if( (rc2 = CGWriterSeq_Whack(h->wseq, !drop, NULL)) != 0 && !drop ) {
drop = true;
rc = rc2;
}
h->wseq = NULL;
h->reads = NULL;
PLOGMSG(klogInfo, (klogInfo, "Fini (PRI&SEC)_ALIGNMENT", "severity=status"));
if( (rc2 = CGWriterAlgn_Whack(h->walgn, !drop, NULL, NULL)) != 0 && !drop ) {
drop = true;
rc = rc2;
}
h->walgn = NULL;
h->mappings = NULL;
PLOGMSG(klogInfo, (klogInfo, "Fini EVIDENCE_INTERVAL", "severity=status"));
if( (rc2 = CGWriterEvdInt_Whack(h->wev_int, !drop, NULL)) != 0 && !drop ) {
drop = true;
rc = rc2;
}
h->wev_int = NULL;
h->ev_int = NULL;
PLOGMSG(klogInfo, (klogInfo, "Fini EVIDENCE_ALIGNMENT", "severity=status"));
if( (rc2 = CGWriterEvdDnbs_Whack(h->wev_dnb, !drop, NULL)) != 0 && !drop ) {
drop = true;
rc = rc2;
}
h->wev_dnb = NULL;
h->ev_dnb = NULL;
PLOGMSG(klogInfo, (klogInfo, "Fini calculating reference coverage", "severity=status"));
if( (rc2 = ReferenceMgr_Release(h->rmgr, !drop, NULL, drop ? false : true)) != 0 && !drop ) {
drop = true;
rc = rc2;
LOGERR(klogErr, rc, "Failed calculating reference coverage");
}
h->rmgr = NULL;
if( rc == 0 )
{
KMetadata* meta;
if( (rc = VDatabaseOpenMetadataUpdate(h->db, &meta)) == 0 ) {
KMDataNode *node;
if( (rc = KMetadataOpenNodeUpdate(meta, &node, "/")) == 0 ) {
if( (rc = KLoaderMeta_Write(node, p->argv0, __DATE__, "Complete Genomics", KAppVersion())) != 0 ) {
LOGERR(klogErr, rc, "Cannot update loader meta");
}
KMDataNodeRelease(node);
}
KMetadataRelease(meta);
}
}
PLOGMSG(klogInfo, (klogInfo, "Fini VDatabaseRelease", "severity=status"));
VDatabaseRelease(h->db);
h->db = NULL;
VSchemaRelease(h->schema);
h->schema = NULL;
if( drop || rc != 0 ) {
rc2 = VDBManagerDrop(h->mgr, kptDatabase, p->out);
if( GetRCState(rc2) == rcNotFound ) {
/* WHAT WOULD BE THE POINT OF RESETTING "rc" TO ZERO? */
rc = 0;
} else if( rc2 != 0 ) {
if ( rc == 0 )
rc = rc2;
PLOGERR(klogErr, (klogErr, rc2, "cannot drop db at '$(path)'", PLOG_S(path), p->out));
}
}
VDBManagerRelease(h->mgr);
h->mgr = NULL;
}
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;
}
static
rc_t MakeIndexes(const SRATable* stbl, KTable* ktbl, KMetadata* meta)
{
rc_t rc = 0;
int i;
char* buffer = NULL;
size_t buffer_sz = g_file_block_sz * 100;
SIndexObj idx[] = {
/* meta, file, format, index, func, file_size, buffer_sz, minSpotId, maxSpotId */
{NULL, "fastq", "fastq", "fuse-fastq", Fastq_Idx, 0, 0, 0, 0},
{NULL, "sff", "SFF", "fuse-sff", SFF_Idx, 0, 0, 0, 0},
{NULL, "fastq.gz", "fastq-gzip", "fuse-fastq-gz", FastqGzip_Idx, 0, 0, 0, 0},
{NULL, "sff.gz", "SFF-gzip", "fuse-sff-gz", SFFGzip_Idx, 0, 0, 0, 0}
};
for(i = 0; rc == 0 && i < sizeof(idx) / sizeof(idx[0]); i++) {
KMDataNode* parent = NULL;
if( (rc = KMetadataOpenNodeUpdate(meta, &parent, "/FUSE")) == 0 ) {
KMDataNodeDropChild(parent, "root"); /* drop old stuff */
if( g_ungzip || strcmp(&idx[i].file[strlen(idx[i].file) - 3], ".gz") == 0 ) {
STSMSG(0, ("Preparing index %s", idx[i].index));
MD5StateInit(&idx[i].md5);
SLListInit(&idx[i].li);
KMDataNodeDropChild(parent, "%s.tmp", idx[i].file);
if( (rc = KMDataNodeOpenNodeUpdate(parent, &idx[i].meta, "%s.tmp", idx[i].file)) == 0 ) {
if( idx[i].func != NULL ) {
if( buffer == NULL ) {
if( (buffer = malloc(buffer_sz)) == NULL ) {
rc = RC(rcExe, rcIndex, rcConstructing, rcMemory, rcExhausted);
break;
}
}
rc = idx[i].func(stbl, &idx[i], buffer, buffer_sz);
if( rc == 0 ) {
MD5StateFinish(&idx[i].md5, idx[i].md5_digest);
rc = CommitIndex(ktbl, idx[i].index, &idx[i].li);
}
}
if( rc == 0 ) {
rc = WriteFileMeta(&idx[i]);
}
KMDataNodeRelease(idx[i].meta);
}
if( GetRCState(rc) == rcUnsupported ) {
KMDataNodeDropChild(parent, "%s", idx[i].file);
PLOGERR(klogWarn, (klogWarn, rc, "Index $(i) is not supported for this table", PLOG_S(i), idx[i].index));
rc = 0;
} else if( rc == 0 ) {
char f[4096];
strcpy(f, idx[i].file);
strcat(f, ".tmp");
KMDataNodeDropChild(parent, "%s", idx[i].file);
rc = KMDataNodeRenameChild(parent, f, idx[i].file);
}
} else if( !g_ungzip ) {
KTableDropIndex(ktbl, idx[i].index);
KMDataNodeDropChild(parent, "%s", idx[i].file);
}
KMDataNodeDropChild(parent, "%s.tmp", idx[i].file);
KMDataNodeRelease(parent);
}
SLListWhack(&idx[i].li, WhackIndexData, NULL);
}
free(buffer);
return rc;
}
