Add SQLite compatibility with new module

.gitignore

@@ -25,4 +25,5 @@ Manifest.toml
 
 *.out
 *.ok
-debug_psrclasses
+debug_psrclasses
+*.sqlite

Project.toml

@@ -3,14 +3,17 @@ uuid = "1eab49e5-27d8-4905-b9f6-327b6ea666c4"
 version = "0.11.1"
 
 [deps]
+DBInterface = "a10d1c49-ce27-4219-8d33-6db1a4562965"
+DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
 Encodings = "8275c4fe-57c3-4fbf-b39c-271e6148849a"
 JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
+SQLite = "0aa819cd-b072-5ff4-a722-6bc24af294d9"
 Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
 
 [compat]
+Dates = "1.6.7"
 Encodings = "0.1.1"
 JSON = "0.21"
 Tables = "1.10"
 julia = "1.6"
-Dates = "1.6.7"

src/OpenSQL/OpenSQL.jl

@@ -0,0 +1,22 @@
+module OpenSQL
+
+using SQLite
+using DBInterface
+using Tables
+# TODO talvez a gente nem precise dos DataFrames, da pra fazer com o Tables mesmo
+using DataFrames
+
+const DB = SQLite.DB
+
+"""
+SQLInterface
+"""
+struct SQLInterface end
+
+include("utils.jl")
+include("create.jl")
+include("read.jl")
+include("update.jl")
+include("delete.jl")
+
+end # module OpenSQL

src/OpenSQL/README.md

@@ -0,0 +1,127 @@
+# OpenSQL
+
+Following PSRI's `OpenStudy` standards, SQL schemas for the `OpenSQL` framework should follow the conventions described in this document.
+
+
+## SQL Schema Conventions
+
+
+### Collections
+
+- The Table name should be the same as the name of the Collection.
+- The Table name of a Collection should beging with a capital letter and be in singular form.
+- In case of a Collection with a composite name, the Table name should be separeted by an underscore.
+- The Table must contain a primary key named `id`.
+
+Examples:
+
+
+```sql
+CREATE TABLE Resource (
+    id TEXT PRIMARY KEY,
+    type TEXT NOT NULL DEFAULT "D" CHECK(type IN ('D', 'E', 'F'))
+);
+
+CREATE TABLE Thermal_Plant(
+    id TEXT PRIMARY KEY,
+    capacity REAL NOT NULL DEFAULT 0
+);
+```
+
+
+### Non-vector Attributes
+
+- The name of an Attribute should be in snake case and be in singular form.
+
+Example:
+```sql
+CREATE TABLE Thermal_Plant(
+    id TEXT PRIMARY KEY,
+    capacity REAL NOT NULL
+);
+```
+
+### Vector Attributes
+
+- In case of a vector attribute, a Table should be created with its name indicating the name of the Collection and the name of the attribute, separated by `_vector_`, as presented below
+
+<p style="text-align: center;"> COLLECTION_NAME_vector_ATTRIBUTE_NAME</p>
+
+- Note that after **_vector_** the name of the attribute should follow the same rule as non-vector attributes.
+- The Table must contain a Column named `id` and another named `idx`.
+- There must be a Column named after the attribute name, which will store the value of the attribute for the specified element `id` and index `idx`.
+
+Example:
+```sql
+CREATE TABLE Thermal_Plant_vector_some_value(
+    id TEXT,
+    idx INTEGER NOT NULL,
+    some_value REAL NOT NULL,
+    FOREIGN KEY (id) REFERENCES Thermal_Plant(id) ON DELETE CASCADE,
+    PRIMARY KEY (id, idx)
+);
+```
+
+### Time Series
+
+- All Time Series for the elements from a Collection should be stored in a Table
+- The Table name should be the same as the name of the Collection followed by `_timeseries`, as presented below
+
+<p style="text-align: center"> COLLECTION_NAME_vector_ATTRIBUTE_NAME</p>
+
+- The Table must contain a Column named `id`.
+- Each Column of the table should be named after the name of the attribute.
+- Each Column should store the path to the file containing the time series data.
+
+Example:
+
+```sql
+CREATE TABLE Plant_timeseries (
+    id TEXT PRIMARY KEY,
+    generation TEXT,
+    cost TEXT
+);
+```
+
+### 1 to 1 Relations
+
+- One to One relations (1:1, To, From, etc) should be stored in the Source's Table.
+- The name of the Column storing the Target's element id should have the name of the Target Collection in lowercase and indicate the type of the relation (e.g. `plant_turbine_to`).
+- For the case of a standard 1 to 1 relationship, the name of the Column should be the name of the Target Collection followed by `_id` (e.g. `resource_id`).
+
+Example:
+
+```sql
+CREATE TABLE Plant (
+    id TEXT PRIMARY KEY,
+    capacity REAL NOT NULL DEFAULT 0,
+    resource_id TEXT,
+    plant_turbine_to TEXT,
+    plant_spill_to TEXT,
+    FOREIGN KEY(resource_id) REFERENCES Resource(id),
+    FOREIGN KEY(plant_turbine_to) REFERENCES Plant(id),
+    FOREIGN KEY(plant_spill_to) REFERENCES Plant(id)
+);
+```
+
+### N to N Relations
+
+- N to N relations should be stored in a separate Table, named after the Source and Target Collections, separated by `_relation_`, as presented below
+
+<p style="text-align: center"> SOURCE_NAME_relation_TARGET_NAME</p>
+
+- The Table must contain a Column named `source_id` and another named `target_id`.
+- The Table must contain a Column named `relation_type`
+
+Example:
+
+```sql
+CREATE TABLE Plant_relation_Cost (
+    source_id TEXT,
+    target_id TEXT,
+    relation_type TEXT,
+    FOREIGN KEY(source_id) REFERENCES Plant(id) ON DELETE CASCADE,
+    FOREIGN KEY(target_id) REFERENCES Costs(id) ON DELETE CASCADE,
+    PRIMARY KEY (source_id, target_id, relation_type)
+);
+```

