🚧 modify and query sqlite_tbl by index

Author: kkharji

lua/sqlite/assert.lua

@@ -13,6 +13,8 @@ local errors = {
   missing_db_object = "%s's db object is not set. set it with `%s:set_db(db)` and try again.",
   outdated_schema = "`%s` does not exists in {`%s`}, schema is outdateset `self.db.tbl_schemas[table_name]` or reload",
   auto_alter_more_less_keys = "schema defined ~= db schema. Please drop `%s` table first or set ensure to false.",
+  miss_match_pk_type = "Primary key ('%s') is of type '%s', '%s' can't be used to access %s table. RECEIVED KEY: %s",
+  no_primary_key = "%s has no primary key.",
 }
 
 for key, value in pairs(errors) do
@@ -80,4 +82,19 @@ M.auto_alter_should_have_equal_len = function(len_new, len_old, tname)
   end
 end
 
+M.should_match_pk_type = function(name, kt, pk, key)
+  local knotstr = kt ~= "string"
+  local knotnum = kt ~= "number"
+  local pt = pk.type
+  if not pk or not pk.type then
+    return error(errors.no_primary_key:format(name))
+  end
+
+  if knotstr and (pt == "string" or pt == "text") or knotnum and (pt == "number" or pt == "integer") then
+    return error(errors.miss_match_pk_type:format(pk.name, pk.type, kt, name, key))
+  end
+
+  return true
+end
+
 return M

lua/sqlite/defs.lua

@@ -579,7 +579,7 @@ ffi.cdef [[
 ]]
 
 ---@class sqlite3 @sqlite3 db object
----@class sqlite_blob @sqlite3 blob object
+---@class sqlite_blob* @sqlite3 blob object
 
 M.to_str = function(ptr, len)
   if ptr == nil then

lua/sqlite/helpers.lua

@@ -66,6 +66,7 @@ end
 ---@param o sqlite_tbl
 ---@return any
 M.run = function(func, o)
+  func = func or function() end
   a.should_have_db_object(o.db, o.name)
   local exec = function()
     local valid_schema = o.tbl_schema and next(o.tbl_schema) ~= nil

lua/sqlite/tbl.lua

@@ -11,12 +11,15 @@
 local u = require "sqlite.utils"
 local h = require "sqlite.helpers"
 
+local indexer = require "sqlite.tbl.indexer"
 local sqlite = {}
 
 ---@type sqlite_tbl
 sqlite.tbl = {}
 sqlite.tbl.__index = sqlite.tbl
 
+-- TODO: Add examples to index access in sqlite.tbl.new
+
 ---Create new |sqlite_tbl| object. This object encouraged to be extend and
 ---modified by the user. overwritten method can be still accessed via
 ---pre-appending `__`  e.g. redefining |sqlite_tbl:get|, result in
@@ -49,27 +52,19 @@ sqlite.tbl.__index = sqlite.tbl
 ---@return sqlite_tbl
 function sqlite.tbl.new(name, schema, db)
   schema = schema or {}
