Edit D:\app\Administrator\product\11.2.0\dbhome

Edit D:\app\Administrator\product\11.2.0\dbhome_1\ord\xml\xsd\ordcmct.xsd

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

<!--
 Copyright (c) 2007, Oracle. All rights reserved.

NAME
     ordcmct.xsd - XML schema for DICOM constraint documents

MODIFIED   (MM/DD/YY)
   dolin       06/06/07 - doc editor comments
   myalavar    04/10/07 - doc comments
   myalavar    04/09/07 - add major_minor version
   dolin       04/03/07 - associate action with predicate instead of predicate
                          set, bug5949967
   dguo        08/01/06 - Beta release 1
   dguo        04/03/05 - Created

-->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://xmlns.oracle.com/ord/dicom/constraint_1_0" xmlns:ct="http://xmlns.oracle.com/ord/dicom/constraint_1_0" xmlns:dt="http://xmlns.oracle.com/ord/dicom/datatype_1_0" targetNamespace="http://xmlns.oracle.com/ord/dicom/constraint_1_0" elementFormDefault="qualified" attributeFormDefault="unqualified">
  <xs:import namespace="http://xmlns.oracle.com/ord/dicom/datatype_1_0" schemaLocation="http://xmlns.oracle.com/ord/dicom/datatype_1_0"/>
  <xs:annotation>
    <xs:documentation>

Introduction
      This schema defines the DICOM constraint document.
      
      A DICOM constraint document defines rules 
      to check the conformance of a DICOM content with respect to 
      the DICOM standard and other organization-wide guidelines.  
      This XML schema document defines the XML schema constraining 
      constraint documents.
      
      A constraint document defines one or more constraint rules.  
      A constraint rule is the unit of invocation for conformance checking.
      At run time, a user may invoke a PL/SQL
      or Java function to check the conformance of a DICOM content
      with respect to a particular rule. Each invocable rule
      is defined as a GLOBAL_RULE, which can reference other global 
      rules internally.  
      A constraint rule can be decomposed into individual predicates.  
      A predicate can be a logical statement, a relational statement 
      comparing values, a function call evaluation that returns a
      Boolean type, or a reference to other predicate definitions.   
      Predicate definitions are recursive. A predicate can be a logical
      statement, which includes the logical OR of two other predicates. 
      Each predicate can be a relational predicate. For example:
      (patientName=="Joe Smith"  AND patientSex=="M")
      After being translated into a predicate, the preceding example becomes:     
      <PREDICATE>
        <DESCRIPTION>An example to find an object that has
              (patientName="Joe Smith" AND patientSex=="M")
         </DESCRIPTION>
        <LOGICAL operator="and">
          <PREDICATE>
            <RELATIONAL operator="eq">
              <DICOM_ATTRIBUTE>00100010</DICOM_ATTRIBUTE>
              <XML_VALUE>
                <dt:PERSON_NAME>
                  <dt:NAME>
                    <dt:FAMILY>Smith</dt:FAMILY>
                    <dt:GIVEN>Joe</dt:GIVEN>
                  </dt:NAME>
                </dt:PERSON_NAME>
              </XML_VALUE>
            </RELATIONAL>
          </PREDICATE>
          <PREDICATE>
            <RELATIONAL operator="eq">
              <DICOM_ATTRIBUTE>00100040</DICOM_ATTRIBUTE>
              <XML_VALUE>
                <dt:CODE_STRING>M</dt:CODE_STRING>
              </XML_VALUE>
            </RELATIONAL>
          </PREDICATE>
        </LOGICAL>
      </PREDICATE>
 
      Constraint macros can be used to simplify the definition of 
      complex constraint rules. Constraint macros follow the same predicate 
      definition grammar as constraint rules. The operands in 
      constraint macros can be variables rather than fixed values, as they are 
      in constraint rules. The variables in a macro are substituted when the 
      macro is invoked. For example, you can define a macro to compare
      patient names ( patientName == $NAME ). When this macro is invoked,
      the parameter NAME is assigned the value "Joe Smith" and the macro is
      transformed into the predicate:( patientName == "Joe Smith").
      As another example, you can define a macro to check if a DICOM attribute
      is a code sequence attribute. A code sequence attribute must contain the
      mandatory child attributes, code value and code scheme. This macro
      checks whether the specified code sequence attribute contains these
      mandatory child attributes.

