⚡ improve require time (#111)

kkharji · web-flow · commit f9a106068061 · 2021-09-04T05:44:33.000+03:00
decrease require time (cost on startup) from `0.791636 ms` to `4.140682` (423% faster)
diff --git a/doc/sqlite.txt b/doc/sqlite.txt
@@ -481,7 +481,7 @@ sqlite.db:select({tbl_name}, {spec})                      *sqlite.db:select()*
         table[]
 
 
-sqlite.db:tbl({tbl_name}, {opts})                            *sqlite.db:tbl()*
+sqlite.db:tbl({tbl_name}, {schema})                          *sqlite.db:tbl()*
     Create new sqlite_tbl object. If {opts}.ensure = false, then on each run it
     will drop the table and recreate it. NOTE: this might change someday to
     alter the table instead. For now alteration is auto and limited to field
@@ -506,7 +506,7 @@ sqlite.db:tbl({tbl_name}, {opts})                            *sqlite.db:tbl()*
     Parameters: ~
         {tbl_name} (string)              the name of the table. can be new or
                                          existing one.
-        {opts}     (sqlite_schema_dict)  {schema, ensure (defalut true)}
+        {schema}   (sqlite_schema_dict)  {schema, ensure (defalut true)}
 
     Return: ~
         sqlite_tbl
diff --git a/lua/sqlite/db.lua b/lua/sqlite/db.lua
@@ -3,6 +3,9 @@
 ---@brief ]]
 ---@tag sqlite.db.lua
 
+local u = require "sqlite.utils"
+local require = u.require_on_index
+
 local sqlite = {}
 ---@type sqlite_db
 sqlite.db = {}
@@ -11,11 +14,10 @@ sqlite.db.__version = "v1.0.0"
 
 local clib = require "sqlite.defs"
 local s = require "sqlite.stmt"
-local u = require "sqlite.utils"
 local h = require "sqlite.helpers"
 local a = require "sqlite.assert"
 local p = require "sqlite.parser"
-local flags = clib.flags
+local tbl = require "sqlite.tbl"
 
 ---Creates a new sqlite.lua object, without creating a connection to uri.
 ---|sqlite.new| is identical to |sqlite.db:open| but it without opening sqlite db
@@ -279,7 +281,7 @@ function sqlite.db:eval(statement, params)
   stmt:finalize()
 
   -- if no rows is returned, then check return the result of errcode == flags.ok
-  res = rawequal(next(res), nil) and clib.last_errcode(self.conn) == flags.ok or res
+  res = rawequal(next(res), nil) and clib.last_errcode(self.conn) == clib.flags.ok or res
 
   -- fix res of its table, so that select all doesn't return { [1] = {[1] = { row }} }
   if type(res) == "table" and res[2] == nil and u.is_nested(res[1]) then
