voruby 1.0.1

data/lib/voruby/adql/adql.rb

@@ -0,0 +1,2735 @@
+require 'voruby/adql/loader'
+
+# A set of classes designed to read and manipulate ADQL[http://www.ivoa.net/Documents/latest/ADQL.html].
+module VORuby
+  
+  module ADQL
+    # Acts as glue between xsi:types and their corresponding
+    # domain objects in the * hierarchy.
+    class ObjectBuilder
+      def self.classes
+        {:allSelectionItemType => AllSelectionItem,
+         :columnReferenceType => ColumnReference,
+         :tableType => ArchiveTable,
+         :atomType => Atom,
+         :stringType => StringType,
+         :realType => RealType,
+         :integerType => IntegerType,
+         :binaryExprType => BinaryExpr,
+         :unaryExprType => UnaryExpr,
+         :closedExprType => ClosedExpr,
+         :trigonometricFunctionType => TrigonometricFunction,
+         :trigonometricFunctionNameType => TrigonometricFunctionName,
+         :mathFunctionType => MathFunction,
+         :mathFunctionNameType => MathFunctionName,
+         :aggregateFunctionType => AggregateFunction,
+         :aggregateFunctionNameType => AggregateFunctionName,
+         :userDefinedFunctionType => UserDefinedFunction,
+         :aliasSelectionItemType => AliasSelectionItem,
+         :likePredType => LikePred,
+         :notLikePredType => NotLikePred,
+         :closedSearchType => ClosedSearch,
+         :intersectionSearchType => IntersectionSearch,
+         :unionSearchType => UnionSearch,
+         :comparisonPredType => ComparisonPred,
+         :betweenPredType => BetweenPred,
+         :notBetweenPredType => NotBetweenPred,
+         :includeTableType => IncludeTable,
+         :dropTableType => DropTable,
+         :xMatchType => XMatch,
+         :xMatchTableAliasType => XMatchTableAlias,
+         :comparisonType => Comparison,
+         :regionSearchType => RegionSearch,
+         :inverseSearchType => InverseSearch,
+         :inclusionSetType => InclusionSet,
+         :inclusiveSearchType => InclusiveSearch,
+         :exclusiveSearchType => ExclusiveSearch,
+         :subQuerySetType => SubQuerySet,
+         :joinTableType => JoinTable,
+         :constantListSetType => ConstantListSet,
+         :orderType => Order,
+         :circleType => Circle,
+         :boxType => Box,
+         :archiveTableType => ArchiveTable}
+      end
+    
+      # Get the domain class associated with a particular xsi:type.
+      def self.get_class_for(type)
+        klass = self.classes()[type.to_sym] || self.classes()[type]
+        raise "Unable to find type #{type}" if !klass
+        return klass
+      end
+    end
+  
+  	# The abstract base type for any of items to be selected in a query.
+  	class SelectionItem
+  	  def self.from_xml(node)
+  	    #type_s = node.elements['xsi:type']
+  	    type_s = node.find_attribute('type', 'http://www.w3.org/2001/XMLSchema-instance')
+  	    return ObjectBuilder.get_class_for(type_s).from_xml(node)
+      end
+  	end
+
+  	# The base type for a scalar expression.
+  	class ScalarExpression < SelectionItem
+  		attr_reader :value
+		
+  		def initialize(val)
+  			self.value = val
+  		end
+		
+  		def is_scalar?(v)
+  			if v.is_a?(String) or v.is_a?(Integer) or v.is_a?(Float)
+  				return true
+  			else
+  				return false
+  			end
+  		end
+		
+  		def value=(v)
+  			if self.is_scalar?(v)
+  				@value = v
+  			else
+  				raise "Scalar expression must contain scalar values"
+  			end
+  		end
+		
+  		def to_s
+  			"{value=#{self.value}}"
+  		end
+
+      def self.from_xml(node)
+        #type_s = node.attributes['xsi:type']
+        type_s = node.find_attribute('type', 'http://www.w3.org/2001/XMLSchema-instance')
+        return ObjectBuilder.get_class_for(type_s).from_xml(node)
+      end
+  	end
+
+  	# Represents an expression inside a bracket.
+  	class ClosedExpr < ScalarExpression
+  		attr_reader :value
+
+  		def initialize(val)
+  			self.value = val
+  		end
+		
+  		def value=(v)
+  		  VOTables::VOTable::Misc::TypeCheck.new(v, ScalarExpression).check()
+  		  @value = v
+  	  end
+	  
+  	  def self.from_xml(node)
+  	    expr_node = REXML::XPath.first(node, 'Arg')
+  	    expr = ScalarExpression.from_xml(expr_node)
+  	    return ClosedExpr.new(expr)
+      end
+  	end
+
+  	# Used for expressing operations like A+B.
+  	class BinaryOperator
+  		attr_reader :operator
+	
+  		@@operators = ['+', '-', '*', '/']
+	
+  		def initialize(operator, op_list=nil)
+  			@op_list = op_list || @@operators
+  			self.operator = operator
+  		end
+	
+  		def operator=(o)
+  			if @op_list.include?(o)
+  				@operator = o
+  			else
+  				raise "Binary operator is not valid.  Use one of: " +
+  					@op_list.join(', ')
+  			end
+  		end
+	
+  		def to_s
+  			"{operator=#{self.operator}}"
+  		end
+  	end
+	
+  	# Represents a binary expression such as a+b.
+  	class BinaryExpr < ScalarExpression
+  		attr_reader :oper, :arg1, :arg2
+
+  		def initialize(arg1, oper, arg2)
+  			super("#{arg1} #{oper} #{arg2}")
+
+  			self.arg1 = arg1
+  			self.arg2 = arg2
+  			self.oper = oper
+  		end
+	
+  		def arg1=(a)
+  			begin
+  				VOTables::VOTable::Misc::TypeCheck.new(a, ScalarExpression).check()
+  			rescue VOTables::VOTable::Misc::TypeException
+  				@arg1 = ScalarExpression.new(a)
+  			else
+  				@arg1 = a
+  			end
+  		end
+	
+  		def arg2=(a)
+  			begin
+  				VOTables::VOTable::Misc::TypeCheck.new(a, ScalarExpression).check()
+  			rescue VOTables::VOTable::Misc::TypeException
+  				@arg2 = ScalarExpression.new(a)
+  			else
+  				@arg2 = a
+  			end
+  		end
+	
+  		def oper=(o)
+  			begin
+  				VOTables::VOTable::Misc::TypeCheck.new(o, BinaryOperator).check()
+  			rescue VOTables::VOTable::Misc::TypeException
+  				@oper = BinaryOperator.new(o)
+  			else
+  				@oper = o
+  			end
+  		end
+	
+  		def to_s
+  			"{arg1=#{self.arg1},oper=#{self.oper},arg2=#{self.arg2}}"
+  		end
+
+      def self.from_xml(node)
+        oper = BinaryOperator.new(node.attributes['Oper'])
+        arg1_node, arg2_node = node.elements.to_a('Arg')
+        arg1 = ScalarExpression.from_xml(arg1_node)
+        arg2 = ScalarExpression.from_xml(arg2_node)
+        return BinaryExpr.new(arg1, oper, arg2)
+      end
+  	end
+	
+  	# Operators for expressing a single element operation.
+  	class UnaryOperator
+  		attr_reader :operator
+		
+  		@@operators = ['+', '-']
+	
+  		def initialize(operator, op_list=nil)
+  			@op_list = op_list || @@operators
+  			self.operator = operator
+  		end
+	
+  		def operator=(o)
+  			if @op_list.include?(o)
+  				@operator = o
+  			else
+  				raise "Unary operator is not valid.  Use one of: " +
+  					@op_list.join(', ')
+  			end
+  		end
+	
+  		def to_s
+  			"{operator=#{self.operator}}"
+  		end	
+  	end
+	
+  	# Represents an unary expression such as -(a.ra)
+  	class UnaryExpr < ScalarExpression
+  		attr_reader :arg, :oper
+		
+  		def initialize(oper, arg)
+  			super("#{oper}#{arg}")
+			
+  			self.arg = arg
+  			self.oper = oper
+  		end
+		
+  		def arg=(a)
+  			begin
+  				VOTables::VOTable::Misc::TypeCheck.new(a, ScalarExpression).check()
+  			rescue VOTables::VOTable::Misc::TypeException
+  				@arg = ScalarExpression.new(a)
+  			else
+  				@arg = a
+  			end
+  		end
+		
+  		def oper=(o)
+  			begin
+  				VOTables::VOTable::Misc::TypeCheck.new(o, UnaryOperator).check()
+  			rescue VOTables::VOTable::Misc::TypeException
+  				@oper = UnaryOperator.new(o)
+  			else
+  				@oper = o
+  			end
+  		end
+		
+  		def to_s
+  			"{arg=#{self.oper},oper=#{self.arg}}"
+  		end
+	
+  	  def self.from_xml(node)
+  	    oper = UnaryOperator.new(node.attributes['Oper'])
+  	    arg_node = REXML::XPath.first(node, 'Arg')
+  	    arg = ScalarExpression.from_xml(arg_node)
+  	    return UnaryExpr.new(oper, arg)
+      end
+  	end
+	
+  	# Represents a column.
+  	class ColumnReference < ScalarExpression
+  		attr_accessor :table, :name, :xpath_name
+	
+  		def initialize(table, name, xpath_name=nil)
+  			super("#{table}.#{name} #{xpath_name || ''}")
+			
+  			self.table = table
+  			self.name = name
+  			self.xpath_name = xpath_name
+  		end
+		
+  		def to_s
+  			self.value
+  		end
+		
+  		def self.from_xml(el)
+  		  table = el.attributes['Table']
+  		  name = el.attributes['Name']
+  		  xpath = el.attributes['xpathName']
+  		  cr = ColumnReference.new(table, name, xpath)
+  	  end
+  	end
+	
+  	# Encapsulates basic literals such as Strings, Integers and Real numbers.
+  	class Atom < ScalarExpression
+  		attr_reader :literal
+  		attr_accessor :unit
+		
+  		def initialize(literal, unit=nil)
+  			super("#{literal}#{unit || ''}")
+		
+  			self.literal = literal
+  			self.unit = unit
+  		end
+		
+  		def literal=(l)
+  			begin
+  				VOTables::VOTable::Misc::TypeCheck.new(l, LiteralType).check()
+  			rescue VOTables::VOTable::Misc::TypeException
+  				if l.is_a?(Float)
+  					@literal = RealType.new(l)
+  				elsif l.is_a?(Integer)
+  					@literal = IntegerType.new(l)
+  				elsif l.is_a?(String)
+  					@literal = StringType.new(l)
+  				else
+  					raise "Literal is not a real, integer or string"
+  				end
+  			else
+  				@literal = l
+  			end
+  		end
+		
+  		def to_s
+  			"{literal=#{self.literal},unit=#{self.unit}}"
+  		end
+		
+  		def self.from_xml(node)
+  		  literal_node = REXML::XPath.first(node, 'Literal')
+  		  literal = LiteralType.from_xml(literal_node)
+  		  return Atom.new(literal)
+  		end
+  	end
+	
+  	# The base type for all literals.
+  	class LiteralType
+  		def to_s
+  			"{value=#{self.value}}"
+  		end
+	
+  	  def self.from_xml(node)
+  	    #type_s = node.attributes['xsi:type']
+  	    type_s = node.find_attribute('type', 'http://www.w3.org/2001/XMLSchema-instance')
+  	    literal = ObjectBuilder.get_class_for(type_s).from_xml(node)
+  	    return literal
+  	  end
+  	end
+	
+  	# The base type for all numbers.
+  	class NumberType < LiteralType
+  	  def self.from_xml(node)
+  	    #type_s = node.attributes['xsi:type']
+  	    type_s = node.find_attribute('type', 'http://www.w3.org/2001/XMLSchema-instance')
+  	    number = ObjectBuilder.get_class_for(type_s).from_xml(node)
+  	  end
+  	end
+	
+  	# Represents a real number.
+  	class RealType < NumberType
+  		attr_reader :value
+		
+  		def initialize(value)
+  			self.value = value
+  		end
+		
+  		def value=(v)
+  		  begin
+  			VOTables::VOTable::Misc::TypeCheck.new(v, Float).check()
+  			rescue VOTables::VOTable::Misc::TypeException
+  			  if v.is_a?(Integer)
+  			    @value = v.to_f
+  			  else
+  			    raise VOTables::VOTable::Misc::TypeException
+  			  end
+  			else
+  			  @value = v
+  			end
+  		end
+
+      def self.from_xml(node)
+        return RealType.new(node.attributes['Value'].to_f)
+      end
+  	end
+	
+  	# Represents an integer.
+  	class IntegerType < NumberType
+  		attr_reader :value
+		
+  		def initialize(value)
+  			self.value = value
+  		end
+		
+  		def value=(v)
+  			VOTables::VOTable::Misc::TypeCheck.new(v, Integer).check()
+  			@value = v
+  		end
+	
+  	  def self.from_xml(node)
+  	    return IntegerType.new(node.attributes['Value'].to_i)
+      end
+  	end
+	
+  	# Represents a string literal.
+  	class StringType < LiteralType
+  		attr_reader :value
+		
+  		def initialize(value)
+  			self.value = value
+  		end
+		
+  		def value=(v)
+  			VOTables::VOTable::Misc::TypeCheck.new(v, String).check()
+  			@value = v
+  		end
+	
+  	  def self.from_xml(node)
+  	    return StringType.new(node.attributes['Value'])
+  	  end
+  	end
+	
+  	# The base type for a function.
+  	class FunctionType < ScalarExpression
+  		def to_s
+  			"{name=#{self.name}}"
+  		end
+  	end
+	
+  	# Option of selecting all or distinct elements in a query.
+  	class SelectionOption
+  		attr_reader :option
+		
+  		def initialize(option)
+  			self.option = option
+  		end
+		
+  		def option=(o)
+  			begin
+  				VOTables::VOTable::Misc::TypeCheck.new(o, AllOrDistinct).check()
+  			rescue VOTables::VOTable::Misc::TypeException
+  				@option = AllOrDistinct.new(o)
+  			else
+  				@option = o
+  			end
+  		end
+		
+  		def content
+  			self.option.option
+  		end
+		
+  		def to_s
+  			"{option=#{self.option}}"
+  		end
+
+      def self.from_xml(node)
+        option = AllOrDistinct.new(node.attributes['Option'])
+        return SelectionOption.new(option)
+      end
+  	end
+	
+  	# Enumeration for All and Distinct options.
+  	class AllOrDistinct
+  		attr_reader :option, :option_list
+		
+  		@@options = ['ALL', 'DISTINCT']
+		
+  		def initialize(option, option_list=nil)
+  			@option_list = option_list || @@options
+  			self.option = option
+  		end
+		
+  		def option=(o)
+  			if @option_list.include?(o)
+  				@option = o
+  			else
+  				raise "Option is not valid.  Use one of: " +
+  					@option_list.join(', ')
+  			end
+  		end
+		
+  		def to_s
+  			"{option=#{self.option}}"
+  		end
+  	end
+	
+  	# Represents a trigonometric function.
+  	class TrigonometricFunction < FunctionType
+  		attr_reader :name, :arg, :allow
+		
+  		def initialize(name, arg, allow=nil)
+  			self.name = name
+  			self.arg = arg
+  			self.allow = allow
+  		end
+		
+  		def name=(n)
+  			begin
+  				VOTables::VOTable::Misc::TypeCheck.new(n, TrigonometricFunctionName).check()
+  			rescue VOTables::VOTable::Misc::TypeException
+  				@name = TrigonometricFunctionName.new(n)
+  			else
+  				@name = n
+  			end
+  		end
+		
+  		def arg=(a)
+  		  VOTables::VOTable::Misc::TypeCheck.new(a, SelectionItem).check()
+  		  @arg = a
+  	  end
+	  
+  	  def allow=(a)
+  	    VOTables::VOTable::Misc::TypeCheck.new(a, SelectionOption).check()
+  	    @allow = a
+      end
+    
+      def to_s
+        "{name=#{self.name},allow=#{self.allow},arg=#{self.arg}}"
+      end
+    
+      def self.from_xml(node)
+        name = TrigonometricFunctionName.from_xml(node)
+        arg_node = REXML::XPath.first(node, 'Arg')
+        arg = Arg.from_xml(arg_node)
+        allow_node = REXML::XPath.first(node, 'Allow')
+        allow = nil
+        if allow_node
+          allow = Allow.from_xml(allow_node)
+        end
+        return TrigonometricFunction.new(name, arg, allow)
+      end
+  	end
+	
+  	# Enumeration of allowed trigonometric functions.
+  	class TrigonometricFunctionName
+  		attr_reader :value, :values_list
+		
+  		@@values = ['SIN', 'COS', 'TAN', 'COT', 'ASIN', 'ACOS', 'ATAN', 'ATAN2']
+		
+  		def initialize(value, values_list=nil)
+  			@values_list = values_list || @@values
+  			self.value = value
+  		end
+		
+  		def value=(v)
+  			if @values_list.include?(v)
+  				@value = v
+  			else
+  				raise "Value is not valid.  Use one of: " +
+  					@values_list.join(', ')
+  			end
+  		end
+		
+  		def to_s
+  			"{value=#{self.value}}"
+  		end
+	  
+  	  def self.from_xml(node)
+  	    return TrigonometricFunctionName.new(node.attributes['Name'])
+      end
+  	end
+	
+  	# Represents a math function.
+  	class MathFunction < FunctionType
+  		attr_reader :name, :arg, :allow
+		
+  		def initialize(name, arg, allow=nil)
+  			self.name = name
+  			self.arg = arg
+  			self.allow = allow
+  		end
+		
+  		def name=(n)
+  			begin
+  				VOTables::VOTable::Misc::TypeCheck.new(n, MathFunctionName).check()
+  			rescue VOTables::VOTable::Misc::TypeException
+  				@name = MathFunctionName.new(n)
+  			else
+  				@name = n
+  			end
+  		end
+	
+  	  def arg=(a)
+  		  VOTables::VOTable::Misc::TypeCheck.new(a, SelectionItem).check()
+  		  @arg = a
+  	  end
+	  
+  	  def allow=(a)
+  	    VOTables::VOTable::Misc::TypeCheck.new(a, SelectionOption).check()
+  	    @allow = a
+      end
+    
+      def self.from_xml(node)
+        name = MathFunctionName.from_xml(node)
+        arg_node = REXML::XPath.first(node, 'Arg')
+        arg = Arg.from_xml(arg_node)
+        allow_node = REXML::XPath.first(node, 'Allow')
+        allow = nil
+        if allow_node
+          allow = Allow.from_xml(allow_node)
+        end
+        return MathFunction.new(name, arg, allow)
+      end
+    
+      def to_s
+        "{name=#{self.name},arg=#{self.arg},allow=#{self.allow}}"
+      end
+  	end
+	
+  	# Enumeration of allowed math functions.
+  	class MathFunctionName
+  		attr_reader :value, :values_list
+		
+  		@@values = ['ABS', 'CEILING', 'DEGREES', 'EXP', 'FLOOR', 'LOG',
+  					'PI', 'POWER', 'RADIANS', 'SQRT', 'SQUARE', 'LOG10',
+  					'RAND', 'ROUND', 'TRUNCATE']
+					
+  		def initialize(value, values_list=nil)
+  			@values_list = values_list || @@values
+  			self.value = value
+  		end
+		
+  		def value=(v)
+  			if @values_list.include?(v)
+  				@value = v
+  			else
+  				raise "Value is not valid.  Use one of: " +
+  					@values_list.join(', ')
+  			end
+  		end
+		
+  		def to_s
+  			"{value=#{self.value}}"
+  		end
+
+      def self.from_xml(node)
+    	  return MathFunctionName.new(node.attributes['Name'])
+      end
+  	end
+	
+  	# Represents an aggregate function.
+  	class AggregateFunction < FunctionType
+  		attr_reader :name, :arg, :allow
+		
+  		def initialize(name, arg, allow=nil)
+  			self.name = name
+  			self.arg = arg
+  			self.allow = allow
+  		end
+		
+  		def name=(n)
+    		begin
+    			VOTables::VOTable::Misc::TypeCheck.new(n, AggregateFunctionName).check()
+    		rescue VOTables::VOTable::Misc::TypeException
+    			@name = AggregateFunctionName.new(n)
+    		else
+    			@name = n
+    		end
+    	end
+	
+  	  def arg=(a)
+  		  VOTables::VOTable::Misc::TypeCheck.new(a, SelectionItem).check()
+  		  @arg = a
+  	  end
+	  
+  	  def allow=(a)
+  	    VOTables::VOTable::Misc::TypeCheck.new(a, SelectionOption).check()
+  	    @allow = a
+      end
+  
+      def to_s
+        "{name=#{self.name},arg=#{self.arg},allow=#{self.allow}}"
+      end
+		
+  		def self.from_xml(node)
+  		  name = AggregateFunctionName.from_xml(node)
+  		  arg_node = REXML::XPath.first(node, 'Arg')
+        arg = Arg.from_xml(arg_node)
+        allow_node = REXML::XPath.first(node, 'Allow')
+        allow = nil
+        if allow_node
+          allow = Allow.from_xml(allow_node)
+        end
+        return AggregateFunction.new(name, arg, allow)
+  	  end
+  	end
+	
+  	# Enumeration of allowed aggregate functions.
+  	class AggregateFunctionName
+  		attr_reader :value, :values_list
+		
+  		@@values = ['AVG', 'MIN', 'MAX', 'SUM', 'COUNT']
+					
+  		def initialize(value, values_list=nil)
+  			@values_list = values_list || @@values
+  			self.value = value
+  		end
+		
+  		def value=(v)
+  			if @values_list.include?(v)
+  				@value = v
+  			else
+  				raise "Value is not valid.  Use one of: " +
+  					@values_list.join(', ')
+  			end
+  		end
+		
+  		def to_s
+  			"{value=#{self.value}}"
+  		end
+		
+  		def self.from_xml(node)
+     	  return AggregateFunctionName.new(node.attributes['Name'])
+      end
+  	end
+	
+  	# Used to select an expression as a new alias column.
+  	class AliasSelectionItem < SelectionItem
+  		attr_reader :expression
+  		attr_accessor :as
+		
+  		def initialize(expression, as=nil)
+  			self.expression = expression
+  			self.as = as
+  		end
+		
+  		def expression=(e)
+  			begin
+  				VOTables::VOTable::Misc::TypeCheck.new(e, ScalarExpression).check()
+  			rescue VOTables::VOTable::Misc::TypeException
+  				@expression = ScalarExpression.new(e)
+  			else
+  				@expression = e
+  			end
+  		end
+		
+  		def to_s
+  			"{expression=#{self.expression},as=#{self.as}}"
+  		end
+	
+  	  def self.from_xml(node)
+  	    as = node.attributes['As']
+  	    expr_node = REXML::XPath.first(node, 'Expression')
+  	    expr = ScalarExpression.from_xml(expr_node)
+  	    return AliasSelectionItem.new(expr, as)
+      end
+  	end
+	
+      # Represent all columns as in Select * query.
+      class AllSelectionItem < SelectionItem
+        @@value = '*'
+      
+        def initialize;end
+      
+        def self.value
+          return @@value
+        end
+      
+        def to_s
+          "{expression=#{self.value}}"
+  	  end
+	  
+  	  def self.from_xml(node)
+  	    return AllSelectionItem.new()
+  	  end
+  	end
+	
+  	# The comparison operators such as Less-than or More-than, etc.
+  	class Comparison
+  		attr_reader :value, :values_list
+		
+  		@@values = ['=', '<>', '>', '>=', '<', '<=']
+		
+  		def initialize(value, values_list=nil)
+  			@values_list = values_list || @@values
+  			self.value = value
+  		end
+		
+  		def value=(v)
+  			if @values_list.include?(v)
+  				@value = v
+  			else
+  				raise "Value is not valid.  Use one of: " +
+  					@values_list.join(', ')
+  			end
+  		end
+		
+  		def to_s
+  			"{value=#{self.value}}"
+  		end
+
+      def self.from_xml(node)
+        return Comparison.new(node.attributes['Comparison'])
+      end
+  	end
+	
+  	# The base type for all tables used in the From clause of the query.
+  	class FromTable
+  	  def self.from_xml(node)
+  	    type_s = node.find_attribute('type', 'http://www.w3.org/2001/XMLSchema-instance')
+        table = ObjectBuilder.get_class_for(type_s).from_xml(node)
+      end
+  	end
+	
+    # Same as a TableType with an additional archive name.
+    class ArchiveTable < FromTable
+      attr_accessor :archive, :name, :alias_name
+    
+      def initialize(archive, name, alias_name=nil)
+        self.archive = archive
+        self.name = name
+        self.alias_name = alias_name
+      end
+    
+      def to_s
+      "{archive=#{self.archive},name=#{self.name},alias=#{self.alias_name}}"
+      end
+    
+      def self.from_xml(node)
+        archive = node.attributes['Archive'] or raise "No ArchiveTable attribute 'Archive'"
+        #name = CGI::escapeHTML(node.attributes['Name']) or raise "No ArchiveTable attribute 'Name'"
+        name = node.attributes['Name'] or raise "No ArchiveTable attribute 'Name'"
+        alias_name = node.attributes['Alias']
+      
+        at = ArchiveTable.new(archive, name, alias_name)
+      end
+    end
+	
+  	# Represents a table with its name and its alias name.
+  	class Table < FromTable
+  		attr_accessor :name, :alias_name, :xpath_name
+		
+  		def initialize(name, alias_name=nil, xpath_name=nil)
+  			self.name = name
+  			self.alias_name = alias_name
+  			self.xpath_name = xpath_name
+  		end
+		
+  		def to_s
+  			"{name=#{self.name},alias=#{self.alias_name},xpath=#{self.xpath_name}}"
+  		end
+
+      def self.from_xml(node)
+         type_s = node.find_attribute('type', 'http://www.w3.org/2001/XMLSchema-instance')
+         table = ObjectBuilder.get_class_for(type_s).from_xml(node)
+       end
+  	end
+	
+  	# The base type for all table inclusion or drop types used in a cross match expression.
+  	class XMatchTableAlias
+  		def to_s
+  			"{name=#{self.name}}"
+  		end
+	
+  	  def self.from_xml(node)
+  	    #type_s = node.attributes['xsi:type']
+  	    type_s = node.find_attribute('type', 'http://www.w3.org/2001/XMLSchema-instance')
+  	    xtable = ObjectBuilder.get_class_for(type_s).from_xml(node)
+      end
+  	end
+	
+  	# Used for adding a table for the Xmatch operation.
+  	class IncludeTable < XMatchTableAlias
+  		attr_accessor :name
+		
+  		def initialize(name)
+  			self.name = name
+  		end
+	
+  	  def self.from_xml(node)
+  	    name = node.attributes['Name']
+  	    return IncludeTable.new(name)
+  	  end
+  	end
+	
+  	# Used for avoiding a table in Xmatch.
+  	class DropTable < XMatchTableAlias
+  		attr_accessor :name
+		
+  		def initialize(name)
+  			self.name = name
+  		end
+	
+  	  def self.from_xml(node)
+  	    name = node.attributes['Name']
+  	    return DropTable.new(name)
+      end
+  	end
+	
+    # The base type for searches in Where and Having clauses of the query.
+    class Search
+      def self.from_xml(node)
+        type_s = node.find_attribute('type', 'http://www.w3.org/2001/XMLSchema-instance')
+        search = ObjectBuilder.get_class_for(type_s).from_xml(node)
+      end
+    end
+	
+    # Represents expressions like a AND b.
+    class IntersectionSearch < Search
+      attr_reader :cond1, :cond2
+    
+      def initialize(cond1, cond2)
+        self.cond1 = cond1
+        self.cond2 = cond2
+      end
+    
+      def cond1=(cond)
+        VOTables::VOTable::Misc::TypeCheck.new(cond, Search).check()
+        @cond1 = cond
+      end
+    
+      def cond2=(cond)
+        VOTables::VOTable::Misc::TypeCheck.new(cond, Search).check()
+        @cond2 = cond
+      end
+    
+      def to_s
+        "{cond1=#{self.cond1},cond2=#{self.cond2}}"
+      end
+    
+      def self.from_xml(node)
+        cond1_node, cond2_node = node.elements.to_a('Condition')
+        cond1 = Search.from_xml(cond1_node)
+        cond2 = Search.from_xml(cond2_node)
+        return IntersectionSearch.new(cond1, cond2)
+      end
+    
+      # This method finds a condition given its attributes and it returns it
+      def find_condition(type, attributes)
+        condition = self.cond1.find_condition(type, attributes)
+        if condition == nil
+          condition = self.cond2.find_condition(type, attributes)
+        end
+      
+        return condition
+      end
+    
+      # This method removes a condition. -1 means that the condition must
+      # be removed. 1 means that the condition given its attributes wasn't
+      # found, so that the process must continue.
+      def remove_condition(type, attributes)
+        cond1 = self.cond1.remove_condition(type, attributes)
+        if cond1 == -1
+          return self.cond2
+        elsif cond1 == 1
+          cond2 = self.cond2.remove_condition(type, attributes)
+          if cond2 == -1
+            return self.cond1
+          elsif cond2 == 1
+            return 1
+          end
+        else
+          self.cond1 = cond1
+          return self
+        end
+      end
+    
+      # This method modifies a condition given its old attributes,
+      # replacing the old attributes with the new attributes.
+      def modify_condition(type, attributes_old, attributes_new)
+        cond1 = self.cond1.modify_condition(type, attributes_old, attributes_new)
+        if cond1 != nil
+          self.cond1 = cond1
+        else
+          cond2 = self.cond2.modify_condition(type, attributes_old, attributes_new)
+          if cond2 != nil
+            self.cond2 = cond2
+          else
+            return nil
+          end
+        end
+      
+        return self
+      end
+    
+      # This method replaces a condition for a new condition. -1 means that
+      # the condition must be replaced for the new condition. 1 means that
+      # the process must continue.
+      def replace_condition(type, attributes, new_condition)
+        cond1 = self.cond1.replace_condition(type, attributes, new_condition)
+        if cond1 == -1
+          self.cond1 = new_condition
+          return self
+        elsif cond1 == 1
+          cond2 = self.cond2.replace_condition(type, attributes, new_condition)
+          if cond2 == -1
+            self.cond2 = new_condition
+            return self
+          elsif cond2 == 1
+            return 1
+          end
+        else
+          return self
+        end
+      end
+    end
+  
+    # Represents expressions like A Or B.
+    class UnionSearch < Search
+      attr_reader :cond1, :cond2
+    
+      def initialize(cond1, cond2)
+        self.cond1 = cond1
+        self.cond2 = cond2
+      end
+    
+      def cond1=(cond)
+        VOTables::VOTable::Misc::TypeCheck.new(cond, Search).check()
+        @cond1 = cond
+      end
+    
+      def cond2=(cond)
+        VOTables::VOTable::Misc::TypeCheck.new(cond, Search).check()
+        @cond2 = cond
+      end
+    
+      def to_s
+        "{cond1=#{self.cond1},cond2=#{self.cond2}}"
+      end
+    
+      def self.from_xml(node)
+        cond1_node, cond2_node = node.elements.to_a('Condition')
+        cond1 = Search.from_xml(cond1_node)
+        cond2 = Search.from_xml(cond2_node)
+        return UnionSearch.new(cond1, cond2)
+      end
+    
+      # This method finds a condition given its attributes and it returns it
+      def find_condition(type, attributes)
+        condition = self.cond1.find_condition(type, attributes)
+        if condition == nil
+          condition = self.cond2.find_condition(type, attributes)
+        end
+      
+        return condition
+      end
+    
+      # This method removes a condition. -1 means that the condition must
+      # be removed. 1 means that the condition given its attributes wasn't
+      # found, so that the process must continue.
+      def remove_condition(type, attributes)
+        cond1 = self.cond1.remove_condition(type, attributes)
+        if cond1 == -1
+          return self.cond2
+        elsif cond1 == 1
+          cond2 = self.cond2.remove_condition(type, attributes)
+          if cond2 == -1
+            return self.cond1
+          elsif cond2 == 1
+            return 1
+          end
+        else
+          self.cond1 = cond1
+          return self
+        end
+      end
+    
+      # This method modifies a condition given its old attributes,
+      # replacing the old attributes with the new attributes.
+      def modify_condition(type, attributes_old, attributes_new)
+        cond1 = self.cond1.modify_condition(type, attributes_old, attributes_new)
+        if cond1 != nil
+          self.cond1 = cond1
+        else
+          cond2 = self.cond2.modify_condition(type, attributes_old, attributes_new)
+          if cond2 != nil
+            self.cond2 = cond2
+          else
+            return nil
+          end
+        end
+      
+        return self
+      end
+    
+      # This method replaces a condition for a new condition. -1 means that
+      # the condition must be replaced for the new condition. 1 means that
+      # the process must continue
+      def replace_condition(type, attributes, new_condition)
+        cond1 = self.cond1.replace_condition(type, attributes, new_condition)
+        if cond1 == -1
+          self.cond1 = new_condition
+          return self
+        elsif cond1 == 1
+          cond2 = self.cond2.replace_condition(type, attributes, new_condition)
+          if cond2 == -1
+            self.cond2 = new_condition
+            return self
+          elsif cond2 == 1
+            return 1
+          end
+        else
+          return self
+        end
+      end
+    end
+	
+  	# A cross match expression.
+  	class XMatch < Search
+  		attr_reader :tables, :nature, :sigma
+		
+  		def initialize(tables, nature, sigma)
+  			self.tables = tables
+  			self.nature = nature
+  			self.sigma = sigma
+  		end
+		
+  		def tables=(ts)
+  			raise "Specify at least two tables" if !ts or ts.length < 2
+			
+  			ts.each do |t|
+  				VOTables::VOTable::Misc::TypeCheck.new(t, XMatchTableAlias)
+  			end
+			
+  			@tables = ts
+  		end
+		
+  		def nature=(n)
+  			begin
+  				VOTables::VOTable::Misc::TypeCheck.new(n, Comparison).check()
+  			rescue VOTables::VOTable::Misc::TypeException
+  				@nature = Comparison.new(n)
+  			else
+  				@nature = n
+  			end
+  		end
+		
+  		def sigma=(s)
+  			begin
+  				VOTables::VOTable::Misc::TypeCheck.new(s, NumberType).check()
+  			rescue VOTables::VOTable::Misc::TypeException
+  				if s.is_a?(Float)
+  					@sigma = RealType.new(s)
+  				elsif s.is_a?(Integer)
+  					@sigma = IntegerType.new(s)
+  				else
+  					raise "Sigma must be a float or integer"
+  				end
+  			else
+  				@sigma = s
+  			end
+  		end
+		
+  		def to_s
+  			tables = self.tables.collect{|x| x.to_s}.join('|')
+  			"{tables=#{tables},nature=#{self.nature},sigma=#{self.sigma}}"
+  		end
+	
+  	  def self.from_xml(node)
+  	    tables = []
+  	    node.elements.each('Table') do |tbl_node|
+  	      table = XMatchTableAlias.from_xml(tbl_node)
+  	      tables.push(table)
+  	    end
+	  
+  	    nature_node = REXML::XPath.first(node, 'Nature')
+  	    nature = Nature.from_xml(nature_node)
+	    
+  	    sigma_node = REXML::XPath.first(node, 'Sigma')
+  	    sigma = Sigma.from_xml(sigma_node)
+	    
+  	    return XMatch.new(tables, nature, sigma)
+  	  end
+  	end
+	
+    # The Like expression of a query.
+    class LikePred < Search
+      attr_reader :arg, :pattern
+    
+      def initialize(arg, pattern)
+        self.arg = arg
+        self.pattern = pattern
+      end
+    
+      def arg=(a)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(a, ScalarExpression).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @arg = ScalarExpression.new(a)
+          else
+            @arg = a
+        end
+      end
+    
+      def pattern=(p)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(p, Atom).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @pattern = Atom.new(p)
+          else
+            @pattern = p
+        end
+      end
+    
+      def to_s
+        "{arg=#{self.arg},pattern=#{self.pattern}}"
+      end
+    
+      def self.from_xml(node)
+        arg_node = REXML::XPath.first(node, 'Arg')
+        arg = Arg.from_xml(arg_node)
+        pattern_node = REXML::XPath.first(node, 'Pattern')
+        pattern = Pattern.from_xml(pattern_node)
+      
+        return LikePred.new(arg, pattern)
+      end
+    
+      def self.create_new_object(attributes)
+        arg = ColumnReference.new(attributes['table'], attributes['name'], nil)
+        pattern = StringType.new(attributes['pattern'])
+        return LikePred.new(arg, pattern)
+      end
+    
+      def match_attributtes(attributes)
+        return true if self.arg.table == attributes['table'] and
+            self.arg.name == attributes['name'] and
+            self.pattern.literal.value == attributes['pattern']
+        return false
+      end
+    
+      # This method finds a condition given its attributes and it returns it
+      def find_condition(type, attributes)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          return self if self.match_attributtes(attributes)
+          return nil
+        end
+        return nil
+      end
+    
+      # This method removes a condition. -1 means that the condition must
+      # be removed. 1 means that the condition given its attributes wasn't
+      # found, so that the process must continue.
+      def remove_condition(type, attributes)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          return -1 if self.match_attributtes(attributes)
+          return 1
+        end
+        return 1
+      end
+    
+      # This method modifies a condition given its old attributes,
+      # replacing the old attributes with the new attributes.
+      def modify_condition(type, attributes_old, attributes_new)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          if self.match_attributtes(attributes_old)
+            return LikePred.create_new_object(attributes_new)
+          else
+            return nil
+          end
+        end
+        return nil
+      end
+    
+      # This method replaces a condition given its attributes.
+      # Returns -1 if the object must be replaced, or returns 1 if 
+      # isn't the object that must be replaced, so the process must continue
+      def replace_condition(type, attributes, new_condition)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          return -1 if self.match_attributtes(attributes)
+          return 1
+        end
+        return 1
+      end
+    end
+	
+  	# The Not Like expression of a query.
+  	class NotLikePred < LikePred
+  	  def self.from_xml(node)
+  	    arg_node = REXML::XPath.first(node, 'Arg')
+  	    arg = Arg.from_xml(arg_node)
+  	    pattern_node = REXML::XPath.first(node, 'Pattern')
+  	    pattern = Pattern.from_xml(pattern_node)
+  	    return NotLikePred.new(arg, pattern)
+      end
+  	end
+	
+  	# Represents SQL NOT IN expression.
+  	class ExclusiveSearch < Search
+  		attr_reader :expression, :set
+		
+  		def initialize(expression, set)
+  			self.expression = expression
+  			self.set = set
+  		end
+		
+  		def expression=(e)
+  			begin
+  				VOTables::VOTable::Misc::TypeCheck.new(e, ScalarExpression).check()
+  			rescue VOTables::VOTable::Misc::TypeException
+  				@expression = ScalarExpression.new(e)
+  			else
+  				@expression = e
+  			end
+  		end
+		
+  		def set=(s)
+  			VOTables::VOTable::Misc::TypeCheck.new(s, InclusionSet).check()
+  			@set = s
+  		end
+		
+  		def to_s
+  			"{expression=#{self.expression},set=#{self.set}}"
+  		end
+	
+  	  def self.from_xml(node)
+         expr_node = REXML::XPath.first(node, 'Expression')
+         expr = Expression.from_xml(expr_node)
+         set_node = REXML::XPath.first(node, 'Set')
+         set = Set.from_xml(set_node)
+         return ExclusiveSearch.new(expr, set)
+       end
+  	end
+	
+  	# The base type for selection set in a SQL IN expression.
+  	class InclusionSet
+  	  def self.from_xml(node)
+  	    #type_s = node.attributes['xsi:type']
+  	    type_s = node.find_attribute('type', 'http://www.w3.org/2001/XMLSchema-instance')
+  	    return ObjectBuilder.get_class_for(type_s).from_xml(node)
+  	  end
+  	end
+	
+  	# Represents the subquery in a SQL IN expression.
+  	class SubQuerySet < InclusionSet
+  		attr_reader :selection
+		
+  		def initialize(selection)
+  			self.selection = selection
+  		end
+		
+  		def selection=(s)
+  			VOTables::VOTable::Misc::TypeCheck.new(s, Select).check()
+  			@selection = s
+  		end
+		
+  		def to_s
+  			"{selection=#{self.selection}}"
+  		end
+	
+  	  def self.from_xml(node)
+  	    select_node = REXML::XPath.first(node, 'Select')
+  	    select = Select.from_xml(select_node)
+  	    return SubQuerySet.new(select)
+  	  end
+  	end
+	
+  	# Represents expressions like (A).
+  	class ClosedSearch < Search
+  		attr_reader :condition
+		
+  		def initialize(condition)
+  			self.condition = condition
+  		end
+		
+  		def condition=(c)
+  			VOTables::VOTable::Misc::TypeCheck.new(c, Search).check()
+  			@condition = c
+  		end
+		
+  		def to_s
+  			"{condition=#{self.condition}}"
+  		end
+
+      def self.from_xml(node)
+        cond_node = REXML::XPath.first(node, 'Condition')
+        cond = Condition.from_xml(cond_node)
+        return ClosedSearch.new(cond)
+      end
+  	end
+	
+    # Represents the Comparison of two expressions.
+    class ComparisonPred < Search
+      attr_reader :arg1, :arg2, :comparison
+    
+      def initialize(arg1, comparison, arg2)
+        self.arg1 = arg1
+        self.comparison = comparison
+        self.arg2 = arg2
+      end
+    
+      def arg1=(a)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(a, ScalarExpression).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @arg1 = ScalarExpression.new(a)
+          else
+            @arg1 = a
+        end
+      end
+    
+      def arg2=(a)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(a, ScalarExpression).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @arg2 = ScalarExpression.new(a)
+          else
+            @arg2 = a
+        end
+      end
+    
+      def comparison=(c)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(c, Comparison).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @comparison = Comparison.new(c)
+          else
+            @comparison = c
+        end
+      end
+    
+      def to_s
+        "{arg1=#{self.arg1},comparison=#{self.comparison},arg2=#{self.arg2}}"
+      end
+    
+      def self.from_xml(node)
+        comparison_s = node.attributes['Comparison']
+        arg1_node, arg2_node = node.elements.to_a('Arg')
+        arg1 = Arg.from_xml(arg1_node)
+        arg2 = Arg.from_xml(arg2_node)
+      
+        return ComparisonPred.new(arg1, comparison_s, arg2)
+      end
+    
+      def self.create_new_object(attributes)
+        arg1 = ColumnReference.new(attributes['table'], attributes['name'], nil)
+      
+        arg2 = nil
+        if attributes['value'].is_a?(Float)
+          arg2 = Atom.new(RealType.new(attributes['value']))
+        elsif attributes['value'].is_a?(Integer)
+          arg2 = Atom.new(IntegerType.new(attributes['value']))
+        elsif attributes['value'].is_a?(String)
+          arg2 = Atom.new(StringType.new(attributes['value']))
+        else
+          raise "value is not a real, integer or string"
+        end
+      
+        return ComparisonPred.new(arg1, attributes['comparison'], arg2)
+      end
+    
+      def match_attributtes(attributes)
+        return true if self.arg1.table == attributes['table'] and
+            self.arg1.name == attributes['name'] and
+            self.comparison.value == attributes['comparison'] and
+            self.arg2.literal.value == attributes['value']
+        return false
+      end
+    
+      # This method finds a condition given its attributes and it returns it
+      def find_condition(type, attributes)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          return self if self.match_attributtes(attributes)
+          return nil
+        end
+        return nil
+      end
+    
+      # This method removes a condition. -1 means that the condition must
+      # be removed. 1 means that the condition given its attributes wasn't
+      # found, so that the process must continue.
+      def remove_condition(type, attributes)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          return -1 if self.match_attributtes(attributes)
+          return 1
+        end
+        return 1
+      end
+    
+      # This method modifies a condition given its old attributes,
+      # replacing the old attributes with the new attributes.
+      def modify_condition(type, attributes_old, attributes_new)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          if self.match_attributtes(attributes_old)
+            return ComparisonPred.create_new_object(attributes_new)
+          else
+            return nil
+          end
+        end
+        return nil
+      end
+    
+      # This method replaces a condition given its attributes.
+      # Returns -1 if the object must be replaced, or returns 1 if 
+      # isn't the object that must be replaced, so the process must continue
+      def replace_condition(type, attributes, new_condition)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          return -1 if self.match_attributtes(attributes)
+          return 1
+        end
+        return 1
+      end
+    end
+  
+    # Represents the Between expression of a query.
+    class BetweenPred < Search
+      attr_reader :arg1, :arg2, :arg3
+    
+      def initialize(arg1, arg2, arg3)
+        self.arg1 = arg1
+        self.arg2 = arg2
+        self.arg3 = arg3
+      end
+    
+      def arg1=(a)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(a, ScalarExpression).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @arg1 = ScalarExpression.new(a)
+          else
+            @arg1 = a
+        end
+      end
+    
+      def arg2=(a)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(a, ScalarExpression).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @arg2 = ScalarExpression.new(a)
+          else
+            @arg2 = a
+        end
+      end
+    
+      def arg3=(a)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(a, ScalarExpression).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @arg3 = ScalarExpression.new(a)
+          else
+            @arg3 = a
+        end
+      end
+    
+      def to_s
+        "{arg1=#{self.arg1},arg2=#{self.arg2},arg3=#{self.arg3}}"
+      end
+    
+      def self.from_xml(node)
+        arg1_node, arg2_node, arg3_node = node.elements.to_a('Arg')
+  	  arg1 = Arg.from_xml(arg1_node)
+  	  arg2 = Arg.from_xml(arg2_node)
+  	  arg3 = Arg.from_xml(arg3_node)
+	  
+  	  return BetweenPred.new(arg1, arg2, arg3)
+      end
+    
+      def self.create_new_object(attributes)
+        arg1 = ColumnReference.new(attributes['table'], attributes['name'], nil)
+      
+        arg2 = nil
+        arg3 = nil
+        if attributes['value_min'].is_a?(Float) and attributes['value_max'].is_a?(Float)
+          arg2 = Atom.new(RealType.new(attributes['value_min']))
+          arg3 = Atom.new(RealType.new(attributes['value_max']))
+        elsif attributes['value_min'].is_a?(Integer) and attributes['value_max'].is_a?(Integer)
+          arg2 = Atom.new(IntegerType.new(attributes['value_min']))
+          arg3 = Atom.new(IntegerType.new(attributes['value_max']))
+        else
+          raise "value is not a real or integer"
+        end
+      
+        return BetweenPred.new(arg1, arg2, arg3)
+      end
+    
+      def match_attributtes(attributes)
+        return true if self.arg1.table == attributes['table'] and
+            self.arg1.name == attributes['name'] and
+            self.arg2.literal.value == attributes['value_min'] and
+            self.arg3.literal.value == attributes['value_max']
+        return false
+      end
+    
+      # This method finds a condition given its attributes and it returns it
+      def find_condition(type, attributes)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          return self if self.match_attributtes(attributes)
+          return nil
+        end
+        return nil
+      end
+    
+      # This method removes a condition. -1 means that the condition must
+      # be removed. 1 means that the condition given its attributes wasn't
+      # found, so that the process must continue.
+      def remove_condition(type, attributes)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          return -1 if self.match_attributtes(attributes)
+          return 1
+        end
+        return 1
+      end
+    
+      # This method modifies a condition given its old attributes,
+      # replacing the old attributes with the new attributes.
+      def modify_condition(type, attributes_old, attributes_new)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          if self.match_attributtes(attributes_old)
+            return BetweenPred.create_new_object(attributes_new)
+          else
+            return nil
+          end
+        end
+        return nil
+      end
+    
+      # This method replaces a condition given its attributes.
+      # Returns -1 if the object must be replaced, or returns 1 if 
+      # isn't the object that must be replaced, so the process must continue
+      def replace_condition(type, attributes, new_condition)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          return -1 if self.match_attributtes(attributes)
+          return 1
+        end
+        return 1
+      end
+    end
+	
+  	# Represents expressions like Not A.
+  	class NotBetweenPred < BetweenPred
+  	  def self.from_xml(node)
+    	  arg1_node, arg2_node, arg3_node = node.elements.to_a('Arg')
+    	  arg1 = Arg.from_xml(arg1_node)
+    	  arg2 = Arg.from_xml(arg2_node)
+    	  arg3 = Arg.from_xml(arg3_node)
+    	  return NotBetweenPred.new(arg1, arg2, arg3)
+      end
+  	end
+  
+    # Abstract Shape type. Shape definitions; Allsky, Circle, Polygon, 
+    # Box, and Sector are derived from Shape; Ellipse is derived from 
+    # Circle; Polygon includes also Vertex and SmallCircle
+    class Shape
+      def self.from_xml(node)
+        type_s = node.find_attribute('type', 'http://www.w3.org/2001/XMLSchema-instance')
+        type_s = type_s.slice(type_s.index(':')+1, type_s.length)
+        return ObjectBuilder.get_class_for(type_s).from_xml(node)
+      end
+    end
+  
+    # Circle shape. The circle is defined by a center and a radius
+    class Circle < Shape
+      attr_reader :ra, :dec, :radius, :system, :shape
+    
+      def initialize(ra, dec, radius, system='J2000')
+        self.ra = ra
+        self.dec = dec
+        self.radius = radius
+        self.system = system
+        self.shape = 'CIRCLE'
+      end
+    
+      def ra=(ra)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(ra, RealType).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @ra = RealType.new(ra)
+          else
+            @ra = ra
+        end
+      end
+    
+      def dec=(dec)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(dec, RealType).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @dec = RealType.new(dec)
+          else
+            @dec = dec
+        end
+      end
+    
+      def radius=(radius)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(radius, RealType).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @radius = RealType.new(radius)
+          else
+            @radius = radius
+        end
+      end
+    
+      def system=(sys)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(sys, StringType).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @system = StringType.new(sys)
+          else
+            @system = sys
+        end
+      end
+    
+      def shape=(sh)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(sh, StringType).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @shape = StringType.new(sh)
+          else
+            @shape = sh
+        end
+      end
+    
+      def to_s
+        "{shape=#{self.shape},system=#{self.system},ra=#{self.ra},dec=#{self.dec},radius=#{self.radius}}"
+      end
+    
+      def self.from_xml(node)
+        unit = node.attributes['unit'] || 'deg'
+      
+        center = REXML::XPath.first(node, 'reg:Center', {'reg' => 'http://www.ivoa.net/xml/STC/STCregion/v1.10'}).text
+        ra_s, dec_s = center.split(/\s+/)
+        ra = RealType.new(ra_s.to_f)
+        dec = RealType.new(dec_s.to_f)
+      
+        radius_s = REXML::XPath.first(node, 'reg:Radius', {'reg' => 'http://www.ivoa.net/xml/STC/STCregion/v1.10'}).text
+        radius = RealType.new(radius_s.to_f)
+      
+        return Circle.new(ra, dec, radius)
+      end
+    
+      def self.create_new_object(attributes)
+        ra = RealType.new(attributes['ra'])
+        dec = RealType.new(attributes['dec'])
+        radius = RealType.new(attributes['radius'])
+      
+        return Circle.new(ra, dec, radius)
+      end
+    
+      def match_attributtes(attributes)
+        return true if self.ra.value == attributes['ra'] and
+            self.dec.value == attributes['dec'] and
+            self.radius.value == attributes['radius']
+        return false
+      end
+    end
+  
+    # Box shape. The box is defined by a center and a size
+    class Box < Shape
+      attr_reader :ra, :dec, :dra, :ddec, :system, :shape
+    
+      def initialize(ra, dec, dra, ddec, system='J2000')
+        self.ra = ra
+        self.dec = dec
+        self.dra = dra#deltha RA
+        self.ddec = ddec#deltha DEC
+        self.system = system
+        self.shape = 'BOX'
+      end
+    
+      def ra=(ra)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(ra, RealType).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @ra = RealType.new(ra)
+          else
+            @ra = ra
+        end
+      end
+    
+      def dec=(dec)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(dec, RealType).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @dec = RealType.new(dec)
+          else
+            @dec = dec
+        end
+      end
+    
+      def dra=(dra)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(dra, RealType).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @dra = RealType.new(dra)
+          else
+            @dra = dra
+        end
+      end
+    
+      def ddec=(ddec)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(ddec, RealType).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @ddec = RealType.new(ddec)
+          else
+            @ddec = ddec
+        end
+      end
+    
+      def system=(sys)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(sys, StringType).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @system = StringType.new(sys)
+          else
+            @system = sys
+        end
+      end
+    
+      def shape=(sh)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(sh, StringType).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @shape = StringType.new(sh)
+          else
+            @shape = sh
+        end
+      end
+    
+      def to_s
+        "{shape=#{self.shape},system=#{self.system},ra=#{self.ra}," +
+        "dec=#{self.dec},dra=#{self.dra},ddec=#{self.ddec}}"
+      end
+    
+      def self.from_xml(node)
+        unit = node.attributes['unit'] || 'deg'
+      
+        center = REXML::XPath.first(node, 'reg:Center').text
+        ra_s, dec_s = center.split(/\s+/)
+        ra = RealType.new(ra_s.to_f)
+        dec = RealType.new(dec_s.to_f)
+      
+        size = REXML::XPath.first(node, 'reg:Size').text
+        dra_s, ddec_s = size.split(/\s+/)
+        dra = RealType.new(dra_s.to_f)
+        ddec = RealType.new(ddec_s.to_f)
+      
+        return Box.new(ra, dec, dra, ddec)
+      end
+    
+      def self.create_new_object(attributes)
+        ra = RealType.new(attributes['ra'])
+        dec = RealType.new(attributes['dec'])
+        dra = RealType.new(attributes['dra'])
+        ddec = RealType.new(attributes['ddec'])
+      
+        return Box.new(ra, dec, dra, ddec)
+      end
+    
+      def match_attributtes(attributes)
+        return true if self.ra.value == attributes['ra'] and
+            self.dec.value == attributes['dec'] and
+            self.dra.value == attributes['dra'] and
+            self.ddec.value == attributes['ddec']
+        return false
+      end
+    end
+  
+    # Represents the Regions such as circle in Where clause.
+    class RegionSearch < Search
+      attr_reader :shape, :intersection
+    
+      def initialize(shape, intersection='overlaps')
+        self.shape = shape
+        self.intersection = intersection
+      end
+    
+      def shape=(s)
+        VOTables::VOTable::Misc::TypeCheck.new(s, Shape).check()
+        @shape = s
+      end
+    
+      def intersection=(i)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(i, StringType).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            @intersection = StringType.new(i)
+          else
+            @intersection = i
+        end
+      end
+    
+      def to_s
+        "{region={intersection=#{self.intersection},shape=#{self.shape}}}"
+      end
+    
+      def self.from_xml(node)
+        inter = node.attributes['intersection'].to_s
+        region_node = REXML::XPath.first(node, 'Region')
+        sh = Shape.from_xml(region_node)
+        return RegionSearch.new(sh, inter)
+      end
+    
+      def self.create_new_object(attributes)
+        sh = ObjectBuilder.get_class_for(attributes['shape_type']).create_new_object(attributes)
+        return RegionSearch.new(sh, attributes['intersection'].to_s)
+      end
+    
+      def match_attributtes(attributes)
+        return self.shape.match_attributtes(attributes)
+      end
+    
+      # This method finds a condition given its attributes and it returns it
+      def find_condition(type, attributes)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          return self if self.match_attributtes(attributes)
+          return nil
+        end
+        return nil
+      end
+    
+      # This method removes a condition. -1 means that the condition must
+      # be removed. 1 means that the condition given its attributes wasn't
+      # found, so that the process must continue.
+      def remove_condition(type, attributes)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          return -1 if self.match_attributtes(attributes)
+          return 1
+        end
+        return 1
+      end
+    
+      # This method modifies a condition given its old attributes,
+      # replacing the old attributes with the new attributes.
+      def modify_condition(type, attributes_old, attributes_new)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          if self.match_attributtes(attributes_old)
+            return RegionSearch.create_new_object(attributes_new)
+          else
+            return nil
+          end
+        end
+        return nil
+      end
+    
+      # This method replaces a condition given its attributes.
+      # Returns -1 if the object must be replaced, or returns 1 if 
+      # isn't the object that must be replaced, so the process must continue
+      def replace_condition(type, attributes, new_condition)
+        if ObjectBuilder.get_class_for(type).to_s() == self.class.to_s()
+          return -1 if self.match_attributtes(attributes)
+          return 1
+        end
+        return 1
+      end
+    end
+	
+  	# Represents expressions like Not A.
+  	class InverseSearch < Search
+  	  attr_reader :condition
+	  
+  	  def initialize(condition)
+  	    self.condition = condition
+      end
+    
+      def condition=(c)
+        VOTables::VOTable::Misc::TypeCheck.new(c, Search).check()
+        @condition = c
+      end
+    
+      def to_s
+        "{condition=#{self.condition}}"
+      end
+    
+      def self.from_xml(node)
+        cond_node = REXML::XPath.first(node, 'Condition')
+        cond = Condition.from_xml(cond_node)
+        return InverseSearch.new(cond)
+      end
+    end
+	
+  	# Represents the Having expression part of a query.
+  	class Having
+  		attr_reader :condition
+		
+  		def initialize(condition)
+  			self.condition = condition
+  		end
+		
+  		def condition=(c)
+  			VOTables::VOTable::Misc::TypeCheck.new(c, Search).check()
+  			@condition = c
+  		end
+		
+  		def to_s
+  			"{condition=#{self.condition}}"
+  		end
+
+      def self.from_xml(node)
+        cond_node = REXML::XPath.first(node, 'Condition')
+        cond = Condition.from_xml(cond_node)
+        return Having.new(cond)
+      end
+  	end
+	
+  	# Represents the Group By expression part of a query.
+  	class GroupBy
+  		attr_reader :columns
+		
+  		def initialize(columns)
+  			self.columns = columns
+  		end
+		
+  		def columns=(c)
+  			raise "Provide at least one condition" if c.size < 1
+		
+  			@columns = []
+  			c.each do |col|
+  				VOTables::VOTable::Misc::TypeCheck.new(col, ColumnReference).check()
+  				@columns.push(col)
+  			end
+  		end
+		
+  		def to_s
+  			cols = self.columns.collect{|x| x.to_s}.join('|')
+  			"{columns=#{cols}}"
+  		end
+	
+  	  def self.from_xml(node)
+  	    columns = []
+  	    node.elements.each('Column') do |col_node|
+  	      col = Column.from_xml(col_node)
+  	      columns.push(col)
+  	    end
+	    
+  	    return GroupBy.new(columns)
+  	  end
+  	end
+	
+    # Represents the Where part of the query.
+    class Where
+      attr_reader :condition
+    
+      def initialize(condition)
+        self.condition = condition
+      end
+    
+      def condition=(c)
+        VOTables::VOTable::Misc::TypeCheck.new(c, Search).check()
+        @condition = c
+      end
+    
+      def to_s
+        "{condition=#{self.condition}}"
+      end
+    
+      def self.from_xml(node)
+        cond_node = REXML::XPath.first(node, 'Condition')
+        cond = Condition.from_xml(cond_node)
+        return Where.new(cond)
+      end
+    
+      # This method finds a condition given its attributes and it returns it
+      def find_condition(type, attributes)
+        return self.condition.find_condition(type, attributes)
+      end
+    
+      # This method removes a condition. -1 means that the condition must
+      # be removed. 1 means that the condition given its attributes wasn't
+      # found. The other case is that the condition was changed in another
+      # place, for example could have been removed in the intersectionSearchType
+      # called.
+      def remove_condition(type, attributes)
+        condition = self.condition.remove_condition(type, attributes)
+        if condition == -1
+          self.condition = nil
+        elsif condition != 1
+          self.condition = condition
+        end
+      end
+    
+      # This method modify a condition given its old attributtes,
+      # replacing the old attributes with the new attributes.
+      def modify_condition(type, attributes_old, attributes_new)
+        self.condition = self.condition.modify_condition(type, attributes_old, attributes_new)
+      end
+    
+      # This method replaces a condition for a new condition. -1 means that
+      # the condition must be replaced. 1 means that the old condition in
+      # this case wasn't found so that the old condition won't be replaced.
+      # The other case is that the condition was changed in another place,
+      # for example could have been replaced in the intersectionSearchType 
+      # called.
+      def replace_condition(type, attributes, new_condition)
+        condition = self.condition.replace_condition(type, attributes, new_condition)
+        if condition == -1
+          self.condition = new_condition
+        elsif condition != 1
+          self.condition = condition
+        end
+      end
+    end
+	
+  	# Represents the From part of the query.
+  	class From
+  	  attr_reader :tables
+	  
+  	  def initialize(tables)
+  	    self.tables = tables
+      end
+    
+      def tables=(ts)
+        raise "Specify at least one table" if ts.size < 1
+      
+        @tables = []
+        ts.each do |t|
+          VOTables::VOTable::Misc::TypeCheck.new(t, FromTable).check()
+          @tables.push(t)
+        end
+      end
+    
+      def to_s
+        tables = self.tables.collect{|x| x.to_s}.join('|')
+        "{tables=#{tables}}"
+      end
+    
+      def self.from_xml(node)
+        table_list = []
+        node.elements.each("Table") do |tbl_node|
+          table = Table.from_xml(tbl_node)
+          table_list.push(table)
+        end
+      
+        return From.new(table_list)
+      end
+    end
+    
+    # List of items to be selected in the Query.
+    class SelectionList
+      attr_reader :items
+    
+      def initialize(items)
+        self.items = items
+      end
+    
+      def items=(is)
+        raise "Specify at least one item" if is.size < 1
+      
+        @items = []
+        is.each do |i|
+          VOTables::VOTable::Misc::TypeCheck.new(i, SelectionItem).check()
+          @items.push(i)
+        end
+      end
+    
+      def to_s
+        items = self.items.collect{|x| x.to_s}.join('|')
+        return "{items=#{items}}"
+      end
+    
+      def self.from_xml(node)
+        item_list = []
+        node.elements.each('Item') do |item_node|
+          item_list.push(Item.from_xml(item_node))
+        end
+      
+        return SelectionList.new(item_list)
+      end
+    
+      def add(attributes)
+        new_item = nil
+        if attributes['name'] == AllSelectionItem.value
+          new_item = AllSelectionItem.new()
+        else
+          new_item = ColumnReference.new(attributes['table'],
+            attributes['name'], attributes['xpath_name'])
+        end
+        self.items.push(new_item) if new_item and find(attributes) == nil
+      end
+    
+      def remove(attributes)
+        remove_item = find(attributes)
+        self.items.delete(remove_item) if remove_item != nil
+      end
+    
+      def find(attributes)
+        self.items().each do |item|
+          if !item.is_a?(AllSelectionItem)
+            return item if item.name() == attributes['name'] and item.table() == attributes['table']
+          elsif item.is_a?(AllSelectionItem)
+            return item if AllSelectionItem.value == attributes['name']
+          end
+        end
+        return nil
+      end
+    
+      def is_empty
+        self.items().empty?
+      end
+    end
+  
+    # Represents the TOP part of a query.
+    class SelectionLimit
+      attr_reader :top
+    
+      def initialize(top)
+        self.top = top
+      end
+    
+      def top=(t)
+        raise "Provide an integer > 0" if t < 1 or !t.is_a?(Integer)
+        @top = t
+      end
+    
+      def to_s
+        "{top=#{self.top}}"
+      end
+    
+      def self.from_xml(node)
+        top = node.attributes['Top'].to_i
+        return SelectionLimit.new(top)
+      end
+    end
+  
+    # Represents the SQL INTO expression.
+    class Into
+      attr_accessor :table_name
+    
+      def initialize(name)
+        self.table_name = name
+      end
+    
+      def to_s
+        "{table_name=#{self.table_name}}"
+      end
+  
+      def self.from_xml(node)
+        table_name_node = REXML::XPath.first(node, 'TableName')
+        table_name = TableName.from_xml(table_name_node)
+        return Into.new(table_name)
+      end
+    end
+  
+    # Ascending or Descending order of an Order by term.
+    class OrderDirection
+      attr_reader :value
+    
+      @@options = ['ASC', 'DESC']
+    
+      def initialize(value, options_list=nil)
+        @options_list = options_list || @@options
+        self.value = value
+      end
+    
+      def value=(v)
+        if @options_list.include?(v)
+    				@value = v
+    		else
+    			raise "Value is not valid.  Use one of: " +
+    				@options_list.join(', ')
+    		end
+      end
+    
+      def to_s
+        "{value=#{self.value}}"
+      end
+    end
+  
+    # Option for setting the direction for Order By.
+    class OrderOption
+      attr_reader :direction
+    
+      def initialize(direction)
+        self.direction = direction
+      end
+    
+      def direction=(d)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(d, OrderDirection).check()
+        rescue VOTables::VOTable::Misc::TypeException
+          @direction = OrderDirection.new(d)
+        else
+          @direction = d
+        end
+      end
+    
+      def to_s
+        "{direction=#{self.direction}}"
+      end
+ 
+      def self.from_xml(node)
+        return OrderOption.new(node.attributes['Direction'])
+      end
+    end
+  
+    # Represents the ORDER BY part of a query.
+    class Order
+      attr_reader :expression, :order
+    
+      def initialize(expression, order=nil)
+        self.expression = expression
+        self.order = order
+      end
+    
+      def expression=(e)
+        VOTables::VOTable::Misc::TypeCheck.new(e, ScalarExpression).check()
+        @expression = e
+      end
+    
+      def order=(o)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(o, OrderOption).check()
+        rescue VOTables::VOTable::Misc::TypeException
+            @order = OrderOption.new(o)
+        else
+          @order = o
+        end
+      end
+    
+      def to_s
+        "{expression=#{self.expression},order=#{self.order}}"
+      end
+ 
+      def self.from_xml(node)
+        expr_node = REXML::XPath.first(node, 'Expression')
+        expr = Expression.from_xml(expr_node)
+        order_option_node = REXML::XPath.first(node, 'Order')
+        order_option = OrderOption.from_xml(order_option_node)
+        return Order.new(expr, order_option)
+      end
+    end
+  
+    # List of expressions in which order the results should be provided.
+    class OrderExpression
+      attr_reader :items
+    
+      def initialize(items)
+        self.items = items
+      end
+    
+      def items=(is)
+        raise "Specify at least one item" if is.size < 1
+      
+        @items = []
+        is.each do |i|
+          VOTables::VOTable::Misc::TypeCheck.new(i, Order).check()
+          @items.push(i)
+        end
+      end
+    
+      def to_s
+        items = self.items.collect{|x| x.to_s}.join('|')
+        "{items=#{items}}"
+      end
+ 
+      def self.from_xml(node)
+        items = []
+        node.elements.each('Item') do |item_node|
+          item = Item.from_xml(item_node)
+          items.push(item)
+        end
+      
+        return OrderExpression.new(items)
+      end
+    end
+  
+    # Represents a list of constants provided for a SQL IN expression.
+    class ConstantListSet < InclusionSet
+      attr_reader :items
+    
+      def initialize(items)
+        self.items = items
+      end
+    
+      def items=(is)
+        raise "Specify at least one item" if is.size < 1
+      
+        @items = []
+        is.each do |i|
+          begin
+            VOTables::VOTable::Misc::TypeCheck.new(i, LiteralType).check()
+          rescue VOTables::VOTable::Misc::TypeException
+            if i.is_a?(String)
+              @items.push(StringType.new(i))
+            elsif i.is_a?(Integer)
+              @items.push(IntegerType.new(i))
+            elsif i.is_a?(Float)
+              @items.push(RealType.new(i))
+            else
+              raise "Item must be of type LiteralType"
+            end
+          else
+            @items.push(i)
+          end
+        end
+      end
+    
+      def to_s
+        items = self.items.collect{|x| x.to_s}.join('|')
+        "{items=#{items}}"
+      end
+ 
+      def self.from_xml(node)
+        item_list = []
+        node.elements.each('Item') do |item_node|
+          item = Item.from_xml(item_node)
+          item_list.push(Item.from_xml(item_node))
+        end
+  
+        return ConstantListSet.new(item_list)
+      end
+    end
+  
+    # Represents SQL IN expression.
+    class InclusiveSearch < Search
+      attr_reader :expression, :set
+    
+      def initialize(expression, set)
+        self.expression = expression
+        self.set = set
+      end
+    
+      def expression=(e)
+        VOTables::VOTable::Misc::TypeCheck.new(e, ScalarExpression).check()
+        @expression = e
+      end
+    
+      def set=(s)
+        VOTables::VOTable::Misc::TypeCheck.new(s, InclusionSet).check()
+        @set = s
+      end
+    
+      def to_s
+        "{expression=#{self.expression},set=#{self.set}}"
+      end
+ 
+      def self.from_xml(node)
+        expr_node = REXML::XPath.first(node, 'Expression')
+        expr = Expression.from_xml(expr_node)
+        set_node = REXML::XPath.first(node, 'Set')
+        set = Set.from_xml(set_node)
+        return InclusiveSearch.new(expr, set)
+      end
+    end
+  
+    # The SELECT part of a query.
+    class Select
+      attr_reader :allow, :restrict, :selection_list, :in_to, :from,
+        :where, :group_by, :having, :order_by
+      attr_accessor :start_comment, :end_comment
+    
+      def initialize(selection_list, allow=nil, restrict=nil, in_to=nil,
+        from=nil, where=nil, group_by=nil, having=nil, order_by=nil,
+        start_comment=nil, end_comment=nil)
+        self.selection_list = selection_list
+        self.allow = allow
+        self.restrict = restrict
+        self.in_to = in_to
+        self.from = from
+        self.where = where
+        self.group_by = group_by
+        self.having = having
+        self.order_by = order_by
+        self.start_comment = start_comment
+        self.end_comment = end_comment
+      end
+  
+      def selection_list=(sl)
+        VOTables::VOTable::Misc::TypeCheck.new(sl, SelectionList).check()
+        @selection_list = sl
+      end
+  
+      def allow=(a)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(a, SelectionOption).check()
+        rescue VOTables::VOTable::Misc::TypeException
+          @allow = SelectionOption.new(a)
+        else
+          @allow = a
+        end
+      end
+  
+      def restrict=(r)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(r, SelectionLimit).check()
+        rescue VOTables::VOTable::Misc::TypeException
+          @restrict = SelectionLimit.new(r)
+        else
+          @restrict = r
+        end
+      end
+    
+      def in_to=(it)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(it, Into).check()
+        rescue VOTables::VOTable::Misc::TypeException
+          @in_to = Into.new(it)
+        else
+          @in_to = it
+        end
+      end
+    
+      def from=(f)
+        VOTables::VOTable::Misc::TypeCheck.new(f, From).check()
+        @from = f
+      end
+    
+      def where=(w)
+        VOTables::VOTable::Misc::TypeCheck.new(w, Where).check()
+        @where = w
+      end
+    
+      def group_by=(gb)
+        VOTables::VOTable::Misc::TypeCheck.new(gb, GroupBy).check()
+        @group_by = gb
+      end
+    
+      def having=(h)
+        VOTables::VOTable::Misc::TypeCheck.new(h, Having).check()
+        @having = h
+      end
+    
+      def order_by=(ob)
+        VOTables::VOTable::Misc::TypeCheck.new(ob, OrderExpression).check()
+        @order_by = ob
+      end
+    
+      def to_s
+        "{allow=#{self.allow},restrict=#{self.restrict},selection_list=#{self.selection_list}," +
+        "in_to=#{self.in_to},from=#{self.from},where=#{self.where},group_by=#{self.group_by}," +
+        "having=#{self.having},order_by=#{self.order_by},start_comment=#{self.start_comment}," +
+        "end_comment=#{self.end_comment}}"
+      end
+    
+      def to_file(file_path)
+        file = File.new(file_path, 'w')
+        file.syswrite(self.to_adqlx)
+        file.close()
+      end
+    
+      def self.from_xml(node)
+          # SelectionList
+          sl_node = REXML::XPath.first(node, 'SelectionList') or raise "No SelectionList element"
+          selection_list = SelectionList.from_xml(sl_node)
+        
+          # Allow
+          allow_node = REXML::XPath.first(node, 'Allow')
+          allow = nil
+          allow = Allow.from_xml(allow_node) if allow_node
+        
+          # Restrict
+          restrict_node = REXML::XPath.first(node, 'Restrict')
+          restrict = nil
+          restrict = Restrict.from_xml(restrict_node) if restrict_node
+        
+          # InTo
+          into_node = REXML::XPath.first(node, 'InTo')
+          into = nil
+          into = InTo.from_xml(into_node) if into_node
+        
+          # From
+          from_node = REXML::XPath.first(node, 'From')
+          from = nil
+          from = From.from_xml(from_node) if from_node
+        
+          # Where
+          where_node = REXML::XPath.first(node, 'Where')
+          where = nil
+          where = Where.from_xml(where_node) if where_node
+        
+          # GroupBy
+          groupby_node = REXML::XPath.first(node, 'GroupBy')
+          groupby = nil
+          groupby = GroupBy.from_xml(groupby_node) if groupby_node
+        
+          # Having
+          having_node = REXML::XPath.first(node, 'Having')
+          having = nil
+          having = Having.from_xml(having_node) if having_node
+        
+          # OrderBy
+          orderby_node = REXML::XPath.first(node, 'OrderBy')
+          orderby = nil
+          orderby = OrderBy.from_xml(orderby_node) if orderby_node
+        
+          # StartComment
+          start_comment_node = REXML::XPath.first(node, 'StartComment')
+          start_comment = nil
+          start_comment = StartComment.from_xml(start_comment_node) if start_comment_node
+        
+          # EndComment
+          end_comment_node = REXML::XPath.first(node, 'EndComment')
+          end_comment = nil
+          end_comment = EndComment.from_xml(end_comment_node) if end_comment_node
+        
+          return Select.new(selection_list, allow, restrict, into,
+                            from, where, groupby, having, orderby,
+                            start_comment, end_comment)
+        end
+    end
+  
+    # Represents user defined function expressions.
+    class UserDefinedFunction < ScalarExpression
+      attr_accessor :name
+      attr_reader :params
+    
+      def initialize(name, params=nil)
+        self.name = name
+        self.params = params
+      end
+    
+      def params=(ps)
+        if ps
+          raise "Provide at least 1 parameter" if ps.size < 1
+        
+          @params = []
+          ps.each do |p|
+            VOTables::VOTable::Misc::TypeCheck.new(p, ScalarExpression)
+            @params.push(p)
+          end
+        end
+      end
+    
+      def to_s
+        params = self.params.collect{|x| x.to_s}.join('|')
+        "{name=#{self.name},params=#{params}}"
+      end
+    
+      def self.from_xml(node)
+        name = REXML::XPath.first(node, 'Name').text
+        params = []
+        node.elements.each('Params') do |param_node|
+          params.push(ScalarExpression.from_xml(param_node))
+        end
+        params = nil if params.size < 1
+        return UserDefinedFunction.new(name, params)
+      end
+    end
+  
+    # Denotes the type of a Join operation.
+    class JointTableQualifier
+      attr_reader :value
+    
+      @@joins = ['LEFT_OUTER', 'RIGHT_OUTER', 'FULL_OUTER',
+                 'INNER', 'CROSS']
+    
+      def initialize(value, join_list=nil)
+        @join_list = join_list || @@joins
+        self.value = value
+      end
+    
+      def value=(v)
+        if @join_list.include?(v)
+          @value = v
+        else
+          raise "Join type is not valid.  Use one of: " +
+  					@join_list.join(', ')
+        end
+      end
+    
+      def to_s
+        "{value=#{self.value}}"
+      end
+
+      def self.from_xml(node)
+        return JointTableQualifier.new(node.text)
+      end
+    end
+  
+    # Represents SQL JOIN expression.
+    class JoinTable < FromTable
+      attr_reader :qualifier, :tables, :condition
+    
+      def initialize(qualifier, tables, condition)
+        self.qualifier = qualifier
+        self.tables = tables
+        self.condition = condition
+      end
+    
+      def qualifier=(q)
+        begin
+          VOTables::VOTable::Misc::TypeCheck.new(q, JointTableQualifier).check()
+        rescue VOTables::VOTable::Misc::TypeException
+          @qualifier = JointTableQualifier.new(q)
+        else
+          @qualifier = q
+        end
+      end
+    
+      def tables=(ts)
+        VOTables::VOTable::Misc::TypeCheck.new(ts, ArrayOfFromTable).check()
+        @tables = ts
+      end
+    
+      def condition=(c)
+        VOTables::VOTable::Misc::TypeCheck.new(c, ComparisonPred).check()
+        @condition = c
+      end
+    
+      def to_s
+        "{qualifier=#{self.qualifier},tables=#{self.tables},condition=#{self.condition}}"
+      end
+  
+      def self.from_xml(node)
+        qual_node = REXML::XPath.first(node, 'Qualifier')
+        qual = Qualifier.from_xml(qual_node)
+        tables_node = REXML::XPath.first(node, 'Tables')
+        tables = Tables.from_xml(tables_node)
+        cond_node = REXML::XPath.first(node, 'Condition')
+        cond = Condition.from_xml(cond_node)
+        return JoinTable.new(qual, tables, cond)
+      end
+    end
+  
+    # Represents an array of tables in the from expression.def expression.
+    class ArrayOfFromTable
+      attr_reader :from_tables
+    
+      def initialize(tables)
+        self.from_tables = tables
+      end
+    
+      def from_tables=(fts)
+        raise "Provide at least one table" if fts.size < 1
+      
+        @from_tables = []
+        if fts
+          fts.each do |ft|
+            VOTables::VOTable::Misc::TypeCheck.new(ft, FromTable)
+            @from_tables.push(ft)
+          end
+        end
+      end
+    
+      def to_s
+        tables = self.from_tables.collect{|x| x.to_s}.join('|')
+        "{from_tables=#{tables}}"
+      end
+  
+      def self.from_xml(node)
+        from_tables = []
+        node.elements.to_a('Table').each do |ftbl|
+          from_tables.push(FromTable.from_xml(ftbl))
+        end
+      
+        return ArrayOfFromTable.new(from_tables)
+      end
+    end
+  
+  end
+
+end