voruby 1.1.1 → 2.0.0

data/lib/voruby/adql/1.0/adql.rb

@@ -0,0 +1,2418 @@
+require 'voruby/adql/support'
+require 'voruby/stc/1.10/region'
+include VORuby::STC::V1_10::Region
+
+module VORuby
+  module ADQL
+    module V1_0
+      include XMLUtilities
+      
+      def element_root(name, type=nil)
+        element(name, nil, {:include_xsi => true, :type => type || self.class.xml_type})
+      end
+      
+      # The base type for any of items to be selected in a query
+      class SelectionItem
+        include SerializableToXml
+        
+        def to_xml(name=nil)
+          element_root(name)
+        end
+      end
+      
+      # The base type for a scalar expression
+      class ScalarExpression < SelectionItem; end
+      
+      # Represents an expression inside a bracket
+      class ClosedExpr < ScalarExpression
+        attr_reader :arg
+        
+        def self.xml_type; 'closedExprType' end
+        
+        def initialize(a)
+          super()
+          self.arg = a
+        end
+        
+        def arg=(a)
+          raise_argument_required_error('argument') if !a
+          raise_type_mismatch_error(a, ScalarExpression)
+          @arg = a
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          el.add_element(self.arg.to_xml('Arg'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def to_s
+          "(#{self.arg})"
+        end
+        
+        def ==(e)
+          self.arg == e.arg
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            xml_to_obj(REXML::XPath.first(root, 'x:Arg', {'x' => obj_ns.uri}))
+          )
+        end
+      end
+      
+      # Used for expressing operations like A+B
+      class BinaryOperator < Enumeration
+        def self.choices; ['+', '-', '*', '/'] end
+      end
+      
+      # Represents a binary expression such as a+b
+      class BinaryExpr < ScalarExpression
+        attr_reader :arg1, :oper, :arg2
+        
+        def self.xml_type; 'binaryExprType' end
+        
+        def initialize(arg1, oper, arg2)
+          super()
+          self.arg1 = arg1
+          self.oper = oper
+          self.arg2 = arg2
+        end
+        
+        def arg1=(a)
+          raise_argument_required_error('argument 1') if !a
+          raise_type_mismatch_error(a, ScalarExpression)
+          @arg1 = a
+        end
+        
+        def oper=(o)
+          raise_argument_required_error('operator') if !o
+          
+          o = BinaryOperator.new(o) if o.is_a?(::String)
+          raise_type_mismatch_error(o, BinaryOperator)
+          
+          @oper = o
+        end
+        
+        def arg2=(a)
+          raise_argument_required_error('argument 2') if !a
+          raise_type_mismatch_error(a, ScalarExpression)
+          @arg2 = a
+        end
+        
+        def to_s
+          "#{self.arg1} #{self.oper} #{self.arg2}"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.attributes["#{obj_ns.prefix}:Oper"] = self.oper.to_s
+          el.add_element(self.arg1.to_xml('Arg'))
+          el.add_element(self.arg2.to_xml('Arg'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def ==(e)
+          self.arg1 == e.arg1 and
+          self.oper == e.oper and
+          self.arg2 == e.arg2
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          args = REXML::XPath.match(root, 'x:Arg', {'x' => obj_ns.uri}).collect{ |a| xml_to_obj(a) }
+          self.new(
+            args[0],
+            BinaryOperator.new(root.attributes.get_attribute_ns(obj_ns.uri, 'Oper').value),
+            args[1]
+          )
+        end
+      end
+      
+      # Operators for expressing a single element operation
+      class UnaryOperator < Enumeration
+        def self.choices; ['+', '-'] end
+      end
+      
+      # Represents an unary expression such as -(a.ra)
+      class UnaryExpr < ScalarExpression
+        attr_reader :arg, :oper
+        
+        def self.xml_type; 'unaryExprType' end
+        
+        def initialize(oper, arg)
+          super()
+          self.oper = oper
+          self.arg = arg
+        end
+        
+        def oper=(o)
+          raise_argument_required_error('operator') if !o
+          
+          o = UnaryOperator.new(o) if o.is_a?(::String)
+          raise_type_mismatch_error(o, UnaryOperator)
+          
+          @oper = o
+        end
+        
+        def arg=(a)
+          raise_argument_required_error('argument') if !a
+          raise_type_mismatch_error(a, ScalarExpression)
+          @arg = a
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.attributes["#{obj_ns.prefix}:Oper"] = self.oper.to_s
+          el.add_element(self.arg.to_xml('Arg'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def to_s
+          "#{self.oper}(#{self.arg})"
+        end
+        
+        def ==(e)
+          self.oper == e.oper and
+          self.arg == e.arg
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+
+          self.new(
+            UnaryOperator.new(root.attributes.get_attribute_ns(obj_ns.uri, 'Oper').value),
+            xml_to_obj(REXML::XPath.first(root, 'x:Arg', {'x' => obj_ns.uri}))
+          )
+        end
+      end
+      
+      # Represents a column
+      class ColumnReference < ScalarExpression
+        attr_reader :table, :name, :xpath_name
+        
+        def self.xml_type; 'columnReferenceType' end
+        
+        def initialize(table, name, xpath_name=nil)
+          super()
+          self.table = table
+          self.name = name
+          self.xpath_name = xpath_name
+        end
+        
+        def table=(t)
+          raise_argument_required_error('table') if !t or t.strip == ''
+          @table = t.to_s
+        end
+        
+        def name=(n)
+          raise_argument_required_error('name') if !n or n.strip == ''
+          @name = n.to_s
+        end
+        
+        def xpath_name=(n)
+          @xpath_name = n ? n.to_s : nil
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.attributes["#{obj_ns.prefix}:Table"] = self.table
+          el.attributes["#{obj_ns.prefix}:Name"] = self.name
+          el.attributes["#{obj_ns.prefix}:xpathName"] = self.xpath_name if self.xpath_name
+          
+          el
+        end
+        
+        def to_s
+          "#{self.table}.#{self.name}"
+        end
+        
+        def ==(r)
+          self.table == r.table and
+          self.name == r.name and
+          self.xpath_name == r.xpath_name
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          xpath_name = root.attributes.get_attribute_ns(obj_ns.uri, 'xpathName')
+          self.new(
+            root.attributes.get_attribute_ns(obj_ns.uri, 'Table').value,
+            root.attributes.get_attribute_ns(obj_ns.uri, 'Name').value,
+            xpath_name ? xpath_name.value : nil
+          )
+        end
+      end
+      
+      # The base type for all literals
+      class Literal
+        include SerializableToXml
+        
+        attr_reader :value
+        
+        def initialize(v)
+          self.value = v
+        end
+        
+        def value=(v)
+          @value = v
+        end
+        
+        def ==(l)
+          self.value == l.value
+        end
+        
+        def to_s
+          self.value.to_s
+        end
+        
+        def to_xml(name=nil)
+          el = element_root(name)
+          el.attributes["#{obj_ns.prefix}:Value"] = self.value.to_s
+          el
+        end
+      end
+      
+      # The base type for all numbers
+      class NumberLiteral < Literal; end
+      
+      # Represents a real number
+      class RealLiteral < NumberLiteral
+        def self.xml_type; 'realType' end
+        
+        def value=(v)
+          raise_argument_required_error('value') if v == nil
+          super(Float(v))
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          self.new(
+            Float(root.attributes.get_attribute_ns(obj_ns.uri, 'Value').value)
+          )
+        end
+      end
+      
+      # Represents an integer
+      class IntegerLiteral < NumberLiteral
+        def self.xml_type; 'integerType' end
+        
+        def value=(v)
+          raise_argument_required_error('value') if v == nil
+          super(Integer(v))
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          self.new(
+            Integer(root.attributes.get_attribute_ns(obj_ns.uri, 'Value').value)
+          )
+        end
+      end
+      
+      # Represents a string literal
+      class StringLiteral < Literal
+        def self.xml_type; 'stringType' end
+        
+        def value=(v)
+          raise_argument_required_error('value') if v == nil
+          super(v.to_s)
+        end
+        
+        def to_s
+          "'#{super}'"
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          self.new(
+            root.attributes.get_attribute_ns(obj_ns.uri, 'Value').value
+          )
+        end
+      end
+      
+      # Encapsulates basic literals such as Strings, Integers and Real numbers
+      class Atom < ScalarExpression
+        attr_reader :literal, :unit
+        
+        def self.xml_type; 'atomType' end
+        
+        def initialize(l, u=nil)
+          super()
+          self.literal = l
+          self.unit = u
+        end
+        
+        def literal=(l)
+          raise_argument_required_error('literal') if !l
+          
+          if !l.is_a?(Literal)
+            if l.is_a?(::String)
+              l = StringLiteral.new(l)
+            elsif l.is_a?(Float)
+              l = RealLiteral.new(l)
+            elsif l.is_a?(Fixnum)
+              l = IntegerLiteral.new(l)
+            end
+          end
+          raise_type_mismatch_error(l, Literal)
+          
+          @literal = l
+        end
+        
+        def unit=(u)
+          @unit = u ? u.to_s : nil
+        end
+        
+        def ==(a)
+          self.literal == a.literal and
+          self.unit == a.unit
+        end
+        
+        def to_s
+          self.literal.to_s
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.add_element(self.literal.to_xml('Literal'))
+          
+          if self.unit
+            unit_el = element('Unit')
+            unit_el.text = self.unit.to_s
+            el.add_element(unit_el)
+          end
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          unit_el = REXML::XPath.first(root, 'x:Unit', {'x' => obj_ns.uri})
+          unit = unit_el ? unit_el.text : nil
+          
+          self.new(
+            xml_to_obj(REXML::XPath.first(root, 'x:Literal', {'x' => obj_ns.uri})),
+            unit
+          )
+        end
+      end
+      
+      # Enumeration for All and Distinct options
+      class AllOrDistinct < Enumeration
+        def self.choices; ['All', 'DISTINCT'] end
+      end
+      
+      # Option of selecting all or distinct elements in a query
+      class SelectionOption
+        include SerializableToXml
+        
+        attr_reader :option
+        
+        def self.xml_type; 'selectionOptionType' end
+        
+        def initialize(option)
+          self.option = option
+        end
+        
+        def option=(o)
+          raise_argument_required_error('option') if !o
+          
+          o = AllOrDistinct.new(o) if o.is_a?(::String)
+          raise_type_mismatch_error(o, AllOrDistinct)
+          
+          @option = o
+        end
+        
+        def ==(o)
+          self.option == o.option
+        end
+        
+        def to_s
+          self.option.to_s
+        end
+        
+        def to_xml(name=nil)
+          el = element_root(name)
+          el.attributes["#{obj_ns.prefix}:Option"] = self.option.to_s
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            AllOrDistinct.new(root.attributes.get_attribute_ns(obj_ns.uri, 'Option').value)
+          )
+        end
+      end
+      
+      # The base type for a function
+      class Function < ScalarExpression
+        attr_reader :arg, :allow, :name
+        
+        def initialize(arg, allow=nil)
+          super()
+          self.arg = arg
+          self.allow = allow
+        end
+        
+        def arg=(a)
+          raise_argument_required_error('argument') if !a
+          raise_type_mismatch_error(a, SelectionItem)
+          @arg = a
+        end
+        
+        def allow=(a)
+          raise_type_mismatch_error(a, SelectionOption) if a
+          @allow = a
+        end
+        
+        def ==(f)
+          self.name == f.name and
+          self.arg == f.arg and
+          self.allow == f.allow
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.attributes["#{obj_ns.prefix}:Name"] = self.name.to_s
+          el.add_element(self.allow.to_xml('Allow')) if self.allow
+          el.add_element(self.arg.to_xml('Arg'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def to_s
+          f = "#{self.name}(#{self.arg})"
+          f = "#{self.allow} #{f}" if self.allow
+          f
+        end
+      end
+      
+      # Enumeration of allowed trigonometric functions
+      class TrigonometricFunctionName < Enumeration
+        def self.choices; ['SIN', 'COS', 'TAN', 'COT', 'ASIN', 'ACOS', 'ATAN', 'ATAN2'] end
+      end
+      
+      # Represents a trigonometric function
+      class TrigonometricFunction < Function
+        def self.xml_type; 'trigonometricFunctionType' end
+        
+        def initialize(name, arg, allow=nil)
+          super(arg, allow)
+          self.name = name
+        end
+        
+        def name=(n)
+          raise_argument_required_error('trigonometric function name') if !n
+          
+          n = TrigonometricFunctionName.new(n) if n.is_a?(::String)
+          raise_type_mismatch_error(n, TrigonometricFunctionName)
+          
+          @name = n
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          allow_el = REXML::XPath.first(root, 'x:Allow', {'x' => obj_ns.uri})
+          self.new(
+            TrigonometricFunctionName.new(root.attributes.get_attribute_ns(obj_ns.uri, 'Name').value),
+            xml_to_obj(REXML::XPath.first(root, 'x:Arg', {'x' => obj_ns.uri})),
+            allow_el ? xml_to_obj(allow_el) : nil
+          )
+        end
+      end
+      
+      # Enumeration of allowed math functions
+       class MathFunctionName < Enumeration
+         def self.choices
+           ['ABS', 'CEILING', 'DEGREES', 'EXP', 'FLOOR',
+            'LOG', 'PI', 'POWER', 'RADIANS', 'SQRT',
+            'SQUARE', 'LOG10', 'RAND', 'ROUND', 'TRUNCATE']
+         end
+       end
+      
+      # Represents a math function
+      class MathFunction < Function
+        def self.xml_type; 'mathFunctionType' end
+        
+        def initialize(name, arg, allow=nil)
+          super(arg, allow)
+          self.name = name
+        end
+        
+        def name=(n)
+          raise_argument_required_error('math function name') if !n
+          
+          n = MathFunctionName.new(n) if n.is_a?(::String)
+          raise_type_mismatch_error(n, MathFunctionName)
+          
+          @name = n
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          allow_el = REXML::XPath.first(root, 'x:Allow', {'x' => obj_ns.uri})
+          self.new(
+            MathFunctionName.new(root.attributes.get_attribute_ns(obj_ns.uri, 'Name').value),
+            xml_to_obj(REXML::XPath.first(root, 'x:Arg', {'x' => obj_ns.uri})),
+            allow_el ? xml_to_obj(allow_el) : nil
+          )
+        end
+      end
+      
+      # Enumeration of allowed aggregate functions
+      class AggregateFunctionName < Enumeration
+        def self.choices; ['AVG', 'MIN', 'MAX', 'SUM', 'COUNT'] end
+      end
+      
+      # Represents an aggregate function
+      class AggregateFunction < Function
+        def self.xml_type; 'aggregateFunctionType' end
+        
+        def initialize(name, arg, allow=nil)
+          super(arg, allow)
+          self.name = name
+        end
+        
+        def name=(n)
+          raise_argument_required_error('aggregate function name') if !n
+          
+          n = AggregateFunctionName.new(n) if n.is_a?(::String)
+          raise_type_mismatch_error(n, AggregateFunctionName)
+          
+          @name = n
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          allow_el = REXML::XPath.first(root, 'x:Allow', {'x' => obj_ns.uri})
+          self.new(
+            AggregateFunctionName.new(root.attributes.get_attribute_ns(obj_ns.uri, 'Name').value),
+            xml_to_obj(REXML::XPath.first(root, 'x:Arg', {'x' => obj_ns.uri})),
+            allow_el ? xml_to_obj(allow_el) : nil
+          )
+        end
+      end
+      
+      # Represents user defined function expressions
+      class UserDefinedFunction < ScalarExpression
+        class ListOfScalarExpression < TypedArray
+          def self.restricted_to; [ScalarExpression] end
+        end
+        
+        attr_reader :name, :params
+        
+        def self.xml_type; 'userDefinedFunctionType' end
+        
+        def initialize(name, params=nil)
+          self.name = name
+          self.params = params
+        end
+        
+        def name=(n)
+          raise_argument_required_error('name') if !n
+          @name = n.to_s
+        end
+        
+        def params=(ps)
+          if ps
+            ps = UserDefinedFunction::ListOfScalarExpression.new(ps) if ps.class == Array
+            raise_type_mismatch_error(ps, UserDefinedFunction::ListOfScalarExpression)
+          end
+          
+          @params = ps
+        end
+        
+        def ==(f)
+          self.name == f.name and
+          self.params == f.params
+        end
+        
+        def to_s
+          s = "#{self.name}("
+          s << self.params.collect{ |p| p.to_s }.join(', ') if self.params
+          s << ')'
+          s
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          name_el = REXML::Element.new("#{obj_ns.prefix}:Name")
+          name_el.text = self.name
+          el.add_element(name_el)
+          
+          self.params.each{ |p| el.add_element(p.to_xml('Params'))} if self.params
+          
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          params_el = REXML::XPath.match(root, 'x:Params', {'x' => obj_ns.uri})
+          params = params_el ?
+            UserDefinedFunction::ListOfScalarExpression.new(params_el.collect{ |pel| xml_to_obj(pel) }) :
+            nil
+          
+          self.new(
+            REXML::XPath.first(root, 'x:Name', {'x' => obj_ns.uri}).text,
+            params
+          )
+        end
+      end
+      
+      # Used to select an expression as a new alias column
+      class AliasSelectionItem < SelectionItem
+        attr_reader :expression, :as
+        
+        def self.xml_type; 'aliasSelectionItemType' end
+        
+        def initialize(expression, as=nil)
+          self.expression = expression
+          self.as = as
+        end
+        
+        def expression=(e)
+          raise_argument_required_error('expression') if !e
+          raise_type_mismatch_error(e, ScalarExpression)
+          @expression = e
+        end
+        
+        def as=(a)
+          @as = a ? a.to_s : nil
+        end
+        
+        def ==(a)
+          self.expression == a.expression and
+          self.as == a.as
+        end
+        
+        def to_s
+          a = self.expression.to_s
+          a = "#{a} AS #{as}" if self.as
+          a
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.attributes["#{obj_ns.prefix}:As"] = self.as if self.as
+          el.add_element(self.expression.to_xml('Expression'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          as = root.attributes.get_attribute_ns(obj_ns.uri, 'As')
+          self.new(
+            xml_to_obj(REXML::XPath.first(root, 'x:Expression', {'x' => obj_ns.uri})),
+            as ? as.value : nil
+          )
+        end
+      end
+      
+      # Represent all columns as in Select * query
+      class AllSelectionItem < SelectionItem
+        def self.xml_type; 'allSelectionItemType' end
+        
+        def to_s; '*' end
+        
+        def to_xml(name=nil)
+          super(name)
+        end
+        
+        def ==(a)
+          self.class == a.class
+        end
+        
+        def self.from_xml(xml)
+          self.new
+        end
+      end
+      
+      # The Comparison operators such as Less-than or More-than, etc
+      class Comparison < Enumeration
+        def self.choices; ['=', '<>', '>', '>=', '<', '<='] end
+      end
+      
+      # The base type for all tables used in the From clause of the query
+      class FromTable
+        include SerializableToXml
+        
+        def to_xml(name=nil)
+          element_root(name)
+        end
+      end
+      
+      # Same as a Table with an additional archive name
+      class ArchiveTable < FromTable
+        attr_reader :archive, :name, :table_alias
+        
+        def self.xml_type; 'archiveTableType' end
+        
+        def initialize(archive, name, table_alias=nil)
+          self.archive = archive
+          self.name = name
+          self.table_alias = table_alias
+        end
+        
+        def archive=(a)
+          raise_argument_required_error('archive') if !a or a.to_s.strip == ''
+          @archive = a.to_s
+        end
+        
+        def name=(n)
+          raise_argument_required_error('name') if !n or n.to_s.strip == ''
+          @name = n.to_s
+        end
+        
+        def table_alias=(a)
+          @table_alias = a ? a.to_s : nil
+        end
+        
+        def ==(t)
+          self.archive == t.archive and
+          self.name == t.name and
+          self.table_alias == t.table_alias
+        end
+        
+        def to_s
+          t = "#{self.archive}:#{self.name}"
+          t = "#{t} #{self.table_alias}" if self.table_alias
+          t
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.attributes["#{obj_ns.prefix}:Archive"] = self.archive
+          el.attributes["#{obj_ns.prefix}:Name"] = self.name
+          el.attributes["#{obj_ns.prefix}:Alias"] = self.table_alias if self.table_alias
+          
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          table_alias = root.attributes.get_attribute_ns(obj_ns.uri, 'Alias')
+          self.new(
+            root.attributes.get_attribute_ns(obj_ns.uri, 'Archive').value,
+            root.attributes.get_attribute_ns(obj_ns.uri, 'Name').value,
+            table_alias ? table_alias.value : nil
+          )
+        end
+      end
+      
+      # Represents a table with its name and its alias name
+      class Table < FromTable
+        attr_reader :name, :table_alias, :xpath_name
+        
+        def self.xml_type; 'tableType' end
+        
+        def initialize(name, table_alias=nil, xpath_name=nil)
+          self.name = name
+          self.table_alias = table_alias
+          self.xpath_name = xpath_name
+        end
+        
+        def name=(n)
+          raise_argument_required_error('name') if !n or n.to_s.strip == ''
+          @name = n.to_s
+        end
+        
+        def table_alias=(a)
+          @table_alias = a ? a.to_s : nil
+        end
+        
+        def xpath_name=(p)
+          @xpath_name = p ? p.to_s : nil
+        end
+        
+        def ==(t)
+          self.name == t.name and
+          self.table_alias == t.table_alias and
+          self.xpath_name == t.xpath_name
+        end
+        
+        def to_s
+          t = self.name
+          t = "#{t} #{self.table_alias}" if self.table_alias
+          t
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.attributes["#{obj_ns.prefix}:Name"] = self.name
+          el.attributes["#{obj_ns.prefix}:Alias"] = self.table_alias if self.table_alias
+          el.attributes["#{obj_ns.prefix}:xpathName"] = self.xpath_name if self.xpath_name
+          
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          table_alias = root.attributes.get_attribute_ns(obj_ns.uri, 'Alias')
+          xpath_name = root.attributes.get_attribute_ns(obj_ns.uri, 'xpathName')
+          self.new(
+            root.attributes.get_attribute_ns(obj_ns.uri, 'Name').value,
+            table_alias ? table_alias.value : nil,
+            xpath_name ? xpath_name.value : nil
+          )
+        end
+      end
+      
+      # Denotes the type of a Join operation
+      class JointTableQualifier < Enumeration
+        def self.choices; ['LEFT_OUTER', 'RIGHT_OUTER', 'FULL_OUTER', 'INNER', 'CROSS'] end
+      end
+      
+      # Represents SQL JOIN expression
+      class JoinTable < FromTable
+        class ListOfFromTable < TypedArray
+          def self.restricted_to; [FromTable] end
+          def self.minimum_length; 1 end
+        end
+        
+        attr_reader :qualifier, :tables, :condition
+        
+        def self.xml_type; 'joinTableType' end
+        
+        def initialize(qualifier, tables, condition)
+          self.qualifier = qualifier
+          self.tables = tables
+          self.condition = condition
+        end
+        
+        def qualifier=(q)
+          raise_argument_required_error('qualifier') if !q
+          
+          q = JointTableQualifier.new(q) if q.is_a?(String)
+          raise_type_mismatch_error(q, JointTableQualifier)
+          
+          @qualifier = q
+        end
+        
+        def tables=(ts)
+          raise_argument_required_error('tables') if !ts
+          
+          ts = JoinTable::ListOfFromTable.new(ts) if ts.class == Array
+          raise_type_mismatch_error(ts, JoinTable::ListOfFromTable)
+          
+          @tables = ts
+        end
+        
+        def condition=(c)
+          raise_argument_required_error('condition') if !c
+          raise_type_mismatch_error(c, ComparisonPred)
+          @condition = c
+        end
+        
+        def ==(t)
+          self.qualifier == t.qualifier and
+          self.tables == t.tables and
+          self.condition == t.condition
+        end
+        
+        def to_s
+          "#{self.qualifier} #{self.tables.collect{ |t| t.to_s}.join(', ')} ON #{self.condition}"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          qualifier = REXML::Element.new("#{obj_ns.prefix}:Qualifier")
+          qualifier.text = self.qualifier.to_s
+          el.add_element(qualifier)
+          
+          self.tables.collect{ |t| el.add_element(t.to_xml('Table')) }
+          
+          el.add_element(self.condition.to_xml('Condition'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            JointTableQualifier.new(REXML::XPath.first(root, 'x:Qualifier', {'x' => obj_ns.uri}).text),
+            JoinTable::ListOfFromTable.new(
+              REXML::XPath.match(root, 'x:Table', {'x' => obj_ns.uri}).collect{ |tel| xml_to_obj(tel) }
+            ),
+            xml_to_obj(REXML::XPath.first(root, 'x:Condition', {'x' => obj_ns.uri}))
+          )
+        end
+      end
+      
+      # The base type for all table inclusion or drop types used in a cross match expression
+      class XMatchTableAlias
+        include SerializableToXml
+        
+        attr_reader :name
+        
+        def initialize(name)
+          self.name = name
+        end
+        
+        def name=(n)
+          raise_argument_required_error('name') if !n or n.to_s.strip == ''
+          @name = n.to_s
+        end
+        
+        def ==(t)
+          self.name == t.name
+        end
+        
+        def to_xml(name=nil)
+          el = element_root(name)
+          el.attributes["#{obj_ns.prefix}:Name"] = self.name
+          el
+        end
+        
+        def self.from_xml(xml=nil)
+          root = element_from(xml)
+          self.new(root.attributes.get_attribute_ns(obj_ns.uri, 'Name'))
+        end
+      end
+      
+      # Used for adding a table for the Xmatch operation
+      class IncludeTable < XMatchTableAlias
+        def self.xml_type; 'includeTableType' end
+        
+        def to_s
+          self.name
+        end
+      end
+      
+      # Used for avoiding a table in Xmatch
+      class DropTable < XMatchTableAlias
+        def self.xml_type; 'dropTableType' end
+        
+        def to_s
+          "!#{self.name}"
+        end
+      end
+      
+      # The base type for searches in Where and Having clauses of the query
+      class Search
+        include SerializableToXml
+        
+        def to_xml(name=nil)
+          element_root(name)
+        end
+      end
+      
+      # Represents expressions like A And B
+      class IntersectionSearch < Search
+        attr_reader :condition1, :condition2
+        
+        def self.xml_type; 'intersectionSearchType' end
+        
+        def initialize(condition1, condition2)
+          self.condition1 = condition1
+          self.condition2 = condition2
+        end
+        
+        def condition1=(c)
+          raise_argument_required_error('condition 1') if !c
+          raise_type_mismatch_error(c, Search)
+          @condition1 = c
+        end
+        
+        def condition2=(c)
+          raise_argument_required_error('condition 2') if !c
+          raise_type_mismatch_error(c, Search)
+          @condition2 = c
+        end
+        
+        def ==(s)
+          self.condition1 == s.condition1 and
+          self.condition2 == s.condition2
+        end
+        
+        def to_s
+          "#{self.condition1} AND #{self.condition2}"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.add_element(self.condition1.to_xml('Condition'))
+          el.add_element(self.condition2.to_xml('Condition'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          conds = REXML::XPath.match(root, 'x:Condition', {'x' => obj_ns.uri})
+          self.new(xml_to_obj(conds[0]), xml_to_obj(conds[1]))
+        end
+      end
+      
+      # Represents expressions like A Or B
+      class UnionSearch < Search
+        attr_reader :condition1, :condition2
+        
+        def self.xml_type; 'unionSearchType' end
+        
+        def initialize(condition1, condition2)
+          self.condition1 = condition1
+          self.condition2 = condition2
+        end
+        
+        def condition1=(c)
+          raise_argument_required_error('condition 1') if !c
+          raise_type_mismatch_error(c, Search)
+          @condition1 = c
+        end
+        
+        def condition2=(c)
+          raise_argument_required_error('condition 2') if !c
+          raise_type_mismatch_error(c, Search)
+          @condition2 = c
+        end
+        
+        def ==(s)
+          self.condition1 == s.condition1 and
+          self.condition2 == s.condition2
+        end
+        
+        def to_s
+          "#{self.condition1} OR #{self.condition2}"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.add_element(self.condition1.to_xml('Condition'))
+          el.add_element(self.condition2.to_xml('Condition'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          conds = REXML::XPath.match(root, 'x:Condition', {'x' => obj_ns.uri})
+          self.new(xml_to_obj(conds[0]), xml_to_obj(conds[1]))
+        end
+      end
+      
+      # A cross match expression
+      class XMatch < Search
+        attr_reader :tables, :nature, :sigma
+        
+        def self.xml_type; 'xMatchType' end
+        
+        class XMatchTableAliasList < TypedArray
+          def self.restricted_to; [XMatchTableAlias] end
+          def self.minimum_length; 2 end
+        end
+        
+        def initialize(tables, nature, sigma)
+          self.tables = tables
+          self.nature = nature
+          self.sigma = sigma
+        end
+        
+        def tables=(ts)
+          raise_argument_required_error('tables') if !ts
+          
+          ts = XMatchTableAliasList.new(ts) if ts.class == Array
+          raise_type_mismatch_error(ts, XMatchTableAliasList)
+          
+          @tables = ts
+        end
+        
+        def nature=(n)
+          raise_argument_required_error('nature') if !n
+          
+          n = Comparison.new(n) if n.is_a?(::String)
+          raise_type_mismatch_error(n, Comparison)
+          
+          @nature = n
+        end
+        
+        def sigma=(s)
+          raise_argument_required_error('sigma') if !s
+          
+          if s.is_a?(Fixnum)
+            s = IntegerLiteral.new(s)
+          elsif s.is_a?(Float)
+            s = RealLiteral.new(s)
+          end
+          raise_type_mismatch_error(s, NumberLiteral)
+          
+          @sigma = s
+        end
+        
+        def ==(m)
+          self.tables == m.tables and
+          self.nature == m.nature and
+          self.sigma == m.sigma
+        end
+        
+        def to_s
+          "XMATCH(#{self.tables.collect{ |t| t.to_s }.join(', ')}) #{self.nature} #{self.sigma}"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          self.tables.each{ |t| el.add_element(t.to_xml('Table')) }
+          
+          nature = element_root('Nature', 'comparisonType')
+          nature.text = self.nature.to_s
+          el.add_element(nature)
+          
+          el.add_element(self.sigma.to_xml('Sigma'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            XMatchTableAliasList.new(
+              REXML::XPath.match(root, 'x:Table', {'x' => obj_ns.uri}).collect{ |el| xml_to_obj(el) }
+            ),
+            Comparison.new(REXML::XPath.first(root, 'x:Nature', {'x' => obj_ns.uri}).text),
+            xml_to_obj(REXML::XPath.first(root, 'x:Sigma', {'x' => obj_ns.uri}))
+          )
+        end
+      end
+      
+      # The Like expression of a query
+      class LikePred < Search
+        attr_reader :arg, :pattern
+        
+        def self.xml_type; 'likePredType' end
+        
+        def initialize(arg, pattern)
+          self.arg = arg
+          self.pattern = pattern
+        end
+        
+        def arg=(a)
+          raise_argument_required_error('argument') if !a
+          raise_type_mismatch_error(a, ScalarExpression)
+          @arg = a
+        end
+        
+        def pattern=(p)
+          raise_argument_required_error('pattern') if !p
+          
+          p = Atom.new(p) if !p.is_a?(Atom)
+          raise_type_mismatch_error(p, Atom)
+          
+          @pattern = p
+        end
+        
+        def ==(p)
+          self.arg == p.arg and
+          self.pattern == p.pattern
+        end
+        
+        def to_s
+          "#{arg} LIKE #{pattern}"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.add_element(self.arg.to_xml('Arg'))
+          el.add_element(self.pattern.to_xml('Pattern'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            xml_to_obj(REXML::XPath.first(root, 'x:Arg', {'x' => obj_ns.uri})),
+            xml_to_obj(REXML::XPath.first(root, 'x:Pattern', {'x' => obj_ns.uri}))
+          )
+        end
+      end
+      
+      # The Not Like expression of a query
+      class NotLikePred < LikePred
+        def self.xml_type; 'notLikePredType' end
+        
+        def to_s
+          "#{arg} NOT LIKE #{pattern}"
+        end
+      end
+      
+      # Represents expressions like (A)
+      class ClosedSearch < Search
+        attr_reader :condition
+        
+        def self.xml_type; 'closedSearchType' end
+        
+        def initialize(condition)
+          self.condition = condition
+        end
+        
+        def condition=(c)
+          raise_argument_required_error('condition') if !c
+          raise_type_mismatch_error(c, Search)
+          @condition = c
+        end
+        
+        def ==(s)
+          self.condition == s.condition
+        end
+        
+        def to_s
+          "(#{self.condition})"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          el.add_element(self.condition.to_xml('Condition'))
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(xml_to_obj(REXML::XPath.first(root, 'x:Condition', {'x' => obj_ns.uri})))
+        end
+      end
+      
+      # Represents the Comparison of two expressions
+      class ComparisonPred < Search
+        attr_reader :arg1, :comparison, :arg2
+        
+        def self.xml_type; 'comparisonPredType' end
+        
+        def initialize(arg1, comparison, arg2)
+          self.arg1 = arg1
+          self.comparison = comparison
+          self.arg2 = arg2
+        end
+        
+        def arg1=(a)
+          raise_argument_required_error('argument 1') if !a
+          raise_type_mismatch_error(a, ScalarExpression)
+          @arg1 = a
+        end
+        
+        def comparison=(c)
+          raise_argument_required_error('comparison') if !c
+          
+          c = Comparison.new(c) if c.is_a?(String)
+          raise_type_mismatch_error(c, Comparison)
+          
+          @comparison = c
+        end
+        
+        def arg2=(a)
+          raise_argument_required_error('argument 2') if !a
+          raise_type_mismatch_error(a, ScalarExpression)
+          @arg2 = a
+        end
+        
+        def ==(p)
+          self.arg1 == p.arg1 and
+          self.comparison == p.comparison and
+          self.arg2 == p.arg2
+        end
+        
+        def to_s
+          "#{self.arg1} #{self.comparison} #{self.arg2}"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.attributes["#{obj_ns.prefix}:Comparison"] = self.comparison.to_s
+          el.add_element(self.arg1.to_xml('Arg'))
+          el.add_element(self.arg2.to_xml('Arg'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          args = REXML::XPath.match(root, 'x:Arg', {'x' => obj_ns.uri})
+          self.new(
+            xml_to_obj(args[0]),
+            Comparison.new(root.attributes.get_attribute_ns(obj_ns.uri, 'Comparison').value),
+            xml_to_obj(args[1])
+          )
+        end
+      end
+      
+      # Represents the Between expression of a query
+      class BetweenPred < Search
+        attr_reader :arg1, :arg2, :arg3
+        
+        def self.xml_type; 'betweenPredType' end
+        
+        def initialize(arg1, arg2, arg3)
+          self.arg1 = arg1
+          self.arg2 = arg2
+          self.arg3 = arg3
+        end
+        
+        def arg1=(a)
+          raise_argument_required_error('argument 1') if !a
+          raise_type_mismatch_error(a, ScalarExpression)
+          @arg1 = a
+        end
+        
+        def arg2=(a)
+          raise_argument_required_error('argument 2') if !a
+          raise_type_mismatch_error(a, ScalarExpression)
+          @arg2 = a
+        end
+        
+        def arg3=(a)
+          raise_argument_required_error('argument 3') if !a
+          raise_type_mismatch_error(a, ScalarExpression)
+          @arg3 = a
+        end
+        
+        def ==(p)
+          self.arg1 == p.arg1 and
+          self.arg2 == p.arg2 and
+          self.arg3 == p.arg3
+        end
+        
+        def to_s
+          "#{self.arg1} BETWEEN #{self.arg2} AND #{self.arg3}"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.add_element(self.arg1.to_xml('Arg'))
+          el.add_element(self.arg2.to_xml('Arg'))
+          el.add_element(self.arg3.to_xml('Arg'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          args = REXML::XPath.match(root, 'x:Arg', {'x' => obj_ns.uri})
+          self.new(
+            xml_to_obj(args[0]),
+            xml_to_obj(args[1]),
+            xml_to_obj(args[2])
+          )
+        end
+      end
+      
+      # Represents the Not Between expression of a query
+      class NotBetweenPred < BetweenPred
+        def self.xml_type; 'notBetweenPredType' end
+        
+        def to_s
+          "#{self.arg1} NOT BETWEEN #{self.arg2} AND #{self.arg3}"
+        end
+      end
+      
+      # Represents expressions like Not A
+      class InverseSearch < Search
+        attr_reader :condition
+        
+        def self.xml_type; 'inverseSearchType' end
+        
+        def initialize(condition)
+          self.condition = condition
+        end
+        
+        def condition=(c)
+          raise_argument_required_error('condition') if !c
+          raise_type_mismatch_error(c, Search)
+          @condition = c
+        end
+        
+        def ==(p)
+          self.condition == p.condition
+        end
+        
+        def to_s
+          "NOT #{condition}"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          el.add_element(self.condition.to_xml('Condition'))
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(xml_to_obj(REXML::XPath.first(root, 'x:Condition', {'x' => obj_ns.uri})))
+        end
+      end
+      
+      # Represents the Regions such as circle in Where clause
+      class RegionSearch < Search
+        attr_reader :region
+        
+        def self.xml_type; 'regionSearchType' end
+        
+        def initialize(region)
+          self.region = region
+        end
+        
+        def region=(r)
+          raise_argument_required_error('region') if !r
+          raise_type_mismatch_error(r, RegionType)
+          @region = r
+        end
+        
+        def ==(s)
+          self.region == s.region
+        end
+        
+        def to_s
+          "REGION(#{self.region})"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          reg_ns = obj_ns('VORuby::STC::V1_10::Region')
+          el.add_namespace(reg_ns.prefix, reg_ns.uri)
+          
+          reg = el.add_element(self.region.to_xml('Region'))
+          
+          raise "unable to determine xsi:type of region #{self.region.inspect}" if !self.region.class.respond_to?(:xml_type)
+          reg.attributes["#{XSI_NAMESPACE.prefix}:type"] = "#{reg_ns.prefix}:#{self.region.class.xml_type}"
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            xml_to_obj(REXML::XPath.first(root, 'x:Region', {'x' => obj_ns('VORuby::STC::V1_10::Region').uri}))
+          )
+        end
+      end
+      
+      # Represents the Having expression part of a query
+      class Having
+        include SerializableToXml
+        
+        attr_reader :condition
+        
+        def self.xml_type; 'havingType' end
+        
+        def initialize(condition)
+          self.condition = condition
+        end
+        
+        def condition=(c)
+          raise_argument_required_error('condition') if !c
+          raise_type_mismatch_error(c, Search)
+          @condition = c
+        end
+        
+        def ==(h)
+          self.condition == h.condition
+        end
+        
+        def to_s
+          "HAVING #{self.condition.to_s}"
+        end
+        
+        def to_xml(name=nil)
+          el = element_root(name)
+          
+          el.add_element(self.condition.to_xml('Condition'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            xml_to_obj(REXML::XPath.first(root, 'x:Condition', {'x' => obj_ns.uri}))
+          )
+        end
+      end
+      
+      # Represents the Group By expression part of a query
+      class GroupBy
+        include SerializableToXml
+        
+        class ColumnList < TypedArray
+          def self.restricted_to; [ColumnReference] end
+          def self.minimum_length; 1 end
+        end
+        
+        attr_reader :columns
+        
+        def self.xml_type; 'groupByType' end
+        
+        def initialize(columns)
+          self.columns = columns
+        end
+        
+        def columns=(cs)
+          raise_argument_required_error('columns') if !cs
+          
+          cs = GroupBy::ColumnList.new(cs) if cs.class == Array
+          raise_type_mismatch_error(cs, GroupBy::ColumnList)
+          
+          @columns = cs
+        end
+        
+        def ==(g)
+          self.columns == g.columns
+        end
+        
+        def to_s
+          "GROUP BY #{self.columns.collect{ |c| c.to_s }.join(', ')}"
+        end
+        
+        def to_xml(name=nil)
+          el = element_root(name)
+          
+          self.columns.each{ |c| el.add_element(c.to_xml('Column')) }
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            GroupBy::ColumnList.new(
+              REXML::XPath.match(root, 'x:Column', {'x' => obj_ns.uri}).collect{ |cel| xml_to_obj(cel) }
+            )
+          )
+        end
+      end
+      
+      # Represents the Where part of the query
+      class Where
+        include SerializableToXml
+        
+        attr_reader :condition
+        
+        def self.xml_type; 'whereType' end
+        
+        def initialize(condition)
+          self.condition = condition
+        end
+        
+        def condition=(c)
+          raise_argument_required_error('condition') if !c
+          raise_type_mismatch_error(c, Search)
+          @condition = c
+        end
+        
+        def ==(w)
+          self.condition == w.condition
+        end
+        
+        def to_s
+          "WHERE #{self.condition}"
+        end
+        
+        def to_xml(name=nil)
+          el = element_root(name)
+          
+          el.add_element(self.condition.to_xml('Condition'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            xml_to_obj(REXML::XPath.first(root, 'x:Condition', {'x' => obj_ns.uri}))
+          )
+        end
+      end
+      
+      # Represents the From part of the query
+      class From
+        include SerializableToXml
+        
+        attr_reader :tables
+        
+        def self.xml_type; 'fromType' end
+        
+        class TableList < TypedArray
+          def self.restricted_to; [FromTable] end
+          def self.minimum_length; 1 end
+        end
+        
+        def initialize(tables)
+          self.tables = tables
+        end
+        
+        def tables=(ts)
+          raise_argument_required_error('tables') if !ts
+          
+          ts = From::TableList.new(ts) if ts.class == Array
+          raise_type_mismatch_error(ts, From::TableList)
+          
+          @tables = ts
+        end
+        
+        def ==(f)
+          self.tables == f.tables
+        end
+        
+        def to_s
+          "FROM #{self.tables.collect{ |t| t.to_s }.join(', ')}"
+        end
+        
+        def to_xml(name=nil)
+          el = element_root(name)
+          
+          self.tables.each { |t| el.add_element(t.to_xml('Table')) }
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            From::TableList.new(
+              REXML::XPath.match(root, 'x:Table', {'x' => obj_ns.uri}).collect{ |tel| xml_to_obj(tel) }
+            )
+          )
+        end
+      end
+      
+      # List of items to be selected in the Query
+      class SelectionList
+        include SerializableToXml
+        
+        attr_reader :items
+        
+        class ItemList < TypedArray
+          def self.restricted_to; [SelectionItem] end
+          def self.minimum_length; 1 end
+        end
+        
+        def self.xml_type; 'selectionListType' end
+        
+        def initialize(items)
+          self.items = items
+        end
+        
+        def items=(is)
+          raise_argument_required_error('items') if !is
+          
+          is = SelectionList::ItemList.new(is) if is.class == Array
+          raise_type_mismatch_error(is, SelectionList::ItemList)
+          
+          @items = is
+        end
+        
+        def ==(l)
+          self.items == l.items
+        end
+        
+        def to_s
+          self.items.collect{ |i| i.to_s }.join(', ')
+        end
+        
+        def to_xml(name=nil)
+          el = element_root(name)
+          
+          self.items.collect{ |i| el.add_element(i.to_xml('Item')) }
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            SelectionList::ItemList.new(
+              REXML::XPath.match(root, 'x:Item', {'x' => obj_ns.uri}).collect{ |iel| xml_to_obj(iel) }
+            )
+          )
+        end
+      end
+      
+      # Represents the TOP part of a query
+      class SelectionLimit
+        include SerializableToXml
+        
+        attr_reader :top
+        
+        def self.xml_type; 'selectionLimitType' end
+        
+        def initialize(top)
+          self.top = top
+        end
+        
+        def top=(t)
+          raise_argument_required_error('top') if !t
+          @top = Integer(t)
+        end
+        
+        def ==(l)
+          self.top == l.top
+        end
+        
+        def to_s
+          "TOP #{self.top}"
+        end
+        
+        def to_xml(name=nil)
+          el = element_root(name)
+          el.attributes["#{obj_ns.prefix}:Top"] = self.top.to_s
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          self.new(
+            Integer(
+              root.attributes.get_attribute_ns(obj_ns.uri, 'Top').value
+            )
+          )
+        end
+      end
+      
+      # Represents the SQL INTO expression
+      class Into
+        include SerializableToXml
+        
+        attr_reader :table_name
+        
+        def self.xml_type; 'intoType' end
+        
+        def initialize(table_name)
+          self.table_name = table_name
+        end
+        
+        def table_name=(n)
+          raise_argument_required_error('table name') if !n
+          @table_name = n.to_s
+        end
+        
+        def ==(i)
+          self.table_name == i.table_name
+        end
+        
+        def to_s
+          "INTO #{self.table_name}"
+        end
+        
+        def to_xml(name=nil)
+          el = element_root(name)
+          
+          name = REXML::Element.new("#{obj_ns.prefix}:TableName")
+          name.text = self.table_name
+          el.add_element(name)
+          
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            REXML::XPath.first(root, 'x:TableName', {'x' => obj_ns.uri}).text
+          )
+        end
+      end
+      
+      # Ascending or Descending order of an Order by term
+      class OrderDirection < Enumeration
+        def self.choices; ['ASC', 'DESC'] end
+      end
+      
+      # Option for setting the direction for Order By
+      class OrderOption
+        include SerializableToXml
+        
+        attr_reader :direction
+        
+        def self.xml_type; 'orderOptionType' end
+        
+        def initialize(direction)
+          self.direction = direction
+        end
+        
+        def direction=(d)
+          raise_argument_required_error('direction') if !d
+          
+          d = OrderDirection.new(d) if d.is_a?(String)
+          raise_type_mismatch_error(d, OrderDirection)
+          
+          @direction = d
+        end
+        
+        def ==(o)
+          self.direction == o.direction
+        end
+        
+        def to_s
+          self.direction.to_s
+        end
+        
+        def to_xml(name=nil)
+          el = element_root(name)
+          el.attributes["#{obj_ns.prefix}:Direction"] = self.direction.to_s
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            OrderDirection.new(
+              root.attributes.get_attribute_ns(obj_ns.uri, 'Direction').value
+            )
+          )
+        end
+      end
+      
+      # Represents the ORDER BY part of a query
+      class Order
+        include SerializableToXml
+        
+        def self.xml_type; 'orderType' end
+        
+        attr_reader :expression, :order
+        
+        def initialize(expression, order=nil)
+          self.expression = expression
+          self.order = order
+        end
+        
+        def expression=(e)
+          raise_argument_required_error('expression') if !e
+          raise_type_mismatch_error(e, ScalarExpression)
+          @expression = e
+        end
+        
+        def order=(o)
+          raise_type_mismatch_error(o, OrderOption) if o
+          @order = o
+        end
+        
+        def ==(o)
+          self.expression == o.expression and
+          self.order == o.order
+        end
+        
+        def to_s
+          s = self.expression.to_s
+          s = "#{s} #{self.order}" if self.order
+          s
+        end
+        
+        def to_xml(name=nil)
+          el = element_root(name)
+          
+          el.add_element(self.expression.to_xml('Expression'))
+          el.add_element(self.order.to_xml('Order')) if self.order
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          order_el = REXML::XPath.first(root, 'x:Order', {'x' => obj_ns.uri})
+          self.new(
+            xml_to_obj(REXML::XPath.first(root, 'x:Expression', {'x' => obj_ns.uri})),
+            order_el ? xml_to_obj(order_el) : nil
+          )
+        end
+      end
+      
+      # List of expressions in which order the results should be provided
+      class OrderExpression
+        include SerializableToXml
+        
+        class OrderList < TypedArray
+          def self.restricted_to; [Order] end
+          def self.minimum_length; 1 end
+        end
+        
+        attr_reader :items
+        
+        def self.xml_type; 'orderExpressionType' end
+        
+        def initialize(items)
+          self.items = items
+        end
+        
+        def items=(is)
+          raise_argument_required_error('items') if !is
+          
+          is = OrderExpression::OrderList.new(is) if is.class == Array
+          raise_type_mismatch_error(is, OrderExpression::OrderList)
+          
+          @items = is
+        end
+        
+        def ==(e)
+          self.items == e.items
+        end
+        
+        def to_s
+          "ORDER BY #{self.items.collect{ |i| i.to_s }.join(', ')}"
+        end
+        
+        def to_xml(name=nil)
+          el = element_root(name)
+          
+          self.items.collect{ |i| el.add_element(i.to_xml('Item')) }
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            OrderExpression::OrderList.new(
+              REXML::XPath.match(root, 'x:Item', {'x' => obj_ns.uri}).collect{ |iel| xml_to_obj(iel) }
+            )
+          )
+        end
+      end
+      
+      # The base type for selection set in a SQL IN expression
+      class InclusionSet
+        include SerializableToXml
+        
+        def to_xml(name=nil)
+          element_root(name)
+        end
+      end
+      
+      # Represents a list of constants provided for a SQL IN expression
+      class ConstantListSet < InclusionSet
+        class LiteralList < TypedArray
+          def self.restricted_to; [Literal] end
+          def self.minimum_length; 1 end
+        end
+        
+        attr_reader :items
+        
+        def self.xml_type; 'ConstantListSet' end
+        
+        def initialize(items)
+          self.items = items
+        end
+        
+        def items=(is)
+          raise_argument_required_error('items') if !is
+          
+          is = ConstantListSet::LiteralList.new(is) if is.class == Array
+          raise_type_mismatch_error(is, ConstantListSet::LiteralList)
+          
+          @items = is
+        end
+        
+        def ==(s)
+          self.items == s.items
+        end
+        
+        def to_s
+          "(#{self.items.collect{ |i| i.to_s }.join(', ')})"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          self.items.each{ |i| el.add_element(i.to_xml('Item')) }
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            ConstantListSet::LiteralList.new(
+              REXML::XPath.match(root, 'x:Item', {'x' => obj_ns.uri}).collect{ |iel| xml_to_obj(iel) }
+            )
+          )
+        end
+      end
+      
+      # Represents the subquery in a SQL IN expression
+      class SubQuerySet < InclusionSet
+        attr_reader :selection
+        
+        def self.xml_type; 'subQuerySet' end
+        
+        def initialize(selection)
+          self.selection = selection
+        end
+        
+        def selection=(s)
+          raise_argument_required_error('selection') if !s
+          raise_type_mismatch_error(s, Select)
+          @selection = s
+        end
+        
+        def ==(s)
+          self.selection == s.selection
+        end
+        
+        def to_s
+          "(#{self.selection})"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.add_element(self.selection.to_xml('selection'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(xml_to_obj(REXML::XPath.first(root, 'x:selection', {'x' => obj_ns.uri})))
+        end
+      end
+      
+      # Represents SQL IN expression
+      class InclusiveSearch < Search
+        attr_reader :expression, :set
+        
+        def self.xml_type; 'inclusiveSearchType' end
+        
+        def initialize(expression, set)
+          self.expression = expression
+          self.set = set
+        end
+        
+        def expression=(e)
+          raise_argument_required_error('expression') if !e
+          raise_type_mismatch_error(e, ScalarExpression)
+          @expression = e
+        end
+        
+        def set=(s)
+          raise_argument_required_error('set') if !s
+          raise_type_mismatch_error(s, InclusionSet)
+          @set = s
+        end
+        
+        def ==(s)
+          self.expression == s.expression and
+          self.set == s.set
+        end
+        
+        def to_s
+          "#{self.expression} IN #{self.set}"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.add_element(self.expression.to_xml('Expression'))
+          el.add_element(self.set.to_xml('Set'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+
+          self.new(
+            xml_to_obj(REXML::XPath.first(root, 'x:Expression', {'x' => obj_ns.uri})),
+            xml_to_obj(REXML::XPath.first(root, 'x:Set', {'x' => obj_ns.uri}))
+          )
+        end
+      end
+      
+      # Represents SQL NOT IN expression
+      class ExclusiveSearch < Search
+        attr_reader :expression, :set
+        
+        def self.xml_type; 'exclusiveSearchType' end
+        
+        def initialize(expression, set)
+          self.expression = expression
+          self.set = set
+        end
+        
+        def expression=(e)
+          raise_argument_required_error('expression') if !e
+          raise_type_mismatch_error(e, ScalarExpression)
+          @expression = e
+        end
+        
+        def set=(s)
+          raise_argument_required_error('set') if !s
+          raise_type_mismatch_error(s, InclusionSet)
+          @set = s
+        end
+        
+        def ==(s)
+          self.expression == s.expression and
+          self.set == s.set
+        end
+        
+        def to_s
+          "#{expression} NOT IN #{set}"
+        end
+        
+        def to_xml(name=nil)
+          el = super(name)
+          
+          el.add_element(self.expression.to_xml('Expression'))
+          el.add_element(self.set.to_xml('Set'))
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          self.new(
+            xml_to_obj(REXML::XPath.first(root, 'x:Expression', {'x' => obj_ns.uri})),
+            xml_to_obj(REXML::XPath.first(root, 'x:Set', {'x' => obj_ns.uri}))
+          )
+        end
+      end
+      
+      # The SELECT part of a query
+      class Select
+        include SerializableToXml
+        
+        attr_reader :allow, :restrict, :selection_list, :into,
+          :from, :where, :group_by, :having, :order_by, :start_comment, :end_comment
+          
+        def self.xml_type; 'selectType' end
+          
+        def initialize(selection_list, options={})
+          options.each { |key, value| send("#{key}=", value) }
+          self.selection_list = selection_list
+        end
+        
+        def allow=(a)
+          raise_type_mismatch_error(a, SelectionOption) if a
+          @allow = a
+        end
+        
+        def restrict=(r)
+          raise_type_mismatch_error(r, SelectionLimit) if r
+          @restrict = r
+        end
+        
+        def selection_list=(l)
+          raise_argument_required_error('selection list') if !l
+          raise_type_mismatch_error(l, SelectionList)
+          @selection_list = l
+        end
+        
+        def into=(i)
+          raise_type_mismatch_error(i, Into) if i
+          @into = i
+        end
+        
+        def from=(f)
+          raise_type_mismatch_error(f, From) if f
+          @from = f
+        end
+        
+        def where=(w)
+          raise_type_mismatch_error(w, Where) if w
+          @where = w
+        end
+        
+        def group_by=(g)
+          raise_type_mismatch_error(g, GroupBy) if g
+          @group_by = g
+        end
+        
+        def having=(h)
+          raise_type_mismatch_error(h, Having) if h
+          @having = h
+        end
+        
+        def order_by=(o)
+          raise_type_mismatch_error(o, OrderExpression) if o
+          @order_by = o
+        end
+        
+        def start_comment=(c)
+          @start_comment = c ? c.to_s : nil
+        end
+        
+        def end_comment=(c)
+          @end_comment = c ? c.to_s : nil
+        end
+        
+        def ==(s)
+         self.allow == s.allow and
+         self.restrict == s.restrict and
+         self.selection_list == s.selection_list and
+         self.into == s.into and
+         self.from == s.from and
+         self.where == s.where and
+         self.group_by == s.group_by and
+         self.having == s.having and
+         self.order_by == s.order_by and
+         self.start_comment == s.start_comment and
+         self.end_comment == s.end_comment 
+        end
+        
+        def to_s
+          s = 'SELECT'
+          s << " #{self.allow}" if self.allow
+          s << " #{self.restrict}" if self.restrict
+          s << " #{self.selection_list}"
+          s << " #{self.into}" if self.into
+          s << " #{self.from}" if self.from
+          s << " #{self.where}" if self.where
+          s << " #{self.group_by}" if self.group_by
+          s << " #{self.having}" if self.having
+          s << " #{self.order_by}" if self.order_by
+          s
+        end
+        
+        def to_xml(name='Select')
+          el = element_root(name)
+          
+          el.add_element(self.allow.to_xml('Allow')) if self.allow
+          el.add_element(self.restrict.to_xml('Restrict')) if self.restrict
+          el.add_element(self.selection_list.to_xml('SelectionList'))
+          el.add_element(self.into.to_xml('InTo')) if self.into
+          el.add_element(self.from.to_xml('From')) if self.from
+          el.add_element(self.where.to_xml('Where')) if self.where
+          el.add_element(self.group_by.to_xml('GroupBy')) if self.group_by
+          el.add_element(self.having.to_xml('Having')) if self.having
+          el.add_element(self.order_by.to_xml('OrderBy')) if self.order_by
+          
+          if self.start_comment
+            sc = REXML::Element.new("#{obj_ns.prefix}:StartComment")
+            sc.text = self.start_comment
+            el.add_element(sc)
+          end
+          
+          if self.end_comment
+            ec = REXML::Element.new("#{obj_ns.prefix}:EndComment")
+            ec.text = self.end_comment
+            el.add_element(ec)
+          end
+          
+          collapse_namespaces(el)
+          el
+        end
+        
+        def self.from_xml(xml)
+          root = element_from(xml)
+          
+          options = {}
+          
+          allow = REXML::XPath.first(root, 'x:Allow', {'x' => obj_ns.uri})
+          options[:allow] = xml_to_obj(allow) if allow
+          
+          restrict = REXML::XPath.first(root, 'x:Restrict', {'x' => obj_ns.uri})
+          options[:restrict] = xml_to_obj(restrict) if restrict
+          
+          into = REXML::XPath.first(root, 'x:InTo', {'x' => obj_ns.uri})
+          options[:into] = xml_to_obj(into) if into
+          
+          from = REXML::XPath.first(root, 'x:From', {'x' => obj_ns.uri})
+          options[:from] = xml_to_obj(from) if from
+          
+          where = REXML::XPath.first(root, 'x:Where', {'x' => obj_ns.uri})
+          options[:where] = xml_to_obj(where) if where
+          
+          group_by = REXML::XPath.first(root, 'x:GroupBy', {'x' => obj_ns.uri})
+          options[:group_by] = xml_to_obj(group_by) if group_by
+          
+          having = REXML::XPath.first(root, 'x:Having', {'x' => obj_ns.uri})
+          options[:having] = xml_to_obj(having) if having
+          
+          order_by = REXML::XPath.first(root, 'x:OrderBy', {'x' => obj_ns.uri})
+          options[:order_by] = xml_to_obj(order_by) if order_by
+          
+          start_comment = REXML::XPath.first(root, 'x:StartComment', {'x' => obj_ns.uri})
+          options[:start_comment] = start_comment.text if start_comment
+          
+          end_comment = REXML::XPath.first(root, 'x:EndComment', {'x' => obj_ns.uri})
+          options[:end_comment] = end_comment.text if end_comment
+          
+          self.new(
+            xml_to_obj(REXML::XPath.first(root, 'x:SelectionList', {'x' => obj_ns.uri})),
+            options
+          )
+        end
+      end
+      
+    end
+  end
+end