Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· openaiHugging Face Suzhen/CodeChat

store local directory‘s structure metadata into sqlite using c++,and support add…

  1. User

    store local directory‘s structure metadata into sqlite using c++,and support add file,remove file,add directory,remove directory,query file’s size, query directory’s size,remove directory recursive from sqlite

  2. Assistant

    This implementation is broken down into parts as follows.

    • Part 1: C++ Header file for classes and methods declaration
    • Part 2: C++ Source file for classes and methods implementation
    • Part 3: Main function to use and test.

    Part 1: DirectoryMetadata.h

    #include <iostream>
    #include <string>
    #include <unordered_map>
    #include <vector>
    #include <sqlite3.h>
    
    class DirectoryMetadata {
    public:
        DirectoryMetadata();
        ~DirectoryMetadata();
        bool createDatabase(const std::string &dbName);
        bool closeDatabase();
        bool addFile(const std::string &dir, const std::string &filename, uint64_t size);
        bool removeFile(const std::string &dir, const std::string &filename);
        bool addDirectory(const std::string &dir);
        bool removeDirectory(const std::string &dir);
        int64_t queryFileSize(const std::string &dir, const std::string &filename);
        int64_t queryDirectorySize(const std::string &dir);
        bool removeDirectoryRecursive(const std::string &_dir);
    
    private:
        // SQLite3 functions wrapper
        bool executeSql(const std::string &sql);
        static int callback(void *data, int argc, char **argv, char **azColName);
    
        sqlite3 *db;
    };
    
    

    Part 2: DirectoryMetadata.cpp

    #include "DirectoryMetadata.h"
    
    DirectoryMetadata::DirectoryMetadata() : db(nullptr) {}
    
    DirectoryMetadata::~DirectoryMetadata() {
        closeDatabase();
    }
    
    bool DirectoryMetadata::createDatabase(const std::string &dbName) {
        if (sqlite3_open(dbName.c_str(), &db)) {
            std::cerr << "Error opening sqlite database: " << sqlite3_errmsg(db) << std::endl;
            return false;
        }
    
        std::string createTableSql = "CREATE TABLE IF NOT EXISTS metadata ("
                                     "path TEXT PRIMARY KEY,"
                                     "filename TEXT,"
                                     "size INTEGER);";
    
        return executeSql(createTableSql);
    }
    
    bool DirectoryMetadata::closeDatabase() {
        sqlite3_close(db);
        db = nullptr;
        return true;
    }
    
    bool DirectoryMetadata::addFile(const std::string &dir, const std::string &filename, uint64_t size) {
        std::string addFileSql = "INSERT INTO metadata (path, filename, size) VALUES ('" +
                                 dir + "','" + filename + "'," + std::to_string(size) + ");";
    
        return executeSql(addFileSql);
    }
    
    bool DirectoryMetadata::removeFile(const std::string &dir, const std::string &filename) {
        std::string removeFileSql = "DELETE FROM metadata WHERE path ='" + dir +
                                    "' AND filename = '" + filename + "';";
    
        return executeSql(removeFileSql);
    }
    
    bool DirectoryMetadata::executeSql(const std::string &sql) {
        char *errMsg = nullptr;
        int rc = sqlite3_exec(db, sql.c_str(), nullptr, 0, &errMsg);
        if (rc != SQLITE_OK) {
            std::cerr << "Error executing SQL: " << errMsg << std::endl;
            sqlite3_free(errMsg);
            return false;
        }
        return true;
    }
    
    int DirectoryMetadata::callback(void *data, int argc, char **argv, char **azColName) {
        int64_t *size = reinterpret_cast<int64_t *>(data);
        for (int i = 0; i < argc; ++i) {
            if (strncmp(azColName[i], "size", 4) == 0) {
                *size += strtoll(argv[i], nullptr, 10);
            }
        }
        return 0;
    }
    
    bool DirectoryMetadata::addDirectory(const std::string &dir) {
        return true;  // Note: In our simplified model, no dedicated operation is needed to add a directory.
    }
    
    bool DirectoryMetadata::removeDirectory(const std::string &dir) {
        std::string removeDirSql = "DELETE FROM metadata WHERE path ='" + dir + "';";
    
        return executeSql(removeDirSql);
    }
    
    int64_t DirectoryMetadata::queryFileSize(const std::string &dir, const std::string &filename) {
        std::string queryFileSizeSql = "SELECT size FROM metadata WHERE path ='" + dir +
                                       "' AND filename ='" + filename + "';";
    
        int64_t size = 0;
    
        sqlite3_exec(db, queryFileSizeSql.c_str(), &DirectoryMetadata::callback, &size, nullptr);
    
        return size;
    }
    
    int64_t DirectoryMetadata::queryDirectorySize(const std::string &dir) {
        std::string queryDirSizeSql = "SELECT size FROM metadata WHERE path ='" + dir + "';";
    
        int64_t size = 0;
    
        sqlite3_exec(db, queryDirSizeSql.c_str(), &DirectoryMetadata::callback, &size, nullptr);
    
        return size;
    }
    
    bool DirectoryMetadata::removeDirectoryRecursive(const std::string &_dir) {
        std::string dir = std::string(_dir + "/");
        std::string removeDirRecursiveSql = "DELETE FROM metadata WHERE path LIKE '" + dir + "%';";
    
        return executeSql(removeDirRecursiveSql);
    }
    

    Part 3: Main function

    #include <iostream>
    #include "DirectoryMetadata.h"
    
    int main() {
        // Create an instance of the DirectoryMetadata class
        DirectoryMetadata myDirectory;
    
        // Create the SQLite3 database to store directory metadata
        myDirectory.createDatabase("my_directory.db");
    
        // Add files and directories
        myDirectory.addFile("dir1", "file1.txt", 100);
        myDirectory.addFile("dir1", "file2.txt", 200);
        myDirectory.addFile("dir1/subdir1", "file3.txt", 300);
        myDirectory.addFile("dir1/subdir1", "file4.txt", 400);
    
        // Query file size
        std::cout << "Size of file1.txt: " << myDirectory.queryFileSize("dir1", "file1.txt") << std::endl;
    
        // Query directory size
        std::cout << "Size of dir1: " << myDirectory.queryDirectorySize("dir1") << std::endl;
    
        // Remove a file
        myDirectory.removeFile("dir1", "file1.txt");
    
        std::cout << "Size of dir1 after removing file1.txt: " << myDirectory.queryDirectorySize("dir1")
                  << std::endl;
    
        // Remove a directory
        myDirectory.removeDirectory("dir1/subdir1");
    
        std::cout << "Size of dir1 after removing subdir1: " << myDirectory.queryDirectorySize("dir1")
                  << std::endl;
    
        // Remove a directory recursively
        myDirectory.removeDirectoryRecursive("dir1");
    
        // Close the SQLite3 database
        myDirectory.closeDatabase();
    
        return 0;
    }
    

    Compile the code using:

    g++ -o main main.cpp DirectoryMetadata.cpp -lsqlite3
    

    Run the code:

    ./main
    
  3. User

    不是记录文件全路径,是记录文件系统的结构元数据

  4. Assistant

    I see that you want to store the structure metadata of a file system. Here's a modified version of the code that achieves this:

    Part 1: FileSystemMetadata.h

    #ifndef FILE_SYSTEM_METADATA_H
    #define FILE_SYSTEM_METADATA_H
    
    #include <iostream>
    #include <string>
    #include <unordered_map>
    #include <vector>
    #include <sqlite3.h>
    
    class FileSystemMetadata {
    public:
        FileSystemMetadata();
        ~FileSystemMetadata();
        bool createDatabase(const std::string &dbName);
        bool closeDatabase();
        bool addFile(const std::string &path, const std::string &name, uint64_t size);
        bool removeFile(const std::string &path, const std::string &name);
        bool addDirectory(const std::string &path, const std::string &name);
        bool removeDirectory(const std::string &path, const std::string &name);
        int64_t queryFileSize(const std::string &path, const std::string &name);
        int64_t queryDirectorySize(const std::string &path, const std::string &name);
        bool removeDirectoryRecursive(const std::string &path);
    
    private:
        // SQLite3 functions wrapper
        bool executeSql(const std::string &sql);
        static int callback(void *data, int argc, char **argv, char **azColName);
    
        sqlite3 *db;
    };
    
    #endif // FILE_SYSTEM_METADATA_H
    

    Part 2: FileSystemMetadata.cpp

    #include "FileSystemMetadata.h"
    
    FileSystemMetadata::FileSystemMetadata() : db(nullptr) {}
    
    FileSystemMetadata::~FileSystemMetadata() {
        closeDatabase();
    }
    
    bool FileSystemMetadata::createDatabase(const std::string &dbName) {
        if (sqlite3_open(dbName.c_str(), &db)) {
            std::cerr << "Error opening sqlite database: " << sqlite3_errmsg(db) << std::endl;
            return false;
        }
    
        std::string createTableSql = "CREATE TABLE IF NOT EXISTS metadata ("
                                     "id INTEGER PRIMARY KEY,"
                                     "path TEXT,"
                                     "name TEXT,"
                                     "is_file BOOLEAN,"
                                     "size INTEGER);";
    
        return executeSql(createTableSql);
    }
    
    bool FileSystemMetadata::closeDatabase() {
        sqlite3_close(db);
        db = nullptr;
        return true;
    }
    
    bool FileSystemMetadata::addFile(const std::string &path, const std::string &name, uint64_t size) {
        std::string addFileSql = "INSERT INTO metadata (path, name, is_file, size) VALUES ('" +
                                 path + "','" + name + "'," + "1," + std::to_string(size) + ");";
    
        return executeSql(addFileSql);
    }
    
    bool FileSystemMetadata::removeFile(const std::string &path, const std::string &name) {
        std::string removeFileSql = "DELETE FROM metadata WHERE path ='" + path +
                                    "' AND name = '" + name + "';";
    
        return executeSql(removeFileSql);
    }
    
    bool FileSystemMetadata::executeSql(const std::string &sql) {
        char *errMsg = nullptr;
        int rc = sqlite3_exec(db, sql.c_str(), nullptr, 0, &errMsg);
        if (rc != SQLITE_OK) {
            std::cerr << "Error executing SQL: " << errMsg << std::endl;
            sqlite3_free(errMsg);
            return false;
        }
        return true;
    }
    
    int FileSystemMetadata::callback(void *data, int argc, char **argv, char **azColName) {
        int64_t *size = reinterpret_cast<int64_t *>(data);
        for (int i = 0; i < argc; ++i) {
            if (strncmp(azColName[i], "size", 4) == 0) {
                *size += strtoll(argv[i], nullptr, 10);
            }
        }
        return 0;
    }
    
    bool FileSystemMetadata::addDirectory(const std::string &path, const std::string &name) {
        std::string addDirectorySql = "INSERT INTO metadata (path, name, is_file, size) VALUES ('" +
                                      path + "','" + name + "'," + "0," + "0);";
    
        return executeSql(addDirectorySql);
    }
    
    bool FileSystemMetadata::removeDirectory(const std::string &path, const std::string &name) {
        std::string removeDirectorySql = "DELETE FROM metadata WHERE path ='" + path +
                                         "' AND name = '" + name + "' AND is_file = 0;";
    
        return executeSql(removeDirectorySql);
    }
    
    int64_t FileSystemMetadata::queryFileSize(const std::string &path, const std::string &name) {
        std::string queryFileSizeSql = "SELECT size FROM metadata WHERE path ='" + path +
                                       "' AND name ='" + name + "' AND is_file = 1;";
    
        int64_t size = 0;
    
        sqlite3_exec(db, queryFileSizeSql.c_str(), &FileSystemMetadata::callback, &size, nullptr);
    
        return size;
    }
    
    int64_t FileSystemMetadata::queryDirectorySize(const std::string &path, const std::string &name) {
        std::string path_to_search = path + "/" + name;
        std::string queryDirSizeSql =
            "SELECT size FROM metadata WHERE path ='" + path_to_search + "' AND is_file = 1;";
    
        int64_t size = 0;
    
        sqlite3_exec(db, queryDirSizeSql.c_str(), &FileSystemMetadata::callback, &size, nullptr);
    
        return size;
    }
    
    bool FileSystemMetadata::removeDirectoryRecursive(const std::string &path) {
        std::string removeDirRecursiveSql =
            "DELETE FROM metadata WHERE path LIKE '" + path + "/%' OR (path = '" + path +
            "' AND is_file = 0);";
    
        return executeSql(removeDirRecursiveSql);
    }
    

    Part 3: Main function

    #include <iostream>
    #include "FileSystemMetadata.h"
    
    int main() {
        FileSystemMetadata fs_metadata;
    
        fs_metadata.createDatabase("file_system.db");
    
        fs_metadata.addDirectory("", "dir1");
        fs_metadata.addDirectory("dir1", "subdir1");
        fs_metadata.addFile("dir1/subdir1", "file1.txt", 100);
        fs_metadata.addFile("dir1/subdir1", "file2.txt", 200);
    
        std::cout << "Size of file1.txt: "
                  << fs_metadata.queryFileSize("dir1/subdir1", "file1.txt") << std::endl;
    
        std::cout << "Size of subdir1: " << fs_metadata.queryDirectorySize("dir1", "subdir1")
                  << std::endl;
    
        fs_metadata.removeFile("dir1/subdir1", "file1.txt");
        fs_metadata.removeDirectory("dir1", "subdir1");
        fs_metadata.removeDirectoryRecursive("dir1");
    
        fs_metadata.closeDatabase();
    
        return 0;
    }
    

    Compile and run the code as before:

    g++ -o main main.cpp FileSystemMetadata.cpp -lsqlite3
    ./main