trix51db 0.1.0

data/lib/trix51db.rb

@@ -0,0 +1,1865 @@
+# :title:Trix51 Database Engine
+# Trix51 is a simple file based database based on GDBM
+# and Marshal, which provides a powerful query syntax,
+# helper classes, one to one and one to many relationships,
+# calculated fields, indexes and constraints.  It is 
+# designed to replace simpler file based databases and 
+# provide more flexibility.
+#
+# * +Author:+ - April Ayres-Griffiths (aag6581@gmail.com)
+# * +Copyright:+ - Copyright (c) 2012 April Ayres-Griffiths
+# * +License:+ - Distributes under the Apache License
+
+require 'gdbm'
+require 'pp'
+require 'time'
+require 'logger'
+
+BND = binding  #:nodoc:
+
+# This class handles top level management of the database engine
+# and contains various constants and information about active 
+# databases.  It also provides a logger based interface to the 
+# internals of the other database objects.
+class Trix51
+	# Record prefix
+	RECORD_PREFIX = '@R@:'
+	# Metadata Prefix - For table structure records
+	META_PREFIX = '@T@:'
+	# Sequence Prefix - For column sequences for autoincrement fields.
+	SEQ_PREFIX = '@S@:'
+	# Used to join key values in a Record Key
+	KEY_JOIN = ':'
+	
+	@@databases = []
+	@@class_to_database = {}
+	@@class_to_tablename = {}
+	@@table_to_database = {}
+	@@defer_classref = false
+	@@logger = Logger.new('trix51.log')
+	@@logger.level = Logger::WARN
+	
+	def Trix51.add_connection( database )
+	  @@databases.push( database )
+	end
+	
+	def Trix51.add_helper( classname, database, table )
+	  @@class_to_database[ classname ] = database
+	  @@class_to_tablename[ classname ] = table
+	  @@table_to_database[ table.tablename.to_sym ] = database
+	  self.create_helper_code( classname )
+	end
+	
+	# Return a list of active databases managed by the engine
+	def Trix51.connections
+	  return @@databases
+	end
+	
+	# Map a class name (String) to a Trix51::Table reference.
+	def Trix51.class_to_table( cn )
+	  return @@class_to_tablename[ cn ]
+	end
+	
+	# Map a class name (String) to a Trix51::Database reference. 
+	def Trix51.class_to_database( cn )
+	  return @@class_to_database[ cn ]
+	end
+	
+	# Map a tablename to its database.
+	def Trix51.table_to_database( tbl )
+	  return @@table_to_database[ tbl ]
+	end
+	
+	# Log a debug message to the log.
+	def Trix51.debug( msg )
+	  @@logger.debug( msg )
+	end
+	
+	# Log an info level message to the log.
+	def Trix51.info( msg )
+	  @@logger.info( msg )
+	end	
+	
+	# Log a warning message to the log.
+	def Trix51.warn( msg )
+	  @@logger.warn( msg )
+	end
+	
+	# Log an error to the log.
+	def Trix51.error( msg )
+	  @@logger.error( msg )
+	end
+	
+	# Log a fatal message to the log and exit.
+	def Trix51.fatal( msg )
+	  @@logger.debug( msg )
+	end
+	
+	# Generate a helper class for a table.  
+	def Trix51.create_helper_code( classname ) 
+	  return if (classname == 'Trix51::Tuple') or (@@defer_classref == true)
+	  code = <<TEMPLATE
+				class #{classname} < Trix51::Tuple
+	                             
+	                             def #{classname}._table
+					return Trix51.class_to_table( '#{classname}' )
+	                             end
+	                             
+	                             def #{classname}._db
+					return Trix51.class_to_database( '#{classname}' )
+	                             end
+	                             
+	                             def #{classname}.find_or_create( *args )
+	                             
+					return self._table.find_or_create( *args )
+					
+				      end
+				      
+				      def #{classname}.select( *args )
+					return self._table.select( *args )
+				      end
+				      
+				      def #{classname}.delete( *args )
+					return select._table.delete( *args )
+				      end
+				      
+				      def #{classname}.update( *args )
+					return self._table.update( *args )
+				      end
+				     
+				      def #{classname}.first( *args )
+					return self._table.first( *args )
+				      end
+				      
+				      def #{classname}.all
+					return self._table.all
+				      end
+				      
+				      def #{classname}.dump
+					self._table.dump
+				      end
+	                         
+				end
+TEMPLATE
+          #puts code
+	  
+	  eval( code, BND )
+	end
+	
+	# Sets the defer_classref flag to true or false
+	def Trix51.defer_classref=( toggle )
+	  @@defer_classref = toggle
+	end
+	
+	# Returns the value of the defer_classref flag
+	def Trix51.defer_classref
+	  return @@defer_classref
+	end
+	
+END {
+    Trix51.connections.each do |db|
+      db.close
+    end
+  }
+	
+end
+
+# Class for managing a single Trix51 based database, allowing access to tables.
+class Trix51::Database < Trix51
+  
+	# Construct a Trix51::Database object.
+	#
+	# ==== Arguments
+        # * +path:+ - Path to the database file.
+        # * +database:+ - Name of the database file.
+	#
+	# ====Example
+	#    require 'trix51database'
+        #    
+	#    db = Trix51::Database.new( path: './data', database: 'animals.t51' )
+	#
+
+	def initialize( *args )
+
+		@meta_prefix = Trix51::META_PREFIX
+		@tables = {}
+		@args = {
+			:path => './trix',
+			:database => 'database.db'
+		}
+
+		args.each { |key|
+			key.each_pair { |k,v|
+				@args[k] = v
+			}
+		}
+		
+		if not Dir.exist?( @args[:path] ) then
+		  Dir.mkdir( @args[:path] )
+		end
+		
+		# now create / open the dbm file
+		begin
+		  @dbm = GDBM.new( "#{@args[:path]}/#{@args[:database]}" )
+		rescue => e
+		    raise Trix51::DatabaseError, "Unable to open #{@args[:path]}/#{@args[:database]}: #{e.to_s}"
+		end
+		
+		Trix51.add_connection( self )
+		
+		list = self.tables
+		list.each do |tag|
+		  tagref = self.get_table( tag )
+		  Trix51.add_helper( tagref.classname, self, tagref )
+		end
+
+	end
+	
+	# Close the database, cleaning up a persisting indexes to disk.
+	def close
+	  return if @dbm.closed?
+	  @tables.each_value do |tblref|
+	    tblref.indices_save( @args[:path] )
+	  end
+	  @dbm.close
+	end
+	
+	# Returns a reference object for a given table
+	# Raises an exception if the table does not exist.
+	# ==== Arguments
+        # * +tablename:+ - The name of the table (symbol).
+	# ==== Example
+	#    animal = db.get_table( :animal )
+	# Note: you can also use the alias db.animal to access it.
+	#
+	def get_table( tablename )
+	  
+	    # do we have a cached object?
+	    mref = @dbm[ Trix51::META_PREFIX+tablename.to_s ]
+	  
+	    if @tables[tablename].nil? then
+	      mref = @dbm[ Trix51::META_PREFIX+tablename.to_s ]
+	      raise Trix51::NotFoundError, "Table #{tablename.to_s} does not exist." if mref.nil?
+	      @tables[tablename] = Trix51::Table.new( tablename.to_s, @dbm )
+	      @tables[tablename].indices_load( @args[:path] )
+	    end
+	    
+	    return @tables[tablename]
+	    
+	end
+
+	# Create a new table.
+	#
+	# ==== Arguments
+        # * +tablename:+ - The name of the table (symbol).
+        # * +args:+ - A hash specifying the structure of the table.
+	# * +classname:+ - The name of a helper class.
+	#
+	# ==== Example
+	#    require 'trix51database'
+        #    
+	#    animal = db.create_table(
+	#      :animal,
+	#      {
+	#		id: { datatype: 'integer', key: true, autoincrement: true },
+	#		species_id: { datatype: 'integer', required: true, indexed: true },
+	#		species: { datatype: 'record', source: :species_id, table: :species, dest: :id }, 
+	#		name: { datatype: 'string', required: true, unique: true },
+	#		created_date: { datatype: 'datetime', default: '#{Time.new.to_s}' },
+	#		number_of_legs: { datatype: 'integer', default: 4 },
+	#		number_of_eyes: { datatype: 'integer', default: 2 },
+	#		legs_and_eyes: { datatype: 'integer', calculation: 'number_of_legs + number_of_eyes' }
+	#      },
+	#      'Animal'
+	#    )
+	#
+	# ==== Field types
+	# Valid field types are 'string', 'integer', 'datetime', 'float', 'boolean', 'record', 'resultset'
+	#
+	# The 'calculation:' clause fields are evaluated based on other fields in the table.
+	def create_table( tablename, args, classname = 'Trix51::Tuple' )
+	  
+	  mref = @dbm[ Trix51::META_PREFIX+tablename.to_s ]
+	  
+	  if not mref.nil? then
+	    raise Trix51::TableExistsError, "Attempt to create a table that exists..."
+	  end
+	                      
+	  # create it
+	  @dbm[	Trix51::META_PREFIX+tablename.to_s ] = Marshal.dump(
+	    tablename: tablename,
+	    structure: args,
+	    classname: classname
+	  )
+	  @tables[tablename] = Trix51::Table.new( tablename, @dbm )
+		
+          Trix51.add_helper(  @tables[tablename].classname, self,  @tables[tablename] )	  
+	  
+	  return @tables[tablename]
+	  
+	end
+	
+	# Provides a list of the tables in the database.
+	def tables
+	  list = []
+	  @dbm.each_key do |k|
+	    if k.match( Trix51::META_PREFIX )
+	      list.push( k.gsub( Trix51::META_PREFIX, '' ).to_sym )
+	    end
+	  end
+	  return list
+	end
+	
+	def method_missing( methodid ) #:nodoc:
+	  if self.tables.include?( methodid ) then
+	    return self.get_table( methodid )
+	  end
+	  raise Trix51::NotFoundError, "Table #{methodid.to_s } does not exist"
+	end
+	
+	# Return true or false if a given table exists.
+	def has_table?( table ) 
+	  return (self.tables.include?( table ))
+	end
+	
+	# Database accessor
+	attr_accessor :dbm
+
+end
+
+# Exception class
+class Trix51::DatabaseError < StandardError
+end
+
+# Exception class
+class Trix51::NotFoundError < Trix51::DatabaseError
+end
+
+# Exception class
+class Trix51::TableExistsError < Trix51::DatabaseError
+end
+
+# Exception class
+class Trix51::ConstraintError < Trix51::DatabaseError
+end
+
+# Exception class
+class Trix51::TypeError < Trix51::DatabaseError
+end
+
+# Exception class
+class Trix51::ExistsError < Trix51::DatabaseError
+end
+
+# Represents a single record from the database.  
+class Trix51::Tuple < Trix51
+
+  # Create a new tuple object
+  # 
+  # Arguments:
+  # table:: A Trix51::Table object
+  # urid:: A unique record identifier
+  # anonhash:: An optional anonymous hash containing the data for the tuple.
+  def initialize( table, urid, anonhash=nil )
+    @table = table
+    @data = Marshal.load( @table.dbref[urid] ) if anonhash.nil?
+    @data = anonhash if not anonhash.nil?
+    @newdata = {}
+    @urid = urid
+  end
+  
+  # Returns true or false if the record has been updated.
+  def has_updates?
+    return (@newdata.keys.length > 0)
+  end
+  
+  def method_missing( methodId, *args ) #:nodoc:
+    
+    name = methodId.to_s
+    
+    basename = name.gsub( '=', '' ).to_sym
+    
+    if not @table.structure[basename].nil? then
+      #return @data[name]
+      if name.match( '=' ) then
+	@newdata[basename] = args.shift
+	#puts "setting value of #{basename} to #{@newdata[basename]}.."
+      else
+	return @newdata[basename] || @data[basename] if ['string', 'integer', 'datetime'].include?( self.table.structure[basename][:datatype])
+	                                                                                            
+	# derived fields
+	dt = self.table.structure[basename][:datatype]
+	"------------------------------"
+	                                                                                          
+	if dt == 'record' then
+	   # handle one to one   
+	   #pp self.table.structure[basename][:table]
+	   dbref = Trix51.table_to_database( self.table.structure[basename][:table] )
+	   #pp dbref
+	   tblref = dbref.get_table( self.table.structure[basename][:table] )
+	   srcref = self.table.structure[basename][:source]
+	   dstref = self.table.structure[basename][:dest]   
+	   return tblref.first( dstref => @data[srcref] )
+	end     
+	
+	if dt == 'resultset' then
+	   dbref = Trix51.table_to_database( self.table.structure[basename][:table] )
+	   tblref = dbref.get_table( self.table.structure[basename][:table] )
+	   srcref = self.table.structure[basename][:source]
+	   dstref = self.table.structure[basename][:dest] 
+	   #puts "#{tblref.tablename}.#{dstref} = #{@data[srcref]}"
+	   h = { dstref => @data[srcref].to_s }
+	   return tblref.select_hash( h )
+	end
+	
+	if dt == 'calculated' then
+	  c = self.table.structure[basename][:calculation] 
+	  return eval( c ).to_s
+	end
+	                                                                                            
+      end
+    else
+      raise Trix51::NotFoundError, "No such field #{methodId}"
+    end
+    
+  end
+  
+  # post any record updates, update any indexes and keys.
+  def update
+    
+    ref = @data.merge( @newdata ) { |key, oldval, newval|
+	    (not newval.nil?) ? newval : oldval
+    }
+    
+    # ref now represents the new record
+    newurid = self.table.get_hash_key( ref )
+    
+    @newdata.each_pair do |fieldname,fieldvalue|
+      raise Trix51::ConstraintError, "Update would violate unique constraint on field #{fieldname}" unless self.table.index_chk_unique_update( fieldname, fieldvalue, @urid )
+    end
+    
+    if newurid == @urid then
+      self.table.index_update( @urid, newurid, @newdata )
+      # simple update
+      self.table.dbref[ @urid ] = Marshal.dump( ref )
+      @data = ref
+      @newdata = {}
+      
+      #puts "Key is unchanged"
+      
+      return true
+    end
+    
+    # if we are here the key has changed
+    # make sure the new one does not exist
+    if not self.table.dbref[ newurid ].nil? then
+      @newdata = {}
+      raise Trix51::ConstraintError, "Update to record would violate unique contraints"
+    end
+    
+    # if we are here, add the new record
+    self.table.index_update( @urid, newurid, @newdata )
+    #puts "Re-keying the record due to a change in unique key"
+    self.table.dbref[ newurid ] = Marshal.dump( ref )
+    @data = @newdata
+    @newdata = {}
+    @urid = newurid
+    
+    return true
+    
+  end
+  
+  # Accessors for the tuple class.
+  attr_accessor :table, :data, :urid
+  
+end
+
+# This class represents a set of records which can either be a table, query 
+# result, or the result of a group expression. 
+class Trix51::TupleSet
+  
+	# Creates a new TupleSet object, the core class for tables / query results.
+	def initialize( tablename, dataref, options )
+	  @tablename = tablename
+	  @dbref = dataref
+	  @options = {}
+	  @indices = {}
+	  @sort_order = nil
+	  @options = options
+	  @updateable = false
+	  @meta = nil
+	  if self.table? then
+	    #pp "table"
+	    @updateable = true
+	    @meta = self.meta
+	  else
+	    @meta = {}
+	    #pp "query or view"
+	    @meta[:tablename] = '__query'
+	    self.clone_structure( @options[:tableref] )
+	    @meta[:classname] = 'Trix51::Tuple'
+	  end
+	  
+	  #pp @meta
+	  
+	  @classname = @meta[:classname] || 'Trix51::Tuple'
+	  
+	  #pp @classname
+	  
+	  if @classname != 'Trix51::Tuple' then
+	      eval( 
+"
+class #{@classname} < Trix51::Tuple	      
+	      
+end
+", BND
+		    )
+	  end
+	  
+	end
+	
+	def build_temp_idx( field ) #:nodoc:
+	  
+	  if (self.indexed?( field )) and (not self.indices[field].nil?) and (field != :random) then
+	    return @indices[field].clone
+	  end
+	  
+	  res = {}
+	  self.dbref.each_pair { |k, v|
+	    next unless self.table_record?( k )
+	    record = {}
+	    if v.class.name == 'String' then
+	      record = Marshal.load( v )
+	    else
+		record = v.data
+	    end
+	    rv = record[field] if field != :random
+	    rv = rand() if field == :random
+	    rlist = res[rv] || []
+	    rlist.push( k )
+	    res[rv] = rlist
+	  }
+	  return res
+	end
+	
+	def build_sorted_keys( field, dir='asc' ) #:nodoc:
+	  # sort records by list of fields
+	  idx = self.build_temp_idx( field )
+	  sk = []
+	  idx.keys.sort.each do |fieldvalue|
+	    keyref = idx[fieldvalue]
+	    keyref.each do |key|
+	      sk.push( key )
+	    end
+	  end
+	  return sk if dir == 'asc'
+	  return sk.reverse if dir == 'desc'
+	end
+	
+	def sorted_keys #:nodoc:
+	  if (not @options[:sorted].nil?) and (@options[:sorted] == true) then
+	    #return self.build_sorted_keys( @options['sortfield'].to_s, @options['sortorder'] )
+	    if @sort_order.nil? then
+	      @sort_order = self.build_sorted_keys( @options[:sortfield], @options[:sortorder] )
+	    end
+	    return @sort_order
+	  end
+	  return @dbref.keys
+	end
+	
+	def record_keys #:nodoc:
+	  list = []
+	  @dbref.each_key do |k|
+	    list.push( k ) if self.table_record?(k)
+	  end
+	  return list
+	end
+	
+	# Returns the number of records in the database.
+	def size
+	      c = 0
+	      @dbref.each_key do |k|
+		c = c + 1 if k.match( self.record_prefix )
+	      end
+	      return c
+	end
+	
+	def clone_structure( tupleset ) #:nodoc:
+	  @meta[:structure] = tupleset.structure.clone
+	end
+
+	def structure #:nodoc:
+	  return @meta[:structure]
+	end
+	
+	# Returns the default for the specified field.
+	def default( fieldname )
+	  
+	  unless self.exists?( fieldname) then
+	    raise Trix51::NotFoundError, "field not found: #{fieldname} in table #{@meta[:tablename]}"
+	  end
+	  
+	  ref = self.structure[fieldname]
+	  
+	  #pp ref
+	  
+	  if (ref[:autoincrement] == true) and (ref[:datatype] == 'integer') then
+	    return self.find_or_create_seq( fieldname )
+	  end
+	  
+	  if (not ref[:default].nil?) then
+	    d = ref[:default]
+	    if m = d.to_s.match( /^\#\{(.+)\}$/ ) then
+	      return eval(m[1])
+	    end
+	    return d
+	  end
+	  
+	  return nil
+	  
+	end
+	
+	# Returns true / false if the table contains field
+	def exists?( fieldname )
+	  return (not self.structure[fieldname].nil?)
+	end
+	
+	def find_or_create_seq( fieldname ) #:nodoc:
+	  
+	  seq_name =self.seq_prefix( fieldname )
+	  #puts "Sequence is called: #{seq_name}"
+	  
+	  if @dbref[seq_name].nil? then
+	    @dbref[seq_name] = '2'
+	    return 1
+	  else
+	    v = @dbref[seq_name].to_i
+	    @dbref[seq_name] = (v+1).to_s
+	    return v
+	  end
+	  
+	end
+	
+	# insert record into the database using a hash
+	# ==== Example
+	#    daisy = animal.insert_hash( {
+	#        name: 'cow',
+	#	 species_id: 2
+	#    } )
+	def insert_hash( hashdata ) #:nodoc:
+	  
+	  ref = self.empty_rec.merge( hashdata ) { |key, oldval, newval|
+	    (not newval.nil?) ? newval : oldval
+	  }
+	  
+	  #pp ref
+	  
+	  flt = {}
+	  
+	  ref.each_key { |key|
+	    flt[key] = ref[key] if self.exists?( key )
+	  }
+	  
+	  #pp flt
+	  
+	  self.check_required_fields( flt )
+	  
+	  urid = self.get_hash_key( flt )
+	  
+	  #puts "Record key: #{urid}"
+	  
+	  raise Trix51::ConstraintError, "unique constraint has been violated (#{urid})" if @dbref[urid]
+	  
+	  @dbref[urid] = Marshal.dump( flt )
+	  
+	  #puts "INSERT "+@dbref[urid]
+	  
+	  self.index_add( urid, flt )
+	  
+	  return self.init_record( urid )
+	end
+	
+	def comparison( value, operand, target ) #:nodoc:
+	  
+	  #puts "[#{value}] #{operand.to_s} [#{target}]"
+	  
+	  if operand.to_s == 'is' then
+	    return (value.to_s == target.to_s)
+	  elsif operand.to_s == 'not' then
+	    return (value.to_s != target.to_s)
+	  elsif operand.to_s == 'like' then
+	    target = '^' + target.gsub( /\%/, '.*' ) + '$'
+	    return (value.to_s.match( target ))
+	  elsif operand.to_s == 'unlike' then
+	    target = '^' + target.gsub( /\%/, '.*' ) + '$'
+	    return (not value.to_s.match( target ))
+	  elsif operand.to_s == 'under' then
+	    return (value.to_f < target.to_f)
+	  elsif operand.to_s == 'over' then
+	    return (value.to_f > target.to_f)
+	  elsif operand.to_s == 'before' then
+	    return (value.to_s < target.to_s)
+	  elsif operand.to_s == 'after' then
+	    return (value.to_s > target.to_s)
+	  elsif operand.to_s == 'between' then
+	    raise Trix51::TypeError, "BETWEEN clause requires two values" unless (target.class.name == 'Array') and (target.length > 1)
+	    s = target.sort
+	    lower_bound = s.shift
+	    upper_bound = s.pop
+	    return ( ( value.to_s >= lower_bound.to_s ) and ( value.to_s <= upper_bound.to_s ) )
+	  elsif operand.to_s == 'in' then
+	    raise Trix51::TypeError, "IN clause requires an array" unless (target.class.name == 'Array') and (target.length >= 1)
+	    return (target.include?( value ))
+	  end
+	  
+	end
+	
+	def eval_in_context( hashdata, expression ) #:nodoc:
+	  inits = []
+	  hashdata.each_pair do |k,v|
+	    next if v.nil?
+	    str = ''
+	    str = "#{k} = #{v}"  if v.class.name != 'String'
+	    str = "#{k} = \"#{v}\"" if v.class.name == 'String'
+	    inits.push( str )
+	  end
+	  inits.push( expression )
+	  str = inits.join("\n")
+	  return eval( str )
+	end
+	
+	def hash_compare( h1, h2 ) #:nodoc:
+	  
+	  # Comparitors: like, not_like, not, equals, lt, gt
+	  # 
+	  
+	  h1.keys.each { |key|
+	    #pp key
+	    #pp self.structure[key]
+	    if self.structure[key][:datatype] == 'calculated' then
+		h2[key] = self.eval_in_context( h2, self.structure[key][:calculation] )
+	    end
+	    v1 = h1[key]
+	    if v1.class.name != 'Hash' then
+	      return false if not comparison( h2[key], 'is', h1[key] )
+	    else
+	      v1.each_pair do |operand, target|
+	         return false if not comparison( h2[key], operand, target )
+	      end
+	    end
+	  }
+	  return true
+	end
+	
+	# delete records matching the specified hash
+	# ==== Example
+	#     num_deleted = animal.delete_hash( {
+	#	name: 'cow'
+	#     } )
+	def delete_hash( hashdata ) #:nodoc:
+	  
+	  matches = self.select_hash( hashdata )
+	   
+	  matches.each_record do |record|
+		     urid = record.urid 
+	             @dbref.delete( urid )
+		     self.index_remove( urid )
+	  end
+	  
+	  return matches.length
+	  
+	end
+	
+	# Updates any records matching the values in hash
+	# ==== Example
+	#     animal.update_hash ( { name: 'cow' } ) do |record|
+	#	record.name = 'sheep' # baaa?
+	#     end
+	def update_hash( hashdata ) #:nodoc:
+	 
+	    matches = self.select_hash( hashdata )
+	    
+	    matches.each { |record|
+	      yield record
+	      record.update if record.has_updates?
+	    }
+	  
+	    return matches.length
+	end
+	
+	# Updates records matching the query.
+	# ==== Example
+	#    animal.update( number_of_eyes: 2, number_of_legs: 4 ) do |record|
+	#	record.number_of_eyes = 8
+	#    end
+	def update( *args )
+
+	    hashdata = args_to_hash( *args )
+	  
+	    matches = self.select_hash( hashdata )
+	    
+	    matches.each { |record|
+	      yield record
+	      record.update if record.has_updates?
+	    }
+	  
+	    return matches.length
+	end	
+	
+	# Deletes records matching the query.
+	# ==== Example
+	#     count = animal.delete( species_id: 2 )
+	def delete( *args )
+	  return self.delete_hash( args_to_hash(*args) )
+	end	
+	
+	# Returns a Trix51::ResultSet containing records matching the query.
+	# ==== Example
+	#     records = animal.select(
+	#	 name: { like: 'mon%' },
+	#	 created_date: { between: [ '2012-04-11', 2012-12-31' ],
+	#	 number_of_eyes: 2,
+	#        number_of_legs: { in: [2,4] }
+	#     )
+	#
+	# ==== Query operands
+	# * +is:+ - true if value matches 
+	# * +in:+ - true if value is in specified list
+	# * +not:+ - true if value does not match
+	# * +under:+ - true if value is less than 
+	# * +over:+ - true if value is greater than
+	# * +like:+ - true if value matches pattern ( '%' acts as wildcard )
+	# * +unlike:+ - true if value does not match pattern ( '%' acts as wildcard )
+	# * +between:+ - true if value is between specified values
+	def select( *args )
+	  return self.select_hash( args_to_hash(*args) )
+	end
+	
+	# Alias for select()
+	def having( *args )
+	  return self.select_hash( args_to_hash(*args) )
+	end
+	
+	# Returns the first record matching the query (Trix51::Tuple)
+	def first( *args )
+	    res = self.select_hash( args_to_hash(*args) )
+	    if res.count > 0 then
+	      res.each_record do |x|
+		return x
+	      end
+	      return nil
+	    end
+	end
+	
+	# Returns all the records.
+	def all
+	  return self.select_hash( {} )
+	end
+	
+	# Deletes all records in the table.
+	def empty
+	  return self.delete_hash( {} )
+	end
+	
+	# Inserts a record into the database using named arguments.
+	def insert( *args )
+	  return self.insert_hash( args_to_hash(*args) )
+	end
+	
+	def args_to_hash( *args ) #:nodoc:
+	  h = {}
+	  args.each { |rec|
+	    rec.each_pair { |k,v|
+	      h[k] = v
+	    }
+	  }
+	  #pp h
+	  return h
+	end
+	
+	def tuple_by_key( *args ) #:nodoc:
+	  keys = self.key_fields
+	  h = {}
+	  keys.each { |key|
+	    h[key] = args.shift
+	  }
+	  #pp h
+	  urid = self.get_hash_key( h )
+	  
+	  s = dbref[urid]
+	  
+	  return Marshal.load( s ) if self.table? and not s.nil?
+	  return s if not s.nil?
+	  
+	  return nil
+	end
+	
+	def init_record( urid )  #:nodoc:
+	  
+	  #pp self.table?
+	  #pp @classname
+	  
+	  unless self.table? then
+	    return @dbref[ urid ]
+	  end
+	  
+	  r = nil
+	  if (@classname == 'Trix51::Tuple') or (Trix51.defer_classref == true) then
+	    r = Trix51::Tuple.new( self, urid )
+	  else
+	    r = eval( "#{@classname}.new( self, urid )" )
+	  end
+	  return r
+	end
+	
+	def check_required_fields( hashdata ) #:nodoc:
+	  
+	  # make sure all required fields are populated
+	  self.structure.each_key { |key|
+	    next if (not self.structure[key][:key] == true) and (not self.structure[key][:required] == true)
+	    raise Trix51::ConstraintError, "required or key field #{self.tablename}.#{key} is nil" if hashdata[key].nil?
+	    raise Trix51::ConstraintError, "unique constraint violated for field #{self.tablename}.#{key} [#{hashdata[key]}]" if not self.index_chk_unique( key, hashdata[key] )
+	  }
+	  
+	end
+	
+	# Returns the key fields for the table
+	def key_fields 
+	  res = []
+	  self.structure.keys.sort.each { |key|
+	    #puts key
+	    res.push(key) if self.structure[key][:key] == true
+	  }
+	  return res
+	end
+	
+	def get_hash_key( hashdata ) #:nodoc:
+	  keys = self.key_fields
+	  
+	  v = []
+	  keys.each { |k|
+	    v.push( hashdata[k] )
+	  }
+	  
+	  return self.record_prefix + ':' + v.join( Trix51::KEY_JOIN )
+	end
+	
+	def empty_rec #:nodoc:
+	  ref = {}
+	  self.structure.each_key { |key|
+	    ref[key] = self.default( key )
+	  }
+	  return ref
+	end
+	
+	def method_missing( meth, *args ) #:nodoc:
+	  name = meth.to_s
+	  
+	  if m = name.match( /^select_by_(.+)/ ) then
+	    
+	    fields = m[1].split('_and_')
+	    h = {}
+	    while fields.length > 0 do
+		n = fields.shift
+		v = args.shift
+		h[n] = v
+	    end
+	    
+	    return self.select_hash( h )
+
+	  end
+	 
+	  if m = name.match( /^delete_by_(.+)/ ) then
+	    
+	    fields = m[1].split('_and_')
+	    h = {}
+	    while fields.length > 0 do
+		n = fields.shift
+		v = args.shift
+		h[n] = v
+	    end
+	    
+	    return self.delete_hash( h )
+
+	  end
+	  
+	  if m = name.match( /^update_by_(.+)/ ) then
+	    
+	    fields = m[1].split('_and_')
+	    h = {}
+	    while fields.length > 0 do
+		n = fields.shift
+		v = args.shift
+		h[n] = v
+	    end
+	    
+	    matches = self.select_hash( h )
+	    
+	    matches.each { |record|
+	      yield record
+	      record.update if record.has_updates?
+	    }
+	  
+	    return matches.length
+
+	  end	  
+	  
+	end
+	
+	# Find (select) or create a record with the named arguments.
+	def find_or_create( *args )  
+	  
+	  res = self.first( *args )
+	  
+	  if res.nil? then
+	    return self.insert_hash( args_to_hash(*args) )
+	  end
+	  
+	  return res
+	  
+	end
+	
+	# returns true or false if a table field is indexed.
+	def indexed?( field )
+	  return false unless self.exists?( field )
+	  return ( (self.key?(field)) or (self.unique?(field)) or ( (not self.structure[field][:indexed].nil?) and (self.structure[field][:indexed] == true) ) )
+	end
+	
+	# returns true or false if a table field must be unique
+	def unique?( field )
+	  return false unless self.exists?( field )
+	  return ( (not self.structure[field][:unique].nil?) and (self.structure[field][:unique] == true) )
+	end
+	
+	# returns true or false if a table field forms part of the record key
+	def key?( field )
+	  return false unless self.exists?( field )
+	  return ( (not self.structure[field][:key].nil?) and (self.structure[field][:key] == true) )
+	end
+	
+	# Rebuilds the index for the given field.
+	def index_build( field )
+	  if not self.indexed?(field) then
+	    raise Trix51::NotFoundError, "field #{field} is not an indexed field"
+	  end
+	  #puts "Building index for field #{field}"
+	  res = {}
+	  self.dbref.each_pair { |k, v|
+	    next unless self.table_record?( k )
+	    record = Marshal.load( v )
+	    rv = record[field]
+	    rlist = res[rv] || []
+	    rlist.push( k )
+	    res[rv] = rlist
+	  }
+	  @indices[field] = res
+	end
+	
+	def index_add( urid, record ) #:nodoc:
+	  record.keys.each { |fieldname|
+	    if self.indexed?(fieldname) then
+	         # check index exists
+	         if self.indices[fieldname].nil? then
+	              self.index_build( fieldname )
+	         else
+	              # partial add
+	              res = self.indices[fieldname]
+	              rv = record[fieldname]
+		      rlist = res[rv] || []
+		      rlist.push( urid )
+		      res[rv] = rlist	              
+	         end
+	    end	    
+	  }
+	end
+	
+	def index_update( oldurid, newurid, record ) #:nodoc:
+	  record.keys.each { |fieldname|
+	    if self.indexed?(fieldname) then
+	         # check index exists
+	         if self.indices[fieldname].nil? then
+	              self.index_build( fieldname )
+	         else
+	              # partial update
+	              self.index_remove( oldurid )
+	              self.index_add( newurid, record )              
+	         end
+	    end
+	  }
+	end
+	
+	def index_remove( urid ) #:nodoc:
+	  self.indices.each_pair { |fieldname, index|
+	      index.each_value { |rlist|
+	          rlist.delete( urid )
+	      }
+	  }
+	end
+	
+	def index_chk_unique( fieldname, fieldvalue )#:nodoc:
+	  
+	  #puts fieldname + '=' + fieldvalue.to_s
+	  
+	  if self.indexed?( fieldname ) == false then
+	    return true
+	  end
+	  
+	  if self.unique?( fieldname) == false then
+	    return true
+	  end
+	  
+	  if fieldvalue.nil? then
+	      return false
+	  end
+	  
+	  if self.indices[fieldname].nil? then
+	    self.index_build( fieldname )
+	  end
+	  
+	  if self.indices[fieldname][fieldvalue].nil? then
+	    return true
+	  end
+	  
+	  if self.indices[fieldname][fieldvalue].length == 0 then
+	    return true
+	  end	  
+	  
+	  return false
+	end
+	
+	def index_chk_unique_update( fieldname, fieldvalue, urid ) #:nodoc:
+	  
+	  #puts fieldname + '=' + fieldvalue.to_s
+	  
+	  if self.indexed?( fieldname ) == false then
+	    return true
+	  end
+	  
+	  if self.unique?( fieldname) == false then
+	    return true
+	  end
+	  
+	  if fieldvalue.nil? then
+	      return false
+	  end
+	  
+	  if self.indices[fieldname].nil? then
+	    self.index_build( fieldname )
+	  end
+	  
+	  if self.indices[fieldname][fieldvalue].nil? then
+	    return true
+	  end
+	  
+	  if self.indices[fieldname][fieldvalue].length == 0 then
+	    return true
+	  end	
+	  
+	  if (self.indices[fieldname][fieldvalue].length == 1) and (self.indices[fieldname][fieldvalue][0] == urid) then
+	    return true
+	  end
+	  
+	  return false
+	end
+
+	# Add a column to the table.
+	def column_add( name, spec )
+	  
+	  if not @meta[:structure][name].nil? then
+	    raise Trix51::ExistsError, "Column #{name} already exists"
+	  end
+	  
+	  # add in and reparse
+	  @meta[:structure][name] = spec
+	  self.meta = @meta
+	  @meta = self.meta
+	  
+	  #pp @meta
+	  
+	  need_rebuild = false
+	  
+	  # now assign default
+	  @dbref.each_pair do |k,v|
+	      next unless self.table_record?( k )
+	      
+	      record = Marshal.load( v )
+	      record[name] = self.default( name )
+	      v = Marshal.dump( record )
+	      newk = self.get_hash_key( record )
+	      if newk != k then
+		@dbref.delete(k)
+		need_rebuild = true
+	      end
+	      
+	      @dbref[ newk ] = v
+	  end
+	  
+	  @indices.clear if need_rebuild
+	      
+	end
+	
+	# Remove a column from the table.
+	def column_remove( name )
+	  
+	  if @meta[:structure][name].nil? then
+	    raise Trix51::NotFoundError, "Column #{name} does not exist"
+	  end
+	  
+	  # add in and reparse
+	  @meta[:structure].delete(name)
+	  self.meta = @meta
+	  @meta = self.meta
+	  
+	  need_rebuild = false
+	  
+	  # now assign default
+	  @dbref.each_pair do |k,v|
+	      next unless self.table_record?( k )
+	      
+	      record = Marshal.load( v )
+	      record.delete( name ) if record.has_key?( name )
+	      v = Marshal.dump( record )
+	      newk = self.get_hash_key( record )
+	      if newk != k then
+		@dbref.delete(k)
+		need_rebuild = true
+	      end
+	      
+	      @dbref[ newk ] = v
+	  end
+	    
+	  @indices.clear if need_rebuild
+	end
+	
+	# Update the specification for a column.
+	def column_update( name, spec )
+	  
+	  if @meta[:structure][name].nil? then
+	    raise Trix51::NotFoundError, "Column #{name} does not exist"
+	  end
+	  
+	  oldspec = @meta[:structure][name]
+	  newspec = Marshal.load( Marshal.dump( spec ) )
+	  
+	  uval = {}
+	  ukey = {}
+	  
+	  @dbref.each_pair do |k,v|
+	    
+	    next unless self.table_record?( k )
+	    
+	    record = Marshal.load( v )
+	    value = record[name]
+	    
+	    #  test field uniqueness
+	    if newspec[:unique] then
+	      raise Trix51::ConstraintError, "Field definition change would create a unique key violation condition" if not uval[value].nil?
+	      uval[value] = 1
+	    end
+	    
+	    # type check
+	    nrecord = record.clone
+	    if newspec[:datatype] != oldspec[:datatype] then
+	      begin
+		nrecord[name] = self.convert_type( value, newspec[:datatype] ).to_s
+		#pp nrecord
+		newurid = self.get_hash_key( nrecord )
+		if not ukey[newurid].nil? then
+		  raise Trix51::ConstraintError, "Field definition change would violate uniqueness of keys"
+		end
+		ukey[newurid] = 1
+	      rescue 
+		raise Trix51::TypeError, "Type conversion from #{oldspec[:datatype]} to #{newspec[:datatype]} would barf..."
+	      end
+	    end
+	    
+	  end
+	  
+	  # update will be okay
+	  @meta[:structure][name] = newspec
+	  self.meta = @meta
+	  @meta = self.meta
+	  
+	  @indices.delete(name) if not @indices[name].nil?
+	  
+	  @dbref.each_pair do |oldurid,v|
+	    next unless oldurid.match( self.record_prefix )
+	    old_record = Marshal.load( v )
+	    new_record = old_record.clone
+	    if oldspec[name] != newspec[name] then
+	      new_record[name] = self.convert_type( old_record[name], newspec[:datatype] )
+	    end
+	    newurid = self.get_hash_key( new_record )
+	    if newurid != oldurid then
+	      @dbref.delete(oldurid)
+	      @dbref[newurid] = Marshal.dump( new_record )
+	    else
+	      @dbref[oldurid] = Marshal.dump( new_record )
+	      #self.index_update( oldurid, newurid, new_record[name] )
+	    end
+	  end
+	  
+	  self.index_build( name ) if self.indexed?(name)
+	  
+	end
+	
+	# Converts a value to the specified type.
+	def convert_type( value, typedef )
+	  newvalue = nil
+	  if typedef == 'string' then
+	    return value.to_s
+	  end
+	  if typedef == 'integer' then
+	    return value.to_i
+	  end
+	  if typedef == 'float' then
+	    return value.to_f
+	  end
+	  if typedef == 'datetime' then
+	    return Time.parse(value.to_s).to_s
+	  end
+	end
+	
+	# Returns true if the given object is a table, false otherwise
+	def table? 
+	  return (@dbref.class.name == 'GDBM')
+	end
+	
+	# Interate over records in the table or resultset.  Any
+	# updates are automatically updated in the database. 
+	def each
+	  
+	  self.sorted_keys.each do |k|
+	    next unless k.match( Trix51::RECORD_PREFIX )
+	    r = init_record(k)
+	    yield record
+	    r.update if r.has_updates?
+	  end
+	  
+	end
+	
+	# Iterates through each key, value for the table.
+	def each_pair
+	  
+	  self.sorted_keys.each do |k|
+	    next unless self.table_record?(k)
+	    yield k, init_record(k) 
+	  end
+	  
+	end
+	
+	# Interates through each key in the dbm store.
+	def each_key
+	  self.sorted_keys.each do |k|
+	    yield k if self.table_record?(k)
+	  end	  
+	end
+	
+	# Interates through each Trix51::Tuple in the table or result set.
+	def each_value
+	  self.sorted_keys.each do |k|
+	    next unless k.match( self.record_prefix )
+	    r = init_record(k)
+	    yield r
+	    r.update if r.has_updates?
+	  end	  
+	end
+	
+	# Iterates through each Trix51::Tuple in the table or result set.
+	def each_record
+	  self.sorted_keys.each do |k|
+	    next unless k.match( self.record_prefix )
+	    r = init_record(k)
+	    yield r
+	    r.update if r.has_updates?
+	  end	  
+	end
+	
+	def push( record ) #:nodoc:
+	  #puts "pushing record with urid = #{record.urid}"
+	  @dbref[ record.urid ] = record
+	end
+	
+	# Returns the number of records in the table or result set.
+	def count
+	  return self.size
+	end
+	
+	# Returns the number of records in the table or result set.
+	def length
+	  return self.size
+	end
+	
+	def record_prefix #:nodoc:
+	  return Trix51::RECORD_PREFIX+self.tablename.to_s
+	end
+	
+	def table_record?( key ) #:nodoc:
+	  return (key.match(self.record_prefix))
+	end
+	
+	def meta_record?( key ) #:nodoc:
+	  return (key.match(Trix51::META_PREFIX))
+	end
+	
+	def seq_record?( key ) #:nodoc:
+	  return (key.match(Trix51::SEQ_PREFIX))
+	end
+	
+	def meta_prefix #:nodoc:
+	  return Trix51::META_PREFIX+self.tablename.to_s
+	end
+	
+	def seq_prefix( fieldname ) #:nodoc:
+	  return Trix51::SEQ_PREFIX+self.tablename.to_s+'_'+fieldname.to_s+'_seq'
+	end
+	
+	def meta #:nodoc:
+	  if @meta.nil? then
+	    @meta = Marshal.load( @dbref[self.meta_prefix] )
+	  end
+	  return @meta
+	end
+	
+	def meta=(meta) #:nodoc:
+	  @dbref[self.meta_prefix ] = Marshal.dump( meta )
+	end
+	
+	# Produces a neatly formatted dump of the records (all fields)
+	def dump
+	  fields = self.structure.keys
+	  self.dump_filtered( *fields )
+	end
+	
+	# Produces a neatly formatted dump of the records (selected fields)
+	def dump_filtered( *fieldnames )
+	  
+	  widths = {}
+	  #fieldnames = self.structure.keys.sort if fieldnames.length == 0
+	  lines = []
+	  
+	  tmp = []
+	  fieldnames.each do |fn|
+	    tmp.push( fn ) if self.exists?( fn )
+	  end
+	  fieldnames = tmp 
+	 
+	  fieldnames.each do |field|
+	    widths[field] = field.length+2
+	    
+	    str = ''
+	    (field.length+1).times do |n|
+	      str = str + '-'
+	    end
+	    
+	    lines.push( str )
+	  end
+	 
+	  @dbref.each_pair do |k, v|
+	    #pp v
+	    next unless self.table_record?(k)
+	    record = nil
+	    if self.table? then
+	      record = Marshal.load( v )
+	    else
+	      record = v.data
+	    end
+	    fieldnames.each do |field|
+	      fv = record[field] || 'nil'
+	      widths[field] = fv.to_s.length+2 if fv.to_s.length+2 > widths[field]
+	    end	    
+	  end
+	  
+	  # create formatstr
+	  formatstr = ''
+	  fieldnames.each do |field|
+	    formatstr = formatstr + " %-#{widths[field]}s|"
+	  end
+	  
+	  puts sprintf "#{formatstr}", *fieldnames
+	  puts sprintf "#{formatstr}", *lines
+	  
+	  self.each_record do |v|
+	    record = v.data
+	    values = []
+	    fieldnames.each do |field|
+	      values.push( record[field] || 'nil' )
+	    end	    
+	    puts sprintf "#{formatstr}", *values
+	  end
+	  
+	  #pp @dbref
+	  
+	end
+	
+	# Returns a random record from the table or result set.
+	def random
+	  
+	  keys = []
+	  @dbref.each_key do |k|
+	    keys.push( k ) if self.table_record?(k)
+	  end
+	  
+	  return nil if keys.count == 0
+	  
+	  urid = keys[ rand( keys.count ) ]
+	  
+	  return init_record( urid )
+	  
+	end
+	
+	# Sorts records by specified field and ordering, returning a new result set. Special symbol :random returns
+	# records in a randomized ordering.
+	# ==== Example
+	#    animal.select( number_of_legs: 4 ).sort( :name ).dump_filtered( :name )
+	#    
+	#    name      |
+	#    -----     |
+	#    aardvark  |
+	#    bullock   |
+	#    cow       |
+	def sort( field, dir='asc' )
+	  
+	  res = Trix51::ResultSet.new( self.tablename, {}, { tableref: self, sorted:  true, sortfield: field, sortorder: dir } )
+	  
+	  self.each_key do |k|
+	    res.push( init_record( k ) )
+	  end
+	  
+	  return res
+	  
+	end
+	
+	def group_key( hashdata, keylist ) #:nodoc:
+	  keycode = []
+	  keylist.each do |key|
+	    if not hashdata[key].nil? then
+	      keycode.push( hashdata[key].to_s )
+	    else
+	      keycode.push( 'nil' )
+	    end
+	  end
+	  return Trix51::RECORD_PREFIX+'aggregate_'+self.tablename+':'+keycode.join(':')
+	end
+	
+	# Groups records by the array of fields specified in the *by:* clause, and returns
+	# the aggregated results for the fields specified in the *calculate:* clause.  
+	#
+	# ==== Group calculations
+	# * +sum:+ - Sum of the field values
+	# * +max:+ - Max of the field values
+	# * +min:+ - Min of the field values
+	# * +avg:+ - Average of the field values
+	# * +count:+ - Count of the field values
+	#
+	# ==== Example
+	#     animal.group( by: [ :species_id ], calculate: { number_of_eyes: 'sum' } ).dump
+	#     
+	#     species_id   |sum_number_of_eyes  |
+	#     -----------  |------------------- |
+	#     1            | 28                 |
+	#     2            | 40                 |
+	#
+	def group( *args )
+	  params = args.shift
+	  #pp params
+	  keylist = params[:by]
+	  fields = params[:calculate]
+	  
+	  collected_data = {}
+	  structure = {}
+	  agg_records = {}
+	  
+	  keylist.each do |key|
+	    structure[key] = self.structure[key]
+	    structure[key][:key] = true
+	  end	  
+	  
+	  fields.each_pair do |field,function|
+	    new_field = function.to_s + '_' + field.to_s
+	    structure[new_field.to_sym] = { :datatype => 'string' }
+	  end
+	  
+	  self.each_record do |record|
+	    
+	    nurid =  self.group_key( record.data, keylist )
+	    
+	    agg_records[nurid] = {}
+	    keylist.each do |key|
+	      key = key
+	      agg_records[nurid][key] = record.data[key]
+	    end
+	   
+	    
+	    # for this record, aggregate 
+	    fields.each_key do |field|
+	      collected_data[nurid] = {} if collected_data[nurid].nil?
+	      collected_data[nurid][field] = [] if collected_data[nurid][field].nil?
+	      values = collected_data[nurid][field]
+	      if self.structure[field][:datatype] == 'calculated' then
+		values.push( self.eval_in_context( record.data, self.structure[field][:calculation] ) )
+	      else
+		values.push( record.data[field] )
+	      end
+	      collected_data[nurid][field] = values
+	    end
+	   
+	    
+	    # now collapse the data into hashes
+	    collected_data.each_key do |nurid|
+	      # by key, process each function
+	      
+	      # copy keylist fields in
+	      
+	      
+	      fields.each_pair do |field,function|
+		field = field
+		function = function
+		new_field = (function.to_s + '_' + field.to_s).to_sym
+		values = collected_data[nurid][field]
+		
+		if function == 'sum' then
+		  agg_records[nurid][new_field] = values.reduce(:+)
+		elsif function == 'avg' then
+		  agg_records[nurid][new_field] = values.reduce(:+) / values.count
+		elsif function == 'min' then
+		  agg_records[nurid][new_field] = values.min
+		elsif function == 'max' then
+		  agg_records[nurid][new_field] = values.max
+		elsif function == 'count' then
+		  agg_records[nurid][new_field] = values.count			  
+		else
+		    raise Trix51::NotFoundError, "unknown group function #{function}"
+		end
+		
+	      end
+	      
+	    end
+	    
+	  end
+	  
+	  res = Trix51::ResultSet.new( 'aggregate_'+self.tablename, {}, { tableref: self, structure: structure } )
+	  meta_init = res.meta
+	  meta_init[:structure] = structure
+	  res.meta = meta_init
+	
+	  agg_records.each_pair do |k,v|
+	    res.dbref[k] = Trix51::Tuple.new( self, k, v )
+	  end
+	  
+	  return res
+	  
+	end
+	
+	# Returns table record at index.
+	def [](index)
+	  keys = []
+	  self.sorted_keys.each do |k|
+	    keys.push( k ) if self.table_record?(k)
+	  end
+	  
+	  return nil if (keys.count == 0) or (keys.count <= index)
+	  
+	  urid = keys[ index ]
+	  
+	  return init_record( urid )
+	end
+	
+	# Returns a new result set containing a list of the unique values.  
+	def distinct( *keylist )
+	  
+	  structure = {}
+	  keylist.each do |key|
+	    key = key
+	    structure[key] = self.structure[key]
+	    structure[key][:key] = true
+	  end	 
+	  
+	  agg_records = {}
+	  
+	  self.each_record do |record|
+	    
+	    nurid =  self.group_key( record.data, keylist )
+	    next unless agg_records[nurid].nil?
+	    
+	    agg_records[nurid] = {}
+	    keylist.each do |key|
+	      key = key
+	      agg_records[nurid][key] = record.data[key]
+	    end
+	    
+	  end
+	  
+	  res = Trix51::ResultSet.new( 'aggregate_'+self.tablename, {}, { tableref: self, structure: structure } )
+	  meta_init = res.meta
+	  meta_init[:structure] = structure
+	  res.meta = meta_init
+	  
+	  agg_records.each_pair do |k,v|
+	    res.dbref[k] = Trix51::Tuple.new( self, k, v )
+	  end
+	  
+	  return res	  
+	end
+	
+	# Returns a new result set contain only the first count records.
+	# ==== Example
+	#    animal.select( number_of_legs: 4 ).sort( :name ).limit(2).dump_filtered( :name )
+	#     
+	#    name      |
+	#    -----     |
+	#    aardvark  |
+	#    bullock   |
+	def limit( count )
+	  res = Trix51::ResultSet.new( self.tablename, {}, { tableref: self } )
+	  done = 0
+	  self.each_record do |record|
+	    res.dbref[ record.urid ] = record if done < count
+	    done = done + 1
+	  end
+	  return res
+	end
+	
+	
+	def hint_matches_by_index( taglist, field, operand, target ) #:nodoc:
+	  newlist = []
+	  
+	  # match the criteria against each key in the index, collecting any matches if they are in the original
+	  # taglist
+	  
+	  self.index_build(field) if self.indices[field].nil?
+	  
+	  self.indices[field].each_pair do |fieldvalue, urid_list|
+	    if comparison( fieldvalue, operand, target ) then
+	      matches = urid_list & taglist
+	      newlist.push( *matches ) if matches.length > 0
+	    end
+	  end
+	  
+	  return newlist
+	end
+	
+	def hint_matches_by_recordscan( taglist, field, operand, target ) #:nodoc:
+	  
+	  newlist = []
+	  
+	  taglist.each do |urid|
+	    v = @dbref[urid]
+	    record = nil
+	    if v.class.name == 'String' then
+	      record = Marshal.load( v )
+	    else
+	      record = v.data
+	    end
+	    if self.structure[field][:datatype] == 'calculated' then
+		record[field] = self.eval_in_context( record, self.structure[field][:calculation] )
+	    end
+	    newlist.push( urid ) if comparison( record[field], operand, target )
+	  end
+	  
+	  return newlist
+	  
+	end
+	
+	def hint_criteria_to_operand_target( criteria ) #:nodoc:
+	  if criteria.class.name != 'Hash' then
+	    return [ 'is', criteria ]
+	  else
+	    operand = ''
+	    target = ''
+	    criteria.each_pair do |k, v|
+	      operand = k.to_s
+	      target = v
+	    end
+	    return [ operand, target ]
+	  end
+	end
+	
+	# Return records based on the specified query.
+	def select_hash( criteria ) #:nodoc:
+	  #criteria = self.args_to_hash( *args )
+	  taglist = self.record_keys
+	  
+	  criteria.each_pair do |field, value|
+	    break if taglist.length == 0
+	    
+	    if self.indexed?(field) then
+	      #puts "#{field} will use index"
+	      taglist = self.hint_matches_by_index( taglist, field, *hint_criteria_to_operand_target(value) )
+	    else
+	      #puts "#{field} will use record level scan (less efficient)"
+	      taglist = self.hint_matches_by_recordscan( taglist, field, *hint_criteria_to_operand_target(value) )
+	    end
+	    
+	  end
+	  
+	  res = Trix51::ResultSet.new( self.tablename, {}, { tableref: self } )
+	  taglist.each do |key|
+	    res.push( self.init_record( key ) )
+	  end
+	  
+	  return res
+	  
+	end
+	
+	# Creates an index on the specified field.
+	def create_index( fieldname )
+	  fieldname = fieldname
+	  raise Trix51::NotFoundError, "Table '#{self.tablename}' does not have a field '#{fieldname}'" unless self.exists?(fieldname)
+	  raise Trix51::ExistsError, "Table '#{self.tablename}' already has an index on field '#{fieldname}'" if self.indexed?(fieldname) 
+	  
+	  @meta = self.meta
+	  self.structure[fieldname][:indexed] = true
+	  self.meta = @meta
+	  
+	  self.index_build( fieldname )
+	end
+	
+	def indices_save( path ) #:nodoc:
+	  filename = path+'/'+self.tablename.to_s+'.idx'
+	  #puts "*** Save index: #{filename}"
+	  File.open( filename, 'w' ) do |file|
+	    Marshal.dump( self.indices, file )
+	  end
+	end
+	
+	def indices_load( path ) #:nodoc:
+	  filename = path+'/'+self.tablename.to_s+'.idx'
+	  
+	  if File.exists?( filename ) then
+	    #puts "*** Load index: #{filename}"
+	    File.open( filename, 'r' ) do |file|
+	      self.indices = Marshal.load( file )
+	    end
+	  else
+	    #puts "*** Generating index for #{self.tablename}"
+	    self.structure.keys.each { |field|
+	      self.index_build( field ) if self.indexed?(field)
+	    }
+	  end
+	  #pp self.indices
+	end
+	
+	# Key accessors for the tupleset class.
+	attr_accessor :dbref, :indices, :tablename, :classname
+end
+
+# Class representing a table 
+class Trix51::Table < Trix51::TupleSet
+  
+  # Create an instance of the table class
+  def initialize( tablename, dbref )
+    super( tablename, dbref, {} )
+  end
+  
+end
+
+# Class representing a set of results
+class Trix51::ResultSet < Trix51::TupleSet
+  
+  # Create an instance of the resultset class used in query results.
+  def initialize( tablename, dbref, options )
+    super( tablename, dbref, options )
+  end
+  
+end