Persistent Tables

wiki

I had to wait for a big download today, so i had time to implement this fancy idea, that was roaming around in my head for quite some time: persistent tables! Ain't Lua surprising? The basic implementation is less than 100 lines! and it works without any additional C-code!

Code follows:

-- Copyright (c) 2001 by Peter Prade - all rights reserved

-- this file introduces a new table "type" that is persistent between sessions
-- each entry in such a table will be saved as a seperate file which 
-- returns the value when executed with dofile

-- tag methods are used to keep those files up to date and to load values that
-- are not yet loaded

-- todo: make all the globals local
persistent_tag = newtag()
persistent_location = {} -- lookup table for locations of each persistent table
persistent_delimiter = "." -- how to delimit one index from another in filenames
persistent_debug = nil -- set to non-nil for debugging output

-- we need to convert any type index to a string (which we use for the location)
function index_to_string(index)
  if type(index) == "string" then
    return index
  end
  if type(index) == "number" then
    return "-"..tostring(index)
  end
  
  -- todo: at least allow persistent tables as indizes (via links ;-)
  print("cannot make indexstring from type: "..type(index)) 
  return nil
end

-- loads a value from the given location
function persistent_load(location)
  if persistent_debug then print("load from", location) end
  local value = dofile(location)
  if type(value) == "table" then
    make_persistent(value, location)
  end
  return value
end

-- save a value to the given location
function persistent_save(location, value)
  local string_to_save = ""
  -- todo: check if old value was a table, and if so, delete old contents
  if type(value) == "nil" then
    string_to_save = "return nil" -- todo: better delete file
  elseif type(value) == "table" then
    make_persistent(value, location)
    string_to_save = "return {}"
  elseif type(value) == "string" then
    string_to_save = "return \""..value.."\""
  elseif type(value) == "number" then
    string_to_save = "return "..value..""
  else
    -- todo: at least functions can be saved as chunks
    print("cannot save type "..type(value).." yet!") 
    return
  end
  -- todo: if we want to build a directory tree (using a delimiter of "/") 
  -- we need to create the directories here: create_path(location)
  if persistent_debug then print("save to", location) end
  local f = openfile(location,"w")
  write(f, string_to_save)
  closefile(f)
end

-- tag method for reading from persistent tables
function persistent_get(table, index)
  local value = rawget(table, index)
  if value == nil then	
    local index_string = index_to_string(index)
    if index_string then
      value = persistent_load(persistent_location[table]..
                  persistent_delimiter..index_string)
      rawset(table, index, value)
    end
  end
  return value
end

-- tag method for writing to persistent tables
function persistent_set(table, index, value)
  rawset(table, index, value) -- todo: if i overwrite a table here, free it!
  local index_string = index_to_string(index)
  if index_string then
    persistent_save(persistent_location[table]..
              persistent_delimiter..index_string, value)
  end
end

-- activate tag methods
settagmethod (persistent_tag, "gettable", persistent_get)
settagmethod (persistent_tag, "settable", persistent_set)

-- you only need to call this once for your "root" persistent table.
-- but you can make as many tables persistent as you like 
-- (as long as those tables are stored at different locations)
-- any table within this table will be made persistent as well
function make_persistent(table,location)
  if tag(table)~=persistent_tag then
    persistent_location[table] = location
    settag(table,persistent_tag)
    for index,value in table do
      persistent_set(table,index,value) -- rewrite table contents
    end
  else
    if persistent_location[table] ~= location then
      print("table with location of", persistent_location[table])
      print("reused at",location)
      print("-> cannot store other than simple trees yet!")
      -- todo: store links to other location...
    end
  end
end

---------------------------------------------------------------------
-- use any directory you'd like as "root": (just make sure the directory 
-- exists, as i cannot create it with just the baselib)
persistent_root = "~/persistent_lua/" 

-- make a table persistent for testing:
persistent = {}
make_persistent(persistent,persistent_root)

-- works also nice: make_persistent(globals(),"C:/Anywhere/")

-- now let's do some fancy testing.
-- any contents of the table "persistent" will also be kept as files

if persistent.test == nil then
  persistent.test = "hello!"
  persistent.table = {"hello!","world!";x=1,y=999}
end

print(persistent.test, persistent.table[2], persistent.table.y)

for i = 1,20 do
  print(persistent.table[i])
end

for i = 1,10 do
  -- watch the strings grow every time you call this file:
  persistent.table[i] = tostring(persistent.table[i])..tostring(i)
end
for i = 11,20 do
  persistent.table[i] = i
end
for i = 8,12 do
  persistent.table[i] = nil
end

persistent.table.parent = persistent -- doesn't work correctly yet.

Add comments here

Wow, this is great! I was looking for something exactly like that. Now all that I would need is to use a db-file instead of the filesystem to store the tables. --MartinSpernau

OK, look here: PersistentTablesSqlite -- DougCurrie