Lua table as frontend to database - lua

Question

I am attempting to implement a database as a Lua table. Using metatables, this table would be empty, and when an item is requested or modified in the table, it would return or modify the item in the database. The database itself would never be loaded into memory, except for the parts which are requested. It should be interacted with by the program as a table (as it is a table). The table, since it's only a "front", would save modified data to the database (rather than defining that item in the table).
In a table with no tables inside of it, this is easy to implement. I'm trying to make it work with a multi-layered table of indefinite depth.
(Aside: The database I'm considering is redis. Ideally this could be implemented for any database or database-like server by only changing the basic operating syntax.)
Because of the behavior of Lua's metatables, the __newindex method is only used when something is modified in the top-level (or created, if you're using a proxy). The __index method is called when something is read, even if the call is to modify something within a sub-table. Because of this, I'm trying to write an __index method that, when a table is requested, returns yet another pseudo-proxy (a table proxying a database rather than another tables) with the same behavior, except the proxy is for the table/array/list within the top-level, etc, to an indefinite depth. I am struggling.
My questions are:
Has this been implemented before?
Should I be focusing on "proper"
class system rather than what I'm doing now?

Answer 1

When you create a table, simply add an empty table in the fake and set it's metatable:
local fake = {}
do
local lookup = {} --Will be using this to avoid using lots of metatables
local real = {}
local meta
meta = {
__index = function(self,i)
return rawget(lookup[self], i)
end,
__newindex = function(self,i,v)
rawset(lookup[self], i, v)
if type(v) == "table" then
rawset(self, i, setmetatable({},meta))
lookup[self[i]] = v
end
end
}
setmetatable(fake, meta)
lookup[fake] = real
end
fake[1] = "hello"
print(fake[1])
print(rawget(fake, 1))
fake.x = {"hi"}
print(fake.x)
print(rawget(fake, 'x')) --This still prints a table because there actually is one, but in reality it's abiding by our rules
print(fake.x[1])
print(rawget(fake.x, 1))
fake.x.y = "aha"
print(fake.x.y)
print(rawget(fake.x, 'y'))
The only caveat with this method is they can directly modify the database like so:
fake.myvalue = {}
fake.myvalue = 5
Another method could be to wrap as you go:
local fake = {}
do
local lookup = {} --Will be using this to avoid using lots of metatables
local cache = {} --will be using to avoid usings tons of new objects
local real = {}
local meta
meta = {
__index = function(self,i)
local val = rawget(lookup[self], i)
if type(val) == "table" then
if cache[val] then
return cache[val]
else
local faker = {}
lookup[faker] = val
cache[val] = faker
return setmetatable(faker, meta)
end
else
return val
end
end,
__newindex = function(self,i,v)
rawset(lookup[self], i, v)
end
}
setmetatable(fake, meta)
lookup[fake] = real
end
fake[1] = "hello"
print(fake[1])
print(rawget(fake, 1))
fake.x = {"hi"}
print(fake.x)
print(rawget(fake, 'x')) --This still prints a table because there actually is one, but in reality it's abiding by our rules
print(fake.x[1])
print(rawget(fake.x, 1))
fake.x.y = "aha"
print(fake.x.y)
print(rawget(fake.x, 'y'))
Which avoids the direct modifying problem completely