## Download

You can download the latest version of Strabon from our Mercurial repository.

Strabon is also part of the KR-Suite. The KR-Suite contains the open source tools GeoTriples, Strabon and Sextant under a single docker and offers functionality to transform, store/query and visualize Linked Data. You can download and install the KR-Suite here.

## Getting Started

Here you will find a selection of guides to assist you in the installation and use of Strabon:

- stRDF and stSPARQL tutorial
- stSPARQL reference
- xsd:int
**strdf:dimension(strdf:geometry A):**Returns the inherent dimension of geometry A, which must be less than or equal to the coordinate dimension. - xsd:string
**strdf:geometryType(strdf:geometry A):**Returns the type of geometry A as a string. - xsd:int
**strdf:srid(strdf:geometry A):**Returns the unique identifier of the coordinate reference system that is used when ecoding the coordinates of geometry A. - strdf:WKT
**strdf:asText(strdf:geometry A):**Returns the Well-Known Text (WKT) serialization of geometry A. - strdf:GML
**strdf:asGML(strdf:geometry A):**Returns the Geography Markup Language (GML) serialization of geometry A. - xsd:int
**strdf:isEmpty(strdf:geometry A):**Returns true if geometry A is an empty geometry. If true, then this geometry represents an empty geometry collection, polygon, point etc. - xsd:string
**strdf:isSimple(strdf:geometry A):**Returns true if geometry A has no anomalous geometric points, such as selfintersection or selftangency. - xsd:boolean
**strdf:equals(strdf:geometry A, strdf:geometry B):**Returns true if the given geometries are identical. - xsd:boolean
**strdf:disjoint(strdf:geometry A, strdf:geometry B):**Returns true if the the given geometries are disjoint, meaning that they do not share any space together. - xsd:boolean
**strdf:intersects(strdf:geometry A, strdf:geometry B):**Returns true if the given geometries "spatially intersect", meaning that they share some portion of space. - xsd:boolean
**strdf:touches(strdf:geometry A, strdf:geometry B):**Returns true if the given geometries have at least one boundary point in common, but their interiors do not intersect. - xsd:boolean
**strdf:crosses(strdf:geometry A, strdf:geometry B):**Takes two geometries and return true if they "spatially cross", that is, the geometries have some, but not all interior points in common. In addition, the intersection of the interiors of the geometries must not be the empty set and must have a dimensionality less than the the maximum dimension of the two input geometries. Finally, the intersection of the two geometries must not equal either of the source geometries. Otherwise, it returns false. - xsd:boolean
**strdf:within(strdf:geometry A, strdf:geometry B):**Returns true if geometry A is completely inside geometry B. If strdf:within(A, B) is true and strdf:within(B,A) is true, then the two geometries are considered spatially equal. - xsd:boolean
**strdf:contains(strdf:geometry A, strdf:geometry B):**Returns true if and only if no points of B lie in the exterior of A, and at least one point of the interior of B lies in the interior of A. - xsd:boolean
**strdf:overlaps(strdf:geometry A, strdf:geometry B):**Returns true if the geometries share space, are of the same dimension, but are not completely contained by each other. - xsd:boolean
**strdf:relate(strdf:geometry A, strdf:geometry B, xsd:string intersectionPatternMatrix):**Returns true if geometry A is spatially related to geometry B, by testing for intersections between the interior, boundary and exterior of the two geometries as specified by the values in the intersectionPatternMatrix. - xsd:boolean
**strdf:mbbIntersects(strdf:geometry A, strdf:geometry B):**Returns true if the minimum bounding box of geometry A intersects the minimum bounding box of geometry B. - xsd:boolean
**strdf:mbbEquals(strdf:geometry A, strdf:geometry B):**Returns true if the minimum bounding box of geometry A is equal to the minimum bounding box of geometry B. - xsd:boolean
**strdf:mbbWithin(strdf:geometry A, strdf:geometry B):**Returns true if the minimum bounding box of geometry A is within the minimum bounding box of geometry B - xsd:boolean
**strdf:mbbContains(strdf:geometry A, strdf:geometry B):**Returns true if the minimum bounding box of geometry A contains the minimum bounding box of geometry B - xsd:boolean
Returns true if the minumum bounding box of geometry A is strictly on the left of the minimum bounding box of geometry B. - xsd:boolean
**strdf:right(strdf:geometry A, strdf:geometry B):**Returns true if the minumum bounding box of geometry A is strictly on the right of the minimum bounding box of geometry B. - xsd:boolean
**strdf:above(strdf:geometry A, strdf:geometry B):**Returns true if the minumum bounding box of geometry A is strictly above the minimum bounding box of geometry B. - xsd:boolean
**strdf:below(strdf:geometry A, strdf:geometry B):**Returns true if the minumum bounding box of geometry A is strictly below the minimum bounding box of geometry B. - strdf:geometry
**strdf:buffer(strdf:geometry A, xsd:double distance, xsd:anyURI units):**Returns a geometry that represents all points whose distance from this geometry is less than or equal to distance. The supported measurement units are metres (<http://www.opengis.net/def/uom/OGC/1.0/metre>) and degrees (<http://www.opengis.net/def/uom/OGC/1.0/degree>) - strdf:geometry
**strdf:boundary(strdf:geometry A):**Returns the closure of the combinatorial boundary of this Geometry. - strdf:geometry
**strdf:envelope(strdf:geometry A):**Returns the minimum bounding box for the supplied geometry, as a geometry. The polygon is defined by the corner points of the bounding box ((MINX, MINY), (MINX, MAXY), (MAXX, MAXY), (MAXX, MINY), (MINX, MINY)). - strdf:geometry
**strdf:convexHull(strdf:geometry A):**The convex hull of a geometry represents the minimum convex geometry that encloses all geometries within the set. - strdf:geometry
**strdf:intersection (strdf:geometry A, strdf:geometry B):**Returns a geometry that represents the point set intersection of the geometries. - strdf:geometry
**strdf:union(strdf:geometry A, strdf:geometry B):**Returns a geometry that represents the point set union of the geometries. - strdf:geometry
**strdf:difference(strdf:geometry A, strdf:geometry B):**Returns a geometry that represents that part of geometry A that does not intersect with geometry B. - strdf:geometry
**strdf:symDifference (strdf:geometry A, strdf:geometry B):**Returns a geometry that represents the portions of A and B that do not intersect. One can think of this as Union(A,B) - Intersection(A,B). - xsd:float
**strdf:distance(strdf:geometry A, strdf:geometry B, xsd:anyURI units):**Returns the 2-dimensional cartesian minimum distance (based on spatial ref) between two geometries in projected units. The supported measurement units are metres (<http://www.opengis.net/def/uom/OGC/1.0/metre>) and degrees (<http://www.opengis.net/def/uom/OGC/1.0/degree>). - xsd:float
**strdf:area(strdf:geometry A):**Returns the area of the surface if it is a polygon or multi-polygon. - strdf:geometry
**strdf:union(set of strdf:geometry A):**Returns the union of a set of geometries. - strdf:geometry
**strdf:intersection(set of strdf:geometry A) :**Returns the intersection of a set of geometries. - strdf:geometry
**strdf:extent(set of strdf:geometry A):**Returns the bounding box that bounds a set of geometries. - xsd:boolean
**strdf:after**(strdf:period i1, strdf:period i2): returns true if i1 happens after i2. - xsd:boolean
**strdf:before**(strdf:period i1, strdf:period i2): returns true if i1 happens before i2. - xsd:boolean
**strdf:**(strdf:period i1, strdf:period i2): returns true if i1 overlaps with period i2.**PeriodO**verlaps - xsd:boolean
**strdf:starts**(strdf:period i1, strdf:period i2): returns true if i1 starts at the same time as period i2. - xsd:boolean
**strdf:during**(strdf:period i1, strdf:period i2): returns true if i1 is contained by with period i2. - xsd:boolean
**strdf:finishes**(strdf:period i1, strdf:period i2): returns true if i1 finishes at the same time as period i2. - xsd:boolean
**strdf:PeriodContains**(strdf:period i1, strdf:period i2): returns true if i1 contains period i2. - xsd:boolen strdf:
(strdf:period i1, xsd:dateTime i2)}: returns true if period i1 contains instant i2**PeriodC**ontains - xsd:boolean
**strdf:meets**(strdf:period i1, strdf:period i2): returns true if i1 meets period i2. - xsd:boolean
**strdf:isMetBy**(strdf:period i1, strdf:period i2): returns true if i2 meets period i1. - xsd:boolean
**strdf:equalsPeriod**(strdf:period i1, strdf:period i2): returns true if i1 is cotemporal with period i2. - xsd:boolen
**strdf:overright**(strdf:period i1, strdf:period i2): returns true if all values of i1 are greater than or equal to the start of period i2. - xsd:boolen
**strdf:overleft**(strdf:period i1, strdf:period i2): returns true if all values of i1 are greater than or equal to the end of period i2. - xsd:boolen
**strdf:nequalsPeriod**(strdf:period i1, strdf:period i2): returns true if i1 is not contemporal with period i2. - xsd:boolean
**strdf:meetsBefore**(strdf:period i1, strdf:period i2): returns true if i1 meets period i2 and i1 started before i2. - xsd:boolean
**strdf:meetsAfter**(strdf:period i1, strdf:period i2): returns true if i1 meets period i2 and i1 started after i2. - strdf:validTime
**strdf:period_intersect**(strdf:period p1, strdf:period p2):This function returns the temporal intersection of period p1 with period p2. A literal of strdf:period or xsd:dateTime will be returned. - strdf:period
**strdf:period_union**(strdf:period p1, strdf:period p2):This function returns the temporal union of period p1 with period p2. - strdf:period
**strdf:minus**(strdf:period p1, strdf:period p2):This function returns the temporal difference of period p1 temporally minus period p2. - strdf:period
**strdf:period_preceding**(strdf:period p1, strdf:period p2): This function returns the part of period p1 that preceeds period p2. - strdf:period
**strdf:period_succeding**(strdf:period p1, strdf:period p2): This function returns the part of period p1 that succeeds period p2. - strdf:period
**strdf:period**(xsd:dateTime i1, xsd:dateTime i2): This function constructs a period starting from instant i1 and ending to instant i2 . - xsd:dateTime
**strdf:period_start**(strdf:period p): This function returns the starting point of period p. - xsd:dateTime
**strdf:period_end**(strdf:period p): This function returns the ending point of period p. - strdf:period
**strdf:intersectAll**(set of strdf:period P): Computes the intersection of all periods present each group of the result set. - strdf:period
**strdf:maxDuration**(set of strdf:period P): Computes the maximum duration of the periods in each group. strdf:period - strdf:period
**strdf:maximalPeriod**(set of strdf:period P): Computes the maximal interval given the periods of each group. - User Guide: Installation Instructions for Linux
- User Guide: Installation Instructions for Windows
- User Guide: Install Strabon Endpoint
- User Guide: Store/Query Instructions
- The name of the spatially-enabled database that was created previously
- The username used to connect to the database
- The password used to connect to the database
- The port where the PostgreSQL connection listens to (usually 5432)
- The name of the database host (e.g., localhost)
- Go to tab
*Explore/Modify Operations-->Store* - Specify the RDF format of the dataset
- Insert directly the stRDF dataset in the text area
*Direct Input*or specify the url or the local path of the dataset in the 'URI input' (e.g., file:///home/user/example.nt) - Developer Guide
- Install PostgreSQL from http://www.postgresql.org/download/. At the time of this writing the latest PostgreSQL version is 9.1.
- Install PostGIS from http://postgis.refractions.net/download/. At the time of this writing we have tested Strabon with PostGIS 1.5.3.
- Install Maven from http://maven.apache.org/download.html. At the time of this writing the latest Maven version is 3.0.4.
- Install Eclipse from http://www.eclipse.org/downloads/. At the time of this writing the latest Eclipse version is 3.7.2.
- Install the m2e plugin for Eclipse from http://www.eclipse.org/m2e/.
- From Eclipse, go to File --> Import --> Mercurial --> Clone Existing Mercurial Repository --> Next. In the URL textarea paste the following url: http://hg.strabon.di.uoa.gr/Strabon and then press Next --> Next --> Finish. If you used the default settings, you should have a new project named StrabonMain. Right click on the project and select Configure --> Convert to Maven project. Eclipse will enable Maven dependency management for the project, download any dependencies and build the project.

### stSPARQL Reference

On this page you can find the definitions of the **spatial** and **temporal** extension functions that we have defined in **stSPARQL**.

The following prefixes are used in this document:

PREFIX strdf: <http://strdf.di.uoa.gr/ontology#>PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> |

### Spatial Extension Functions

#### Basic Functions

The following functions enable the retrieval of a property of a geometry:

The following functions enable the retrieval of the desired representation of a geometry:

The following functions enable us to test whether a certain condition holds:

#### Topological Relationships

The following functions enable us to test whether a topological relation holds among two geometries:

#### Topological Relationships (based on minimum bounding boxes)

The following functions can be used to test whether the bounding boxes of two geometries satisfy a topological relationship:

#### Directional Relationships (based on minimum bounding boxes)

The following functions can be used to test whether two geometries satisfy a directional relationship. The directional relationships covered are defined using the minimun bounding box of the geometries.

#### Spatial Analysis Functions

The following functions can be used to construct new geometric objects from existing geometric objects:

The folllowing are spatial metric functions:

The folllowing are spatial aggregate functions:

### Temporal Extension Functions

The following functions can be used with values of datatype strdf:period that is used to model the valid time of a triple. The first set of such functions available are the following ones that allow us to test if a qualitative temporal relation holds among two given periods. The set of these functions is a superset of Allen's interval algebra.

The following functions are also defined:

Apart from the functions that express temporal relations between periods, stSPARQL also supports a set of functions on periods that construct a new temporal element (period or instant) from existing ones. These functions are the following:

Moreover, stSPARQL defines the following temporal aggregate functions:

### Installation and Execution

Here we provide Strabon installation guidelines, using either MonetDB or PostGIS backend, and present how we can store and query stRDF datasets using Strabon.

For the convenience of the reader, we give specific instructions for executing each step in a computer running Ubuntu 11.10 64-bit.

### Prerequisites

Before downloading and compiling Strabon, the following steps should be executed:

1. Install maven. More information can be found at http://maven.apache.org/

$> sudo apt-get install maven2

2. Install java 6. More information can be found at http://www.oracle.com/technetwork/java/javase/downloads/index.html

$> sudo apt-get install openjdk-6-jdk openjdk-6-jre

3. Install Mercurial. More information can be found at https://www.mercurial-scm.org/

$> sudo apt-get install mercurial

### Installing PostgreSQL and PostGIS

1. Install PostgreSQL 9.0 or higher. More information can be found at http://www.postgresql.org/download/

`$> sudo apt-get install postgresql-9.1`

2. Install PostGIS 1.5 or higher. More information can be found at http://postgis.refractions.net/download/

$> sudo apt-get install postgresql-9.1-postgis

3. Provide a password for default user (postgres)

$> sudo -u postgres psql -c "ALTER USER postgres WITH PASSWORD 'postgres';"

### Creating a spatially enabled database

Spatially-enabled databases permit the use of spatial function calls. MonetDB creates spatially-enabled databases by default if you have enabled the geom module. More information on how to create a spatially-enabled database in PostGIS can be found at http://postgis.refractions.net/docs/.

1. Set postgis-1.5 path.

$> POSTGIS_SQL_PATH=`pg_config --sharedir`/contrib/postgis-1.5

2. Create the spatial database that will be used as a template.

$> createdb -E UTF8 -T template0 template_postgis

3. Add PLPGSQL language support.

$> createlang -d template_postgis plpgsql

### Load the PostGIS SQL routines

$> psql -d template_postgis -f $POSTGIS_SQL_PATH/postgis.sql$> psql -d template_postgis -f $POSTGIS_SQL_PATH/spatial_ref_sys.sql

### Allow users to alter spatial tables

$> psql -d template_postgis -c "GRANT ALL ON geometry_columns TO PUBLIC;"$> psql -d template_postgis -c "GRANT ALL ON geography_columns TO PUBLIC;"$> psql -d template_postgis -c "GRANT ALL ON spatial_ref_sys TO PUBLIC;"

### Perform garbage collection

$> psql -d template_postgis -c "VACUUM FULL;"$> psql -d template_postgis -c "VACUUM FREEZE;"

### Allows non-superusers the ability to create from this template

$> psql -d postgres -c "UPDATE pg_database SET datistemplate='true' WHERE datname='template_postgis';"$> psql -d postgres -c "UPDATE pg_database SET datallowconn='false' WHERE datname='template_postgis';"

### Create a spatially-enabled database named endpoint

$> createdb endpoint -T template_postgis

### Creating a temporally enabled database

**(ATTENTION: This step is optional; It should be performed only if you want to use the temporal features of Strabon, in addition to the spatial features)**

Similarly to the case of the spatially enabled database, temporally-enabled databases permit the use of spatial function calls:

1. Download and install the PostgreSQL Temporal extension of PostgreSQL as described here: http://github.com/jeff-davis/PostgreSQL-Temporal

2. Create a temporal extension to the existing, spatially-enabled database that you created earlier. For example, if you're running PostgreSQL 9.1.0 or greater, simply connect to your database and run the following command:

`$> ``CREATE EXTENSION temporal;`

### Download and Compile Strabon

In order to download and compile Strabon, the steps below should be followed:

1. Clone the source code of the Strabon from the Strabon repository.

$> hg clone http://hg.strabon.di.uoa.gr/Strabon/

2. Change to the directory that Strabon source code resides in.

$> cd Strabon

3. **OPTIONAL:** For using also the temporal features of Strabon, move to the respective branch using the following command:

$> hg update temporals

4. Build Strabon.

$> mvn clean package

### Tuning PostgreSQL

The default settings of Postgres are rather conservative. As a result, parameter tuning is neccessary for speeding up Postgres, therefore Strabon. If you are using Strabon to compare its performance against your implementation of stSPARQL/GeoSPARQL, you are *strongly* encouraged to contact us using the Strabon Users mailing list for assistance on tuning Postgres.

You can follow the instructions below for tuning a Postgres server running on an Ubuntu machine that is dedicated to PostgreSQL and Strabon.

**Append the following text at the end of postgresql.conf*Uncomment* the appropriate lines**

`### RAM`

## 4 GB of RAM

#shared_buffers = 3GB

#effective_cache_size = 3GB

#maintenance_work_mem = 1GB

#work_mem = 2GB

## 8 GB of RAM

#shared_buffers = 5GB

#effective_cache_size = 6GB

#maintenance_work_mem = 2GB

#work_mem = 5GB

## 16 GB of RAM

#shared_buffers = 10GB

#effective_cache_size = 14GB

#maintenance_work_mem = 4GB

#work_mem = 10GB

## 24 GB of RAM

#shared_buffers = 16GB

#effective_cache_size = 22GB

#maintenance_work_mem = 6GB

#work_mem = 15GB

## 48 GB of RAM

#shared_buffers = 32GB

#effective_cache_size = 46GB

#maintenance_work_mem = 8GB

#work_mem = 30GB

## 64 GB of RAM

# contact us to find out!

### HD

## RAID with ordinary 7.200 disks

#random_page_cost = 3.5 #3.0-3.5

## High-End NAS/SAN

#random_page_cost = 2 #1.5-2.5

## Amazon EBS/Heroku

#random_page_cost = 1.3 #1.1-2.0

## SSD array

#random_page_cost = 2.0 #1.5-2.5

### Planner options

# Increase the following values in order to avoid using the GEQO planner.

# Small values (<8) reduce planning time but may produce inferior query plans

#

geqo_threshold = 15 # keep this value larger that the following two parameters

from_collapse_limit = 14

join_collapse_limit = 14

### Misc

default_statistics_target = 10000

constraint_exclusion = on

checkpoint_completion_target = 0.9

wal_buffers = 32MB

checkpoint_segments = 64

### Connections

max_connections = 10

**Append the following lines at the end of /etc/sysctl.conf*Uncomment* the appropriate lines**

## 4 GB of RAM

#kernel.shmmax = 3758096384

#kernel.shmall = 3758096384

#kernel.shmmni = 4096

## 8 GB of RAM

#kernel.shmmax = 5905580032

#kernel.shmall = 5905580032

#kernel.shmmni = 4096

## 16 GB of RAM

#kernel.shmmax = 11274289152

#kernel.shmall = 11274289152

#kernel.shmmni = 4096

## 24 GB of RAM

#kernel.shmmax = 17716740096

#kernel.shmall = 17716740096

#kernel.shmmni = 4096

## 48 GB of RAM

#kernel.shmmax = 35433480192

#kernel.shmall = 35433480192

#kernel.shmmni = 4224

## 64 GB of RAM

# contact us to find out!

**Apply all changes by executing**

$> sudo sysctl -p

$> sudo /etc/init.d/postgresql restart

**Prepare for the next run by issuing the command, where db is the name of the Postgres database that Strabon will use**

$> sudo -u postgres psql -c 'VACUUM ANALYZE;' db

**or**

$> psql -c 'VACUUM ANALYZE;' db

### Installation for Windows

1. First download PostgreSQL database from here (try Version 9.1.11)

2. Then install the .exe file

3. When you will be asked for a password for the user postgres, enter postgres

4. For anything else, keep the defaults

5. Then, in the Stack builder select "PostgreSQL 9.1 on port 5432"

6. Then check the Spatial Extension PostGIS 2.0 for PostgreSQL 9.1

7. Then, in the PostGIS installation, check the option "Create spatial database"

8. Then enter the password for the user postgres (it must be postgres from the step 3)

9. Then for the Database Name enter "template_postgis"

10. Then press Yes, Close and Finish

11. Now you have PostgreSQL and PostGIS installed

12. Now open pgadmin III (it was installed with postgreSQL)

13. Create a new database with the name "endpoint" and in the definition select as template the "template_postgis"

### Tomcat

1. Install Tomcat 6.x.x or greater.

2. Add a new user in the `tomcat-users.xml` file. This file is usually located in the folder `$TOMCAT_HOME/conf`. Note that this user should be a member of the `manager` group. For example, add the following line inside a `tomcat-users` element to the file `tomcat-users.conf` and restart tomcat:

<user username="endpoint" password="endpoint" roles="manager"/>

### Initial install

1. Create a directory where you want to place the sources of the Strabon on your machine, and `cd` into that directory, e.g.:

mkdir Strabon

cd Strabon

2. Get a clone of Strabon from the Strabon repository:

`hg clone http://hg.strabon.di.uoa.gr/Strabon/`

3. The source code of the endpoint is located at the folder `Strabon` of the source code tree that you just cloned, so `cd` into that directory, e.g. :

cd Strabon

4. Edit the `endpoint/WebContent/WEB-INF/connection.properties` file and define the PostgreSQL host, the database name and the credentials that will be used by for storing stRDF metadata.

5. Compile the endpoint by calling:

mvn clean package

The result of this action is the creation of a .war file inside the `target` directory.

6. Deploy the endpoint by placing the .war file that was created inside the webapps folder of your Tomcat installation, e.g.:

sudo cp endpoint/target/strabon-endpoint-*.war /var/lib/tomcat6/webapps/strabonendpoint.war

7. Start your Tomcat server, e.g.:

sudo /etc/init.d/tomcat start

8. Open a browser and go to `localhost:<port>/manager/html` where `<port>` is the port number you specified during Tomcat’s installation (the default port is 8080).

### Updating to newer version

1. Go (`cd`) to directory Strabon

cd ~/Strabon

2. Update the source code with the following command:

hg pull -u

3. If you have modified the `*.properties` files, copy then inside the source dir.

sudo cp /var/lib/tomcat6/webapps/strabonendpoint/WEB-INF/*.properties Strabon/endpoint/WebContent/WEB-INF/

4. Build the source code with the following command:

( cd Strabon && mvn clean package )

5. Undeploy the previous version of the endpoint by calling the following url:

http://localhost:8080/manager/undeploy?path=/strabonendpoint

6. Deploy the new version of the endpoint by placing the .war file that was created inside the webapps folder of your Tomcat installation, e.g.:

sudo cp components/Strabon/endpoint/target/strabon-endpoint-*.war /var/lib/tomcat6/webapps/strabonendpoint.war

7. Open a browser and go to `http://localhost:<port>/manager/html` where `<port>` is the port number you specified during Tomcat’s installation (the default port is 8080).

### Configure Database

Before performing any store/query operations, add the following parameters under the tab *Explore/Modify Operations -->Configure*:

### Store

### Query

The evaluation of stSPARQL or GeoSPARQL queries can be performed under the tab *Explore/Modify Operations-->Query/Update*.

### Installation Guide

Assuming that you are familiar with Maven, the following steps need to be followed in order to use Strabon using Eclipse:

### Storing stRDF graphs and evaluating stSPARQL queries

You can see some examples in the classes eu.earthobservatory.runtime.postgis.StoreOp and eu.earthobservatory.runtime.postgis.QueryOp.

For loading large datasets, we provide a bulk loader that is much faster than the StoreOp operation. However, the bulk loader is still in the alpha stage, so we do not have an official release yet. However, if you are interested we can provide you with the current version of Strabon Loader. Just send us an email at the users mailing list!

## Mailing Lists

Strabon is continuously being improved! So, we maintain the following mailing lists:

- Users channel, is meant to be a communication channel for all Strabon users.
- Developers channel, is meant to be a communication channel for all development related issues. This list is also used for receiving all check-in messages.