• Chapter 1: Getting Started with Stylus Studio®
• Chapter 2: Editing and Querying XML
• Chapter 3: Converting Non-XML Files to XML
• Chapter 4: Working with XSLT
  • Getting Started with XSLT
  • Tutorial: Understanding How Templates Work
  • Working with Stylesheets
  • Specifying Extension Functions in Stylesheets
  • Working with Templates
  • Using Third-Party XSLT Processors
  • Validating Result Documents
  • Post-processing Result Documents
  • Generating Formatting Objects
  • Generating Scalable Vector Graphics
  • Generating Java Code for XSLT
  • Generating C# Code for XSLT
  • XSLT Instructions Quick Reference
    • xsl:apply-imports
    • xsl:apply-templates
    • xsl:attribute
    • xsl:attribute-set
    • xsl:call-template
    • xsl:character-map
    • xsl:choose
    • xsl:comment
    • xsl:copy
    • xsl:copy-of
    • xsl:decimal-format
    • xsl:element
    • xsl:fallback
    • xsl:for-each
    • xsl:for-each-group
    • xsl:function
    • xsl:if
    • xsl:import
    • xsl:import-schema
      • Format
      • Description
      • Example
    • xsl:include
    • xsl:key
    • xsl:message
    • xsl:namespace-alias
    • xsl:number
    • xsl:otherwise
    • xsl:output
    • xsl:output-character
    • xsl:param
    • xsl:preserve-space
    • xsl:processing-instruction
    • xsl:sequence
    • xsl:sort
    • xsl:strip-space
    • xsl:stylesheet
    • xsl:template
    • xsl:text
    • xsl:transform
    • xsl:value-of
    • xsl:variable
    • xsl:when
    • xsl:with-param
• Chapter 5: Creating XSLT Using the XSLT Mapper
• Chapter 6: Debugging Stylesheets
• Chapter 7: Defining XML Schemas
• Chapter 8: Defining Document Type Definitions
• Chapter 9: Writing XPath Expressions
• Chapter 10: Working with XQuery in Stylus Studio
• Chapter 11: Composing Web Service Calls
• Chapter 12: Working with WSDL Documents
• Chapter 13: Building XML Pipelines
• Chapter 14: Publishing XML Data
• Chapter 15: Integrating with Third-Party File Systems
• Chapter 16: Extending Stylus Studio
• Chapter 17: The Stylus Studio Java API
• Chapter 18: Stylus Studio GUI Reference

Home > Online Product Documentation > Table of Contents > xsl:import-schema

xsl:import-schema

Identifies schema components (top-level type definitions and top-level element and attribute declarations) that need to be available statically, that is, before any source document is available. Allows you to extend XSLT built-in types with the types defined in the imported XML Schema.

Format

<xsl:import-schema
               
  namespace = uri-reference
               
  schema-location = uri-reference>
               
  <!-- Content: xs:schema -->
               
</xsl:import-schema>
               

            

Description

The xsl:import-schema declaration identifies a namespace containing the names of the components to be imported (or indicates that components whose names are in no namespace are to be imported). The effect is that the names of top-level element and attribute declarations and type definitions from this namespace (or non-namespace) become available for use within XPath expressions in the stylesheet, and within other stylesheet constructs such as the type and as attributes of various XSLT elements.

The same schema components are available in all stylesheet modules; importing components in one stylesheet module makes them available throughout the stylesheet.

The namespace and schema-location elements are optional. The namespace attribute indicates that a schema for the given namespace is required by the stylesheet. This information may be enough on its own to enable an implementation to locate the required schema components. The namespace attribute may be omitted to indicate that a schema for names in no namespace is being imported. The zero-length string is not a valid namespace URI, and is therefore not a valid value for the namespace attribute.

The schema-location attribute is a URI Reference that describes where a schema document or other resource containing the required definitions may be found. It is likely that a schema-aware XSLT processor will be able to process a schema document found at this location.

The use of a namespace in an xsl:import-schema declaration does not by itself associate any namespace prefix with the namespace. If names from the namespace are used within the stylesheet module then a namespace declaration must be included in the stylesheet module, in the usual way.

You can also define an inline schema document using the xs:schema element as a child of xsl:import-schema. An inline schema document has the same status as an external schema document, in the sense that it acts as a hint for a source of schema components in the relevant namespace. To ensure that the inline schema document is always used, it is advisable to use a target namespace that is unique to this schema document.

Example

The following example shows an inline schema document defined using the xs:schema subelement. This schema declares a simple type local:yes-no, which the stylesheet then uses in the declaration of a variable. The example assumes the namespace declaration xmlns:local="http://localhost/ns/yes-no".

<xsl:import-schema>
               
  <xs:schema targetNamespace="http://localhost/ns/yes-no">
               
    <xs:simpleType name="local:yes-no">
               
      <xs:restriction base="xs:string">
               
        <xs:enumeration value="yes"/>
               
        <xs:enumeration value="no"/>
               
      </xs:restriction>
               
    </xs:simpleType>
               
  </xs:schema>
               
</xs:import-schema>
               
 
               
<xs:variable name="condition" select="'yes'" as="local:yes-no"/>