This article contains raw text results from hangouts or meetings around Teiid Designer Komodo planning and brainstorming sessions.

To date, communty members, Dan Florian, Ted Jones, Barry LaFond, Paul Richardson and Mark Drilling have been involved.

Initial Planning Session

Komodo Planning Session 1 - Tuesday August 21, 2012

Barry LaFond, Dan Florian, Ted Jones, Paul Richardson, Mark Drilling

Goals

• Create simple use-case/scenario that will excersize required framework

• Create action items/tasks for team members

Action Items:1) Need a term for "tweaked DB tables"

• The concept of the word "Virtual" is/has become more or less a global term when looking at our target DDL

• CREATE VIEW YYYY = definition of a standard relational VIEW containing column definition and SQL

• So in a sense, both constructs are "Virtual", so unless a "source" is defined as a "dynamic" source in a vdb, then the whole VDB is Virtual, which is a GOOD thing

2) Common DB view of sources, including deployed VDBs and VDBs defined in your "workspace"

Dan and Ted: Modeshape/Repo

• Investigate local repo

• 1 vs many MS "workspaces"/sessions, etc.

• Options for persistance (workspace xml dump?)

• Import "products" from "jdbc:oracle:thin:@slntds04.mw.lab.eng.bos.redhat.com:1521:ds04"

• Actual  DDL/Metadata will be accessed through  deployment of a Teiid Data source  (ds.xml), deploying a dynamic VDB  and retrieving the DDL through the  Teiid Server

                 CREATE FOREIGN SCHEMA PRODUCT (connection-jndi-name=product-oracle:translator-name=jdbc);

                 CREATE FOREIGN TABLE PRODUCT.PRODUCTDATA (

                     id integer PRIMARY KEY, 

                     firstname  varchar(25),

                     lastname varchar(25), 

                     dob timestamp);

                CREATE FOREIGN TABLE PRODUCT.PRODUCTSYMBOLS (

                    id integer PRIMARY KEY,

                    customerid  integer, 

                    saledate date,

                    amount decimal(25,4) CONSTRAINT FOREIGN  KEY(customerid)  REFERENCES Cust

• Create VIEW containing PRODUCTINFO joined from PRODUCTDATA and PRODUCTSYMBOLS

                CREATE VIRTUAL SCHEMA PRODUCT_VIEWS;                                CREATE VIEW PRODUCT_VIEWS.PRODUCTINFO (                        name varchar(50),                          saledate date,                         amount decimal) OPTIONS (CARDINALITY 100, ANNOTATION 'Example')                      AS                      SELECT                           concat(c.firstname, c.lastname) as name,                           o.saledate as saledate,                           o.amount as amount                       FROM Customer C JOIN Order o ON c.id = o.customerid;                     

• Create productsVDB and deploy on AS 7.x/Teiid 8.x

• Execute SELECT * FROM PRODUCTINFO query

• Define Second VDB using tables from first VDB

Standard VDB fragment:

<model visible="true" type="VIRTUAL" name="US_CustomerAccounts_VBL" path="/Financials/VirtualBaseLayer/US_CustomerAccounts_VBL.xmi">

        <property value="4097408696" name="checksum"/>

        <property value="Relational" name="modelClass"/>

        <property value="false" name="builtIn"/>

        <property value="1592679058.INDEX" name="indexName"/>

</model>

Dynamic VDB Example:

=======================================================

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<vdb name="twitter" version="1">

    <description>Shows how to call Web Services</description>

    <property name="UseConnectorMetadata" value="cached" />

    <model name="twitter">

        <source name="twitter" translator-name="rest" connection-jndi-name="java:/twitterDS"/>

    </model>

    <model name="twitterview" type="VIRTUAL">

         <metadata type="DDL"><![CDATA[

             CREATE VIRTUAL PROCEDURE getTweets(query varchar) RETURNS (created_on varchar(25), from_user varchar(25), to_user varchar(25),

                 profile_image_url varchar(25), source varchar(25), text varchar(140)) AS

                select tweet.* from

                    (call twitter.invokeHTTP(action => 'GET', endpoint =>querystring('',query as "q"))) w,

                    XMLTABLE('results' passing JSONTOXML('myxml', w.result) columns

                    created_on string PATH 'created_at',

                    from_user string PATH 'from_user',

                    to_user string PATH 'to_user', 

                    profile_image_url string PATH 'profile_image_url', 

                    source string PATH 'source',   

                    text string PATH 'text') tweet;

                CREATE VIEW Tweet AS select * FROM twitterview.getTweets;

        ]]> </metadata>

    </model>

    <translator name="rest" type="ws">

        <property name="DefaultBinding" value="HTTP"/>

        <property name="DefaultServiceMode" value="MESSAGE"/>

    </translator>

</vdb>

=== Architecture ===

Non-Overridden Properties

ProductVDB -> Dynamic VDB(s) of data sources -> ds.xml

Overridden Properties

ProductVDB -> ds.xml ??

===========================================================

1) Simplify terminology by removing references to Models and Metamodels

