Efficient Portable Database for Hierarchical Dataset - Json, Sqlite or?

I need to make a file that contains a hierarchical dataset. The dataset in question is a file-system listing (directory names, file name/sizes in each directory, sub-directories, ...).

My first instinct was to use Json and flatten the hierarchy using paths so the parser doesn't have to recurse so much. As seen in the example below, each entry is a path ("/", "/child01", "/child01/gchild01",...) and it's files.

{
    "entries":
    [
        {
            "path":"/",
            "files":
            [
                {"name":"File1", "size":1024}开发者_StackOverflow中文版,
                {"name":"File2", "size":1024}
            ]
        },
        {
            "path":"/child01",
            "files":
            [
                {"name":"File1", "size":1024},
                {"name":"File2", "size":1024}
            ]
        },
        {
            "path":"/child01/gchild01",
            "files":
            [
                {"name":"File1", "size":1024},
                {"name":"File2", "size":1024}
            ]
        },
        {
            "path":"/child02",
            "files":
            [
                {"name":"File1", "size":1024},
                {"name":"File2", "size":1024}
            ]
        }
    ]
}

Then I thought that repeating the keys over and over ("name", "size") for each file kind of sucks. So I found this article about how to use Json as if it were a database - http://peter.michaux.ca/articles/json-db-a-compressed-json-format

Using that technique I'd have a Json table like "Entry" with columns "Id", "ParentId", "EntryType", "Name", "FileSize" where "EntryType" would be 0 for Directory and 1 for File.

So, at this point, I'm wondering if sqlite would be a better choice. I'm thinking that the file size would be a LOT smaller than a Json file, but it might only be negligible if I use Json-DB-compressed format from the article. Besides size, are there any other advantages that you can think of?

I think a Javascript object for datasource, loaded as a file stream into the browser and then used in javascript logic in the browser would consume the least time and have good performance.. BUT only until a limited hierarchy size of the content.

Also, not storing the hierarchy anywhere else and keeping it only as a JSON file badly limits your data source's use in your project to client-side technologies.. or forces conversions to other technologies.

If you are building a pure javascript based application (html, js, css only app), then you could keep it as JSON object alone.. and limit your hierarchy sizes.. you could split bigger hierarchies into multiple files linking json objects.

If you will have server-side code like php, in your project, Considering managebility of code, and scaling, you should ideally store the data in SQLite DB, at runtime create your json hierarchies for limited levels as ajax loads from your page.

If this is the only data your application stores then you can do something really simple like just store the data in an easy to parse/read text file like this:

File1:1024
File2:1024
child01
    File1:1024
    File2:1024
    gchild01
        File1:1024
        File2:1024
child02
    File1:1024
    File2:1024

Files get File:Size and directories get just their name. Indentation gives structure. For something slightly more standard but just as easy to read, use yaml.

http://www.yaml.org/

Both can benefit from decreased file size (but decreased user readability) by gzipping the file.

And if you have more data to store, then use SQLite. SQLite is great.

Don't use JSON for data persistence. It's wasteful.