<?xml version="1.0" encoding="utf-8"?>
<xs:schema targetNamespace="http://www.ivoa.net/xml/ADQL/v1.04" xmlns:tns="http://www.ivoa.net/xml/ADQL/v1.04" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:stc="http://www.ivoa.net/xml/STC/stc-v1.20.xsd" xmlns:reg="http://www.ivoa.net/xml/STC/STCregion/v1.20" xmlns:crd="http://www.ivoa.net/xml/STC/STCcoords/v1.20" xmlns:vr="http://www.ivoa.net/xml/VOResource/v0.10" elementFormDefault="qualified">

	<xs:element name="Select" type="tns:selectType">
		<xs:annotation>
			<xs:documentation>The only permitted root element of a query, the SELECT element</xs:documentation>
		</xs:annotation>
	</xs:element>

	<xs:complexType name="selectType">
		<xs:annotation>
			<xs:documentation>The SELECT part of a query</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Allow" type="tns:selectionOptionType" minOccurs="0"/>
			<xs:element name="Restrict" type="tns:selectionLimitType" minOccurs="0"/>
			<xs:element name="SelectionList" type="tns:selectionListType"/>
			<xs:element name="InTo" type="tns:intoType" minOccurs="0"/>
			<xs:element name="From" type="tns:fromType" minOccurs="0"/>
			<xs:element name="Where" type="tns:whereType" minOccurs="0"/>
			<xs:element name="GroupBy" type="tns:groupByType" minOccurs="0"/>
			<xs:element name="Having" type="tns:havingType" minOccurs="0"/>
			<xs:element name="OrderBy" type="tns:orderExpressionType" minOccurs="0"/>
			<xs:element name="StartComment" type="xs:string" minOccurs="0"/>
			<xs:element name="EndComment" type="xs:string" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="selectionOptionType">
		<xs:annotation>
			<xs:documentation>Option of selecting all or distinct elements in a query</xs:documentation>
		</xs:annotation>
		<xs:attribute name="Option" type="tns:allOrDistinctType" default="All"/>
	</xs:complexType>

	<xs:simpleType name="allOrDistinctType">
		<xs:annotation>
			<xs:documentation>Enumeration for All and Distinct options</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="All"/>
			<xs:enumeration value="DISTINCT"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="selectionLimitType">
		<xs:annotation>
			<xs:documentation>Represents the TOP and OFFSET part of a query</xs:documentation>
		</xs:annotation>
		<xs:attribute name="Top" type="xs:unsignedInt"/>
		<xs:attribute name="Offset" type="xs:unsignedInt"/>
	</xs:complexType>

	<xs:complexType name="selectionListType">
		<xs:annotation>
			<xs:documentation>List of items to be selected in the Query</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Item" type="tns:selectionItemType" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="selectionItemType" abstract="true">
		<xs:annotation>
			<xs:documentation>The base type for any of items to be selected in a query</xs:documentation>
		</xs:annotation>
	</xs:complexType>

	<xs:complexType name="intoType">
		<xs:annotation>
			<xs:documentation>Represents the SQL INTO expression</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="TableName" type="xs:string"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="fromType">
		<xs:annotation>
			<xs:documentation>Represents the From part of the query</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Table" type="tns:fromTableType" minOccurs="1" maxOccurs="1"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="fromTableType" abstract="true">
		<xs:annotation>
			<xs:documentation>The base type for all tables used in the From clause of the query</xs:documentation>
		</xs:annotation>
	</xs:complexType>

	<xs:complexType name="whereType">
		<xs:annotation>
			<xs:documentation>Represents the Where part of the query</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Condition" type="tns:searchType"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="searchType" abstract="true">
		<xs:annotation>
			<xs:documentation>The base type for searches in Where and Having clauses of the query</xs:documentation>
		</xs:annotation>
		<xs:attribute name="not" type="xs:boolean" default="false"/>
	</xs:complexType>

	<xs:complexType name="groupByType">
		<xs:annotation>
			<xs:documentation>Represents the Group By expression part of a query</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Column" type="tns:columnReferenceType" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="havingType">
		<xs:annotation>
			<xs:documentation>Represents the Having expression part of a query</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Condition" type="tns:searchType"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="orderExpressionType">
		<xs:annotation>
			<xs:documentation>List of expressions in which order the results should be provided</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Item" type="tns:orderType" maxOccurs="unbounded"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="orderType">
		<xs:annotation>
			<xs:documentation>Represents the ORDER BY part of a query</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Expression" type="tns:scalarExpressionType"/>
			<xs:element name="Order" type="tns:orderOptionType" minOccurs="0"/>
		</xs:sequence>
	</xs:complexType>

	<xs:complexType name="orderOptionType">
		<xs:annotation>
			<xs:documentation>Option for setting the direction for Order By </xs:documentation>
		</xs:annotation>
		<xs:attribute name="Direction" type="tns:orderDirectionType" use="required"/>
	</xs:complexType>

	<xs:simpleType name="orderDirectionType">
		<xs:annotation>
			<xs:documentation>Ascending or Descending order of an Order by term</xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="ASC"/>
			<xs:enumeration value="DESC"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="aliasSelectionItemType" mixed="false">
		<xs:annotation>
			<xs:documentation>Used to select an expression as a new alias column</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:selectionItemType">
				<xs:sequence>
					<xs:element name="Expression" type="tns:scalarExpressionType"/>
				</xs:sequence>
				<xs:attribute name="As" type="xs:string" use="optional"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="allSelectionItemType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represent all columns as in Select * query</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:selectionItemType"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="scalarExpressionType" abstract="true" mixed="false">
		<xs:annotation>
			<xs:documentation>The base type for a scalar expression</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:selectionItemType"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="closedExprType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents an expression inside a bracket such as (a) </xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:scalarExpressionType">
				<xs:sequence>
					<xs:element name="Arg" type="tns:scalarExpressionType"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="binaryExprType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents a binary expression such as a+b</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:scalarExpressionType">
				<xs:sequence>
					<xs:element name="Arg" type="tns:scalarExpressionType" minOccurs="2" maxOccurs="2"/>
				</xs:sequence>
				<xs:attribute name="Oper" type="xs:string" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="unaryExprType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents an unary expression such as -(a.ra)</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:scalarExpressionType">
				<xs:sequence>
					<xs:element name="Arg" type="tns:scalarExpressionType"/>
				</xs:sequence>
				<xs:attribute name="Oper" type="xs:string" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="columnReferenceType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents a column. Table attribute represents a table alias name.</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:scalarExpressionType">
				<xs:attribute name="Table" type="xs:string" use="required"/>
				<xs:attribute name="Name" type="xs:string" use="required"/>
				<xs:attribute name="CaseSensitive" type="xs:boolean" default="false"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="xpathReferenceType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents an xpath</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:scalarExpressionType">
				<xs:attribute name="xpath" type="xs:string"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="literalType" abstract="true">
		<xs:annotation>
			<xs:documentation>The base type for all literals</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:scalarExpressionType"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="functionType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represent a function</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:scalarExpressionType">
				<xs:sequence>
				        <xs:element name="Args" type="tns:scalarExpressionType" minOccurs="0" maxOccurs="unbounded"/>
				</xs:sequence>
				<xs:attribute name="Name" type="xs:string" use="required"/>
                        </xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="aggregateFunctionType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents an aggregate function</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:scalarExpressionType">
				<xs:sequence>
					<xs:element name="Allow" type="tns:selectionOptionType" minOccurs="0"/>
					<xs:element name="Arg" type="tns:selectionItemType"/>
				</xs:sequence>
				<xs:attribute name="Name" type="xs:string" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="numberType" abstract="true" mixed="false">
		<xs:annotation>
			<xs:documentation>The base type for all numbers</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:literalType">
				<xs:attribute name="unit" type="xs:string" use="optional"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="realType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents a real number</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:numberType">
				<xs:attribute name="value" type="xs:double" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="integerType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents an integer</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:numberType">
				<xs:attribute name="value" type="xs:integer" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="nonNumericType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents a literal of non-number type, such as string, timestamp, boolean and so on</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:literalType">
				<xs:attribute name="value" type="xs:string" use="required"/>
				<xs:attribute name="type" type="xs:string"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="tableType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents a table with its archive name (optioanl), its name (required) and its alias name (required) </xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:fromTableType">
				<xs:attribute name="ShortName" type="vr:ShortName" use="optional"/>
				<xs:attribute name="Identifier" type="vr:IdentifierURI" use="optional"/>
				<xs:attribute name="Name" type="xs:string" use="required"/>
				<xs:attribute name="Alias" type="xs:string" use="required"/>
				<xs:attribute name="CaseSensitive" type="xs:boolean" default="false"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="subqueryTableType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents a subquery table</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:fromTableType">
                  		<xs:sequence>
					<xs:element name="selection" type="tns:selectType"/>
                  		</xs:sequence>
				<xs:attribute name="Alias" type="xs:string" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="joinTableType" abstract="true" mixed="false">
		<xs:annotation>
			<xs:documentation>The base type for a JOIN expression</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:fromTableType">
				<xs:sequence>
					<xs:element name="LeftTable" type="tns:fromTableType"/>
					<xs:element name="RightTable" type="tns:fromTableType"/>
					<xs:element name="Condition" type="tns:joinConditionType"/>
				</xs:sequence>
				<xs:attribute name="Qualifier" type="tns:joinTableQualifierType" default="INNER"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="joinConditionType" abstract="true" mixed="false">
		<xs:annotation>
			<xs:documentation>abstract for JOIN condition</xs:documentation>
		</xs:annotation>
	</xs:complexType>

	<xs:complexType name="crossJoin" mixed="false">
		<xs:annotation>
			<xs:documentation>represent Cross Join conidtion</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:joinConditionType"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="onJoin" mixed="false">
		<xs:annotation>
			<xs:documentation>represents JOIN ON condition</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:joinConditionType">
				<xs:sequence>
					<xs:element name="Condition" type="tns:comparisonPredType"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="naturalJoin" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents NATURAL JOIN condition</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:joinConditionType"/>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="usingJoin" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents SQL JOIN USING condition</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:joinConditionType">
				<xs:sequence>
					<xs:element name="Column" type="tns:columnReferenceType" minOccurs="0" maxOccurs="unbounded"/>
				</xs:sequence>
                        </xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:simpleType name="joinTableQualifierType">
		<xs:annotation>
			<xs:documentation>Denotes the type of a Join operation 
                        LEFT OUTER, RIGHT OUTER, FULL OUTER, INNER </xs:documentation>
		</xs:annotation>
		<xs:restriction base="xs:string">
			<xs:enumeration value="LEFT"/>
			<xs:enumeration value="RIGHT"/>
			<xs:enumeration value="FULL"/>
			<xs:enumeration value="INNER"/>
		</xs:restriction>
	</xs:simpleType>

	<xs:complexType name="intersectionSearchType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents expressions like A And B</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:searchType">
				<xs:sequence>
					<xs:element name="Condition" type="tns:searchType" minOccurs="2" maxOccurs="2"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="unionSearchType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents expressions like A Or B</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:searchType">
				<xs:sequence>
					<xs:element name="Condition" type="tns:searchType" minOccurs="2" maxOccurs="2"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="likePredType" mixed="false">
		<xs:annotation>
			<xs:documentation>The Like expression of a query</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:searchType">
				<xs:sequence>
					<xs:element name="Arg" type="tns:scalarExpressionType"/>
					<xs:element name="Pattern" type="tns:nonNumericType"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="closedSearchType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents expressions like (A)</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:searchType">
				<xs:sequence>
					<xs:element name="Condition" type="tns:searchType"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="comparisonPredType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents the Comparison of two expressions</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:searchType">
				<xs:sequence>
					<xs:element name="Arg" type="tns:scalarExpressionType" minOccurs="2" maxOccurs="2"/>
				</xs:sequence>
				<xs:attribute name="Comparison" type="xs:string" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="betweenPredType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents the Between expression of a query</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:searchType">
				<xs:sequence>
					<xs:element name="Arg" type="tns:scalarExpressionType" minOccurs="3" maxOccurs="3"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="regionSearchType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents the Regions such as circle in Where clause</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:searchType">
				<xs:sequence>
					<xs:element name="frame" type="stc:spaceFrameType" minOccurs="0"/>
					<xs:element name="area" type="stc:spatialIntervalType"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="ExistsPredType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents SQL EXISTS expression</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:searchType">
				<xs:sequence>
					<xs:element name="selection" type="tns:selectType"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="AnyPredType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents SQL ANY expression</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:searchType">
				<xs:sequence>
					<xs:element name="Arg" type="tns:scalarExpressionType" minOccurs="1" maxOccurs="1"/>
					<xs:element name="selection" type="tns:selectType" minOccurs="1" maxOccurs="1"/>
				</xs:sequence>
   				<xs:attribute name="Comparison" type="xs:string" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="AllPredType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents SQL ALL expression</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:searchType">
				<xs:sequence>
					<xs:element name="Arg" type="tns:scalarExpressionType" minOccurs="1" maxOccurs="1"/>
					<xs:element name="selection" type="tns:selectType" minOccurs="1" maxOccurs="1"/>
				</xs:sequence>
   				<xs:attribute name="Comparison" type="xs:string" use="required"/>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>


	<xs:complexType name="booleanValueFunctionType" mixed="false">
		<xs:annotation>
			<xs:documentation>The base type for a boolean function</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:searchType">
				<xs:sequence>
					<xs:element name="Function" type="tns:functionType"/>
				</xs:sequence>
                        </xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="inclusiveSearchType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents SQL IN expression</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:searchType">
				<xs:sequence>
					<xs:element name="Expression" type="tns:scalarExpressionType"/>
					<xs:element name="Set" type="tns:inclusionSetType"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="inclusionSetType" abstract="true">
		<xs:annotation>
			<xs:documentation>The base type for selection set in a SQL IN expression</xs:documentation>
		</xs:annotation>
	</xs:complexType>

	<xs:complexType name="subQuerySetType" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents the subquery in a SQL IN expression</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:inclusionSetType">
				<xs:sequence>
					<xs:element name="selection" type="tns:selectType"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

	<xs:complexType name="constantListSet" mixed="false">
		<xs:annotation>
			<xs:documentation>Represents a list of constants provided for a SQL IN expression</xs:documentation>
		</xs:annotation>
		<xs:complexContent mixed="false">
			<xs:extension base="tns:inclusionSetType">
				<xs:sequence>
					<xs:element name="Item" type="tns:literalType" maxOccurs="unbounded"/>
				</xs:sequence>
			</xs:extension>
		</xs:complexContent>
	</xs:complexType>

