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 );
}
}
static rc_t add_source( void *data, const char *my_name )
{
VSchema *my_schema = (VSchema*)data;
rc_t rc = VSchemaParseFile( my_schema, "%s", my_name );
display_rescode( rc, "VSchemaParseFile failed", NULL );
return rc;
}
static rc_t make_schema( const KNamelist * schema_list,
VDBManager *my_manager, VSchema ** schema )
{
rc_t rc = VDBManagerMakeSchema ( my_manager, schema );
if ( rc != 0 )
LogErr( klogInt, rc, "VDBManagerMakeSchema() failed\n" );
else
{
uint32_t count;
rc = KNamelistCount ( schema_list, &count );
if ( rc !=0 )
LogErr( klogInt, rc, "KNamelistCount(schema-list) failed\n" );
else
{
uint32_t i;
for ( i = 0; i < count && rc == 0; ++i )
{
const char * name;
rc = KNamelistGet ( schema_list, i, &name );
if ( rc !=0 )
LogErr( klogInt, rc, "KNamelistGet(schema-list) failed\n" );
else
{
rc = VSchemaParseFile ( *schema, name );
if ( rc !=0 )
LogErr( klogInt, rc, "VSchemaParseFile() failed\n" );
}
}
}
}
return rc;
}
/* 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;
}
static rc_t pacbio_load_schema( ld_context *lctx, const char *schema_name )
{
rc_t rc;
if ( pacbio_is_schema_dflt( schema_name ) )
{
rc = VDBManagerMakeSRASchema ( lctx->vdb_mgr, &lctx->schema );
if ( rc != 0 )
LOGERR( klogErr, rc, "cannot create sra-schema" );
if ( rc == 0 )
{
rc = VSchemaParseFile ( lctx->schema, schema_name );
if ( rc != 0 )
PLOGERR( klogErr, ( klogErr, rc, "cannot to parse schema file '$(schema)'",
"schema=%s", schema_name ) );
}
}
else
{
rc = VDBManagerMakeSchema ( lctx->vdb_mgr, &lctx->schema );
if ( rc != 0 )
LOGERR( klogErr, rc, "cannot create sra-schema" );
else
{
char path[ 4096 ];
rc = pacbio_extract_path( lctx->wd, schema_name, path, sizeof path );
if ( rc == 0 )
{
rc = VSchemaAddIncludePath ( lctx->schema, path );
if ( rc != 0 )
PLOGERR( klogErr, ( klogErr, rc, "cannot add schema-include-path '$(path)'",
"path=%s", path ) );
else
{
rc = VSchemaParseFile ( lctx->schema, schema_name );
if ( rc != 0 )
PLOGERR( klogErr, ( klogErr, rc, "cannot to parse schema file '$(schema)'",
"schema=%s", schema_name ) );
}
}
}
}
return rc;
}
static
rc_t DB_Init(const SParam* p, DB_Handle* h)
{
rc_t rc;
if( (rc = VDBManagerMakeUpdate(&h->mgr, NULL)) != 0 ) {
LOGERR(klogErr, rc, "failed to create VDB Manager");
}
else if( (rc = VDBManagerMakeSchema(h->mgr, &h->schema)) != 0 ) {
LOGERR(klogErr, rc, "failed to create schema");
}
else if( (rc = VSchemaParseFile(h->schema, p->schema)) != 0 ) {
PLOGERR(klogErr, (klogErr, rc, "failed to parse schema file '$(schema)'", PLOG_S(schema), p->schema));
}
else if( (rc = VDBManagerCreateDB(h->mgr, &h->db, h->schema, "NCBI:align:db:alignment_evidence",
p->force ? kcmInit : kcmCreate, p->out)) != 0 ) {
PLOGERR(klogErr, (klogErr, rc, "failed to create database at '$(path)'", PLOG_S(path), p->out));
}
else if( (rc = ReferenceMgr_Make(&h->rmgr, h->db, h->mgr, (p->force_refw ? ewrefmgr_co_allREADs : 0),
p->refseqcfg, p->refseqpath, p->refseq_chunk, 350 * 1024 * 1024, 0)) != 0 ) {
LOGERR(klogErr, rc, "failed to create reference manager");
}
else if( (rc = CGWriterAlgn_Make(&h->walgn, &h->mappings, h->db, h->rmgr, p->min_mapq, p->single_mate, p->cluster_size)) != 0 ) {
LOGERR(klogErr, rc, "failed to create alignment writer");
}
else if( (rc = CGWriterSeq_Make(&h->wseq, &h->reads, h->db, (p->force_readw ? ewseq_co_SaveRead : 0) |
(p->no_spot_group ? 0 : ewseq_co_SpotGroup), p->qual_quant)) != 0 ) {
LOGERR(klogErr, rc, "failed to create sequence writer");
} else if( p->asm_path && (rc = CGWriterEvdInt_Make(&h->wev_int, &h->ev_int, h->db, h->rmgr, 0)) != 0 ) {
LOGERR(klogErr, rc, "failed to create evidence intervals writer");
} else if( p->asm_path && (rc = CGWriterEvdDnbs_Make(&h->wev_dnb, &h->ev_dnb, h->db, h->rmgr, 0)) != 0 ) {
LOGERR(klogErr, rc, "failed to create evidence dnbs writer");
} else {
const char** r = p->refFiles;
while( rc == 0 && *r != NULL ) {
if( (rc = ReferenceMgr_FastaPath(h->rmgr, *r++)) != 0 ) {
PLOGERR(klogInfo, (klogInfo, rc, "fasta file '$(file)'", "file=%s", r[-1]));
}
}
}
return rc;
}
static rc_t pacbio_load( context *ctx, ld_context *lctx,
bool cache_content, bool check_src_obj )
{
bool consensus_present = true;
rc_t rc1 = 0;
rc_t rc = KLoadProgressbar_Make( &lctx->xml_progress, 0 );
if ( rc != 0 )
LOGERR( klogErr, rc, "cannot create LoadProgressBar" );
if ( rc == 0 )
{
rc = VDBManagerMakeUpdate ( &lctx->vdb_mgr, lctx->wd );
if ( rc != 0 )
LOGERR( klogErr, rc, "cannot create vdb-update-manager" );
}
if ( rc == 0 )
rc = pacbio_load_schema( lctx, ctx->schema_name );
if ( rc == 0 )
{
rc = VSchemaParseFile ( lctx->schema, ctx->schema_name );
if ( rc != 0 )
PLOGERR( klogErr, ( klogErr, rc, "cannot to parse schema file '$(schema)'",
"schema=%s", ctx->schema_name ) );
}
if ( rc == 0 )
{
rc = MakeHDF5RootDir ( lctx->wd, &lctx->hdf5_dir, false, ctx->src_path );
if ( rc != 0 )
PLOGERR( klogErr, ( klogErr, rc, "cannot open hdf5-source-file '$(srcfile)'",
"srcfile=%s", ctx->src_path ) );
}
if ( rc == 0 )
{
KCreateMode cmode = kcmMD5 | kcmParents;
if ( ctx->force )
cmode |= kcmInit;
else
cmode |= kcmCreate;
rc = VDBManagerCreateDB( lctx->vdb_mgr, & lctx->database, lctx->schema,
PACBIO_SCHEMA_DB, cmode, ctx->dst_path );
if ( rc != 0 )
PLOGERR( klogErr, ( klogErr, rc, "cannot create output-database '$(dst)'",
"dst=%s", ctx->dst_path ) );
}
if ( rc == 0 && ctx_ld_sequence( ctx ) )
rc = load_seq( lctx, cache_content, check_src_obj );
if ( rc == 0 && ctx_ld_consensus( ctx ) )
{
rc1 = load_consensus( lctx, cache_content, check_src_obj );
if ( rc1 != 0 )
{
LOGMSG( klogWarn, "the consensus-group is missing" );
VDatabaseDropTable ( lctx->database, "CONSENSUS" );
consensus_present = false;
}
}
if ( rc == 0 )
{
if ( rc1 == 0 )
{
/* CONSENSUS exists, create a alias named SEQUENCE to CONSENSUS */
/* rc = pacbio_make_alias( lctx->database, "CONSENSUS", "SEQUENCE" ); */
}
else
{
/* CONSENSUS does not exist, create a alias named SEQUENCE to PULSE */
/* rc = pacbio_make_alias( lctx->database, "PULSE", "SEQUENCE" ); */
}
}
if ( rc == 0 && ctx_ld_passes( ctx )&& consensus_present )
{
rc1 = load_passes( lctx, cache_content, check_src_obj );
if ( rc1 != 0 )
LOGMSG( klogWarn, "the passes-table is missing" );
}
if ( rc == 0 && ctx_ld_metrics( ctx ) )
{
rc1 = load_metrics( lctx, cache_content, check_src_obj );
if ( rc1 != 0 )
LOGMSG( klogWarn, "the metrics-table is missing" );
}
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;
}
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 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 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;
}