<GLOBAL_MACRO name="CSMacro">
        <DESCRIPTION>
          A subset of Code Sequence Macro defined in DICOM standard, 
          PS3.3-2007, Table 8.8-1
        </DESCRIPTION>
        <PARAMETER_DECLARATION>
          CodeAttr
        </PARAMETER_DECLARATION>
        <PREDICATE>
          <DESCRIPTION>Code value must not be empty</DESCRIPTION>
          <BOOLEAN_FUNC operator="notEmpty">
            <DICOM_ATTRIBUTE>${CodeAttr}.00080100
            </DICOM_ATTRIBUTE>
          </BOOLEAN_FUNC>
        </PREDICATE>
        <PREDICATE>
          <DESCRIPTION>Code scheme designator must not be empty
          </DESCRIPTION>
          <BOOLEAN_FUNC operator="notEmpty">
            <DICOM_ATTRIBUTE>${CodeAttr}.00080102
            </DICOM_ATTRIBUTE>
          </BOOLEAN_FUNC>
        </PREDICATE>
        
      </GLOBAL_MACRO>
       
      You can separate a constraint definition into multiple files.  
      Each file defines one or more constraint rules or macros.  
      A file can import the macros and constraint rules that are 
      defined in a difference file. You must specify the set of 
      external rules or macros before referencing them in a file.
      EXTERNAL_RULE_INCLUDE and EXTERNAL_MACRO_INCLUDE
      statements serve this purpose.
      
     Structure Overview
      Question mark "?" means optional items.
      Plus "+" means one or more items.
      Asterisk "*" means zero or more items.

CONFORMANCE_CONSTRAINT_DEFINITION
      DOCUMENT_HEADER?
        DOCUMENT_CHANGE_LOG+
          DOCUMENT_MODIFIER
          DOCUMENT_MODIFICATION_DATE
          DOCUMENT_VERSION?
          MODIFICATION_COMMENT?
          BASE_DOCUMENT?
          BASE_DOCUMENT_RELEASE_DATE?
          BASE_DOCUMENT_DESCRIPTION?
    EXTERNAL_MACRO_INCLUDE*
    EXTERNAL_RULE_INCLUDE*
    (GLOBAL_MACRO|GLOBAL_RULE)+
    
    GLOBAL_RULE (name) | PREDICATE_DEFINITION (name)
      DESCRIPTION?
      PREDICATE_DEFINITION*
      PREDICATE+
      ACTION (when, action)*
        
    GLOBAL_MACRO (name)
      DESCRIPTION?
      PARAMETER_DECLARATION+
      PREDICATE_DEFINITION*
      PREDICATE+
      ACTION (when, action)*
      
    PREDICATE
      DESCRIPTION?
      (LOGICAL|RELATIONAL|BOOLEAN_FUNC|INVOKE_MACRO|PREDICATE_REF|GLOBAL_RULE_REF)
      ACTION (when, action)*
      
    LOGICAL(operator)
      PREDICATE+

RELATIONAL(operator)
      (ATTRIBUTE_TAG|FUNCTION)(ATTRIBUTE_TAG|STRING_VALUE|XML_VALUE|FUNCTION)+

BOOLEAN_FUNC(operator)
      (ATTRIBUTE_TAG|STRING_VALUE|XML_VALUE|FUNCTION)*

INVOKE_MACRO
      MACRO_NAME
      PARAMETER+
        NAME
        VALUE

FUNCTION(operator)
      (ATTRIBUTE_TAG|STRING_VALUE|XML_VALUE|FUNCTION)*

