NXDRIVE-2489: Remove useless manual Path -> str calls

SQLite will automatically handle those data thanks to the adapter.

Also restored the private adapter name to ease code reading everywhere.

Author: Mickaël Schoentgen

docs/changes/4.5.1.md

@@ -78,6 +78,7 @@ Release date: `2021-xx-xx`
 - Added `new_folder` keyword argument to `Engine.direct_transfer()`
 - Added `new_folder` keyword argument to `Engine.direct_transfer_async()`
 - Added `remote_parent_title` argument to `Engine.direct_transfer_async()`
+- Changed `local_parent_path` argument type of `EngineDAO.update_remote_parent_path_dt()` from `str` to `Path`
 - Added `doc_pair` keyword argument to `FileAction.__init__()`
 - Added `FoldersDialog.remote_folder_title`
 - Added `FoldersDialog.CSS`

nxdrive/engine/dao/sqlite.py

@@ -125,21 +125,25 @@
 }
 
 
-def _path(path: Path) -> str:
+def _adapt_path(path: Path, /) -> str:
     """
     Return the string needed to work with data from the database from a given *path*.
     It is used across the whole file and also in the SQLite adapter to convert
     a Path object to str before insertion into database.
+
+    Note: The starting forward-slash will be automatically added if not present
+          and if the *path* is not absolute (Direct Transfer paths for instance).
     """
     posix_path = path.as_posix()
-    if posix_path == ".":  # Note: ROOT.as_posix() and Path().as_posix() will return "."
+    # Note: ROOT.as_posix(), Path.path().as_posix(), Path.path("").as_posix() and Path(".").as_posix() will return "."
+    if posix_path == ".":
         return "/"
     if posix_path[0] != "/" and not path.is_absolute():
         return f"/{posix_path}"
     return posix_path
 
 
-register_adapter(WindowsPath if WINDOWS else PosixPath, _path)
+register_adapter(WindowsPath if WINDOWS else PosixPath, _adapt_path)
 
 
 class AutoRetryCursor(Cursor):