• Teiid is a server and framework designed to expose a VDB as a database

• Tooling for Teiid should be designed to allow users to create/configure/edit schema in their VDBs

• Tooling should highlight the value-added functionality of federating many different types of data sources

• Users will utilize DTP connection profile info like current tooling

• Actual   DDL/Metadata will be accessed through deployment of a Teiid Data  source  (ds.xml), deploying a dynamic VDB and retrieving the DDL through  the  Teiid Server

• Users can also create new or edit Data Sources in the form of Tables, Procedures or Functions.

• Source functions will be treated as "push-down" functions handled by the source's translator.

3) Expose Create Views or Virtual Procedures as primary feature.

• Remove  the need to manage multiple model types (i.e. Relational, Source, View,  Web Services, XML Documents, Function and Extension)

• Users create Schema to contain/organize views/tables/procedures/functions

• Users define details for simpler DDL constructions:  CREATE VIEW, CREATE VIRTUAL PROCEDURE, CREATE VIRTUAL FUNCTION statements.

• Similar SQL definition/editing as current Teiid Designer's transformation editor

• Delete (local)

ModeShape Design Issues in Komodo

Date:  September, 2012

* Investigate using local repo for BO management

• If  the ModeShape repository persisted content locally to the file system  (e.g., within ".metadata"),  then the "saving" of the editor (e.g.,  writing out a file to the  Eclipse workspace) can be decoupled from the  "saving" of the model  content in the repository. The latter can be done  very frequently, while  the former can happen only when the user wishes  to save their editor  and would involve only exporting/writing the  content to the file system.
• Seems  like we do not want to use node types and  properties for everything  (like Randall suggests). Need to be able to  persist in  incomplete/invalid state. Validation rules could be saved in repo and  then run on model content.  We probably would want a ModeShape sequencer reacting to model content  changes and would create/delete/manage validation error nodes. Designer  could register a ModeShape listener that listened for changes to model  content and react appropriately. This is putting more logic on the  ModeShape side though. Not sure if this is what we want.
• Updates to the MS repo will be wrapped in a transaction and when the POJOs are pushed to the JCR Node, the transaction will be committed.
• Action Item:

• Determine layers of objects to manage... JCR Repo, POJOs, etc.

• POJOs could implement javax.jcr.Node so MS can persist in memory

• A Cache will exist with defined POJOs and APIs used by the client.  The Cache will communicate with the MS repo.

• http://cosketch.com/Saved/pOwoxaYC

Question: Do we want to have a single MS repo per Eclipse workspace?

Answer: We have to think in terms of multiple client types, not just Eclipse. So

it makes sense to have a single MS repo and allow for multiple MS workspaces.

For the first time opening an Eclipse workspace after installing Designer, we allow then to select select

* 1 vs many MS "workspaces"/sessions, etc.

• Suggest  one workspace for simplicity of implementation. Also, multiple  workspaces can be used in Eclipse which would accomplish the same thing.

* Options for persistance (workspace xml dump?)

• Persistance will occur via the local repo in .metadata. No need to dump.

* Investigate existing DDL CND, Teiid VDB sequencing. clarify use of existing capabilities (or not)

• if  the Designer artifacts will now be just vdb.xml files, ModeShape has a  VDB manifest sequencer to sequence those files. That sequencer is backed  by a VDB manifest CND file so the vdb.xml being sequenced has to be in a  valid/complete state for sequencing to be successful. We will want to  save Designer artifacts in invalid/incomplete state so not sue we can  reuse existing ModeShape sequencers. For Teiid DDL, we can potentially  create a new DDL dialect for the current ModeShape DDL sequencer to save  valid Teiid DDL in the repository.

Questions:

• What version of MS will we be using?

Barry's email:

