attempt to fix path resolution

Author: zvonand

src/Storages/ObjectStorage/Utils.cpp

@@ -269,23 +269,8 @@ std::string normalizePathToStorageRoot(const std::string & table_location, const
     if (!rel_path.empty() && rel_path.front() == '/')
         rel_path = rel_path.substr(1);
 
-    if (!rel_path.empty() && !base.key.empty())
-    {
-        if (rel_path == base.key || rel_path.starts_with(base.key + "/"))
-        {
-            std::filesystem::path fs_path(rel_path);
-            std::filesystem::path normalized = fs_path.lexically_normal();
-            
-            std::string result = normalized.string();
-            std::replace(result.begin(), result.end(), '\\', '/');
-            
-            while (!result.empty() && result.front() == '/')
-                result = result.substr(1);
-            
-            return result;
-        }
-    }
-
+    // First, try combining and normalizing to see if the path resolves outside the table location
+    // This handles cases where paths use ".." to go up from table location to shared parent
     std::string combined = base.key;
     if (!combined.empty() && combined.back() != '/')
         combined += '/';
@@ -295,13 +280,33 @@ std::string normalizePathToStorageRoot(const std::string & table_location, const
     std::filesystem::path fs_path(combined);
     std::filesystem::path normalized = fs_path.lexically_normal();
 
-    std::string result = normalized.string();
-    std::replace(result.begin(), result.end(), '\\', '/'); // Unlikely but some may use Windows paths
+    std::string normalized_result = normalized.string();
+    std::replace(normalized_result.begin(), normalized_result.end(), '\\', '/');
 
-    while (!result.empty() && result.front() == '/')
-        result = result.substr(1);
+    while (!normalized_result.empty() && normalized_result.front() == '/')
+        normalized_result = normalized_result.substr(1);
+
+    // Check if the normalized path still starts with base.key (meaning it's under table location)
+    // or if it doesn't (meaning it resolved outside, e.g., via "..")
+    if (!normalized_result.empty() && !base.key.empty())
+    {
+        // If normalized path doesn't start with base.key, it means the original path
+        // used ".." to go outside the table location - use the normalized path as-is
+        if (!normalized_result.starts_with(base.key + "/") && normalized_result != base.key)
+        {
+            return normalized_result;
+        }
+        
+        // If normalized path starts with base.key, check if original path already included it
+        // This handles cases where paths in metadata are already relative to storage root
+        if (rel_path == base.key || rel_path.starts_with(base.key + "/"))
+        {
+            // Path already includes table location, return normalized version
+            return normalized_result;
+        }
+    }
 
-    return result;
+    return normalized_result;
 }
 
 std::string makeAbsolutePath(const std::string & table_location, const std::string & path)