@@ -1207,10 +1211,6 @@ def insert_local_state(
             c = con.cursor()
             pair_state = PAIR_STATES[("created", "unknown")]
 
-            # parent_path is None when registering a new sync root
-            local_path = _path(info.path) if parent_path else "/"
-            local_parent_path = _path(parent_path) if parent_path else None
-
             c.execute(
                 "INSERT INTO States "
                 "(last_local_updated, local_digest, local_path, "
@@ -1220,8 +1220,8 @@ def insert_local_state(
                 (
                     info.last_modification_time,
                     digest,
-                    local_path,
-                    local_parent_path,
+                    info.path,
+                    parent_path,
                     info.path.name,
                     info.folderish,
                     info.size,
@@ -1231,14 +1231,14 @@ def insert_local_state(
             row_id = c.lastrowid
             parent = (
                 c.execute(
-                    "SELECT * FROM States WHERE local_path = ?", (local_parent_path,)
+                    "SELECT * FROM States WHERE local_path = ?", (parent_path,)
                 ).fetchone()
-                if local_parent_path
+                if parent_path
                 else None
             )
 
             # Don't queue if parent is not yet created
-            if (parent is None and local_parent_path is None) or (
+            if (parent is None and parent_path is None) or (
                 parent and parent.pair_state != "locally_created"
             ):
                 self._queue_pair_state(row_id, info.folderish, pair_state)
@@ -1443,7 +1443,7 @@ def update_local_state(
             log.debug(f"Increasing version to {row.version + 1} for pair {row!r}")
 
         with self.lock:
-            parent_path = _path(info.path.parent)
+            parent_path = info.path.parent
             con = self._get_write_connection()
             c = con.cursor()
             c.execute(
@@ -1461,7 +1461,7 @@ def update_local_state(
                 (
                     info.last_modification_time,
                     row.local_digest,
-                    _path(info.path),
+                    info.path,
                     parent_path,
                     info.path.name,
                     row.local_state,
@@ -1608,19 +1608,18 @@ def get_errors(self, *, limit: int = 3) -> DocPairs:
     def get_local_children(self, path: Path, /) -> DocPairs:
         c = self._get_read_connection().cursor()
         return c.execute(
-            "SELECT * FROM States WHERE local_parent_path = ?", (_path(path),)
+            "SELECT * FROM States WHERE local_parent_path = ?", (path,)
         ).fetchall()
 
     def get_states_from_partial_local(
         self, path: Path, /, *, strict: bool = True
     ) -> DocPairs:
         c = self._get_read_connection().cursor()
 
-        local_path = _path(path)
-        if path == ROOT:
-            local_path += "%"
-        else:
-            local_path += "/%" if strict else "%"
+        local_path = _adapt_path(path)
+        if local_path[-1] != "/" and strict:
+            local_path += "/"
+        local_path += "%"
 
         return c.execute(
             "SELECT * FROM States WHERE local_path LIKE ?", (local_path,)
@@ -1677,7 +1676,7 @@ def get_state_from_id(
         return state
 
     def _get_recursive_condition(self, doc_pair: DocPair, /) -> str:
-        path = self._escape(_path(doc_pair.local_path))
+        path = self._escape(_adapt_path(doc_pair.local_path))
         res = (
             f" WHERE (local_parent_path LIKE '{path}/%'"
             f"        OR local_parent_path = '{path}')"
@@ -1701,8 +1700,8 @@ def replace_local_paths(self, old_path: Path, new_path: Path) -> None:
         (including starting and ending slashes).
         """
 
-        old = f"{_path(old_path)}/"
-        new = f"{_path(new_path)}/"
+        old = f"{_adapt_path(old_path)}/"
+        new = f"{_adapt_path(new_path)}/"
         log.debug(f"Updating all local paths from {old!r} to {new!r}")
 
         with self.lock:
@@ -1746,8 +1745,8 @@ def update_local_parent_path(
             con = self._get_write_connection()
             c = con.cursor()
             if doc_pair.folderish:
-                path = self._escape(_path(new_path / new_name))
-                count = len(self._escape(_path(doc_pair.local_path)))
+                path = self._escape(_adapt_path(new_path / new_name))
+                count = len(self._escape(_adapt_path(doc_pair.local_path)))
                 query = (
                     "UPDATE States"
                     f"  SET local_parent_path = '{path}'"
@@ -1760,7 +1759,7 @@ def update_local_parent_path(
             # Don't need to update the path as it is refresh later
             c.execute(
                 "UPDATE States SET local_parent_path = ? WHERE id = ?",
-                (_path(new_path), doc_pair.id),
+                (new_path, doc_pair.id),
             )
 
     def update_remote_parent_path_dt(
@@ -1778,14 +1777,14 @@ def update_remote_parent_path_dt(
             doc_pairs = c.execute(
                 "SELECT * FROM States WHERE local_state = 'direct' AND remote_state = 'todo'"
                 " AND local_parent_path = ?",
-                (_path(local_parent_path),),
+                (local_parent_path,),
             ).fetchall()
 
             c.execute(
                 "UPDATE States SET remote_state = 'unknown', remote_parent_path = ?,"
                 " remote_parent_ref = ?, processor = 0"
                 " WHERE local_state = 'direct' AND remote_state = 'todo' AND local_parent_path = ?",
-                (remote_parent_path, remote_parent_ref, _path(local_parent_path)),
+                (remote_parent_path, remote_parent_ref, local_parent_path),
             )
 
             for doc_pair in doc_pairs:
@@ -1844,7 +1843,7 @@ def remove_state_children(
     def get_state_from_local(self, path: Path, /) -> Optional[DocPair]:
         c = self._get_read_connection().cursor()
         return c.execute(
-            "SELECT * FROM States WHERE local_path = ?", (_path(path),)
+            "SELECT * FROM States WHERE local_path = ?", (path,)
         ).fetchone()
 
     def insert_remote_state(
@@ -1884,8 +1883,8 @@ def insert_remote_state(
                     info.digest,
                     info.folderish,
                     info.last_contributor,
-                    _path(local_path),
-                    _path(local_parent_path),
+                    local_path,
+                    local_parent_path,
                     pair_state,
                     info.name,
                     info.creation_time,
@@ -1914,7 +1913,7 @@ def queue_children(self, row: DocPair, /) -> None:
                 " WHERE remote_parent_ref = ?"
                 "    OR local_parent_path = ?"
                 "   AND " + self._get_to_sync_condition(),
-                (row.remote_ref, _path(row.local_path)),
+                (row.remote_ref, row.local_path),
             ).fetchall()
             if children:
                 log.info(f"Queuing {len(children)} children of {row}")
@@ -2046,7 +2045,7 @@ def unset_unsychronised(self, row: DocPair, /) -> None:
                     row.remote_state,
                     row.pair_state,
                     datetime.utcnow(),
-                    f"{_path(row.local_path)}%",
+                    f"{_adapt_path(row.local_path)}%",
                 ),
             )
 
@@ -2120,7 +2119,7 @@ def synchronize_state(
                         row.pair_state,
                         datetime.utcnow(),
                         row.id,
-                        _path(row.local_path),
+                        row.local_path,
                         row.remote_name,
                         row.remote_ref,
                         row.remote_parent_ref,