archidata/doc/SQL_wrapper.md

Wrapping over the DB

In the current version we consider 2 DB access: MySQL and SQLite, We commonly use the SQLite in test mode to permit to test is a real case.

Generic Access:

Some generic function are available to permit you to simply request the DB

Create a new Value:

MyDataModel dataToInsert = ...;
MyDataModel dataCreated = DataAccess.insert(dataToInsert);

Get a full table:

List<MyDataModel> data = DataAccess.gets(MyDataModel.class);

Get a single element in the DB:

UUID id = ...;
MyDataModel data = DataAccess.get(MyDataModel.class, id);

Note: The Id type fully managed are UUID and Long

Removing the Data:

UUID id = ...;
DataAccess.delete(MyDataModel.class, id);

Note: Removing the data automatically detect if it is a software remove or definitive remove

Updating the Data:

The update of the data can be managed by 2 way:

• Direct update of the Object with direct injection (Good for PUT)
• Update with input json (Good for PATCH)

The second way is preferable for some reasons

• When jakarta transform the data in you object, we can not detect the element set at null or not set (We consider user of Optional il all data class will create a too bug amount of unneeded code in all dev parts)
• Throw in the jakarta parsing are not well catch when we will generate generic error
• The Check will permit to explain what is wrong better than a generic Json parser.

Updating with JSON:

UUID id = ...;
String jsonRequest = "{...}";
DataAccess.updateWithJson(MyDataModel.class, id, jsonRequest);

Updating with direct data:

UUID id = ...;
MyDataModel dataToUpdate = ...;
// This update all fields:
DataAccess.update(dataToUpdate, id);
// Select the field to update:
DataAccess.update(dataToUpdate, id, List.of("field1","field2"));

Generic option of the request:

Many API have a generic multiple option available like:

public static <T> List<T> getsWhere(final Class<T> clazz, final QueryOption... option) throws Exception

You just need to add your options in the list of option.

Filter the list of field read:

public FilterValue(final String... filterValue)
public FilterValue(final List<String> filterValues)
// example:
new newFilterValue("field1", "field2");

Add a condition more detail

public Condition(final QueryItem items)

Order the request:

public OrderBy(final OrderItem... childs);
// example:
new OrderBy(new OrderItem("name", Order.DESC));

Limit the :

public Limit(final long limit)
// example:
new Limit(50);

Read all column like update date and create date or delete field

public ReadAllColumn()

Condition models:

Creating a condition independent of the DB model use need to have a little abstraction of the query model:

For this we propose some condition that update with the internal "auto" condition that is added (like the soft delete...)

default generic comparator

This is the base of the comparison tool. It compare a column with a value

public QueryCondition(final String key, final String comparator, final Object value);

Simple DB comparison element. Note the injected object is injected in the statement and not in the query directly.

Example:

String nameToCheck = "plop";
new QueryCondition("fieldName", "=", nameToCheck);
// OR:
UUID uuid = ...;
new QueryCondition("uuid", "=", uuid);

List comparator

It permit to check a column is (NOT) in a list of value

public QueryInList(final String key, final List<T> value)
public QueryInList(final String key, final T... value)

and his opposite:

public QueryNotInList(final String key, final List<T> value)
public QueryNotInList(final String key, final T... value)

example

new QueryInList("uuid", List.of(uuid1, uuid2));

NULL and NOT NULL checker

This permit to check an element is NULL or not NULL

public QueryNull(final String key);
public QueryNotNull(final String key);

The group condition:

The generic OR group:

public QueryOr(final List<QueryItem> child);
public QueryOr(final QueryItem... child);

Or the generic `AND group:

public QueryAnd(final List<QueryItem> child);
public QueryAnd(final QueryItem... child);

Full example:

List<MyDataModel> result = DataAccess.getsWhere(MyDataModel.class, 
        new Limit(50),
        new OrderBy(new OrderItem("name", Order.DESC)),
        new Condition(
            new QueryAnd(
                QueryNull("Field3")
                new QueryOr(
                    new QueryInList("Field4", 5, 55, 65, 62, 27, 84),
                    new QueryCondition("cityID", ">", 78000);
                )
            )
        )
    );