FIXTURE_TEST_CASE(TestManyNoDep, EmptyFixture) {
rc_t rc = 0;
const char SRR543323[] = "SRR543323";
VPath* acc = NULL;
REQUIRE_RC(VFSManagerMakePath(vmgr, &acc, SRR543323));
const VPath *local = NULL;
REQUIRE_RC_FAIL(VResolverLocal(resolver, acc, &local));
RELEASE(VPath, acc);
struct VSchema *schema;
REQUIRE_RC(VDBManagerMakeSRASchema(mgr, &schema));
const VDatabase *db = NULL;
REQUIRE_RC(VDBManagerOpenDBRead(mgr, &db, schema, SRR543323));
REQUIRE_RC(VSchemaRelease(schema));
const VDBDependencies *dep = NULL;
// missing
REQUIRE_RC(VDatabaseListDependencies(db, &dep, true));
uint32_t count = 1;
REQUIRE_RC(VDBDependenciesCount(dep, &count));
CHECK_EQUAL(count, (uint32_t)21);
RELEASE(VDBDependencies, dep);
REQUIRE_RC(VDatabaseListDependencies(db, &dep, false));
REQUIRE_RC(VDBDependenciesCount(dep, &count));
CHECK_EQUAL(count, (uint32_t)21);
RELEASE(VDBDependencies, dep);
RELEASE(VDatabase, db);
RELEASE(VPath, local);
}
/* init_schema
*/
static
rc_t init_schema ( const vtblcp_parms *pb,
const VDBManager *mgr, VSchema **schemap )
{
VSchema *schema;
rc_t rc = VDBManagerMakeSchema ( mgr, & schema );
if ( rc != 0 )
LOGERR ( klogInt, rc, "failed to create empty schema" );
else
{
/* parse schema file */
rc = VSchemaParseFile ( schema, pb -> schema_src );
if ( rc != 0 )
PLOGERR ( klogErr, (klogErr, rc, "failed to parse schema file '$(file)'", "file=%s", pb -> schema_src ));
else
{
* schemap = schema;
return 0;
}
VSchemaRelease ( schema );
}
return rc;
}
rc_t write_statistic_into_tab( KDirectory *dir, statistic * data,
const KNamelist *schema_list, const char *output_file_path,
uint64_t * written, bool show_progress )
{
VDBManager *my_manager;
rc_t rc;
if ( written != NULL ) *written = 0;
rc = VDBManagerMakeUpdate ( &my_manager, dir );
if ( rc != 0 )
LogErr( klogInt, rc, "VDBManagerMakeUpdate() failed\n" );
else
{
VSchema * my_schema;
rc = make_schema( schema_list, my_manager, &my_schema );
if ( rc == 0 )
{
VTable * my_table;
rc = VDBManagerCreateTable( my_manager, &my_table, my_schema,
"NCBI:align:tbl:qstat",
kcmInit | kcmParents,
output_file_path );
if ( rc != 0 )
LogErr( klogInt, rc, "VDBManagerCreateTable() failed\n" );
else
{
rc = write_statistic_cmn( my_table, data, written, show_progress );
VTableRelease( my_table );
}
VSchemaRelease( my_schema );
}
VDBManagerRelease( my_manager );
}
return rc;
}
rc_t vdb_info( Vector * schema_list, dump_format_t format, const VDBManager *mgr,
const char * acc_or_path, struct num_gen * rows )
{
rc_t rc = 0;
VSchema * schema = NULL;
vdh_parse_schema( mgr, &schema, schema_list );
if ( format == df_sql )
rc = vdb_info_print_sql_header( acc_or_path );
if ( rows != NULL && !num_gen_empty( rows ) )
{
const struct num_gen_iter * iter;
rc = num_gen_iterator_make( rows, &iter );
if ( rc == 0 )
{
int64_t max_row;
rc = num_gen_iterator_max( iter, &max_row );
if ( rc == 0 )
{
int64_t id;
uint8_t digits = digits_of( max_row );
while ( rc == 0 && num_gen_iterator_next( iter, &id, &rc ) )
{
char acc[ 64 ];
size_t num_writ;
rc_t rc1 = -1;
switch ( digits )
{
case 1 : rc1 = string_printf ( acc, sizeof acc, &num_writ, "%s%ld", acc_or_path, id ); break;
case 2 : rc1 = string_printf ( acc, sizeof acc, &num_writ, "%s%.02ld", acc_or_path, id ); break;
case 3 : rc1 = string_printf ( acc, sizeof acc, &num_writ, "%s%.03ld", acc_or_path, id ); break;
case 4 : rc1 = string_printf ( acc, sizeof acc, &num_writ, "%s%.04ld", acc_or_path, id ); break;
case 5 : rc1 = string_printf ( acc, sizeof acc, &num_writ, "%s%.05ld", acc_or_path, id ); break;
case 6 : rc1 = string_printf ( acc, sizeof acc, &num_writ, "%s%.06ld", acc_or_path, id ); break;
case 7 : rc1 = string_printf ( acc, sizeof acc, &num_writ, "%s%.07ld", acc_or_path, id ); break;
case 8 : rc1 = string_printf ( acc, sizeof acc, &num_writ, "%s%.08ld", acc_or_path, id ); break;
case 9 : rc1 = string_printf ( acc, sizeof acc, &num_writ, "%s%.09ld", acc_or_path, id ); break;
}
if ( rc1 == 0 )
rc = vdb_info_1( schema, format, mgr, acc, acc_or_path );
}
}
num_gen_iterator_destroy( iter );
}
}
else
rc = vdb_info_1( schema, format, mgr, acc_or_path, acc_or_path );
if ( schema != NULL )
VSchemaRelease( schema );
return rc;
}
static void ref_walker_release( struct ref_walker * self )
{
KDirectoryRelease( self->dir );
VDBManagerRelease( self->vmgr );
VSchemaRelease( self->vschema );
AlignMgrRelease ( self->amgr );
VFSManagerRelease ( self->vfs_mgr );
VNamelistRelease ( self->sources );
free_ref_regions( &self->regions );
free( ( void * )self->spot_group );
}
CVDBTable::CVDBTable(const CVDBMgr& mgr,
const string& acc_or_path,
EMissing missing)
: m_Name(acc_or_path)
{
*x_InitPtr() = 0;
VSchema *schema;
DECLARE_SDK_GUARD();
if ( rc_t rc = SRASchemaMake(&schema, mgr) ) {
NCBI_THROW2(CSraException, eInitFailed,
"Cannot make default SRA schema", rc);
}
string path = CVPath::ConvertAccOrSysPathToPOSIX(acc_or_path);
if ( rc_t rc = VDBManagerOpenTableRead(mgr, x_InitPtr(), schema, "%.*s",
int(path.size()), path.data()) ) {
*x_InitPtr() = 0;
VSchemaRelease(schema);
if ( (GetRCObject(rc) == RCObject(rcDirectory) ||
GetRCObject(rc) == RCObject(rcPath)) &&
GetRCState(rc) == rcNotFound ) {
// no SRA accession
if ( missing != eMissing_Throw ) {
return;
}
NCBI_THROW2_FMT(CSraException, eNotFoundTable,
"Cannot open SRA table: "<<acc_or_path, rc);
}
else if ( GetRCObject(rc) == RCObject(rcDatabase) &&
GetRCState(rc) == rcIncorrect ) {
// invalid SRA database
NCBI_THROW2_FMT(CSraException, eDataError,
"Cannot open SRA table: "<<acc_or_path, rc);
}
else {
// other errors
NCBI_THROW2_FMT(CSraException, eOtherError,
"Cannot open SRA table: "<<acc_or_path, rc);
}
}
VSchemaRelease(schema);
}
static
VSchema *map_schema_types ( TypeParams *type, const ctx_t *ctx, const VSchema *src_schema )
{
FUNC_ENTRY ( ctx );
bool mapped;
char schema_src [ 256 ];
assert ( sizeof schema_src == sizeof type -> dst_type );
TRY ( mapped = map_typename ( ctx, "out-map", type -> src_type, type -> dst_type, schema_src, sizeof schema_src ) )
{
rc_t rc;
VSchema *dst_schema;
if ( ! mapped )
{
type -> view_type [ 0 ] = 0;
rc = VSchemaAddRef ( src_schema );
if ( rc != 0 )
ERROR ( rc, "VSchemaAddRef failed" );
return ( VSchema* ) src_schema;
}
rc = VDBManagerMakeSchema ( ctx -> caps -> vdb, & dst_schema );
if ( rc != 0 )
ERROR ( rc, "VDBManagerMakeSchema failed" );
else
{
rc = VSchemaParseFile ( dst_schema, "%s", schema_src );
if ( rc != 0 )
ERROR ( rc, "VSchemaParseFile failed adding file '%s' for destination", src_schema );
else
{
TRY ( mapped = map_typename ( ctx, "view-map", type -> src_type, type -> view_type, schema_src, sizeof schema_src ) )
{
if ( ! mapped )
{
type -> view_type [ 0 ] = 0;
return dst_schema;
}
rc = VSchemaParseFile ( dst_schema, "%s", schema_src );
if ( rc == 0 )
return dst_schema;
ERROR ( rc, "VSchemaParseFile failed adding file '%s' for view", src_schema );
}
}
VSchemaRelease ( dst_schema );
}
}
/* run
*/
static
rc_t run ( const vtblcp_parms *pb )
{
VDBManager *mgr;
rc_t rc = init_mgr ( pb, & mgr );
if ( rc == 0 )
{
VSchema *schema;
rc = init_schema ( pb, mgr, & schema );
if ( rc == 0 )
{
const VTable *stbl;
rc = open_src_table ( pb, mgr, schema, & stbl );
if ( rc == 0 )
{
VTable *dtbl;
rc = open_dst_table ( pb, mgr, schema, & dtbl );
if ( rc == 0 )
{
/* determine columns */
Vector v;
rc = get_column_specs ( pb, & v, stbl, dtbl );
/* perform the copy */
if ( rc == 0 )
{
rc = vtblcp ( pb, stbl, dtbl, & v );
VectorWhack ( & v, free_column_spec, NULL );
}
/* cleanup */
rc = close_dst_table ( pb, dtbl, rc );
}
VTableRelease ( stbl );
}
VSchemaRelease ( schema );
}
VDBManagerRelease ( mgr );
}
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;
}
rc_t write_statistic_into_db( KDirectory *dir, statistic * data,
const KNamelist *schema_list, const char *src_path,
uint64_t * written, bool show_progress )
{
VDBManager *my_manager;
rc_t rc;
if ( written != NULL ) *written = 0;
rc = VDBManagerMakeUpdate ( &my_manager, dir );
if ( rc != 0 )
LogErr( klogInt, rc, "VDBManagerMakeUpdate() failed\n" );
else
{
VSchema * my_schema;
rc = make_schema( schema_list, my_manager, &my_schema );
if ( rc == 0 )
{
VDatabase *my_database;
rc = VDBManagerOpenDBUpdate( my_manager, &my_database,
my_schema, src_path );
if ( rc != 0 )
LogErr( klogInt, rc, "VDBManagerOpenDBUpdate() failed\n" );
else
{
VTable * my_table;
rc = VDatabaseCreateTable( my_database, &my_table,
"QUAL_STAT",
kcmOpen | kcmParents,
"QUAL_STAT" );
if ( rc !=0 )
LogErr( klogInt, rc, "VDatabaseCreateTable() failed\n" );
else
{
rc = write_statistic_cmn( my_table, data, written, show_progress );
VTableRelease( my_table );
}
VDatabaseRelease( my_database );
}
VSchemaRelease( my_schema );
}
VDBManagerRelease( my_manager );
}
return rc;
}
static rc_t vdb_fastq_database( const p_dump_context ctx,
const VDBManager *mgr,
fastq_ctx * fctx )
{
const VDatabase * db;
VSchema *schema = NULL;
rc_t rc;
vdh_parse_schema( mgr, &schema, &(ctx->schema_list) );
rc = VDBManagerOpenDBRead( mgr, &db, schema, ctx->path );
DISP_RC( rc, "VDBManagerOpenDBRead() failed" );
if ( rc == 0 )
{
bool table_defined = ( ctx->table != NULL );
if ( !table_defined )
table_defined = vdh_take_this_table_from_db( ctx, db, "SEQUENCE" );
if ( table_defined )
{
const VTable * tbl;
rc = VDatabaseOpenTableRead( db, &tbl, ctx->table );
DISP_RC( rc, "VDatabaseOpenTableRead() failed" );
if ( rc == 0 )
{
rc = vdb_fastq_tbl( ctx, tbl, fctx );
VTableRelease( tbl );
}
}
else
{
LOGMSG( klogInfo, "opened as vdb-database, but no table found/defined" );
ctx->usage_requested = true;
}
VDatabaseRelease( db );
}
VSchemaRelease( schema );
return rc;
}
static rc_t vdb_fastq_table( const p_dump_context ctx,
const VDBManager *mgr,
fastq_ctx * fctx )
{
const VTable * tbl;
VSchema * schema = NULL;
rc_t rc;
vdh_parse_schema( mgr, &schema, &(ctx->schema_list) );
rc = VDBManagerOpenTableRead( mgr, &tbl, schema, ctx->path );
DISP_RC( rc, "VDBManagerOpenTableRead() failed" );
if ( rc == 0 )
{
rc = vdb_fastq_tbl( ctx, tbl, fctx );
VTableRelease( tbl );
}
VSchemaRelease( schema );
return rc;
}
/* Whack
* will not refuse request, and ignores errors
*/
static
rc_t SRAMgrWhack ( const SRAMgr *that )
{
SRAMgr *self = ( SRAMgr* ) that;
VSchemaRelease ( self -> schema );
VDBManagerRelease ( self -> vmgr );
/* must check here for NULL because
SRAPathRelease is weak-linked */
if ( self -> _pmgr != NULL )
{
#if OLD_SRAPATH_MGR
SRAPathRelease ( self -> _pmgr );
#else
VResolverRelease ( ( const VResolver* ) self -> _pmgr );
#endif
}
free ( self );
return 0;
}
/* UseSchema
* allows SRA schema to be entirely replaced
* affects creation/update of all subsequent tables
*
* "schema" [ IN ] - new schema to be applied
*
* NB - manager will attach a new reference to schema object,
* you are still responsible for releasing it via VSchemaRelease
*/
LIB_EXPORT rc_t CC SRAMgrUseSchemaRead ( const SRAMgr *self,
const VSchema *schema )
{
rc_t rc;
if ( self == NULL )
rc = RC ( rcSRA, rcMgr, rcUpdating, rcSelf, rcNull );
else if ( schema == NULL )
rc = RC ( rcSRA, rcMgr, rcUpdating, rcSchema, rcNull );
else if ( schema == self -> schema )
rc = 0;
else
{
rc = VSchemaAddRef ( schema );
if ( rc == 0 )
{
VSchemaRelease ( self -> schema );
( ( SRAMgr* ) self ) -> schema = schema;
}
}
return rc;
}
static rc_t DumpSchema( const context *ctx )
{
KDirectory *my_dir;
rc_t rc = KDirectoryNativeDir ( &my_dir );
display_rescode( rc, "failed to open native dir", NULL );
if ( rc == 0 )
{
const VDBManager *my_manager;
rc = VDBManagerMakeRead ( &my_manager, my_dir );
display_rescode( rc, "failed to make manager", NULL );
if ( rc == 0 )
{
VSchema *my_schema;
rc = VDBManagerMakeSchema( my_manager, &my_schema );
display_rescode( rc, "failed to make schema", NULL );
if ( rc == 0 )
{
rc = for_each_v_name( ctx->include_files, my_schema, add_include );
if ( rc == 0 )
{
rc = for_each_v_name( ctx->src_files, my_schema, add_source );
if ( rc == 0 )
{
rc = DumpSchema_to( my_schema, ctx );
if ( rc == 0 )
rc = WriteDependency( my_schema, ctx );
}
}
VSchemaRelease( my_schema );
}
VDBManagerRelease( my_manager );
}
KDirectoryRelease( my_dir );
}
return rc;
}
rc_t KeyRingDatabaseSave ( struct KeyRingData* self, struct KDirectory* wd, const char* path )
{
rc_t rc;
VDBManager* vdbMgr;
rc = VDBManagerMakeUpdate( &vdbMgr, wd );
if (rc == 0)
{
VSchema* schema;
rc = VDBManagerMakeSchema(vdbMgr, &schema);
if (rc == 0)
{
rc = VSchemaParseText ( schema, "keyring_schema", schema_text, string_measure(schema_text, NULL) );
if (rc == 0)
{ /* create a database */
VDatabase* db;
rc = VDBManagerCreateDB(vdbMgr, & db, schema, "keyring:KEYRING", kcmCreate | kcmMD5, path);
if (rc == 0)
{
rc_t rc2;
rc = SaveProjects(&self->projects, db);
if (rc == 0)
rc = SaveObjects(&self->objects, db);
/*TODO: SaveKeys */
rc2 = VDatabaseRelease(db);
if (rc == 0)
rc = rc2;
}
}
VSchemaRelease(schema);
}
VDBManagerRelease(vdbMgr);
}
return rc;
}
rc_t SRAMgrMake ( SRAMgr **mgrp,
const VDBManager *vmgr, const KDirectory *wd )
{
rc_t rc;
/* require sraschema object */
SRAMgr *mgr = malloc ( sizeof * mgr );
if ( mgr == NULL )
rc = RC ( rcSRA, rcMgr, rcConstructing, rcMemory, rcExhausted );
else
{
VSchema *schema;
rc = VDBManagerMakeSRASchema ( vmgr, & schema );
if ( rc == 0 )
{
rc = SRAMgrInitPath ( mgr, wd );
if ( rc == 0 )
{
KRefcountInit ( & mgr -> refcount, 1, "SRAMgr", "SRAMgrMake", "sramgr" );
mgr -> vmgr = vmgr;
mgr -> schema = schema;
mgr -> mode = kcmCreate; /* TBD - should this include parents? */
mgr -> read_only = true;
* mgrp = mgr;
return 0;
}
VSchemaRelease ( schema );
}
free ( mgr );
}
* mgrp = NULL;
return rc;
}
rc_t run_tests (void)
{
VDBManager * mgr;
rc_t rc;
if (verbose)
printf("%s call VDBManagerMakeUpdate\n", __func__);
rc = VDBManagerMakeUpdate (&mgr, NULL);
if (rc)
{
LOGERR (klogInt, rc, "Failed to open VDBManager");
return rc;
}
else
{
VSchema * schema;
if (verbose)
printf("%s call VDBManagerMakeSchema\n", __func__);
rc = VDBManagerMakeSchema (mgr, &schema);
printf("%s schema == %p\n", __func__, (void*)schema);
if (rc)
LOGERR (klogInt, rc, "Failed to make empty schema");
else
{
if(verbose)
printf("%s call VSchemaParseText\n", __func__);
rc = VSchemaParseText (schema, "rowlen_schema", schema_text, string_size (schema_text));
if (rc)
LOGERR (klogInt, rc, "Failed to parse internal schema");
else
{
int ix;
for ( ix = 0; ix < 6; ++ix)
{
VTable * table;
rc_t orc;
if (verbose)
printf("%s call open_table\n", __func__);
rc = open_table (mgr, schema, &table);
if (rc)
{
LOGERR (klogErr, rc, "Failed to open table");
break;
}
if (verbose)
printf("%s call run_test\n", __func__);
rc = run_test (table, &tests[ix]);
if (rc)
{
pLOGERR (klogErr, rc, "Failed $(D)", PLOG_S(D), tests[ix].test_name);
}
if (verbose)
printf("%s call VTableRelease\n", __func__);
orc = VTableRelease (table);
if (orc)
{
LOGERR (klogErr, rc, "failed to close table");
}
if (orc && (rc == 0))
rc = orc;
if (rc)
break;
}
}
if (verbose)
printf("%s call VSchemaRelease\n", __func__);
VSchemaRelease (schema);
}
if (verbose)
printf("%s call VDBManagerRelease\n", __func__);
VDBManagerRelease (mgr);
}
return rc;
}
static
rc_t open_and_run (Context * context)
{
KDirectory * pwd;
rc_t rc;
rc = KDirectoryNativeDir (&pwd);
if (rc)
LOGERR (klogFatal, rc, "Unable to open file system");
else
{
if (PathExists (pwd, kptDile, context->file_path))
{
if (PathExists (pwd, kptDile, context->file_path))
{
VDBManager * vmgr;
rc = VDBManagerMakeUpdate (&vmgr, pwd);
if (rc)
LOGERR (kptInt, "Failed to create a database manager");
else
{
VSchema * vschema;
rc = VDBManagerMakeSchema (vmgr, &vschema);
if (rc)
LOGERR (kptInt, "Failed to create schema");
else
{
rc = VSchemaParseFile (vschema, args->schema);
if (rc)
PLOGERR (klogFatal, (klogFatal,
"Unable to parse schema file ($S)",
"S=%s", args->schema));
else
{
VTable * vtable;
rc = VDBManagerOpenTableUpdate (vmgr, &vtable, SCHEMA, args->table);
if (rc)
PLOGERR (klogFatal, (klogFatal, "Unable to open table ($T)",
"T=%s", args->table));
else
{
VTableRelease (vtable);
}
}
VSchemaRelease (vschema);
}
VDBManagerRelease (vmgr);
}
}
else
PLOGERR (kptFatal, (kptFatal, "table paramaeter is not a table directory ($F)",
"F=%s", args->table));
}
else
PLOGERR (kptFatal, (kptFatal, "file paramaeter is not a file ($F)",
"F=%s", context->file_path));
KPathType pt;
pt = KDirectoryPathType (arg->file);
if ((pt & ~kptAlias) != kptFile)
else
{
}
KDirectoryRelease (pwd);
}
return rc;
}
static
rc_t populate_cursors ( VTable *dtbl, VCursor *dcurs, const VCursor *scurs,
vtblcp_column_map *cm, const Vector *v, uint32_t *rd_filt )
{
uint32_t end = VectorLength ( v );
uint32_t i = VectorStart ( v );
BSTree stype_tbl, rftype_tbl;
const VSchema *schema;
rc_t rc = VTableOpenSchema ( dtbl, & schema );
if ( rc != 0 )
{
LOGERR ( klogInt, rc, "failed to open destination table schema" );
return rc;
}
/* populate sensitive type table */
rc = populate_stype_tbl ( & stype_tbl, schema );
if ( rc != 0 )
{
VSchemaRelease ( schema );
return rc;
}
/* populate read filter type table */
rc = populate_rdfilt_tbl ( & rftype_tbl, schema );
if ( rc != 0 )
{
BSTreeWhack ( & stype_tbl, stype_id_whack, NULL );
VSchemaRelease ( schema );
return rc;
}
for ( end += i, rc = 0, * rd_filt = 0; i < end; ++ i )
{
VTypedecl td;
char typedecl [ 128 ];
const char *spec = ( const void* ) VectorGet ( v, i );
/* request column in destination */
rc = VCursorAddColumn ( dcurs, & cm [ i ] . wr, spec );
if ( rc != 0 )
{
PLOGERR ( klogErr, (klogErr, rc, "failed to add '$(spec)' to destination cursor", "spec=%s", spec ));
break;
}
/* always retrieve data type */
rc = VCursorDatatype ( dcurs, cm [ i ] . wr, & td, NULL );
if ( rc != 0 )
{
PLOGERR ( klogInt, (klogInt, rc, "failed to determine datatype of destination column '$(name)'", "name=%s", spec ));
break;
}
/* mark column as sensitive or not */
rc = mark_type_sensitivity ( & stype_tbl, schema, & td, & cm [ i ] );
if ( rc != 0 )
break;
/* if spec is already typed, request it in source */
if ( spec [ 0 ] == '(' )
{
rc = VCursorAddColumn ( scurs, & cm [ i ] . rd, spec );
if ( rc != 0 )
{
PLOGERR ( klogErr, (klogErr, rc, "failed to add '$(spec)' to source cursor", "spec=%s", spec ));
break;
}
}
else
{
rc = VTypedeclToText ( & td, schema, typedecl, sizeof typedecl );
if ( rc != 0 )
{
PLOGERR ( klogInt, (klogInt, rc, "failed to print datatype of destination column '$(name)'", "name=%s", spec ));
break;
}
rc = VCursorAddColumn ( scurs, & cm [ i ] . rd, "(%s)%s", typedecl, spec );
if ( rc != 0 )
{
PLOGERR ( klogErr, (klogErr, rc, "failed to add '$(spec)' to source cursor", "spec=(%s)%s", typedecl, spec ));
break;
}
}
/* check if column is a read filter */
cm [ i ] . rd_filter = false;
if ( ! cm [ i ] . sensitive )
{
if ( BSTreeFind ( & rftype_tbl, & td, stype_id_cmp ) != NULL )
{
if ( * rd_filt != 0 )
{
rc = RC ( rcExe, rcColumn, rcOpening, rcColumn, rcExists );
PLOGERR ( klogInt, (klogInt, rc, "can't use column '$(name)' as read filter", "name=%s", spec ));
break;
}
* rd_filt = cm [ i ] . rd;
cm [ i ] . rd_filter = true;
}
}
}
BSTreeWhack ( & rftype_tbl, stype_id_whack, NULL );
BSTreeWhack ( & stype_tbl, stype_id_whack, NULL );
VSchemaRelease ( schema );
/* add read filter to input if not already there in some way */
if ( * rd_filt == 0 )
{
rc = VCursorAddColumn ( scurs, rd_filt, "RD_FILTER" );
if ( rc != 0 && GetRCState ( rc ) == rcNotFound )
rc = 0;
}
return rc;
}
rc_t matcher_execute( matcher* self, const p_matcher_input in )
{
VSchema * dflt_schema;
const VTable * src_table;
rc_t rc;
if ( self == NULL )
return RC( rcExe, rcNoTarg, rcResolving, rcSelf, rcNull );
if ( in->manager == NULL || in->add_schemas == NULL ||
in->cfg == NULL || in->columns == NULL ||
in->src_path == NULL || in->dst_path == NULL ||
in->dst_tabname == NULL )
return RC( rcExe, rcNoTarg, rcResolving, rcParam, rcNull );
rc = matcher_build_column_vector( self, in->columns );
if ( rc != 0 ) return rc;
rc = matcher_exclude_columns( self, in->excluded_columns );
if ( rc != 0 ) return rc;
rc = helper_parse_schema( in->manager, &dflt_schema, in->add_schemas );
if ( rc != 0 ) return rc;
rc = VDBManagerOpenTableRead( in->manager, &src_table, dflt_schema, "%s", in->src_path );
if ( rc == 0 )
{
const VSchema * src_schema;
rc = VTableOpenSchema ( src_table, &src_schema );
if ( rc == 0 )
{
rc = matcher_read_src_types( self, src_table, src_schema );
if ( rc == 0 )
{
if ( in->legacy_schema != NULL )
rc = VSchemaParseFile ( dflt_schema, "%s", in->legacy_schema );
if ( rc == 0 )
{
VTable * dst_table;
KCreateMode cmode = kcmParents;
const VSchema * dst_schema = src_schema;
if ( in->legacy_schema != NULL )
dst_schema = dflt_schema;
if ( in->force_unlock )
VDBManagerUnlock ( in->manager, "%s", in->dst_path );
if ( in->force_kcmInit )
cmode |= kcmInit;
else
cmode |= kcmCreate;
rc = VDBManagerCreateTable( in->manager, &dst_table,
dst_schema, in->dst_tabname, cmode, "%s", in->dst_path );
if ( rc == 0 )
{
rc = matcher_read_dst_types( self, dst_table, dst_schema );
if ( rc == 0 )
{
rc = matcher_make_type_matrix( self );
if ( rc == 0 )
rc = matcher_match_matrix( self, src_schema, in->cfg );
}
VTableRelease( dst_table );
if ( !(in->force_kcmInit) )
KDirectoryRemove ( in->dir, true, "%s", in->dst_path );
}
}
}
VSchemaRelease( src_schema );
}
VTableRelease( src_table );
}
VSchemaRelease( dflt_schema );
return rc;
}
static rc_t static_write(void)
{
const char *schema_text = "version 1; include 'vdb/vdb.vschema'; table foo #1 { column ascii bar { read = .bar; } physical ascii .bar = bar; }";
bool force = 1;
rc_t rc;
VDBManager *vmgr;
rc = VDBManagerMakeUpdate ( & vmgr, NULL );
if ( rc != 0 )
LOGERR ( klogInt, rc, "failed to make VDB manager" );
else
{
VSchema *schema;
rc = VDBManagerMakeSchema ( vmgr, & schema );
if ( rc != 0 )
LOGERR ( klogInt, rc, "failed to make empty schema" );
else
{
rc = VSchemaParseText( schema, "static_schema", schema_text, strlen(schema_text) );
if ( rc != 0 )
PLOGERR ( klogErr, (klogErr, rc, "failed to parse schema '$(text)'", "test=%s", schema_text ));
else
{
VTable *vtbl;
rc = VDBManagerCreateTable ( vmgr, & vtbl, schema, "foo", force ? kcmInit : kcmCreate, table_path );
if ( rc != 0 )
{
PLOGERR ( klogErr, (klogErr, rc, "failed to $(cmode) table '$(path)'"
, "cmode=%s,path=%s"
, force ? "create or replace" : "create"
, table_path
));
}
else
{
VCursor *curs;
rc = VTableCreateCursorWrite ( vtbl, & curs, kcmInsert );
if ( rc != 0 )
LOGERR ( klogInt, rc, "failed to create cursor" );
else
{
uint32_t idx;
rc = VCursorAddColumn ( curs, &idx, "bar" );
if ( rc != 0 )
{
PLOGERR ( klogErr, (klogErr, rc, "failed to add column '$(col)' to cursor"
, "col=bar"
));
}
else {
rc = VCursorOpen ( curs );
if ( rc != 0 )
LOGERR ( klogErr, rc, "failed to open cursor" );
else
{
int i;
for ( i = 0; i != 10 && rc == 0; ++i )
{
rc = VCursorOpenRow ( curs );
if ( rc != 0 )
LOGERR ( klogErr, rc, "failed to open cursor row" );
else
{
rc_t rc2;
uint32_t count = sizeof(buff) - 1;
rc = VCursorWrite ( curs, idx, 8, buff, 0, count );
if ( rc != 0 )
{
int64_t rid = 0;
VCursorRowId ( curs, & rid );
PLOGERR ( klogInt, (klogInt, rc, "failed to write data to row $(row_id)'"
, "row_id=%ld"
, rid
));
break;
}
if ( rc == 0 )
{
rc = VCursorCommitRow ( curs );
if ( rc != 0 )
LOGERR ( klogErr, rc, "failed to commit row" );
}
rc2 = VCursorCloseRow ( curs );
if ( rc2 != 0 )
{
LOGERR ( klogErr, rc2, "failed to close cursor row" );
if ( rc == 0 )
rc = rc2;
}
}
}
if ( GetRCState ( rc ) == rcDone )
rc = 0;
if ( rc == 0 )
rc = VCursorCommit ( curs );
}
}
VCursorRelease ( curs );
}
#if 1
if ( rc == 0 )
rc = VTableReindex ( vtbl );
#endif
VTableRelease ( vtbl );
}
}
VSchemaRelease ( schema );
}
VDBManagerRelease ( vmgr );
}
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;
}
rc_t KMain ( int argc, char *argv [] )
{
VDBManager *vmgr;
rc_t rc = VDBManagerMakeUpdate ( & vmgr, NULL );
if ( rc != 0 )
LOGERR ( klogInt, rc, "failed to make update manager" );
else
{
VSchema *vschema;
rc = VDBManagerMakeSchema ( vmgr, & vschema );
if ( rc != 0 )
LOGERR ( klogInt, rc, "failed to make empty schema" );
else
{
const char *file = "align/align.vschema";
#if _DEBUGGING
VSchemaListSymtab ( vschema );
#endif
rc = VSchemaParseFile ( vschema, "align/align.vschema" );
#if _DEBUGGING
VSchemaListSymtab ( vschema );
#endif
if ( rc != 0 )
{
pLOGERR ( klogErr, rc, "failed to parse schema file '$(file)'"
, "file=%s"
, file );
}
else
{
VDatabase *vdb;
const char *path = "test-ac-db";
const char *typespec = "NCBI:align:db:alignment";
rc = VDBManagerCreateDB ( vmgr, & vdb, vschema, typespec, kcmInit, path );
if ( rc != 0 )
{
pLOGERR ( klogInt, rc, "failed to create '$(typespec)' db at '$(path)'"
, "typespec=%s,path=%s"
, typespec
, path
);
}
else
{
VTable *vtbl;
const char *member = "align";
path = member;
rc = VDatabaseCreateTable ( vdb, & vtbl, member, kcmInit, path );
if ( rc != 0 )
{
pLOGERR ( klogInt, rc, "failed to create '$(member)' table at '$(path)'"
, "member=%s,path=%s"
, member
, path
);
}
else
{
printf ( "done\n" );
VTableRelease ( vtbl );
}
VDatabaseRelease ( vdb );
}
}
VSchemaRelease ( vschema );
}
VDBManagerRelease ( vmgr );
}
return rc;
}
rc_t run (const char * table_path, uint64_t N )
{
static const char *colInf[] = {
"C1: Same value, same length",
"C2: Var. value, same length",
"C3: Var. value, var. legnth",
"C4: Same value except I row",
"C5: Same value except L row" };
rc_t rc;
uint64_t row = 0;
VDBManager *mgr = NULL;
VSchema *schema = NULL;
VTable *table = NULL;
VCursor *cursor;
uint32_t idx[COLUMNS];
uint64_t total[COLUMNS];
int i = 0, j = 0, prev = 0;
char *buffer[BUFFERS];
/* Initialize arrays */
memset(&idx, 0, sizeof idx);
memset(&total, 0, sizeof total);
for (i = 0; i < BUFFERS; ++i) {
char c;
size_t sz = ROWLEN + 1;
if (i == (BUFFERS - 1))
sz += ROWLEN;
buffer[i] = malloc(sz);
for (j = 0, c = 0; j < sz - 1; ++j, ++c) {
if (c >= ROWLEN)
c -= ROWLEN;
buffer[i][j] = '0' + c;
}
buffer[i][j] = '\0';
}
/* Create manager */
rc = VDBManagerMakeUpdate(&mgr, NULL);
if (rc != 0) {
LOGERR(klogInt, rc, "failed to open vdb library");
}
/* Initialize schema */
if (rc == 0) {
rc = VDBManagerMakeSchema(mgr, &schema);
if (rc != 0)
LOGERR(klogInt, rc, "failed to create empty schema");
}
if (rc == 0) {
char text[512] = "table Table #1 {\n";
char col [128];
for (i = 1; i <= COLUMNS; ++i) {
sprintf(col,
" column ascii C%d = .C%d; physical ascii .C%d = C%d;\n",
i, i, i, i);
strcat(text, col);
}
strcat(text, "};");
STSMSG(1,("Parsing schema:\n%s", text));
rc = VSchemaParseText(schema, "Schema", text, strlen(text));
if (rc != 0)
LOGERR(klogInt, rc, "failed to parse schema");
}
/* Create table */
if (rc == 0) {
STSMSG(1,("Creating %s", tablePath));
rc = VDBManagerCreateTable(mgr, &table, schema, "Table", kcmInit,
tablePath);
if (rc != 0)
LOGERR(klogInt, rc, "failed to create table");
}
/* Initialize cursor */
if (rc == 0) {
rc = VTableCreateCursorWrite(table, &cursor, kcmInsert);
if (rc != 0)
LOGERR(klogInt, rc, "failed to create cursor");
}
for (i = 0; rc == 0 && i < COLUMNS; ++i) {
char col[3];
sprintf(col, "C%d", i + 1);
STSMSG(2,("Adding column %s to cursor", col));
rc = VCursorAddColumn(cursor, &idx[i], col);
if (rc != 0)
PLOGERR(klogInt, (klogInt, rc,
"failed to add $(c) to cursor", "c=%s", col));
}
if (rc == 0) {
rc = VCursorOpen(cursor);
if (rc != 0)
LOGERR(klogInt, rc, "failed to open cursor");
}
/* Write data */
for (row = 0; row < N && rc == 0; ++row) {
int max = 2 * ROWLEN - 1;
int sz = 0;
if ((row % 2) == 0) {
int min = 1;
sz = min + (int) (max * (rand() / (RAND_MAX + 1.0)));
prev = sz;
buffer[1][0] = '1';
}
else {
sz = max + 1 - prev;
buffer[1][0] = '2';
}
rc = Quitting();
if (rc == 0) {
KStsLevel lvl = 2;
if (row > 0 && ((row % ROWS) == 0)) {
lvl = 1;
}
STSMSG (lvl, ("Writing row %ji / %ji",
row + 1, N));
rc = VCursorOpenRow(cursor);
if (rc != 0)
LOGERR(klogInt, rc, "failed to open row");
}
for (j = 0; j < COLUMNS && rc == 0; ++j) {
uint32_t count = 0;
int buf = j;
switch (j) {
case 0:
case 1:
count = strlen(buffer[j]);
break;
case 2:
count = sz;
break;
case 3:
buf = 0;
if (row == 0)
buf = 1;
count = strlen(buffer[buf]);
break;
case 4:
buf = 0;
if (row == (N - 1))
buf = 1;
count = strlen(buffer[buf]);
break;
default:
assert(0);
break;
}
STSMSG (3, ("Row %ji/Col.%d: %sd %.*s\n",
row + 1, j + 1, count, count, buffer[buf]));
rc = VCursorWrite
(cursor, idx[j], 8, buffer[buf], 0, count);
if (rc != 0)
PLOGERR(klogInt, (klogInt, rc, "failed to write row[$i]", "i=%d", j + 1));
total[j] += count;
}
if (rc == 0) {
rc = VCursorCommitRow(cursor);
if (rc != 0)
LOGERR(klogInt, rc, "failed to commit row");
}
if (rc == 0) {
rc = VCursorCloseRow(cursor);
if (rc != 0)
LOGERR(klogInt, rc, "failed to close row");
}
}
if (rc == 0) {
STSMSG (1, ("Commiting cursor\n"));
rc = VCursorCommit(cursor);
if (rc != 0)
LOGERR(klogInt, rc, "failed to commit cursor");
}
/* Cleanup */
VCursorRelease(cursor);
VTableRelease(table);
VSchemaRelease(schema);
VDBManagerRelease(mgr);
for (i = 0; i < BUFFERS; ++i) {
free(buffer[i]);
}
/* Log */
if (rc == 0) {
PLOGMSG(klogInfo, (klogInfo, "$(t)", "t=%s", tablePath));
PLOGMSG(klogInfo,(klogInfo,
"$(n)($(N)) rows written - $(b) bytes per row",
PLOG_I64(n) "," PLOG_X64(N) ",b=%d", N, N, ROWLEN));
for (i = 0; i < COLUMNS; ++i) {
PLOGMSG(klogInfo,(klogInfo,
"$(i): $(n)($(N)) bytes",
"i=%s," PLOG_I64(n) "," PLOG_X64(N),
colInf[i], total[i], total[i]));
}
}
if (rc == 0) {
KDirectory *dir = NULL;
uint64_t sizes[COLUMNS];
memset(&sizes, 0, sizeof sizes);
rc = KDirectoryNativeDir(&dir);
if (rc != 0)
LOGERR(klogInt, rc, "failed to KDirectoryNativeDir");
else {
for (i = 1; i <= COLUMNS; ++i) {
uint64_t size = 0;
#define FORMAT "%s/col/%s/data"
#define KFORMAT "$(d)/col/$(n)/data", "d=%s,n=%s"
#define STATUS(action) (action FORMAT, tablePath, name)
char name[3];
sprintf(name, "C%d", i);
STSMSG (1, STATUS("checking "));
rc = KDirectoryFileSize(dir, &size, FORMAT, tablePath, name);
if (rc != 0) {
if (GetRCState(rc) == rcNotFound) {
STSMSG (2, STATUS("not found "));
rc = 0;
}
else
PLOGERR(klogInt, (klogInt, rc,
"failed to check " KFORMAT, tablePath, name));
}
else {
STSMSG (2, STATUS("found "));
}
PLOGMSG(klogInfo, (klogInfo, "Size of $(d)/col/$(n)/data = $(s)",
"d=%s,n=%s," PLOG_I64(s), tablePath, name, size));
sizes[i - 1] = size;
}
}
KDirectoryRelease(dir);
if (rc == 0) {
puts("");
KOutMsg("%ld rows, %d bytes per row:\n", N, ROWLEN);
for (i = 0; i < COLUMNS; ++i) {
puts(colInf[i]);
}
puts("");
for (i = 0; i < COLUMNS; ++i) {
int64_t over = sizes[i] - total[i];
KOutMsg("C%d: %9ld bytes written; "
"%9ld in 'data'", i + 1, total[i], sizes[i]);
if (over > 0) {
double p = 100.0 * over / sizes[i];
printf(": %7ld extra bytes (%.4f%%)\n", over, p);
}
else {
puts("");
}
}
}
}
return rc;
}
rc_t open (param_block * pb)
{
rc_t rc;
rc = KDirectoryNativeDir (&pb->pwd);
if (rc)
LOGERR (klogFatal, rc, "Failed to open file system");
else
{
rc = KDirectoryOpenFileRead (pb->pwd, &pb->file, "%s", pb->file_path);
if (rc)
LOGERR (klogFatal, rc, "Failed to open input file");
else
{
rc = KMMapMakeRead (&pb->mmap, pb->file);
if (rc)
LOGERR (klogFatal, rc, "unable to map file");
else
{
rc = VDBManagerMakeUpdate (&pb->mgr, pb->pwd);
if (rc)
LOGERR (klogFatal, rc, "Failed to open DB Manager");
else
{
rc = VDBManagerMakeSchema (pb->mgr, &pb->schema);
if (rc)
LOGERR (klogFatal, rc, "Failed to create a schema object");
else
{
VSchemaAddIncludePath (pb->schema, "interfaces");
rc = VSchemaParseFile (pb->schema, "%s", pb->schema_path);
if (rc)
LOGERR (klogFatal, rc, "Failed to parse schema");
else
{
rc = VDBManagerCreateTable (pb->mgr, &pb->table, pb->schema,
TYPESPEC, kcmCreate, "%s", pb->table_path);
if (rc)
LOGERR (klogFatal, rc, "Failed to create table");
else
{
rc = VTableCreateCursorWrite (pb->table, &pb->cursor, kcmCreate);
if (rc)
LOGERR (klogFatal, rc, "Failed to create cursor");
else
{
rc = VCursorAddColumn (pb->cursor, &pb->idx, "READ");
if (rc)
LOGERR (klogFatal, rc, "Failed to add READ to cursor");
else
{
rc = VCursorOpen (pb->cursor);
if (rc)
LOGERR (klogFatal, rc, "Failed to open cursor");
else
{
rc = write_rows (pb);
if (rc == 0)
VCursorCommit (pb->cursor);
}
}
VCursorRelease (pb->cursor);
}
VTableRelease (pb->table);
}
}
VSchemaRelease (pb->schema);
}
VDBManagerRelease (pb->mgr);
}
KMMapRelease (pb->mmap);
}
KFileRelease (pb->file);
}
KDirectoryRelease (pb->pwd);
}
return rc;
}
/* 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;
}
LIB_EXPORT rc_t CC VDatatypesRelease ( const VDatatypes *self )
{
return VSchemaRelease ( ( const VSchema* ) self );
}