</xs:documentation>
  </xs:annotation>
  <xs:element name="CONFORMANCE_CONSTRAINT_DEFINITION">
    <xs:annotation>
      <xs:documentation>A constraint document defines groups of predicates to validate the conformance of a DICOM content or a DICOM metadata document.</xs:documentation>
    </xs:annotation>
    <xs:complexType>
      <xs:sequence>
        <xs:element name="DOCUMENT_HEADER" type="dt:DOCUMENT_HEADER_T" minOccurs="0"/>
        <xs:element name="EXTERNAL_MACRO_INCLUDE" minOccurs="0" maxOccurs="unbounded">
          <xs:complexType>
            <xs:simpleContent>
              <xs:extension base="dt:SHORT_TEXT_T">
                <xs:attribute name="name" type="dt:SHORT_ID_T" use="required"/>
              </xs:extension>
            </xs:simpleContent>
          </xs:complexType>
        </xs:element>
        <xs:element name="EXTERNAL_RULE_INCLUDE" minOccurs="0" maxOccurs="unbounded">
          <xs:complexType>
            <xs:simpleContent>
              <xs:extension base="dt:SHORT_TEXT_T">
                <xs:attribute name="name" type="dt:SHORT_ID_T" use="required"/>
              </xs:extension>
            </xs:simpleContent>
          </xs:complexType>
        </xs:element>
        <xs:choice maxOccurs="unbounded">
          <xs:element name="GLOBAL_MACRO" type="PREDICATE_MACRO_T">
            <xs:key name="LOCAL_PRED_KEY1">
              <xs:selector xpath="ct:PREDICATES_DEFINITION"/>
              <xs:field xpath="@name"/>
            </xs:key>
            <xs:keyref name="LOCAL_PREDICATE_REF1" refer="ct:LOCAL_PRED_KEY1">
              <xs:selector xpath=".//ct:LOGICAL"/>
              <xs:field xpath=".//ct:PREDICATE_REF"/>
            </xs:keyref>
          </xs:element>
          <xs:element name="GLOBAL_RULE" type="PREDICATE_GROUP_T">
            <xs:key name="LOCAL_PRED_KEY2">
              <xs:selector xpath="ct:PREDICATES_DEFINITION"/>
              <xs:field xpath="@name"/>
            </xs:key>
            <xs:keyref name="LOCAL_PREDICATE_REF2" refer="ct:LOCAL_PRED_KEY2">
              <xs:selector xpath=".//ct:LOGICAL"/>
              <xs:field xpath=".//ct:PREDICATE_REF"/>
            </xs:keyref>
          </xs:element>
        </xs:choice>
      </xs:sequence>
    </xs:complexType>
    
    <xs:key name="GLOBAL_PRED1">
      <xs:selector xpath="ct:GLOBAL_RULE|ct:EXTERNAL_RULE_INCLUDE"/>
      <xs:field xpath="@name"/>
    </xs:key>
    <xs:keyref name="PREDICATE_REF1" refer="ct:GLOBAL_PRED1">
      <xs:selector xpath=".//ct:LOGICAL"/>
      <xs:field xpath="ct:GLOBAL_RULE_REF"/>
    </xs:keyref>
    <xs:key name="GLOBAL_MACRO1">
      <xs:selector xpath="ct:GLOBAL_MACRO|ct:EXTERNAL_MACRO_INCLUDE"/>
      <xs:field xpath="@name"/>
    </xs:key>
    <xs:keyref name="MACRO_USE1" refer="ct:GLOBAL_MACRO1">
      <xs:selector xpath=".//ct:INVOKE_MACRO"/>
      <xs:field xpath="ct:MACRONAME"/>
    </xs:keyref>
  </xs:element>
  <xs:complexType name="PREDICATE_GROUP_T">
    <xs:annotation>
      <xs:documentation>A predicate group is the logical AND 
      of a collection of predicates or predicate groups. 
      Each predicate group has a name that is unique within 
      its parent. Any other predicates can reference
      this predicate group by its name. The value of the reference 
      is the Boolean of the predicate group.
      Optionally, a predicate group can contain a set of 
      predicate definitions. These definitions are not part of the
      logical AND component of the predicate group, but they
      are meant to be referenced within the predicate group.
      A predicate group has an optional action element that
      specifies what action to take when the predicate evaluates to true
      or false.
      </xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:element name="DESCRIPTION" type="dt:SHORT_TEXT_T" minOccurs="0"/>
      <xs:element name="PREDICATES_DEFINITION" type="PREDICATE_GROUP_T" minOccurs="0" maxOccurs="unbounded"/>
      <xs:choice maxOccurs="unbounded">
        <xs:element name="PREDICATE" type="PREDICATE_T"/>
      </xs:choice>
      <xs:element name="ACTION" type="ACTION_T" nillable="true" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="name" type="dt:SHORT_ID_T"/>
  </xs:complexType>
  <xs:complexType name="PREDICATE_MACRO_T">
    <xs:annotation>
      <xs:documentation>
      </xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:element name="DESCRIPTION" type="dt:SHORT_TEXT_T" minOccurs="0"/>
      <xs:element name="PARAMETER_DECLARATION" type="dt:SHORT_NAME_T" nillable="false" maxOccurs="unbounded"/>
      <xs:element name="PREDICATES_DEFINITION" type="PREDICATE_GROUP_T" minOccurs="0" maxOccurs="unbounded"/>
      <xs:choice maxOccurs="unbounded">
        <xs:element name="PREDICATE" type="PREDICATE_T"/>
      </xs:choice>
      <xs:element name="ACTION" type="ACTION_T" nillable="true" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="name" type="dt:SHORT_ID_T"/>
  </xs:complexType>
  <xs:complexType name="ACTION_T">
    <xs:annotation>
      <xs:documentation>
        A type to specify an action for a predicate value.
        The "when" attribute specifies the predicate value.
        The "action" attribute specifies the type of action.
        When the action type is "log", "warning", or "error",
        the string value of this attribute is returned
        in a log file or as part of warning or error message.
      </xs:documentation>
    </xs:annotation>
    <xs:simpleContent>
      <xs:extension base="dt:SHORT_TEXT_T">
        <xs:attribute name="when" type="xs:boolean" use="required"/>
        <xs:attribute name="action" type="ACTION_LIST_T" use="required"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>
  <xs:simpleType name="ACTION_LIST_T">
    <xs:restriction base="xs:token">
      <xs:enumeration value="none"/>
      <xs:enumeration value="log"/>
      <xs:enumeration value="warning"/>
      <xs:enumeration value="error"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="PREDICATE_T">
    <xs:sequence>
      <xs:element name="DESCRIPTION" type="dt:SHORT_TEXT_T" minOccurs="0"/>
      <xs:choice>
        <xs:element name="LOGICAL" type="LOGICAL_PREDICATE_T"/>
        <xs:element name="RELATIONAL" type="RELATIONAL_PREDICATE_T"/>
        <xs:element name="BOOLEAN_FUNC" type="BOOLEAN_FUNC_PREDICATE_T"/>
        <xs:element name="INVOKE_MACRO" type="MACRO_USE_T"/>
        <xs:element name="PREDICATE_REF" type="xs:IDREF"/>
        <xs:element name="GLOBAL_RULE_REF" type="xs:IDREF"/>
      </xs:choice>
      <xs:element name="ACTION" type="ACTION_T" nillable="true" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="MACRO_USE_T">
    <xs:sequence>
      <xs:element name="MACRO_NAME" type="xs:IDREF"/>
      <xs:element name="PARAMETER" maxOccurs="unbounded">
        <xs:complexType>
          <xs:sequence maxOccurs="unbounded">
            <xs:element name="NAME" type="dt:SHORT_STRING_T" nillable="false"/>
            <xs:element name="VALUE" type="dt:SHORT_TEXT_T"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="LOGICAL_PREDICATE_T">
    <xs:sequence maxOccurs="unbounded">
      
      <xs:element name="PREDICATE" type="PREDICATE_T"/>
    </xs:sequence>
    <xs:attribute name="operator" use="required">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:annotation>
            <xs:documentation>
              A derive B   ( (NOT A)  OR B )
            </xs:documentation>
          </xs:annotation>
          <xs:enumeration value="and"/>
          <xs:enumeration value="or"/>
          <xs:enumeration value="derive"/>
          <xs:enumeration value="not"/>
          <xs:enumeration value="xor"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="RELATIONAL_PREDICATE_T">
    <xs:sequence>
      <xs:choice>
        <xs:element name="ATTRIBUTE_TAG" type="dt:VALUE_LOCATOR_MACRO_T"/>
        <xs:element name="FUNCTION" type="FUNCTION_T"/>
      </xs:choice>
      <xs:choice maxOccurs="unbounded">
        <xs:element name="ATTRIBUTE_TAG" type="dt:VALUE_LOCATOR_MACRO_T"/>
        <xs:element name="STRING_VALUE" type="dt:MIXED_TEXT_T"/>
        <xs:element name="XML_VALUE" type="dt:ATTR_VALUE_T"/>
        <xs:element name="FUNCTION" type="FUNCTION_T"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="operator" use="required">
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:annotation>
            <xs:documentation>
            gt     greater than
            ge     greater than or equal to
            lt     less than
            le     less than or equal to
            eq     equal to
            ne     not equal to
            in     value in the set of
            match  attribute value matches pattern
              The second operand must be a Java regular expression 
              pattern as specified by JDK1.5 java.lang.String class 
              documentation. The first operator should be a DICOM 
              attribute tag. The tag should identify an attribute
              that belongs to one of the following value representation 
              types:
                 AE, AS, AT, CS, DA, DT, LO, LT, PN,
                 SH, ST, TM, UI and UT
            Note that the operands must be compatible with each other 
            when a predicate invokes relational operator. For example, 
            (patientAge > 005M) is a valid predicate. But 
            (patientAge > "Joe Smith") is not a valid predicate, because 
            the operand "Joe Smith" cannot be cast into an instance 
            of the patient age attribute.
            </xs:documentation>
          </xs:annotation>
          <xs:enumeration value="gt"/>
          <xs:enumeration value="ge"/>
          <xs:enumeration value="lt"/>
          <xs:enumeration value="le"/>
          <xs:enumeration value="eq"/>
          <xs:enumeration value="ne"/>
          <xs:enumeration value="in"/>
          <xs:enumeration value="match"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="BOOLEAN_FUNC_PREDICATE_T">
    <xs:choice maxOccurs="unbounded" minOccurs="0">
      <xs:element name="ATTRIBUTE_TAG" type="dt:VALUE_LOCATOR_MACRO_T"/>
      <xs:element name="STRING_VALUE" type="dt:MIXED_TEXT_T"/>
      <xs:element name="XML_VALUE" type="dt:ATTR_VALUE_T"/>
      <xs:element name="FUNCTION" type="FUNCTION_T"/>
    </xs:choice>
    <xs:attribute name="operator" use="required">
      <xs:annotation>
        <xs:documentation>
          To allow future extensions, the set of allowed operators for Boolean 
          function types are not fixed. Operator names are case-sensitive.
          The current values for this operator 
          are: "notEmpty", "occurs", "true", and "false". 
          "occurs" takes a single operand ATTRIBUTE_TAG, 
          and returns true if an attribute matching the tag exists. (The 
          attribute value can be an empty string or null. For example, 
          a DICOM type 2 attribute may be empty.); Otherwise, it returns
          false.
          "notEmpty" takes a single operand ATTRIBUTE_TAG. 
          It returns true if an attribute matching the tag exists in 
          a DICOM content and has a non-null value (e.g. a DICOM type 1 
          attribute); otherwise, it returns false.
          "true" takes no operand and it always returns true.
          "false" takes no operand and it always returns false.
        </xs:documentation>
      </xs:annotation>
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:maxLength value="64"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:complexType>
  <xs:complexType name="FUNCTION_T">
    <xs:choice minOccurs="0" maxOccurs="unbounded">
      <xs:element name="ATTRIBUTE_TAG" type="dt:VALUE_LOCATOR_MACRO_T"/>
      <xs:element name="STRING_VALUE" type="dt:MIXED_TEXT_T"/>
      <xs:element name="XML_VALUE" type="dt:ATTR_VALUE_T"/>
      <xs:element name="FUNCTION" type="FUNCTION_T"/>
    </xs:choice>
    <xs:attribute name="operator" use="required">
      <xs:annotation>
        <xs:documentation>
          To allow future extensions, the set of allowed operators for 
          function types are not fixed. Operator names are case-sensitive.
          This feature is not supported for Oracle Database 11g Release 1.
        </xs:documentation>
      </xs:annotation>
      <xs:simpleType>
        <xs:restriction base="xs:token">
          <xs:maxLength value="64"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:complexType>
</xs:schema>

Ms-Dos/Windows Unix Write backup

jsp File Browser version 1.2 by www.vonloesch.de