src/OpenSQL/create.jl

@@ -0,0 +1,68 @@
+function create_parameters!(
+    db::SQLite.DB,
+    table::String,
+    parameters,
+)
+    columns = string.(keys(parameters))
+    sanity_check(db, table, columns)
+
+    cols = join(keys(parameters), ", ")
+    vals = join(values(parameters), "', '")
+    DBInterface.execute(db, "INSERT INTO $table ($cols) VALUES ('$vals')")
+    return nothing
+end
+
+function create_vector!(
+    db::SQLite.DB,
+    table::String,
+    id::String,
+    vector_name::String,
+    values::V,
+) where {V <: AbstractVector}
+    table_name = _vector_table_name(table, vector_name)
+    sanity_check(db, table_name, vector_name)
+    num_values = length(values)
+    ids = fill(id, num_values)
+    idx = collect(1:num_values)
+    tbl = Tables.table([ids idx values]; header = [:id, :idx, vector_name])
+    SQLite.load!(tbl, db, table_name)
+    return nothing
+end
+
+function create_vectors!(db::SQLite.DB, table::String, id::String, vectors)
+    for (vector_name, values) in vectors
+        create_vector!(db, table, id, string(vector_name), values)
+    end
+    return nothing
+end
+
+function create_element!(
+    db::SQLite.DB,
+    table::String;
+    kwargs...,
+)
+    @assert !isempty(kwargs)
+    dict_parameters = Dict()
+    dict_vectors = Dict()
+
+    for (key, value) in kwargs
+        if isa(value, AbstractVector)
+            dict_vectors[key] = value
+        else
+            dict_parameters[key] = value
+        end
+    end
+
+    if !haskey(dict_parameters, :id)
+        error("A new object requires an \"id\".")
+    end
+    id = dict_parameters[:id]
+
+    # TODO a gente deveria ter algum esquema de transactions aqui
+    # se um for bem sucedido e o outro não, deveriamos dar rollback para 
+    # antes de começar a salvar esse cara.
+    create_parameters!(db, table, dict_parameters)
+    create_vectors!(db, table, id, dict_vectors)
+
+    return nothing
+end

