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 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;
}
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
rc_t CC refseq_meta_stats( void *self, const VXformInfo *info, int64_t row_id,
VRowResult *rslt, uint32_t argc, const VRowData argv [] )
{
rc_t rc = 0;
KMDataNode* node;
refseq_meta_stats_data* data = self;
uint64_t i, seq_len = argv[0].u.data.elem_count;
const INSDC_4na_bin * seq = argv[0].u.data.base;
seq += argv[0].u.data.first_elem;
assert(data != NULL);
if( data->buf_sz < seq_len ) {
char* x = realloc(data->buf, seq_len);
if( x == NULL ) {
rc = RC(rcVDB, rcFunction, rcUpdating, rcMemory, rcExhausted);
} else {
data->buf = x;
data->buf_sz = seq_len;
}
}
for(i = 0; rc == 0 && i < seq_len; i++) {
data->buf[i] = INSDC_4na_map_CHARSET[seq[i]];
}
if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(data->stats, &node, "TOTAL_SEQ_LEN")) == 0 ) {
if( data->total_seq_len + seq_len < data->total_seq_len ) {
rc = RC(rcVDB, rcFunction, rcUpdating, rcMetadata, rcOutofrange);
} else {
data->total_seq_len += seq_len;
rc = KMDataNodeWriteB64(node, &data->total_seq_len);
}
KMDataNodeRelease(node);
}
if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(data->stats, &node, "CRC32")) == 0 ) {
data->crc32 = CRC32(data->crc32, data->buf, seq_len);
rc = KMDataNodeWriteB32(node, &data->crc32);
KMDataNodeRelease(node);
}
if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(data->stats, &node, "MD5")) == 0 ) {
uint8_t digest[16];
MD5State md5;
MD5StateAppend(&data->md5, data->buf, seq_len);
memcpy(&md5, &data->md5, sizeof(md5));
MD5StateFinish(&md5, digest);
rc = KMDataNodeWrite(node, digest, sizeof(digest));
KMDataNodeRelease(node);
}
return rc;
}
rc_t WriteFileMeta(SIndexObj* obj)
{
rc_t rc = 0;
KMDataNode* nd = NULL;
PLOGMSG(klogInfo, (klogInfo, "Meta $(f) on index $(i): file size $(s), buffer $(b)",
PLOG_4(PLOG_S(f),PLOG_S(i),PLOG_U64(s),PLOG_U32(b)), obj->file, obj->index, obj->file_size, obj->buffer_sz));
if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(obj->meta, &nd, "Format")) == 0 ) {
KMDataNode* opt = NULL;
rc = KMDataNodeWriteCString(nd, obj->format);
if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(nd, &opt, "Options")) == 0 ) {
KMDataNode* ond = NULL;
if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &ond, "accession")) == 0 ) {
rc = KMDataNodeWriteCString(ond, g_accession);
KMDataNodeRelease(ond);
}
if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &ond, "minSpotId")) == 0 ) {
rc = KMDataNodeWriteB64(ond, &obj->minSpotId);
KMDataNodeRelease(ond);
}
if( rc == 0 && (rc = KMDataNodeOpenNodeUpdate(opt, &ond, "maxSpotId")) == 0 ) {
rc = KMDataNodeWriteB64(ond, &obj->maxSpotId);
KMDataNodeRelease(ond);
}
KMDataNodeRelease(opt);
}
KMDataNodeRelease(nd);
}
if( rc == 0 && obj->file_size > 0 && (rc = KMDataNodeOpenNodeUpdate(obj->meta, &nd, "Size")) == 0 ) {
rc = KMDataNodeWriteB64(nd, &obj->file_size);
KMDataNodeRelease(nd);
}
if( rc == 0 && obj->buffer_sz > 0 && (rc = KMDataNodeOpenNodeUpdate(obj->meta, &nd, "Buffer")) == 0 ) {
rc = KMDataNodeWriteB32(nd, &obj->buffer_sz);
KMDataNodeRelease(nd);
}
if( rc == 0 && strlen(obj->index) > 0 && (rc = KMDataNodeOpenNodeUpdate(obj->meta, &nd, "Index")) == 0 ) {
rc = KMDataNodeWriteCString(nd, obj->index);
KMDataNodeRelease(nd);
}
if( rc == 0 && obj->file_size > 0 && (rc = KMDataNodeOpenNodeUpdate(obj->meta, &nd, "md5")) == 0 ) {
char x[5];
int i;
for( i = 0; rc == 0 && i < sizeof(obj->md5_digest); i++ ) {
int l = snprintf(x, 4, "%02x", obj->md5_digest[i]);
rc = KMDataNodeAppend(nd, x, l);
}
KMDataNodeRelease(nd);
}
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 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
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;
}
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
rc_t CC VPhysicalLoadSchema ( VPhysical *self,
VTypedecl *td, VSchema *schema, const KMDataNode *node )
{
rc_t rc;
KMDataNodeSchemaFillData pb;
pb . node = node;
pb . pos = 0;
pb . add_v0 = false;
/* add stored declaration to cursor schema */
rc = VSchemaParseTextCallback ( schema,
"VPhysicalLoadSchema", KMDataNodeFillSchema, & pb );
if ( rc == 0 )
{
/* retrieve fully-resolved type attribute */
rc = KMDataNodeReadAttr ( node, "type",
pb . buff, sizeof pb . buff, & pb . pos );
if ( rc == 0 )
rc = VSchemaResolveTypedecl ( schema, td, pb . buff );
if ( rc == 0 )
{
/* get encoding expression */
rc = KMDataNodeReadAttr ( node, "expr",
pb . buff, sizeof pb . buff, & pb . pos );
if ( rc == 0 )
{
VTypedecl etd;
/* create a new expression object */
rc = VSchemaImplicitPhysEncExpr ( schema, & etd,
& self -> enc, pb . buff, "VPhysicalLoadSchema" );
if ( rc != 0 )
{
PLOGERR ( klogInt, ( klogInt, rc, "failed to establish column type from '$(expr)'",
"expr=%s", pb . buff ));
}
/* match SPhysical type against stated type */
else if ( ! VTypedeclToTypedecl ( & etd, schema, td, NULL, NULL ) )
{
rc = RC ( rcVDB, rcColumn, rcLoading, rcType, rcInconsistent );
PLOGERR ( klogInt, ( klogInt, rc, "inconsistent metadata for column '$(name)'"
, "name=%.*s"
, ( int ) self -> smbr -> name -> name . size
, self -> smbr -> name -> name . addr ));
}
}
else if ( GetRCState ( rc ) == rcNotFound )
{
rc = 0;
}
}
}
KMDataNodeRelease ( node );
return rc;
}
/* 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;
}
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 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
void CC refseq_meta_stats_whack( void* self )
{
if( self != NULL ) {
refseq_meta_stats_data* data = self;
KMDataNodeRelease(data->stats);
free(data->buf);
free(data);
}
}
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 group_stats_write_node(KMDataNode *const node,
char const name[],
void const *const value)
{
KMDataNode *subnode;
rc_t rc = KMDataNodeOpenNodeUpdate(node, &subnode, "%s", name);
if (rc == 0) {
rc = KMDataNodeWriteB64(subnode, value);
KMDataNodeRelease(subnode);
}
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;
}
/* CreateTable
* create a new or open an existing table under database
*
* "tbl" [ OUT ] - return parameter for newly opened table
*
* "member" [ IN ] - name of table member template under database
* the named member is a table template rather than a named table.
*
* "cmode" [ IN ] - creation mode
*
* "cmode_mask" [ IN ] - if a bit of "cmode_mask" is set (1) then
* the corresponding bit of "cmode" is used for the table,
* otherwise (0) the corresponding bit is taken from db and "cmode"'s
* bit is ignored
* the mask for setting mode (kcmOpen, kcmInit, kcmCreate) is at least
* one bit set in the mask kcmValueMask.
*
* "name" [ IN ] - NUL terminated string in
* db-native character set giving actual table name
*/
LIB_EXPORT rc_t CC VDatabaseVCreateTableByMask ( VDatabase *self, VTable **tblp,
const char *member, KCreateMode cmode, KCreateMode cmode_mask, const char *name, va_list args )
{
rc_t rc;
if ( tblp == NULL )
rc = RC ( rcVDB, rcDatabase, rcCreating, rcParam, rcNull );
else
{
if ( self == NULL )
rc = RC ( rcVDB, rcDatabase, rcCreating, rcSelf, rcNull );
else if ( member == NULL )
rc = RC ( rcVDB, rcMgr, rcOpening, rcName, rcNull );
else if ( member [ 0 ] == 0 )
rc = RC ( rcVDB, rcMgr, rcOpening, rcName, rcEmpty );
else if ( self -> read_only )
rc = RC ( rcVDB, rcDatabase, rcCreating, rcDatabase, rcReadonly );
else
{
rc = VTableMake ( tblp, self -> mgr, self, self -> schema );
if ( rc == 0 )
{
VTable *tbl = * tblp;
rc = KDatabaseVCreateTableByMask ( self -> kdb, & tbl -> ktbl, cmode, cmode_mask, name, args );
if ( rc == 0 )
{
rc = VTableOpenUpdate ( tbl, member );
if ( rc == 0 )
{
tbl -> pgsize = self -> pgsize;
tbl -> cmode = KDatabaseGetCmode ( self->kdb ); /* TODO: do we really want to inherit open mode from db? */
tbl -> checksum = KDatabaseGetChecksum ( self->kdb );
#if LAZY_OPEN_COL_NODE
KMDataNodeRelease ( tbl -> col_node );
tbl -> col_node = NULL;
#endif
return 0;
}
rc = ResetRCContext ( rc, rcVDB, rcDatabase, rcCreating );
}
VTableWhack ( tbl );
}
}
* tblp = NULL;
}
return rc;
}
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 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;
}
/* CreateTable
* create a new or open an existing table using manager
*
* "tbl" [ OUT ] - return parameter for newly opened table
*
* "schema" [ IN ] - schema object containg table
* declaration to be used in creating tbl.
*
* "typespec" [ IN ] - type and optionally version of table schema,
* e.g. 'MY_NAMESPACE:MyTable' or 'MY_NAMESPACE:MyTable#1.1'
*
* "cmode" [ IN ] - creation mode
*
* "path" [ IN ] - NUL terminated string in
* wd-native character set giving path to table
*/
LIB_EXPORT rc_t CC VDBManagerVCreateTable ( VDBManager *self, VTable **tblp,
const VSchema *schema, const char *typespec,
KCreateMode cmode, const char *path, va_list args )
{
rc_t rc;
if ( tblp == NULL )
rc = RC ( rcVDB, rcMgr, rcCreating, rcParam, rcNull );
else
{
if ( self == NULL )
rc = RC ( rcVDB, rcMgr, rcCreating, rcSelf, rcNull );
else if ( schema == NULL )
rc = RC ( rcVDB, rcMgr, rcOpening, rcSchema, rcNull );
else if ( typespec == NULL )
rc = RC ( rcVDB, rcMgr, rcOpening, rcName, rcNull );
else if ( typespec [ 0 ] == 0 )
rc = RC ( rcVDB, rcMgr, rcOpening, rcName, rcEmpty );
else
{
/* create object with new schema */
rc = VTableMake ( tblp, self, NULL, schema );
if ( rc == 0 )
{
VTable *tbl = * tblp;
/* create physical object */
rc = KDBManagerVCreateTable ( self -> kmgr, & tbl -> ktbl, cmode, path, args );
if ( rc == 0 )
{
rc = VTableOpenUpdate ( tbl, typespec );
if ( rc == 0 )
{
#if LAZY_OPEN_COL_NODE
KMDataNodeRelease ( tbl -> col_node );
tbl -> col_node = NULL;
#endif
return 0;
}
rc = ResetRCContext ( rc, rcVDB, rcMgr, rcCreating );
}
VTableWhack ( tbl );
}
}
* tblp = NULL;
}
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;
}
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;
}
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;
}
/* OpenTableRead
* VOpenTableRead
* open a table for read
*
* "tbl" [ OUT ] - return parameter for newly opened table
*
* "path" [ IN ] - NUL terminated string in
* wd-native character set giving path to table
*/
LIB_EXPORT rc_t CC VDBManagerVOpenTableRead ( const VDBManager *self,
const VTable **tblp, const VSchema *schema,
const char *path, va_list args )
{
rc_t rc;
if ( tblp == NULL )
rc = RC ( rcVDB, rcMgr, rcOpening, rcParam, rcNull );
else
{
if ( self == NULL )
rc = RC ( rcVDB, rcMgr, rcOpening, rcSelf, rcNull );
else
{
VTable *tbl;
/* if no schema is given, always pass intrinsic */
if ( schema == NULL )
schema = self -> schema;
rc = VTableMake ( & tbl, self, NULL, schema );
if ( rc == 0 )
{
tbl -> read_only = true;
rc = KDBManagerVOpenTableRead ( self -> kmgr, & tbl -> ktbl, path, args );
if ( rc == 0 )
{
rc = VTableOpenRead ( tbl );
if ( rc == 0 )
{
#if LAZY_OPEN_COL_NODE
KMDataNodeRelease ( tbl -> col_node );
tbl -> col_node = NULL;
#endif
* tblp = tbl;
return 0;
}
}
VTableWhack ( tbl );
}
}
* tblp = NULL;
}
return rc;
}
/* Whack
*/
rc_t VTableWhack ( VTable *self )
{
KRefcountWhack ( & self -> refcount, "VTable" );
BSTreeWhack ( & self -> read_col_cache, VColumnRefWhack, NULL );
BSTreeWhack ( & self -> write_col_cache, VColumnRefWhack, NULL );
KMDataNodeRelease ( self -> col_node );
KMetadataRelease ( self -> meta );
KTableRelease ( self -> ktbl );
VSchemaRelease ( self -> schema );
VLinkerRelease ( self -> linker );
VDatabaseSever ( self -> db );
VDBManagerSever ( self -> mgr );
free ( self );
return 0;
}
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;
}
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;
}
