https://github.com/dfki/atic

A Specialized Quadstore Tailored for Corporate Memories
https://github.com/dfki/atic

Last synced: 11 days ago
JSON representation

A Specialized Quadstore Tailored for Corporate Memories

Host: GitHub
URL: https://github.com/dfki/atic
Owner: DFKI
License: apache-2.0
Created: 2026-05-29T13:22:33.000Z (29 days ago)
Default Branch: main
Last Pushed: 2026-06-11T12:48:51.000Z (16 days ago)
Last Synced: 2026-06-11T14:22:53.912Z (15 days ago)
Language: Java
Size: 3.5 MB
Stars: 0
Watchers: 0
Forks: 0
Open Issues: 0
Metadata Files:
- Readme: README.MD
- License: LICENSE

Awesome Lists containing this project

README

# Towards ATIC: A Specialized Quadstore Tailored for Corporate Memories

🚀 [Overview](#overview) • 📦 [Installation](#installation) • ⚙️ [Usage](#usage) • 🛠️ [Developer Guide](#developer-guide) • 📊 [Evaluation](#evaluation)

**Table of Contents**

- [Overview](#overview)
- [Installation](#installation)
- [Usage](#usage)
- [Developer API (Java / SDK)](#developer-api-java-sdk)
- [Factory](#factory)
- [Using the Dataset](#using-the-dataset)
- [ATIC-Specific Methods](#atic-specific-methods)
- [Invocation Context](#invocation-context)
- [User \& Group Management](#user-group-management)
- [Discretionary Access Control (Sharing)](#discretionary-access-control-sharing)
- [Virtual Graph](#virtual-graph)
- [RDF Patch Apply and Listener](#rdf-patch-apply-and-listener)
- [Data Generation](#data-generation)
- [Query Logger](#query-logger)
- [REST / Server Usage](#rest-server-usage)
- [Configuration](#configuration)
- [Authorization](#authorization)
- [POST `/auth/register`](#post-authregister)
- [POST `/auth/token`](#post-authtoken)
- [GET `/auth/me`](#get-authme)
- [POST `/auth/logout`](#post-authlogout)
- [GET `/config`](#get-config)
- [GET `/config/{name}`](#get-configname)
- [GET `/sparql`](#get-sparql)
- [POST `/sparql`](#post-sparql)
- [POST `/update`](#post-update)
- [GET `/graph`](#get-graph)
- [POST `/graph`](#post-graph)
- [DELETE `/graph/{uri}`](#delete-graphuri)
- [POST `/graph/share`](#post-graphshare)
- [DELETE `/graph/share`](#delete-graphshare)
- [GET `/graph/access`](#get-graphaccess)
- [POST `/resource/share`](#post-resourceshare)
- [DELETE `/resource/share`](#delete-resourceshare)
- [GET `/resource/access`](#get-resourceaccess)
- [POST `/upload`](#post-upload)
- [GET `/principal`](#get-principal)
- [Developer Guide](#developer-guide)
- [atic-api](#atic-api)
- [jenatic](#jenatic)
- [ac](#ac)
- [api](#api)
- [conf](#conf)
- [atic-sqlite](#atic-sqlite)
- [SQL Database Schema](#sql-database-schema)
- [Resource Description Framework (RDF)](#resource-description-framework-rdf)
- [User & Group Management](#user-group-management)
- [Access Control](#access-control)
- [RDF-star](#rdf-star)
- [Java Classes](#java-classes)
- [atic-server](#atic-server)
- [Java Classes](#java-classes)
- [Evaluation](#evaluation)
- [Correctness](#correctness)
- [Performance](#performance)
- [AticTdbComparisonBsbmLoading](#atictdbcomparisonbsbmloading)
- [AticTdbComparisonBsbmQueryMix](#atictdbcomparisonbsbmquerymix)

## Overview

Corporate Memories are computer systems in organizations that continuously collect, update and structure knowledge for various tasks.
The Resource Description Framework (RDF) is commonly used to represent such knowledge, which is stored in quadstores as subject–predicate–object–graph quadruples.
Since typical RDF stores lack crucial features for enterprise scenarios, we propose an initial version of a tailored quadstore as part of a larger system called ATIC.
Our implementation in this demo paper comprises RDF management with an SQLite backend, Discretionary Access Control on graphs and resources, confidence-attributed triples, change tracking with RDF patches and a virtual graph for accessing a file hosting service via RDF.
This is accompanied with a server component providing endpoints and corresponding frontends.
Results of a preliminary evaluation verify the correct operation of our prototype and indicate moderate performance.

Our [demo page](https://www.dfki.uni-kl.de/~mschroeder/demo/atic/) contains a link to a deployed instance for testing and also presents a video showing the main aspects in action.

## Installation

To build and install all projects, run:
```
mvn install
```

If you would like to skip the JUnit test cases, run:
```
mvn install -DskipTests
```

If you would like to get the executable `atic.jar` which contains the server component, run:
```
mvn install -DskipTests -Pdeploy -pl atic-server -am
```
You will find the file under `atic-server/target/atic.jar`.

## Usage

### Developer API (Java / SDK)

Include this project in your pom.xml as a dependency:
```xml

de.dfki.sds
atic-sqlite
1.0.0

```

#### Factory

Use its factory, to create an instance (similar to TDB2):
```java
Dataset dataset = AticFactory.connectDataset("path/to/folder");
```

For testing purposes, you can create a `DatasetGraph` backed by a temporary storage location.
```java
DatasetGraph datasetGraph = AticFactory.createTxn();
```

Use this for accessing the `DatasetGraph` as `admin` user.
```java
DatasetGraph datasetGraph = AticFactory.createTxnAdminDataset();
```

#### Using the Dataset

Use it as a [Jena Dataset](https://jena.apache.org/documentation/javadoc/arq/org.apache.jena.arq/org/apache/jena/query/Dataset.html).

To switch the user who invokes the calls:

```java
User user = server.getDatasetGraph().calculateRead(() -> {
return server.getDatasetGraph().getUser(username, InvocationContext.EMPTY);
});
InvocationContext ictx = new InvocationContext.Builder().fromUser(user).build();
ictx.transferContext(dataset.getContext());
```

#### ATIC-Specific Methods

Cast to our specific implementation to access the methods.

```java
DatasetGraph datasetGraph;
SqliteAticDatasetGraph aticDatasetGraph = (SqliteAticDatasetGraph) datasetGraph;
```

##### Invocation Context

Each method is extended with an `InvocationContext` which mainly states what user is requesting the operation.
You can build an `InvocationContext` from a `User` in the following way:
```java
User user = server.getDatasetGraph().calculateRead(() -> {
return server.getDatasetGraph().getUser(username, InvocationContext.EMPTY);
});
InvocationContext ictx = new InvocationContext.Builder().fromUser(user).build();
```

Users with different permissions may receive different results for the same operations and arguments.
```java
InvocationContext user1ctx;
InvocationContext user2ctx;

datasetGraph.find(Node.ANY, Node.ANY, Node.ANY, Node.ANY, user1ctx);
datasetGraph.find(Node.ANY, Node.ANY, Node.ANY, Node.ANY, user2ctx);
```

To pass no `InvocationContext` use `InvocationContext.EMPTY` constant.

##### User \& Group Management

* `String addUser(String firstname, String lastname, String email, String username, InvocationContext ctx)`
* `void addGroup(String groupname, InvocationContext ctx)`
* `User getUser(String username, InvocationContext ctx)`
* `User getUser(int userId, InvocationContext ctx)`
* `Group getGroup(String groupname, InvocationContext ctx)`
* `void assignUserToGroup(String username, String groupname, InvocationContext ctx)`
* `void unassignUserFromGroup(String username, String groupname, InvocationContext ctx)`
* `List searchUsers(String query, InvocationContext ctx)`
* `List searchGroups(String query, InvocationContext ctx)`
* `List searchPrincipals(String query, InvocationContext ctx)`

##### Discretionary Access Control (Sharing)

* `void shareGraphs(Set graphUris, Set groupUris, Permission permission, InvocationContext ctx)`
* `void unshareGraphs(Set graphUris, Set groupUris, InvocationContext ctx)`
* `void shareResources(Set resourceUris, Set groupUris, Permission permission, InvocationContext ctx)`
* `void unshareResources(Set resourceUris, Set groupUris, InvocationContext ctx)`
* `Map listResourcePermissions(Set resourceUris, InvocationContext ctx)`
* `Map listGraphPermissions(Set graphUris, InvocationContext ctx)`
* `Map> listPrincipalPermissions( Set uris, boolean forGraphs, InvocationContext ctx)`

##### Virtual Graph

* `void addVirtualGraph(Node graphName, String factoryMethodPath, JSONObject config, InvocationContext ctx)`

##### RDF Patch Apply and Listener

* `void apply(RDFPatch rdfPatch, InvocationContext ctx)`
* `void addListener(RDFPatchListener listener)`
* `void removeListener(RDFPatchListener listener)`

##### Data Generation

* `void generateLUBMftGraph(Node graphName, int univNum, int startIndex, int seed, boolean names, boolean docs, int bufferSize, int batchSize, InvocationContext ctx)`

##### Query Logger

* `void enableQueryLogger(String dbFilePath)`
* `void disableQueryLogger()`

### REST / Server Usage

Use the `atic.jar` built by the `atic-server` project (see [Installation](#installation)).

```bash
export JWT_SECRET="my-secret"
java -jar atic.jar
```

By default, the server runs at `http://127.0.0.1:6583`.

#### Configuration

Use `--help` for possible CLI arguments.

```
java -jar atic.jar --help
```

You can also specify the options in a `atic.toml` file located in the working directory.

It is also possible to specify the options as environment variables.
In this case, an option, for example, `instance.name` has to be defined as `ATIC_INSTANCE_NAME`.

#### Authorization

All endpoints except `/auth/register` and `/auth/token` require a bearer token:

```bash
-H "Authorization: Bearer "
```

#### POST `/auth/register`

Creates a new user account.

```bash
curl -X POST http://127.0.0.1:6583/auth/register \
-d "firstname=John" \
-d "lastname=Doe" \
-d "email=john@example.org" \
-d "username=jdoe"
```

A generated password is returned.
Passwords are stored for lookup in a `passwords.json.generated` file.

#### POST `/auth/token`

Authenticates a user and returns a JWT access token.

```bash
curl -X POST http://127.0.0.1:6583/auth/token \
-d "username=jdoe" \
-d "password=secret"
```

On success, the server returns a JSON response containing the access token (and a corresponding cookie):

```json
{
"access_token": "",
"successful": true,
"redirect": "/"
}
```

#### GET `/auth/me`

Returns information about the currently authenticated user.

```bash
curl \
-H "Authorization: Bearer " \
http://127.0.0.1:6583/auth/me
```

#### POST `/auth/logout`

Logs out the current user.

```bash
curl -X POST \
-H "Authorization: Bearer " \
http://127.0.0.1:6583/auth/logout
```

#### GET `/config`

Returns all visible configuration entries.

```bash
curl \
-H "Authorization: Bearer " \
http://127.0.0.1:6583/config
```

#### GET `/config/{name}`

Returns a single configuration value.

```bash
curl \
-H "Authorization: Bearer " \
http://127.0.0.1:6583/config/port
```

#### GET `/sparql`

Executes a SPARQL query.

```bash
curl --get \
-H "Authorization: Bearer " \
http://127.0.0.1:6583/sparql \
--data-urlencode "query=SELECT * WHERE { ?s ?p ?o } LIMIT 10"
```

#### POST `/sparql`

Executes a SPARQL query.

```bash
curl -X POST \
-H "Authorization: Bearer " \
http://127.0.0.1:6583/sparql \
--data 'SELECT * WHERE { ?s ?p ?o } LIMIT 10'
```

#### POST `/update`

Executes a SPARQL Update request.

```bash
curl -X POST \
-H "Authorization: Bearer " \
http://127.0.0.1:6583/update \
--data 'INSERT DATA { GRAPH { } }'
```

![](evaluation/AticTdbComparisonBsbmQueryMix.png)

ecosyste.ms

Data

Tools

Indexes

Applications

Experiments

Awesome

https://github.com/dfki/atic

Awesome Lists containing this project

README