-
-  local t = setmetatable({
+  schema = u.if_nil(schema.schema, schema)
+  ---@type sqlite_tbl
+  local tbl = setmetatable({
     db = db,
     name = name,
-    tbl_schema = u.if_nil(schema.schema, schema),
+    tbl_schema = schema,
   }, sqlite.tbl)
 
   if db then
-    h.run(function() end, t)
+    h.run(nil, tbl)
   end
 
-  return setmetatable({}, {
-    __index = function(_, key, ...)
-      if type(key) == "string" then
-        key = key:sub(1, 2) == "__" and key:sub(3, -1) or key
-        if t[key] then
-          return t[key]
-        end
-      end
-    end,
-  })
+  return indexer(tbl)
 end
 
 ---Create or change table schema. If no {schema} is given,

lua/sqlite/tbl/indexer.lua

@@ -0,0 +1,150 @@
+local a = require "sqlite.assert"
+local u = require "sqlite.utils"
+---Get primary key from sqlite_tbl schema
+---@param tbl sqlite_schema_dict
+local get_primary_key = function(tbl)
+  local pk
+  for k, v in pairs(tbl or {}) do
+    if type(v) == "table" and v.primary then
+      pk = v
+      if not pk.type then
+        pk.type = pk[1]
+      end
+      pk.name = k
+      break
+    elseif type(v) == "boolean" and k ~= "ensure" then
+      pk = {
+        name = k,
+        type = "integer",
+        primary = true,
+      }
+      break
+    end
+  end
+
+  return pk
+end
+
+---TODO: remove after using value should rawset and rawget in helpers.run, sqlite.tbl
+local is_part_of_tbl_object = function(key)
+  return key == "db"
+    or key == "tbl_exists"
+    or key == "db_schema"
+    or key == "tbl_name"
+    or key == "tbl_schema"
+    or key == "mtime"
+    or key == "has_content"
+    or key == "_name"
+end
+
+local resolve_meta_key = function(kt, key)
+  return kt == "string" and (key:sub(1, 2) == "__" and key:sub(3, -1) or key) or key
+end
+
+---Used to extend a table row to be able to manipulate the row values
+---@param tbl sqlite_tbl
+---@param pk sqlite_schema_key
+---@return function(row, altkey):table
+local tbl_row_extender = function(tbl, pk)
+  -- print(vim.inspect(pk))
+  return function(row, reqkey)
+    row = row or {}
+    local mt = {
+      __newindex = function(_, key, val)
+        tbl:update { -- TODO: maybe return inserted row??
+          where = { [pk.name] = (row[pk.name] or reqkey) },
+          set = { [key] = val },
+        }
+        row = {}
+      end,
+      __index = function(_, key)
+        if key == "values" then
+          return row
+        end
+        if not row[key] then
+          local res = tbl:where { [pk.name] = row[pk.name] } or {}
+          row = res
+          return res[key]
+        else
+          return row[key]
+        end
+      end,
+    }
+
+    return setmetatable({}, mt)
+  end
+end
+
+local sep_query_and_where = function(q, keys)
+  local kv = { where = {} }
+  for k, v in pairs(q) do
+    if u.contains(keys, k) then
+      kv.where[k] = v
+    else
+      kv[k] = v
+    end
+  end
+
+  if next(kv.where) == nil then
+    kv.where = nil
+  end
+  return kv
+end
+return function(tbl)
+  local pk = get_primary_key(tbl.tbl_schema)
+  local extend = tbl_row_extender(tbl, pk)
+  local tbl_keys = u.keys(tbl.tbl_schema)
+  local mt = {}
+
+  mt.__index = function(_, arg)
+    if is_part_of_tbl_object(arg) then
+      return tbl[arg]
+    end
+
+    local kt = type(arg)
+    local skey = resolve_meta_key(kt, arg)
+
+    if not pk or (kt == "string" and tbl[skey]) then
+      return tbl[skey]
+    end
+
+    if kt == "string" or kt == "number" and pk then
+      a.should_match_pk_type(tbl.name, kt, pk, arg)
+      return extend(tbl:where { [pk.name] = arg }, arg)
+    end
+
+    return kt == "table" and tbl:get(sep_query_and_where(arg, tbl_keys))
+  end
+
+  mt.__newindex = function(o, arg, val)
+    if is_part_of_tbl_object(arg) then
+      tbl[arg] = val
+      return
+    end
+
+    local kt, vt = type(arg), type(val)
+
+    if not pk or (vt == "function" and kt == "string") then
+      rawset(o, arg, val)
+      return
+    end
+
+    if vt == "nil" and kt == "string" then
+      tbl:remove { [pk.name] = arg }
+    end
+
+    if vt == "table" and kt == "table" then
+      local q = sep_query_and_where(arg, tbl_keys)
+      q.set = val
+      tbl:update(q)
+      return
+    end
+
+    if vt == "table" and pk then
+      a.should_match_pk_type(tbl.name, kt, pk, arg)
+      return tbl:update { where = { [pk.name] = arg }, set = val }
+    end
+  end
+
+  return setmetatable({ config = {} }, mt)
+end

lua/sqlite/utils.lua

@@ -59,6 +59,15 @@ M.okeys = function(t)
   return r
 end
 
+M.contains = function(tbl, val)
+  for _, v in ipairs(tbl) do
+    if v == val then
+      return true
+    end
+  end
+  return false
+end
+
 M.opairs = (function()
   local __gen_order_index = function(t)
     local orderedIndex = {}

test/auto/tbl_spec.lua

@@ -974,72 +974,74 @@ describe("sqlite.tbl", function()
   end)
 
   describe(":index access", function()
-    -- local db_path = "/tmp/idx_db"
+    local db_path = ":memory:" or "/tmp/idx_db"
     -- vim.loop.fs_unlink(db_path)
-    db = sql:open()
+    db = sql:open(db_path)
 
     describe("string_index:", function()
-      local kvpair = tbl("kvpair", {
+      local kv = tbl("kvpair", {
         key = { "text", primary = true, required = true, unique = true },
-        value = "integer",
+        len = "integer",
       }, db)
 
       it("access/insert-to table using primary key", function()
-        kvpair.a = { value = 1 }
-        eq({ key = "a", value = 1 }, kvpair.a)
+        kv.a = { len = 1 }
+        eq({ key = "a", len = 1 }, kv.a)
       end)
 
-      it("access/update a row field value", function()
-        kvpair.a.value = 2
-        eq(2, kvpair.where({ value = 2 }).value, "should have been set")
-        eq(2, kvpair.a.value, "should have been set")
-        kvpair.a.value = 3
-        eq({ key = "a", value = 3 }, kvpair.a, "should return values")
+      it("access/update a row field len", function()
+        -- eq({}, kv.a)
+        kv.a = { len = 1 }
+        kv.a.len = 2
+        eq(2, kv:where({ len = 2 }).len, "should have been set")
+        eq(2, kv.a.len, "should have been set")
+        kv.a.len = 3
+        eq({ key = "a", len = 3 }, kv.a, "should return values")
       end)
 
       it("remove a row using primary key", function()
-        kvpair.a = nil
-        eq(nil, kvpair.where { key = "a" }, "should be empty")
-        eq({}, kvpair.a, "should be empty")
+        kv.a = nil
+        eq(nil, kv:where { key = "a" }, "should be empty")
+        eq({}, kv.a, "should be empty")
       end)
 
-      it("sets a row field value without creating the row first", function()
-        kvpair["some key with spaces :D"].value = 4
-        eq(kvpair["some key with spaces :D"], { key = "some key with spaces :D", value = 4 })
-        kvpair["some key with spaces :D"] = nil
+      it("sets a row field len without creating the row first", function()
+        kv["some key with spaces :D"].len = 4
+        eq(kv["some key with spaces :D"], { key = "some key with spaces :D", len = 4 })
+        kv["some key with spaces :D"] = nil
       end)
 
       it("query using index", function()
-        kvpair.a.value, kvpair.b.value, kvpair.c.value = 1, 2, 3
+        kv.a.len, kv.b.len, kv.c.len = 1, 2, 3
         eq(
-        {
-          { key = "a", value = 1 },
-          { key = "b", value = 2 },
-        },
-        kvpair[{
-          where = { value = { 1, 2, 3 } },
-          order_by = { asc = { "key", "value" } },
-          limit = 2,
-        }]
+          {
+            { key = "a", len = 1 },
+            { key = "b", len = 2 },
+          },
+          kv[{
+            where = { len = { 1, 2, 3 } },
+            order_by = { asc = { "key", "len" } },
+            limit = 2,
+          }]
         )
       end)
-      -- it("bulk update", function()
-        --   kvpair[{ value = { 1, 2, 3 } }] = { value = 10 }
-        --   eq(
-        --     {
-          --       { key = "a", value = 10 },
-          --       { key = "b", value = 10 },
-          --     },
-          --     kvpair[{
-            --       order_by = { asc = { "key" } },
-            --       limit = 2,
-            --     }]
-            --   )
-            -- end)
-          end)
-
-          -- vim.loop.fs_unlink(db_path)
-        end)
+      it("bulk update", function()
+        kv[{ len = { 1, 2, 3 } }] = { len = 10 }
+        eq(
+          {
+            { key = "a", len = 10 },
+            { key = "b", len = 10 },
+          },
+          kv[{
+            order_by = { asc = { "key" } },
+            limit = 2,
+          }]
+        )
+      end)
+    end)
+
+    -- vim.loop.fs_unlink(db_path)
+  end)
 
   clean()
 end)