src/OpenSQL/delete.jl

@@ -0,0 +1,36 @@
+function delete!(
+    db::SQLite.DB,
+    table::String,
+    id::String,
+)
+    sanity_check(db, table, "id")
+    id_exist_in_table(db, table, id)
+
+    DBInterface.execute(db, "DELETE FROM $table WHERE id = '$id'")
+
+    # TODO We might want to delete corresponding entries in the vector tables too
+    return nothing
+end
+
+function delete_relation!(
+    db::SQLite.DB,
+    table_1::String,
+    table_2::String,
+    table_1_id::String,
+    table_2_id::String,
+)
+    if !are_related(db, table_1, table_2, table_1_id, table_2_id)
+        error(
+            "Element with id $table_1_id from table $table_1 is not related to element with id $table_2_id from table $table_2.",
+        )
+    end
+
+    id_parameter_on_table_1 = lowercase(table_2) * "_id"
+
+    DBInterface.execute(
+        db,
+        "UPDATE $table_1 SET $id_parameter_on_table_1 = '' WHERE id = '$table_1_id'",
+    )
+
+    return nothing
+end

src/OpenSQL/read.jl

@@ -0,0 +1,79 @@
+function read_parameter(
+    db::SQLite.DB,
+    table::String,
+    column::String,
+)
+    if !column_exist_in_table(db, table, column) && is_vector_parameter(db, table, column)
+        error("column $column is a vector parameter, use `read_vector` instead.")
+    end
+
+    sanity_check(db, table, column)
+
+    query = "SELECT $column FROM $table"
+    df = DBInterface.execute(db, query) |> DataFrame
+    # TODO it can have missing values, we should decide what to do with this.
+    results = df[!, 1]
+    return results
+end
+
+function read_parameter(
+    db::SQLite.DB,
+    table::String,
+    column::String,
+    id::String,
+)
+    if !column_exist_in_table(db, table, column) && is_vector_parameter(db, table, column)
+        error("column $column is a vector parameter, use `read_vector` instead.")
+    end
+
+    sanity_check(db, table, column)
+
+    query = "SELECT $column FROM $table WHERE id = '$id'"
+    df = DBInterface.execute(db, query) |> DataFrame
+    # This could be a missing value
+    if isempty(df)
+        error("id \"$id\" does not exist in table \"$table\".")
+    end
+    result = df[!, 1][1]
+    return result
+end
+
+function read_vector(
+    db::SQLite.DB,
+    table::String,
+    vector_name::String,
+)
+    table_name = _vector_table_name(table, vector_name)
+    sanity_check(db, table_name, vector_name)
+    ids_in_table = read_parameter(db, table, "id")
+
+    results = []
+    for id in ids_in_table
+        push!(results, read_vector(db, table, vector_name, id))
+    end
+
+    return results
+end
+
+function read_vector(
+    db::SQLite.DB,
+    table::String,
+    vector_name::String,
+    id::String,
+)
+    table_name = _vector_table_name(table, vector_name)
+    sanity_check(db, table_name, vector_name)
+
+    query = "SELECT $vector_name FROM $table_name WHERE id = '$id' ORDER BY idx"
+    df = DBInterface.execute(db, query) |> DataFrame
+    # This could be a missing value
+    result = df[!, 1]
+    return result
+end
+
+function number_of_rows(db::SQLite.DB, table::String, column::String)
+    sanity_check(db, table, column)
+    query = "SELECT COUNT($column) FROM $table"
+    df = DBInterface.execute(db, query) |> DataFrame
+    return df[!, 1][1]
+end