</xs:schema>

<!--

####################################################################################

Change from ADQL-v1.04.xsd (Yuji SHIRASAKI yuji.shirasaki-at-nao.ac.jp)

- removed type definitions
  
  + crossJoinTableType
  + conditionalJoinTableType
  + naturalJoinTableType
  + usingJoinTableType
 
- added

  + joinConditionType (abstract)
  + crossJoin
  + onJoin
  + naturalJoin
  + usingJoin
  + existsPredType
  + anyPredType
  + allPredType

- modified

  + joinTableType: abstract="true" removed. Condition element is added, Quealifier
    attribute is added.
  + jointTableQualifierType is renamed to joinTableQualifierType

####################################################################################

Change from ADQL-v1.0.xsd (Yuji SHIRASAKI yuji.shirasaki-at-nao.ac.jp)

change/new/remove for each element:

- removed type definitions

  + binaryOperatorType  
  + unaryOperatorType
  + atomType
  + stringType
  + trigonometricFunctionType
  + trigonometricFunctionNameType
  + mathFunctionType
  + mathFunctionNameType
  + aggregateFunctionNameType
  + comparisonType
  + archiveTableType
  + xMatchTableAliasType
  + includeTableType
  + dropTableType
  + xMatchType
  + notLikePredType
  + exclusiveSearchType
  + notBetweenPredType
  + inverseSearchType
  + userDefinedFunctionType
  + ArrayOfFrmoTableType

- added

  + xpathReferenceType
  + nonNumericType
  + subqueryTableType
  + crossJoinTableType
  + conditionalJoinTableType
  + naturalJoinTableType
  + usingJoinTableType
  + booleanValueFunctionType

- changed

  + selectionLimitType: offset attribute is added
  + fromType: maxOccurs of Table element is changed from "unbounded" to "1"
  + searchType: not attribute is added
  + columnReferenceType: CaseSensitive attribute is added, xpathName attribute is removed.
  + functionType: abstract="true" is removed, Allow element is removed, 
    number of apparence of an Args element changed, Name attribute is added.
  + aggregateFunctionType: changed to extend scalarExpressionType, Name attribute is added,
    Allow and Arg elements is added.
  + numberType: unit attribute is added.
  + integerType: type of value attribute is changed from xs:long to xs:integer.
  + tableType: attributes ShortName, Identifier and CaseSensitive are added, xpathName is 
    removed
  + joinTableType: defined as abstract, LeftTable and RightTable elements are added,
    Qualifier, Tables, Condition elements are removed
  + joinTableQualifierType: "_OUTER" suffix is removed, "CROSS" is removed.
  + likePredType: type of Pattern element is changed to nonNumericType.
  + regionSearchType: ???

-->