@@ -595,14 +597,14 @@ end
 ---```
 ---</pre>
 ---@param tbl_name string: the name of the table. can be new or existing one.
----@param opts sqlite_schema_dict: {schema, ensure (defalut true)}
+---@param schema sqlite_schema_dict: {schema, ensure (defalut true)}
 ---@see |sqlite.tbl.new|
 ---@return sqlite_tbl
 function sqlite.db:tbl(tbl_name, schema)
   if type(self) == "string" then
-    return require("sqlite.tbl").new(self, schema)
+    return tbl.new(self, schema)
   end
-  return require("sqlite.tbl").new(tbl_name, schema, self)
+  return tbl.new(tbl_name, schema, self)
 end
 
 ---DEPRECATED
diff --git a/lua/sqlite/init.lua b/lua/sqlite/init.lua
@@ -72,4 +72,14 @@
 ---| '"cascade"' : propagates the delete or update operation on the parent key to each dependent child key.
 
 ---@type sqlite_db
-return require "sqlite.db"
+return setmetatable({}, {
+  __index = function(_, key)
+    return require("sqlite.db")[key]
+  end,
+  __newindex = function(_)
+    error "sqlite.lua: this shouldn't happen. Mutating sqlite base object is prohibited."
+  end,
+  __call = function(_, ...)
+    return require "sqlite.db"(...)
+  end,
+})
diff --git a/lua/sqlite/stmt.lua b/lua/sqlite/stmt.lua
@@ -6,9 +6,14 @@ local clib = require "sqlite.defs"
 local flags = clib.flags
 
 ---@class sqlstmt @Object to deal with sqlite statements
+---@field pstmt sqlite_blob sqlite_pstmt
+---@field conn sqlite_blob sqlite3 object
+---@field str string original statement
 local sqlstmt = {}
 sqlstmt.__index = sqlstmt
 
+--- TODO: refactor and make parser.lua required here only.
+
 ---Parse a statement
 ---@param conn sqlite3: the database connection.
 ---@param str string: the sqlite statement to be parsed.
@@ -18,29 +23,21 @@ sqlstmt.__index = sqlstmt
 function sqlstmt:parse(conn, str)
   assert(clib.type_of(conn) == clib.type_of_db_ptr, "Invalid connection passed to sqlstmt:parse")
   assert(type(str) == "string", "Invalid second argument passed to sqlstmt:parse")
-  local o = {
+  local o = setmetatable({
     str = str,
     conn = conn,
     finalized = false,
-  }
-  setmetatable(o, self)
-  o:__parse()
-  return o
-end
+  }, sqlstmt)
 
----Parse self.str into an sqlite representation and set it to self.pstmt.
-function sqlstmt:__parse()
   local pstmt = clib.get_new_stmt_ptr()
-  local code = clib.prepare_v2(self.conn, self.str, #self.str, pstmt, nil)
+  local code = clib.prepare_v2(o.conn, o.str, #o.str, pstmt, nil)
+
   assert(
     code == flags.ok,
-    string.format(
-      "sqlite.lua: sql statement parse, , stmt: `%s`, err: `(`%s`)`",
-      self.str,
-      clib.to_str(clib.errmsg(self.conn))
-    )
+    ("sqlite.lua: sql statement parse, , stmt: `%s`, err: `(`%s`)`"):format(o.str, clib.last_errmsg(o.conn))
   )
-  self.pstmt = pstmt[0]
+  o.pstmt = pstmt[0]
+  return o
 end
 
 ---Resets the parsed statement. required for parsed statements to be re-executed.
@@ -69,7 +66,7 @@ function sqlstmt:finalize()
 end
 
 ---Called before evaluating the (next iteration) of the prepared statement.
----@return sqlite_flag: Possible Flags: { flags.busy, flags.done, flags.row, flags.error, flags.misuse }
+---@return sqlite_flags: Possible Flags: { flags.busy, flags.done, flags.row, flags.error, flags.misuse }
 function sqlstmt:step()
   local step_code = clib.step(self.pstmt)
   assert(
@@ -283,7 +280,6 @@ local bind_type_to_func = {
 ---If {args[1]} is a number and {args[2]} is a value then it binds by index.
 ---Else first argument is a table, then it binds the table to indicies, and it
 ---works with named and unnamed.
----@param ...: Either a index value pair or a table
 ---@varargs if {args[1]} number and {args[2]} or {args[1]} table
 ---@see sqlstmt:nparam
 ---@see sqlstmt:param
@@ -342,15 +338,15 @@ end
 ---@param idx number: index starting at 1
 ---@param pointer sqlite_blob: blob to bind
 ---@param size number: pointer size
----@return sqlite_flag
+---@return sqlite_flags
 function sqlstmt:bind_blob(idx, pointer, size)
   return clib.bind_blob64(self.pstmt, idx, pointer, size, nil) -- Always 64? or two functions
 end
 
 ---Binds zeroblob at {idx} with {size}
 ---@param idx number: index starting at 1
 ---@param size number: zeroblob size
----@return sqlite_flag
+---@return sqlite_flags
 function sqlstmt:bind_zeroblob(idx, size)
   return clib.bind_zeroblob64(self.pstmt, idx, size)
 end
@@ -385,15 +381,15 @@ function sqlstmt:params()
 end
 
 ---Clear the current bindings.
----@return sqlite_flag
+---@return sqlite_flags
 function sqlstmt:bind_clear()
   self.current_bind_index = nil
   return clib.clear_bindings(self.pstmt)
 end
 
 ---Bind the value at the next index until all values are bound
 ---@param value any: value to bind
----@return sqlite_flag
+---@return sqlite_flags
 ---@TODO does it return sqlite_flag in all cases? @conni
 function sqlstmt:bind_next(value)
   if not self.current_bind_index then
diff --git a/lua/sqlite/utils.lua b/lua/sqlite/utils.lua
@@ -235,4 +235,26 @@ M.flatten = function(tbl)
   return result
 end
 
+--- taken from https://github.com/tjdevries/lazy.nvim/blob/master/lua/lazy.lua
+M.require_on_exported_call = function(require_path)
+  return setmetatable({}, {
+    __index = function(_, k)
+      return function(...)
+        return require(require_path)[k](...)
+      end
+    end,
+  })
+end
+
+M.require_on_index = function(require_path)
+  return setmetatable({}, {
+    __index = function(_, key)
+      return require(require_path)[key]
+    end,
+
+    __newindex = function(_, key, value)
+      require(require_path)[key] = value
+    end,
+  })
+end
 return M
