Managing Databases

1. Navigate to the “Databases” tab
2. Click on the “Create Database” button
3. Enter a name for the new database
4. Click the “Create” button

See the HTTP API documentation for more information.

curl -u username:password -X POST \
-F root="{\
"dbname":"myDatabase"\
}" http://localhost:5820/admin/databases

import com.complexible.stardog.api.admin.AdminConnection;

import static com.complexible.stardog.api.admin.AdminConnectionConfiguration.toServer;

public class CreateDatabaseBasic {

    public static void main(String[] args){

        String serverUrl = "http://localhost:5820";
        String username = "username";
        String password = "password";

        try(AdminConnection adminConnection = toServer(serverUrl).credentials(username, password).connect();){
            adminConnection.newDatabase("myDatabase").create();
        }
    }
}

See com.complexible.stardog.api.admin.AdminConnection.AdminConnection#newDatabase for more information.

1. Navigate to the “Databases” tab
2. Click on the “Create Database” button
3. Enter a name for the new database

4. Select the “Manually Set Immutable Properties” radio button and select which properties to set

   The only way to set mutable and database options at database creation time in Studio is by providing a Java properties file containing configuration options.

5. Click the “Create” button

See the HTTP API documentation for more information.

curl -u username:password -X POST \
-F root="{\
"dbname":"myDatabase",\
"options":{"search.enabled":true, "edge.properties":true}\
}" http://localhost:5820/admin/databases

import com.complexible.stardog.api.admin.AdminConnection;
import com.complexible.stardog.db.DatabaseOptions;
import com.complexible.stardog.metadata.Metadata;
import com.complexible.stardog.search.SearchOptions;

import static com.complexible.stardog.api.admin.AdminConnectionConfiguration.toServer;

public class CreateDatabaseWithConfigOptions {

    public static void main(String[] args){

        String serverUrl = "http://localhost:5820";
        String username = "username";
        String password = "password";

        Metadata metadata = Metadata.create()
                                    .set(SearchOptions.SEARCHABLE, true)
                                    .set(DatabaseOptions.EDGE_PROPERTIES, true);

        try(AdminConnection adminConnection = toServer(serverUrl).credentials(username, password).connect();){
            adminConnection.newDatabase("myDatabase").setAll(metadata).create();
        }
    }
}

1. Navigate to the “Databases” section
2. Click on the “Create Database” button
3. Enter a name for the database if database.name is not defined in the properties file being used to configure the database
4. Select the “Use File” radio button
5. Select the properties file on your filesystem.
6. Click the “Create” button

Create a geospatial enabled database, and bulk load labels_en.nq.bz2 to the named graph some:graph and geo_coordinates_en.nq.bz2 to the default graph. Both of these files exist on the client machine and will be shipped to the server.

curl -u username:password -X POST \
-F root="{\
"dbname":"spatialDB",\
"options":{"spatial.enabled":true},\
"files":[{"filename":"labels_en.nq.bz2", "context":"some:graph"},{"filename":"geo_coordinates_en.nq.bz2"}]\
}"\
-F "geo_coordinates_en.nq.bz2"=@/path/to/geo_coordinates_en.nq.bz2 \
-F "labels_en.nq.bz2"=@/path/to/labels_en.nq.bz2 \
http://remote-server:5820/admin/databases

Create a search enabled database, and bulk load /path/to/data1.ttl to the named graph some:graph and /path/to/data2.ttl to the default graph. Both of these files exist on the same machine Stardog is running on.

curl -u admin:admin -X POST \
-F root="{\
"dbname":"myDatabase",\
"options":{"search.enabled":true},\
"files":[{"filename":'/path/to/data1.ttl',"context":'some:graph'}, {"filename":'/path/to/data2.ttl'}]}" \
http://localhost:5820/admin/databases

See the HTTP API for more information.

import com.complexible.stardog.api.admin.AdminConnection;
import com.google.common.collect.ImmutableMap;
import com.stardog.stark.Resource;
import com.stardog.stark.Values;

import java.nio.file.Path;
import java.nio.file.Paths;

import static com.complexible.stardog.api.admin.AdminConnectionConfiguration.toServer;

public class CreateDatabaseBulkLoad {
    
    public static void main(String[] args){

        String serverUrl = "http://localhost:5820";
        String username = "username";
        String password = "password";

        try(AdminConnection adminConnection = toServer(serverUrl).credentials(username, password).connect();){

            Resource g1 = Values.iri("urn:g1");
            Resource g2 = Values.iri("urn:g2");
            Path f1 = Paths.get("/path/to/data1.ttl");
            Path f2 = Paths.get("/path/to/data2.ttl");
            Path f3 = Paths.get("/path/to/data3.ttl");

            ImmutableMap<Path, Resource> contexts = ImmutableMap.of(f1, g1, f2, g2);

            // f1 is loaded into g1
            // f2 is loaded into g2
            // f3 is loaded into the default graph
            adminConnection.newDatabase("myDatabase").create(contexts::get, f1, f2, f3);
        }
    }
}

See com.complexible.stardog.api.admin.DatabaseBuilder#create for more information.

If the files to be bulk loaded do not exist on the same machine as Stardog, use com.complexible.stardog.api.admin.DatabaseBuilder#copyServerSide to specify that the files should be first copied to the server.

1. Navigate to the “Databases” section. The list of all databases the user has access to will appear in the left pane.

curl -u username:password http://localhost:5820/admin/databases

See the HTTP API for more information

