analytics/webcontent/relmd/metadata/relmdMetadata.xsd

<?xml version="1.0" encoding="UTF-8"?>
<!--
 Licensed Materials - Property of IBM

 IBM Cognos Products: relmd

 (C) Copyright IBM Corp. 2008, 2016

 US Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
-->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://www.ibm.com/xmlns/prod/cognos/relmd/1/0" targetNamespace="http://www.ibm.com/xmlns/prod/cognos/relmd/1/0" elementFormDefault="qualified" attributeFormDefault="qualified">
	<!--Copyright (C) 2008 Cognos ULC, an IBM Company. All rights reserved.-->
	<!--Cognos (R) is a trademark of Cognos ULC, (formerly Cognos Incorporated).-->
	<!---->
	<!--Relational Metadata Model specifications-->
	<xs:element name="relationalMetadata">
		<xs:annotation>
			<xs:documentation>The root of the relational in . The primary design intent is to make it simple to be built by hand. This means a few things, but the general idea is to keep it itght and normalized, yet still as specific as possible. Keeping it normalized will keep it tractible for consumption, however should consumers require additional indexing, then the idea is to provide them their own model that "decorates" this one with the indexes, e.g. "publishedRelationalMetadata.xsd".

It is largely an inferral of the UDA SqlApi functions employed by FM's import process (found in the Documentation Center page go to http://dinobot), but  also takes into what account what the JDBC java.sql.DatabaseMetadata API returns which does seem to be similar to UDA's APIs).