Had  a great discussion with Randall yesterday around adapting ModeShape  repository for Teiid Designer Komodo (TDK ??). It's part of the  vision/solution we dreamed about 5 years ago to handle and fix our large  model memory problem. I touched on it briefly in yesterday's team  meeting.

With  the direction of moving to a simpler, DDL-based VDB definition, it's  even more apparent that MS could handle our business model needs.

Randall, forgive me if I get some terms wrong...feel free to clarify/expand on my points.

Summary/Vision

• JCR workspaces allow definition of nodes, properties and references.

• MS already has a DDL Sequencer containing a handful of different dialects on top of SQL-92

• Teiid Dialect would have to be added

• And possibly we'd create our own sequencer CND (compact node definition) which would meet the exact needs of TDK

• The  full business object model for a user's workspace ((parsing/ seqencing  DDL + VDBs + TDK-specific data) would be loaded into a local MS  repository including references (i.e. links)

• Refactoring (rename/move/delete) framework would likely be greatly improved over current Designer

• VDB's (defined only by their vdb.xml) would also be sequenced and in-memory and refactorable (not in current Designer)

• MS already has 2 available full repository file-persistence options (read/write)

• VDB seqencing is in the works and is close to being available for the "vdb.xml"

• BO's/business model will be drastically easier to test than in EMF Teiid Designer

There's more to story, of course, but addresses a handful of pain points in Designer's current design.

Randall's reply:

-  ModeShape has support for querying content, and this could be leveraged  for internal features (e.g., rename, resolution, etc.) or even to  expose to users (e.g., a "search" area on an editor.

-  If the ModeShape repository persisted content locally to the file  system (e.g., within ".metadata"), then the "saving" of the editor  (e.g., writing out a file to the Eclipse workspace) can be decoupled  from the "saving" of the model content in the repository. The latter can  be done very frequently, while the former can happen only when the user  wishes to save their editor and would involve only exporting/writing  the content to the file system.

-  Komodo codebase could easily use the JCR API (perhaps with some  decorator objects, functions, or other patterns to encapsulate the JCR  API usage) and take advantage of the nodes being able to store any  properties. The JCR node types aren't required (i.e., the node  structures aren't constrained by a "schema"), or they can be used to  have the repository validate the structures. (Note that repository  validation is not akin to model validation; the repository will never  allow storing a node that is invalid.) In short, there's a lot of  flexibility here. And it's extremely extensible and can evolve over  time.

