voruby 1.1.1 → 2.0.0

data/REQUIREMENTS

@@ -1,6 +0,0 @@
-* ruby >= 1.8.6
-* libxml (http://xmlsoft.org/)
-* libxml-ruby installed via gem (i.e. "gem install libxml-ruby")
-* xml-mapping installed via gem (i.e. "gem install xml-mapping")
-* activerecord installed via gem (i.e. "gem install activerecord") for ActiveVotable
-* activesupport installed via gem (i.e. "gem install activesupport") for ActiveVotable

data/lib/voruby/active_votable/loader.rb

@@ -1,5 +0,0 @@
-require 'voruby/loader'
-
-require 'active_record'
-require 'active_support/inflector'
-require 'xml/libxml'

data/lib/voruby/adql/adql.rb

@@ -1,2787 +0,0 @@
-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 '' #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'] or ''
-      
-        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
-      
-      # This method counts the number of times that a condition appears.
-      def count_condition(attributes, times)
-        times = self.cond1.count_condition(attributes, times)
-        times = self.cond2.count_condition(attributes, times)
-        return times
-      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
-      
-      # This method counts the number of times that a condition appears.
-      def count_condition(attributes, times)
-        times = self.cond1.count_condition(attributes, times)
-        times = self.cond2.count_condition(attributes, times)
-        return times
-      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
-      
-      # This method counts the number of times that a condition appears.
-      def count_condition(attributes, times)
-        return times += 1 if self.arg.table == attributes['table'] and
-            self.arg.name == attributes['name']
-        return times
-      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
-      
-      # This method counts the number of times that a condition appears.
-      def count_condition(attributes, times)
-        return times += 1 if self.arg1.table == attributes['table'] and
-            self.arg1.name == attributes['name']
-        return times
-      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
-      
-      # This method counts the number of times that a condition appears.
-      def count_condition(attributes, times)
-        return times += 1 if self.arg1.table == attributes['table'] and
-            self.arg1.name == attributes['name']
-        return times
-      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'
-        
-        # Find the prefix for STCregion.
-        region_prefix = node.namespaces.index('http://www.ivoa.net/xml/STC/STCregion/v1.10')
-        
-        center_tag = region_prefix ? "#{region_prefix}:Center" : 'Center'
-        center = REXML::XPath.first(node, center_tag).text
-        ra_s, dec_s = center.split(/\s+/)
-        ra = RealType.new(ra_s.to_f)
-        dec = RealType.new(dec_s.to_f)
-        
-        radius_tag = region_prefix ? "#{region_prefix}:Radius" : 'Radius'
-        radius_s = REXML::XPath.first(node, radius_tag).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
-      
-      # This method counts the number of times that a condition appears.
-      def count_condition(attributes, times)
-        #TODO
-        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
-      
-      # This method counts the number of times that a condition appears.
-      def count_condition(attributes)
-        times = 0
-        return self.condition.count_condition(attributes, times)
-      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