Note: There are a lot of attributes here, if viewing in XMLSpy 2008 Schema Design view you may want to select the "Display attributes in toolbar" button.</xs:documentation>
		</xs:annotation>
		<xs:complexType>
			<xs:sequence>
				<xs:element name="database" maxOccurs="unbounded">
					<xs:complexType>
						<xs:sequence>
							<xs:group ref="schemaParent"/>
							<xs:element name="catalog" minOccurs="0" maxOccurs="unbounded">
								<xs:complexType>
									<xs:group ref="schemaParent"/>
									<xs:attributeGroup ref="referenceableObject"/>
								</xs:complexType>
							</xs:element>
						</xs:sequence>
						<xs:attributeGroup ref="cmDataSource"/>
						<xs:attribute name="vendorType" use="required">
							<xs:simpleType>
								<xs:restriction base="xs:NMTOKEN">
									<xs:enumeration value="oracle"/>
									<xs:enumeration value="db2"/>
									<xs:enumeration value="sqlserver"/>
									<xs:enumeration value="sybase"/>
									<xs:enumeration value="informix"/>
									<xs:enumeration value="netezza"/>
									<xs:enumeration value="redbrick"/>
									<xs:enumeration value="openedge"/>
									<xs:enumeration value="teradata"/>
									<xs:enumeration value="odbc"/>
									<xs:enumeration value="hive"/>
									<xs:enumeration value="generic"/>
								</xs:restriction>
							</xs:simpleType>
						</xs:attribute>
					</xs:complexType>
				</xs:element>
			</xs:sequence>
			<xs:attribute name="applicationVersion" use="required">
				<xs:annotation>
					<xs:documentation>The release version of the product against which this model was built.</xs:documentation>
				</xs:annotation>
				<xs:simpleType>
					<xs:restriction base="xs:NMTOKEN">
						<xs:enumeration value="10_0"/>
					</xs:restriction>
				</xs:simpleType>
			</xs:attribute>
		</xs:complexType>
	</xs:element>
	<!---->
	<!--Utilitiies-->
	<xs:attributeGroup name="databaseObject">
		<xs:attribute name="description" type="xs:string" use="optional"/>
	</xs:attributeGroup>
	<xs:attributeGroup name="referenceableObject">
		<xs:attributeGroup ref="namedObject"/>
	</xs:attributeGroup>
	<xs:attributeGroup name="objectReference">
		<xs:attribute name="objectReferenceValue" type="objectAddressValue" use="required">
			<xs:annotation>
				<xs:documentation>Note that the reference object may reside in different catalog / schema.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>
	<xs:attributeGroup name="argument">
		<xs:attribute name="name" type="xs:string" use="optional"/>
		<xs:attributeGroup ref="databaseObject"/>
		<xs:attributeGroup ref="sqlColumn"/>
	</xs:attributeGroup>
	<xs:attributeGroup name="sqlColumn">
		<xs:attribute name="datatype" type="xs:string" use="required"/>
		<xs:attribute name="size" type="xs:long" use="optional"/>
		<xs:attribute name="precision" type="xs:long" use="optional"/>
		<xs:attribute name="scale" type="xs:long" use="optional"/>
		<xs:attribute name="isNullable" type="xs:boolean" use="optional" default="false"/>
		<xs:attribute name="defaultValue" type="xs:string" use="optional"/>
		<xs:attribute name="collationSequence" type="xs:string" use="optional"/>
	</xs:attributeGroup>
	<xs:attributeGroup name="tabularColumnReferences">
		<xs:annotation>
			<xs:documentation>references to columns only within the same table / view</xs:documentation>
		</xs:annotation>
		<xs:attribute name="columnRefsList" use="required"/>
	</xs:attributeGroup>
	<xs:attributeGroup name="uniqueKeyReference">
		<xs:attribute name="keyRef" type="externalUniqueKeyName" use="required">
			<xs:annotation>
				<xs:documentation>Note that the reference object may reside in different catalog / schema.</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>
	<xs:simpleType name="objectAddressValue">
		<xs:restriction base="xs:string"/>
	</xs:simpleType>
	<xs:simpleType name="objectReferenceValue">
		<xs:restriction base="objectAddressValue"/>
	</xs:simpleType>
	<xs:simpleType name="columnName">
		<xs:restriction base="objectReferenceValue"/>
	</xs:simpleType>
	<xs:simpleType name="columnListIndexes">
		<xs:list itemType="xs:nonNegativeInteger"/>
	</xs:simpleType>
	<xs:simpleType name="columnListSeparatorIndexes">
		<xs:list itemType="xs:nonNegativeInteger"/>
	</xs:simpleType>
	<xs:simpleType name="uniqueKeyName">
		<xs:restriction base="objectReferenceValue"/>
	</xs:simpleType>
	<xs:simpleType name="externalUniqueKeyName">
		<xs:union memberTypes="uniqueKeyName"/>
	</xs:simpleType>
	<xs:simpleType name="synonymTargetName">
		<xs:union memberTypes="tableName viewName indexName synonymName procedureName"/>
	</xs:simpleType>
	<xs:simpleType name="catalogName">
		<xs:restriction base="objectReferenceValue"/>
	</xs:simpleType>
	<xs:simpleType name="schemaName">
		<xs:restriction base="objectReferenceValue"/>
	</xs:simpleType>
	<xs:simpleType name="tableName">
		<xs:restriction base="objectReferenceValue"/>
	</xs:simpleType>
	<xs:simpleType name="viewName">
		<xs:restriction base="objectReferenceValue"/>
	</xs:simpleType>
	<xs:simpleType name="synonymName">
		<xs:restriction base="objectReferenceValue"/>
	</xs:simpleType>
	<xs:simpleType name="indexName">
		<xs:restriction base="objectReferenceValue"/>
	</xs:simpleType>
	<xs:simpleType name="procedureName">
		<xs:restriction base="objectReferenceValue"/>
	</xs:simpleType>
	<xs:group name="subroutineSignature">
		<xs:sequence/>
	</xs:group>
	<xs:attributeGroup name="externalSchemaReference">
		<xs:attribute name="externalCatalogRef" type="objectReferenceValue" use="optional">
			<xs:annotation>
				<xs:documentation>intended to be specified only if its a reference to a separate schema</xs:documentation>
			</xs:annotation>
		</xs:attribute>
		<xs:attribute name="externalSchemaRef" type="objectReferenceValue" use="optional">
			<xs:annotation>
				<xs:documentation>intended to be specified only if its a reference to a separate schema</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>
	<xs:attributeGroup name="externalTableReference">
		<xs:attributeGroup ref="externalSchemaReference"/>
		<xs:attribute name="importedTableRef" type="objectReferenceValue" use="required">
			<xs:annotation>
				<xs:documentation>The name of the (primary key) table whose columns are being imported</xs:documentation>
			</xs:annotation>
		</xs:attribute>
	</xs:attributeGroup>
	<xs:attributeGroup name="foreignKeyImportedTable">
		<xs:attributeGroup ref="externalTableReference"/>
	</xs:attributeGroup>
	<xs:attributeGroup name="columnRef">
		<xs:attribute name="columnName" type="columnName" use="required"/>
	</xs:attributeGroup>
	<xs:attributeGroup name="sortedColumnRef">
		<xs:attributeGroup ref="columnRef"/>
		<xs:attribute name="sortedOrder" default="ascending">
			<xs:annotation>
				<xs:documentation>Also often referred to as "collation sequence".  Default is "ascending", and yes it is optional here because "ascending" is often the case.</xs:documentation>
			</xs:annotation>
			<xs:simpleType>
				<xs:restriction base="xs:NMTOKEN">
					<xs:enumeration value="ascending"/>
					<xs:enumeration value="descending"/>
					<xs:enumeration value="unknown"/>
				</xs:restriction>
			</xs:simpleType>
		</xs:attribute>
	</xs:attributeGroup>
	<xs:attributeGroup name="referenceable">
		<xs:attribute name="name" type="xs:string" use="required"/>
	</xs:attributeGroup>
	<xs:group name="aliasable">
		<xs:sequence>
			<xs:element name="alias" minOccurs="0" maxOccurs="unbounded">
				<xs:complexType>
					<xs:attributeGroup ref="referenceable"/>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:group>
	<xs:group name="tableParameterGroup">
		<xs:sequence>
			<xs:element name="nestedArgument" maxOccurs="unbounded">
				<xs:complexType>
					<xs:attributeGroup ref="argument"/>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:group>
	<xs:group name="signatureSequenceGroup">
		<xs:choice/>
	</xs:group>
	<xs:group name="argumentNesting">
		<xs:sequence>
			<xs:element name="nestedArgument">
				<xs:complexType>
					<xs:sequence>
						<xs:group ref="argumentNesting" minOccurs="0" maxOccurs="unbounded"/>
					</xs:sequence>
					<xs:attributeGroup ref="argument"/>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:group>
	<xs:group name="tableSequenceGroup">
		<xs:sequence>
			<xs:element name="column" minOccurs="0" maxOccurs="unbounded">
				<xs:complexType>
					<xs:attributeGroup ref="referenceableObject"/>
					<xs:attributeGroup ref="sqlColumn"/>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:group>
	<xs:attributeGroup name="namedObject">
		<xs:attributeGroup ref="referenceable"/>
		<xs:attributeGroup ref="databaseObject"/>
	</xs:attributeGroup>
	<xs:group name="schemaParent">
		<xs:sequence>
			<xs:element name="schema" minOccurs="0" maxOccurs="unbounded">
				<xs:complexType>
					<xs:sequence>
						<xs:element name="table" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>
									<xs:group ref="tableSequenceGroup"/>
									<xs:element name="uniqueKey" minOccurs="0" maxOccurs="unbounded">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="uniqueKeyColumnRef" maxOccurs="unbounded">
													<xs:annotation>
														<xs:documentation>The name of a column  contained within the same parent table.  The order matters here and should logically match that as in the database.</xs:documentation>
													</xs:annotation>
													<xs:complexType>
														<xs:simpleContent>
															<xs:extension base="columnName">
																<xs:attributeGroup ref="columnRef"/>
															</xs:extension>
														</xs:simpleContent>
													</xs:complexType>
												</xs:element>
											</xs:sequence>
											<xs:attributeGroup ref="referenceableObject"/>
										</xs:complexType>
									</xs:element>
									<xs:element name="foreignKey" minOccurs="0" maxOccurs="unbounded">
										<xs:complexType>
											<xs:sequence>
												<xs:element name="exportedColumnRef" maxOccurs="unbounded">
													<xs:annotation>
														<xs:documentation>The names of the columns  contained within the same parent table that comprise this "exported column" list involved in this referential constraint.</xs:documentation>
													</xs:annotation>
													<xs:complexType>
														<xs:simpleContent>
															<xs:extension base="columnName">
																<xs:attributeGroup ref="columnRef"/>
															</xs:extension>
														</xs:simpleContent>
													</xs:complexType>
												</xs:element>
											</xs:sequence>
											<xs:attributeGroup ref="referenceableObject"/>
											<xs:attributeGroup ref="foreignKeyImportedTable"/>
											<xs:attribute name="importedUniqueKeyRef" type="uniqueKeyName" use="required">
												<xs:annotation>
													<xs:documentation>The name of the unique key contained within the imported table, whose columns will comprise imported columns list).</xs:documentation>
												</xs:annotation>
											</xs:attribute>
										</xs:complexType>
									</xs:element>
									<xs:element name="index" minOccurs="0" maxOccurs="unbounded">
										<xs:annotation>
											<xs:documentation>This is designed rather generically because vendor implementations vary greatly. </xs:documentation>
										</xs:annotation>
										<xs:complexType>
											<xs:sequence>
												<xs:element name="indexedColumnRef" minOccurs="0" maxOccurs="unbounded">
													<xs:annotation>
														<xs:documentation>The names of the columns contained within the table (above) that comprise the columns list for this index.</xs:documentation>
													</xs:annotation>
													<xs:complexType>
														<xs:simpleContent>
															<xs:extension base="columnName">
																<xs:attributeGroup ref="columnRef"/>
																<xs:attribute name="sortOrder" default="ascending">
																	<xs:annotation>
																		<xs:documentation>Also often referred to as "collation sequence".  Default is "ascending", and yes it is optional here because "ascending" is often the case.</xs:documentation>
																	</xs:annotation>
																	<xs:simpleType>
																		<xs:restriction base="xs:NMTOKEN">
																			<xs:enumeration value="ascending"/>
																			<xs:enumeration value="descending"/>
																			<xs:enumeration value="unknown"/>
																		</xs:restriction>
																	</xs:simpleType>
																</xs:attribute>
															</xs:extension>
														</xs:simpleContent>
													</xs:complexType>
												</xs:element>
											</xs:sequence>
											<xs:attributeGroup ref="referenceableObject"/>
											<xs:attributeGroup ref="externalContainerSchema"/>
											<xs:attribute name="isUnique" type="xs:boolean" use="required">
												<xs:annotation>
													<xs:documentation>Specifically, is the composition values unique for every "columnRefList" record.</xs:documentation>
												</xs:annotation>
											</xs:attribute>
											<xs:attribute name="storageType" use="required">
												<xs:annotation>
													<xs:documentation>Like "indexType" in JDBC</xs:documentation>
												</xs:annotation>
												<xs:simpleType>
													<xs:restriction base="xs:NMTOKEN">
														<xs:enumeration value="regular"/>
														<xs:enumeration value="hash"/>
														<xs:enumeration value="clustered"/>
														<xs:enumeration value="unknown"/>
													</xs:restriction>
												</xs:simpleType>
											</xs:attribute>
										</xs:complexType>
									</xs:element>
									<xs:element name="columnBasedForeignKey" minOccurs="0" maxOccurs="unbounded">
										<xs:annotation>
											<xs:documentation>RESERVED FOR FUTURE USE: Fallback case in case for some vendor the concept of a imported key did not pertain to the foreign key, and all we got back was a list of primary key column references. I'm not even sure if this is possible  for our conformance, but for some reason UDA kept the primary key optional in their APIs, and so this is here to accomodate for such a case/</xs:documentation>
										</xs:annotation>
										<xs:complexType>
											<xs:sequence>
												<xs:element name="importedColumnRef" maxOccurs="unbounded">
													<xs:annotation>
														<xs:documentation>The names of the columns  contained within the same parent table that comprise this "exported column" list involved in this referential constraint.</xs:documentation>
													</xs:annotation>
													<xs:complexType>
														<xs:simpleContent>
															<xs:extension base="columnName">
																<xs:attributeGroup ref="columnRef"/>
															</xs:extension>
														</xs:simpleContent>
													</xs:complexType>
												</xs:element>
												<xs:element name="exportedColumnRef" maxOccurs="unbounded">
													<xs:annotation>
														<xs:documentation>The names of the columns  contained within the same parent table that comprise this "exported column" list involved in this referential constraint.</xs:documentation>
													</xs:annotation>
													<xs:complexType>
														<xs:simpleContent>
															<xs:extension base="columnName">
																<xs:attributeGroup ref="columnRef"/>
															</xs:extension>
														</xs:simpleContent>
													</xs:complexType>
												</xs:element>
											</xs:sequence>
											<xs:attributeGroup ref="referenceableObject"/>
										</xs:complexType>
									</xs:element>
									<xs:group ref="aliasable"/>
								</xs:sequence>
								<xs:attributeGroup ref="referenceableObject"/>
							</xs:complexType>
						</xs:element>
						<xs:element name="view" minOccurs="0" maxOccurs="unbounded">
							<xs:complexType>
								<xs:sequence>
									<xs:group ref="tableSequenceGroup"/>
								</xs:sequence>
								<xs:attributeGroup ref="referenceableObject"/>
							</xs:complexType>
						</xs:element>
						<xs:element name="synonym" minOccurs="0" maxOccurs="unbounded">
							<xs:annotation>
								<xs:documentation>TO DO: Accommodate for DB2 nickanmes?</xs:documentation>
							</xs:annotation>
							<xs:complexType>
								<xs:sequence>
									<xs:group ref="aliasable"/>
								</xs:sequence>
								<xs:attributeGroup ref="referenceableObject"/>
								<xs:attribute name="externalServerRef" type="xs:string"/>
								<xs:attributeGroup ref="externalSchemaReference"/>
								<xs:attribute name="targetRef" type="synonymTargetName" use="required">
									<xs:annotation>
										<xs:documentation>The name of the targe table, view, routine or index.</xs:documentation>
									</xs:annotation>
								</xs:attribute>
							</xs:complexType>
						</xs:element>
						<xs:element name="storedProcedure" minOccurs="0" maxOccurs="unbounded">
							<xs:annotation>
								<xs:documentation>An stored procedure or a user-defined function (UDF). It is structured generically because we are really talking about an executable body of code here. The only real difference between a procedure or a UDF is that a UDF can be directly invoked in sql, whereas a procedure must be invoked via a CALL stattement in a calling block of stored code - this is captured in the "invocationType" attribute. What kind of results they can or cannot (scalar, result set, none) what kind of parameters they can take in (see the "mode" attribute) varies amongst vendor implementations, especially considering that some don't even return all this information.</xs:documentation>
							</xs:annotation>
							<xs:complexType>
								<xs:group ref="routine"/>
								<xs:attributeGroup ref="referenceableObject"/>
							</xs:complexType>
						</xs:element>
						<xs:element name="userDefinedFunction" minOccurs="0" maxOccurs="unbounded">
							<xs:annotation>
								<xs:documentation>An stored procedure or a user-defined function (UDF). It is structured generically because we are really talking about an executable body of code here. The only real difference between a procedure or a UDF is that a UDF can be directly invoked in sql, whereas a procedure must be invoked via a CALL stattement in a calling block of stored code - this is captured in the "invocationType" attribute. What kind of results they can or cannot (scalar, result set, none) what kind of parameters they can take in (see the "mode" attribute) varies amongst vendor implementations, especially considering that some don't even return all this information.</xs:documentation>
							</xs:annotation>
							<xs:complexType>
								<xs:group ref="routine"/>
								<xs:attributeGroup ref="referenceableObject"/>
							</xs:complexType>
						</xs:element>
						<xs:element name="untargettedSynonym" minOccurs="0" maxOccurs="unbounded">
							<xs:annotation>
								<xs:documentation>This option serves as a fallback for a strange case wherein the database provider does not return a "target", which is the case  for the JDBC DatabaseMetadata API interface!!!!. They still return the synonym (in their "getTables" request), just not the target. But they also may return the columns of the target table (although not the target). This loss of target  and could potentially represent a problem for consumers.  So, this option is here as a fallback. Hopefully, this hole can be restricted to ODBC sources.  Need to investigate what UDA is doing, and devise a strategy to accomodate for this.</xs:documentation>
							</xs:annotation>
							<xs:complexType>
								<xs:sequence>
									<xs:element name="column" minOccurs="0" maxOccurs="unbounded">
										<xs:complexType>
											<xs:attributeGroup ref="referenceableObject"/>
											<xs:attributeGroup ref="sqlColumn"/>
										</xs:complexType>
									</xs:element>
								</xs:sequence>
								<xs:attributeGroup ref="referenceableObject"/>
							</xs:complexType>
						</xs:element>
					</xs:sequence>
					<xs:attributeGroup ref="referenceableObject"/>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
	</xs:group>
	<!--How to read this schema: I built this schemas as if I was defining Java interfaces (not classes).  Elements and attriibute groups are all interfaces.  However, an element also represents a "get" accessor method that belongs to the interface corresponding to the containing group/element's (corresponding interface), and the element's corresponding interface serves as the method's return value. When a group is encountered, then the group(s) / element(s) containing that group corresponds to the interfaces that "extend" the interface of the group itseld. If unbounded, the element returns a collection of instances, and if optional, it can return null). Attributes correspond to methods that return primitive types. The use of "choice"s are rare, but whenever used is consider to represent a "union" type.