-  The repository can also be used for "importing" and creating the  transient representation of the metadata loaded from an external system.  For example, "importing DDL" could consist of loading the DDL file into  an area of the repository, running the DDL sequencer to extract nodes  and properties that represent each of the statements (e.g., a node-based  AST of the DDL statements), and then having the importer simply  navigate and use those extracted/derived nodes. ModeShape 3.1 will also  have a JDBC Metadata connector, which connects to a data source, reads  the database metadata, and constructs nodes representing the tables,  views, procedures, etc. (I'm not sure whether JDBC import will be a  feature of Komodo, or whether it will all be DDL-oriented.)

-  The large model behavior is accomplished because ModeShape can persist  content to disk, yet materialize into memory each of the nodes that are  needed by the JCR client (the TDK in this case).

-  If the core modeling functionality of TDK is written without  dependencies to Eclipse (e.g., just a regular Java library with POJO  APIs), then it's possible to create a web-based version of the TDK that  can be deployed on JBoss AS7, where ModeShape runs as a service.

Data Structure of Business Objects for Komodo

Date: Nov. 12, 2012

General

• Provide Service API to insulate Designer from future changes to Admin API

• Allow separation from UI Modelling

• Allow ground-up, unit testable command line interface

• Use interfaces rather than implemented classes

• How is the DDL encapsulated when returned by the teiid server?

The ModelMetaData objects contain the DDL definitions.  Methods get/setSchemaSourceType and get/setSchemaText are used to get and set the DDL on the Models

• Do we need our own objects to encapsulate the DDL, eg. schema, table, view?

Yes, I think we will need some convenient way to go from object form to the DDL string that gets set on the Model

• There is no ds.xml files concept in teiid 8 anymore. Need to come up with a factory / service that can create the relevant subsystem calls (see https://docs.jboss.org/author/display/teiid80final/Deploying+VDB+Dependencies ).

The repository will, at a minimum, have:

1. a section of referenceable artifacts for use across all JBoss-related applications, and

2. a section for client application state.

These CND files address the referenceable artifacts section: jboss.cnd, teiid.cnd, and teiid-store.cnd. Other JBoss project besides Teiid would contribute CNDs to support their artifacts.

These CND files address the client application data and Designer: teiid-client.cnd and teiid-designer.cnd.

Designer may allow connections to multiple repositories and could use the federation connector to merge content.

========== jboss.cnd ==========

/*

* The jboss.cnd defines the general or highest-level JBoss JCR-related namespaces and

* node type definitions. Specific projects will provide there own CND files.

*/

<nt = "http://www.jcp.org/jcr/nt/1.0">

<mix = "http://www.jcp.org/jcr/mix/1.0">

// namespace for JBoss AS-related JCR objects

<jbas = "http://www.jboss.org/jcr/server/1.0">

// namespace for JBoss data source-related JCR objects

<jbdatasource = "http://www.jboss.org/jcr/datasource/1.0">

// namespace for JBoss JCR registered, global, or reusable artifacts

<jbstore = "http://www.jboss.org/jcr/store/1.0">

//----------------------------------------------------------------------------------------

// The node type definition for a store of artifacts. The node name is the store name.

//----------------------------------------------------------------------------------------

[jbstore:store] > nt:unstructured

    // zero or more grouping child nodes, each with a unique name, that will have artifact

    // child nodes

    + * (jbstore:grouping)

    // zero or more child nodes, representing an artifact, each with a unique names

    + * (jbstore:artifact)

//----------------------------------------------------------------------------------------

// The mixin indicating the node is a store artifact. Artifacts are lockable, versionable,

// and referenceable.

//----------------------------------------------------------------------------------------

[jbstore:artifact] > mix:lockable, mix:versionable mixin

    - jbstore:description (string)

//----------------------------------------------------------------------------------------

// The node type definition for a group or category node for store artifacts. The node name

// is the group/category name.

//----------------------------------------------------------------------------------------

[jbstore:grouping] > nt:unstructured

    // an optional description property

    - jbstore:description (string)

    // zero or more artifact child nodes, each with a unique name

    + * (jbstore:artifact)

//----------------------------------------------------------------------------------------

// The node type definition for a server definition. The node name is the

// server display name. The properties provided can be used to create a new

// server or look up an existing one.

//----------------------------------------------------------------------------------------

[jbas:server] > nt:unstructured

    - jbas:installationLocation (string)

    - jbas:configurationFileLocation (string)

    - jbas:jreLocation (string)

    - jbas:serverType (string)

    - jbas:serverName (string)

    - jbas:hostName (string)

    - jbas:userName (string)

    - jbas:password (string)

//----------------------------------------------------------------------------------------

// The node type definition for a JDBC drivers. The node name is the driver name. The

// properties provided can be used to create a new JDBC driver or look up an existing

// one.

//----------------------------------------------------------------------------------------

[jbdatasource:jdbcDriver] > nt:unstructured

    - jbdatasource:type (string)

    - jbdatasource:className (string)

    - jbdatasource:jarLocations (string) multi

    - jbdatasource:catalog (string)

    - jbdatasource:connectionUrl (string)

    - jbdatasource:databaseName (string)

    - jbdatasource:password (string)

    - jbdatasource:user (string)

//----------------------------------------------------------------------------------------

// The node type definition for connection profiles. The node name is the connection

// profile name. The properties provide can be used to create a new connection

// profile or look up an existing one.

//----------------------------------------------------------------------------------------

[jbdatasource:connectionProfile] > nt:unstructured

    - jbdatasource:driverName (string)

    - jbdatasource:type (string)

    - jbdatasource:sid (string)

    - jbdatasource:host (string)

    - jbdatasource:port (long)

    - jbdatasource:user (string)

    - jbdatasource:password (string)

========== teiid.cnd ==========

/*

* The teiid.cnd defines the Teiid-related namespaces and node type definitions.

*/

<nt = "http://www.jcp.org/jcr/nt/1.0">

<mix = "http://www.jcp.org/jcr/mix/1.0">

<teiid = "http://www.jboss.org/jcr/teiid/1.0">

//----------------------------------------------------------------------------------------

// The node name is the VDB name.

//----------------------------------------------------------------------------------------

[teiid:vdb] > nt:unstructured

    - teiid:description (string)

    - teiid:version (long) = '1' autocreated

    - teiid:queryTimeout (long)

    - teiid:type (string) = 'DYNAMIC' < 'PREVIEW', 'DYNAMIC' autocreated

    // zero or more child nodes uniquely named by the model name

    + * (teiid:model)

    // zero or more child nodes uniquely named by the data policy name

    + * (teiid:dataPolicy)

    // zero or more child nodes uniquely named by the translator name

    + * (teiid:translator)

    // zero or more child nodes uniquely named by the entry name

    + * (teiid:entry)

    // zero or more child nodes uniquely named by the VDB import name

    + * (teiid:vdbImport)

//----------------------------------------------------------------------------------------

// A model defines the alias for the schema of the data being integrated. In a Designer

// built VDB, the schema for this model is defined by external index files. In the

// dynamic VDB this defines the importer properties along with source information the

// schema is generated at deploy time. The node name is the model name.

//----------------------------------------------------------------------------------------

[teiid:model] > nt:unstructured

    - teiid:description (string)

    - teiid:type (string) = 'PHYSICAL' < 'PHYSICAL', 'VIRTUAL' autocreated

    - teiid:visible (boolean) = 'true' autocreated

    - teiid:path (string)

    - teiid:metadataType (string) = 'DDL' auto created

    - teiid:metadata (string)

    + * (teiid:dataSource)

//----------------------------------------------------------------------------------------

// A source defines access to physical data source with its connection JNDI name. Its

// translator name defines the layer between Teiid engine and the data source that knows

// how to convert and execute commands native to source. The node name is the source name.

//----------------------------------------------------------------------------------------

[teiid:dataSource] > nt:unstructured

    - teiid:translatorName (string) mandatory

    - teiid:connectionJndiName (string)

//----------------------------------------------------------------------------------------

// The data role name is the fully qualified name for a schema, table, procedure, etc. and

// is used as the node name. The mapped role names define the role name the user must

// have before they have access to this data. The role name matches the JAAS based

// role that user has.

//----------------------------------------------------------------------------------------

[teiid:dataRole] > nt:unstructured

    - teiid:description (string)

    - teiid:mappedRoleNames (string) multi

    - teiid:allowsTemporaryTables (boolean)

    - teiid:appliesToAllAuthenticatedUsers (boolean)

    // zero or more child nodes uniquely named by the resource name

    + * (teiid:dataPermission) mandatory

//----------------------------------------------------------------------------------------

// A translator modifies the associated pre-built Teiid translator's behavior by using

// property settings. The translator being overridden is identified by the type. The node

// name is the translator name.

//----------------------------------------------------------------------------------------

[teiid:translator] > nt:unstructured

    - teiid:description (string)

    - teiid:translatorType (string) mandatory

//----------------------------------------------------------------------------------------

// The node name is the path of the resource included in the VDB. This is only used

// by Designer VDBs.

//----------------------------------------------------------------------------------------

[teiid:entry] > nt:unstructured

    - teiid:description (string)

//----------------------------------------------------------------------------------------

// An imported VDB is reused in the context of another VDB.

//----------------------------------------------------------------------------------------

[teiid:vdbImport] > nt:unstructured

    - teiid:importDataPolicies (boolean)

    - teiid:version (long) = '1' autocreated

//----------------------------------------------------------------------------------------

// The permission name is the fully qualified name for a schema, table, procedure, etc.

// and is used as the node name. The "allows-*" properties define the security access,

// which are applied to the resource and all child resources.

//----------------------------------------------------------------------------------------

[teiid:dataPermission] > nt:unstructured // resource name is node name

    - teiid:allowsAlter (boolean)

    - teiid:allowsCreate (boolean)

    - teiid:allowsDelete (boolean)

    - teiid:allowsDrop (boolean)

    - teiid:allowsExecute (boolean)

    - teiid:allowsLanguage (boolean)

    - teiid:allowsRead (boolean)

    - teiid:allowsUpdate (boolean)

========== teiid-store.cnd ==========

/*

* The teiid-store.cnd defines the Teiid artifact store's namespaces and node type

* definitions.

*/

<nt = "http://www.jcp.org/jcr/nt/1.0">

<mix = "http://www.jcp.org/jcr/mix/1.0">

<jbas = "http://www.jboss.org/jcr/server/1.0">

<jbdatasource = "http://www.jboss.org/jcr/datasource/1.0">

<jbstore = "http://www.jboss.org/jcr/store/1.0">

<teiid = "http://www.jboss.org/jcr/teiid/1.0">

<teiid-store = "http://www.jboss.org/jcr/teiid/store/1.0">

//----------------------------------------------------------------------------------------

// The node type definition for the store of reusable Teiid artifacts.

//----------------------------------------------------------------------------------------

[teiid-store:store] > jbstore:store

    // an optional node that groups connection profile descriptors

    + teiid-store:connectionProfiles (teiid-store:connectionProfiles) copy

    // an optional node that groups JDBC driver descriptors

    + teiid-store:jdbcDrivers (teiid-store:jdbcDrivers) copy

    // an optional node that groups models

    + teiid-store:models (teiid-store:models) copy

    // an optional node that groups server descriptors

    + teiid-store:servers (teiid-store:servers) copy

    // an optional node that groups translator descriptors

    + teiid-store:translators (teiid-store:translators) copy

    // an optional node that groups VDB import descriptors

    + teiid-store:vdbImports (teiid-store:vdbImports) copy

    // an optional node that groups VDBs

    + teiid-store:virtualDatabases (teiid-store:virtualDatabases) copy

//----------------------------------------------------------------------------------------

// The connection profile descriptors group node.

//----------------------------------------------------------------------------------------

[teiid-store:connectionProfiles] > jbstore:grouping

    + * (teiid-store:connectionProfile) copy

//----------------------------------------------------------------------------------------

// The JDBC driver descriptors group node.

//----------------------------------------------------------------------------------------

[teiid-store:jdbcDrivers] > jbstore:grouping

    + * (teiid-store:jdbcDriver) copy

//----------------------------------------------------------------------------------------

// The models group node.

//----------------------------------------------------------------------------------------

[teiid-store:models] > jbstore:grouping

    + * (teiid-store:model) copy

//----------------------------------------------------------------------------------------

// The AS server descriptors group node.

//----------------------------------------------------------------------------------------

[teiid-store:servers] > jbstore:grouping

    + * (teiid-store:server) copy

//----------------------------------------------------------------------------------------

// The translator descriptors group node.

//----------------------------------------------------------------------------------------

[teiid-store:translators] > jbstore:grouping

    + * (teiid-store:translator) copy

//----------------------------------------------------------------------------------------

// The VDB import descriptors group node.

//----------------------------------------------------------------------------------------

[teiid-store:vdbImports] > jbstore:grouping

    + * (teiid-store:vdbImport) copy

//----------------------------------------------------------------------------------------

// The node type definition for the VDBs group node.

//----------------------------------------------------------------------------------------

[teiid-store:virtualDatabases] > jbstore:grouping

    + * (teiid-store:vdb) copy

//----------------------------------------------------------------------------------------

// The connection profile descriptor store artifact. The node name connection profile

// name. The properties provided can be used to create a new connection profile or look up

// an existing one.

//----------------------------------------------------------------------------------------

[teiid-store:connectionProfile] > jbstore:artifact, jbdatasource:connectionProfile

    // an optional property referencing the driver artifact if found in the store

    - teiid-store:driver (reference) < 'teiid-store:jdbcDriver'

//----------------------------------------------------------------------------------------

// The JDBC driver descriptor store artifact. The node name is the driver name. The

// properties provided can be used to create a new JDBC driver or look up an existing one.

//----------------------------------------------------------------------------------------

[teiid-store:jdbcDriver] > jbstore:artifact, jbdatasource:jdbcDriver

    // an optional property referencing the connection profile artifacts that use the

    // driver represented by this artifact

    - teiid-store:foundInConnectionProfiles (reference) multi < 'teiid-store:connectionProfile'

//----------------------------------------------------------------------------------------

// The model store artifact. The node name is the model name.

//----------------------------------------------------------------------------------------

[teiid-store:model] > jbstore:artifact, teiid:model

    // an optional property referencing the artifact that represents the connection

    // profile used by the model represented by this artifact

    - teiid-store:connectionProfile (reference) < 'teiid-store:connectionProfile'

    // an optional property referencing the artifacts that represents the data sources

    // used by the model represented by this artifact

    - teiid-store:dataSources (reference) multi < 'teiid-store:dataSource'

    // an optional property referencing the VDB artifacts whose VDB contains the model

    // represented by this artifact

    - teiid-store:foundInVdbs (reference) multi < 'teiid-store:vdb'

//----------------------------------------------------------------------------------------

// The source store artifact. The node name is the source name.

//----------------------------------------------------------------------------------------

[teiid-store:dataSource] > jbstore:artifact, teiid:dataSource

    - teiid-store:foundInModels (reference) multi < 'teiid-store:model'

//----------------------------------------------------------------------------------------

// The overridden translator store artifact. The node name is the translator name.

//----------------------------------------------------------------------------------------

[teiid-store:translator] > jbstore:artifact, teiid:translator

    // an optional property of one or more VDB artifact references whose VDB includes the

    // translator represented by this artifact

    - teiid-store:foundInVdbs (reference) multi < 'teiid-store:vdb'

    // an optional property of one or more model artifact references whose model

    // references the translator represented by this artifact

    - teiid-store:foundInSources (reference) multi < 'teiid-store:source'

//----------------------------------------------------------------------------------------

// The VDB import store artifact. The node name is the name of the VDB being imported.

//----------------------------------------------------------------------------------------

[teiid-store:vdbImport] > jbstore:artifact, teiid:vdbImport

    // an optional property or one or more VDB artifact references whose VDB has

    // referenced the VDB import represented by this artifact

    - teiid-store:importedByVdbs (reference) multi < 'teiid-store:vdb'

    // an optional property referencing the VDB artifact whose VDB is represented by

    // this artifact

    - teiid-store:vdb (reference) < 'teiid-store:vdb'

//----------------------------------------------------------------------------------------

// The VDB store artifact. The node name is the VDB name.

//----------------------------------------------------------------------------------------

[teiid-store:vdb] > jbstore:artifact, teiid:vdb

    // the VDB file

    - teiid-store:manifest (nt:file) mandatory

    // an optional property or one or more VDB import artifact references whose VDB import

    // has been referenced by the VDB represented by this artifact

    - teiid-store:importVdbs (reference) multi < 'teiid:vdbImport'

    // an optional property or one or more model artifact references whose model is

    // contained in the VDB represented by this artifact

    - teiid-store:models (reference) multi < 'teiid:model'

    // an optional property referencing the translator artifacts whose translator is

    // referenced by the VDB represented by this artifact

    - teiid-store:translators (reference) multi < 'teiid:translator'

========== teiid-client.cnd ==========

<nt = "http://www.jcp.org/jcr/nt/1.0">

<mix = "http://www.jcp.org/jcr/mix/1.0">

<jbas = "http://www.jboss.org/jcr/server/1.0">

<jbdatasource = "http://www.jboss.org/jcr/datasource/1.0">

<jbstore = "http://www.jboss.org/jcr/store/1.0">

<teiid = "http://www.jboss.org/jcr/teiid/1.0">

<teiid-store = "http://www.jboss.org/jcr/teiid/store/1.0">

<teiid-client = "http://www.jboss.org/jcr/teiid/client/1.0">

[teiid-client:client] > nt:unstructured

    - teiid-client:user (string)

    - teiid-client:password (string)

    + teiid-client:desks (teiid-client:desks)

    + teiid-client:servers (teiid-client:servers)

    + teiid-client:vdbs (teiid-client:vdbs)

[teiid-client:desks] > nt:unstructured

    + * (teiid-client:desk)

[teiid-client:servers] > nt:unstructured

    + * (teiid-client:server)

[teiid-client:vdbs] > nt:unstructured

    + * (teiid-client:vdb)

[teiid-client:desk] > nt:unstructured, mix:referenceable

    - teiid-client:servers (reference) < 'teiid-client:server'

    - teiid-client:vdbs (reference) < 'teiid-client:vdb'

    - dataSources

    - models

[teiid-client:server] > nt:unstructured

    - teiid-client:connected (boolean) = 'false' autocreated

    - teiid-client:previewEnabled (boolean) = 'true' autocreated

    - teiid-client:lastRefreshTime (date)

    - teiid-client:foundInDesks (reference) multi < 'teiid-client:desk'

    + teiid-client:descriptor (jbas:server) mandatory

    + teiid-client:deployedVdbs (teiid-client:deployedVdbs)

    + teiid-client:deployedDataSources (teiid-client:deployedDataSources)

    + teiid-client:deployedTranslators (teiid-client:deployedTranslators)

    + teiid-client:deployedPreviewVdbs (teiid-client:deployedPreviewVdbs)

    + teiid-client:deployedPreviewDataSources (teiid-client:deployedPreviewDataSources)

[teiid-client:deployedVdbs] > nt:unstructured