import com.complexible.stardog.api.admin.AdminConnection;

import static com.complexible.stardog.api.admin.AdminConnectionConfiguration.toServer;

public class ListDatabases {

    public static void main(String[] args) {

        String serverUrl = "http://localhost:5820";
        String username = "admin";
        String password = "admin";

        try (AdminConnection adminConnection = toServer(serverUrl).credentials(username, password).connect();) {
            System.out.println(adminConnection.list());
        }
    }
}

See com.complexible.stardog.api.admin.AdminConnection#list for more information.

1. Navigate to the “Databases” section
   • Not all information obtainable via the db status CLI command is available in Studio. The listing of databases in the left pane shows the approximate amount of triples in each database. If you click on a specific database in the listing and into the “Admin” tab, the number of running queries and the database’s status (offline/online) will be displayed.

1. Navigate to the “Databases” section.
2. Select the database you wish to offline
3. Toggle the switch from the online position to the offline position. The green dot that was previously displayed to the right of the database name should now be orange.

curl -u username:password -X PUT \
http://localhost:5820/admin/databases/myDatabase/offline

See the HTTP API for more information.

import com.complexible.stardog.api.admin.AdminConnection;

import static com.complexible.stardog.api.admin.AdminConnectionConfiguration.toServer;

public class OfflineDatabase {

    public static void main(String[] args) {

        String serverUrl = "http://localhost:5820";
        String username = "username";
        String password = "password";

        try (AdminConnection adminConnection = toServer(serverUrl).credentials(username, password).connect();) {
            adminConnection.offline("myDatabase");
        }
    }
}

See com.complexible.stardog.api.admin.AdminConnection#offline for more information.

1. Navigate to the “Databases” section.
2. Select the database you wish to online
3. Toggle the switch from the offline position to the online position. The orange dot that was previously displayed to the right of the database name should now be green.

curl -u username:password -X PUT \
http://localhost:5820/admin/databases/myDatabase/online

See the HTTP API for more information.

import com.complexible.stardog.api.admin.AdminConnection;

import static com.complexible.stardog.api.admin.AdminConnectionConfiguration.toServer;

public class OnlineDatabase {

    public static void main(String[] args) {

        String serverUrl = "http://localhost:5820";
        String username = "username";
        String password = "password";

        try (AdminConnection adminConnection = toServer(serverUrl).credentials(username, password).connect();) {
            adminConnection.online("myDatabase");
        }
    }
}

See com.complexible.stardog.api.admin.AdminConnection#online for more information.

1. Navigate to the “Databases” section.
2. Select the database you wish to see all namespace prefix bindings for
3. Select the “Namespaces” tab
   • From this view, you can edit, add, or remove any prefix binding. Be sure to click the “Save” button in the top right corner after making any changes you wish to persist.
   • There are two buttons to import new prefix bindings and export the existing ones.

To retrieve the namespaces stored in the database

curl -u username:password http://localhost:5820/movies/namespaces

See the HTTP API for more information

To import namespaces stored in an RDF file:

curl -u username:password -X POST \
-F name=@path/to/prefixes.ttl \
http://localhost:5820/movies/namespaces

See the HTTP API for more information.

import com.complexible.stardog.api.Connection;
import com.complexible.stardog.api.ConnectionConfiguration;
import com.stardog.stark.Namespace;
import com.stardog.stark.io.turtle.TurtleUtil;

import java.io.PrintStream;
import java.util.Optional;

public class ManagingNamespaces {

    public static void main(String[] args) {

        String serverUrl = "http://localhost:5820";
        String username = "username";
        String password = "password";

        try (Connection connection = ConnectionConfiguration.to("movies").server(serverUrl).credentials(username, password).connect()){

            // Add a namespace
            connection.namespaces().add("somePrefix", "http://some.iri");

            // Given an IRI, get the corresponding prefix
            Optional<String> thePrefix = connection.namespaces().prefix("http://some.iri");
            System.out.println(thePrefix.get());

            // Given a prefix, get the corresponding IRI
            Optional<String> theIRI = connection.namespaces().iri("somePrefix");
            System.out.println(theIRI.get());

            // Remove a namespace
            connection.namespaces().remove("somePrefix");

            // List/export namespaces in Turtle
            try(PrintStream out = System.out){
                for(Namespace ns : connection.namespaces()){
                    out.print(ns.prefix());
                    out.print(": <");
                    out.print(TurtleUtil.encodeURIString(ns.iri()));
                    out.print("> .");
                    out.println();
                }
            }
        }
    }
}

See com.complexible.stardog.api.Connection#namespaces for more information.

1. Navigate to the “Databases” section
2. Select the database to be dropped
3. Click on “Drop Database”. Confirm you do indeed want to drop this database.

curl -u username:password -X DELETE \
http://localhost:5820/admin/databases/myDatabase

See the HTTP API for more information.

import com.complexible.stardog.api.admin.AdminConnection;

import static com.complexible.stardog.api.admin.AdminConnectionConfiguration.toServer;

public class DropDatabase {

    public static void main(String[] args) {

        String serverUrl = "http://localhost:5820";
        String username = "username";
        String password = "password";
        String db = "myDatabase";

        try (AdminConnection adminConnection = toServer(serverUrl).credentials(username, password).connect();) {
            if(adminConnection.list().contains(db)){
                adminConnection.drop(db);
            }
        }
    }
}

See com.complexible.stardog.api.admin.AdminConnection#drop for more information.