Sequences / choices are ones wherein if unbounded, then you can expect the "get" accessors for each of its child elements to return a collections of the interface instances that pertain to 

Take for example the "uniqueKey"  element. This corresponds to a method called "getUniqueKeys" (pluralized since it can occur multiple times) in an interface called "I_TabularObjectsContainer" (which corresponds to the "tabularObjectsContainer" group). The method would return a collection of instances of an "I_UniqueKey" interface, which in turn would have a getName and getDescription method, both of which would return strings.  Also, it would contain a method called "getColumns" method which would return a collection of I_Column interface instances.  Note that the I_TabularObjectsContainer interface above would be "extended" by an I_Table and I_View interface, which pertain to the respective elements that contain the "tabularObjectsContainer" group.-->
	<xs:attributeGroup name="externalContainerSchema">
		<xs:annotation>
			<xs:documentation>Specified only if the object is "contained" in a separate schema.</xs:documentation>
		</xs:annotation>
		<xs:attributeGroup ref="externalSchemaReference"/>
	</xs:attributeGroup>
	<xs:attributeGroup name="cmDataSource">
		<xs:attribute name="dataSourceName" type="xs:string" use="required"/>
	</xs:attributeGroup>
	<xs:group name="routine">
		<xs:sequence>
			<xs:sequence>
				<xs:element name="signature" maxOccurs="unbounded">
					<xs:annotation>
						<xs:documentation>The order of subroutineArguments must match that as in the actual signature in the database.</xs:documentation>
					</xs:annotation>
					<xs:complexType>
						<xs:choice>
							<xs:element name="argument" minOccurs="0" maxOccurs="unbounded">
								<xs:complexType>
									<xs:group ref="argumentNesting" minOccurs="0" maxOccurs="unbounded"/>
									<xs:attributeGroup ref="argument"/>
									<xs:attribute name="mode" use="required">
										<xs:simpleType>
											<xs:restriction base="xs:NMTOKEN">
												<xs:enumeration value="in"/>
												<xs:enumeration value="out"/>
												<xs:enumeration value="inout"/>
												<xs:enumeration value="ret"/>
											</xs:restriction>
										</xs:simpleType>
									</xs:attribute>
									<xs:attribute name="ordinalPosition" type="xs:long" use="optional"/>
								</xs:complexType>
							</xs:element>
						</xs:choice>
					</xs:complexType>
				</xs:element>
			</xs:sequence>
			<xs:group ref="aliasable"/>
		</xs:sequence>
	</xs:group>
</xs:schema>