Download

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




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
  • 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:

    • 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.

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

    • 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.

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

    • 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.

    Topological Relationships

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

    • 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.

    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:

    • 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

    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.

    • xsd:boolean strdf:left(strdf:geometry A, strdf:geometry B): 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.

    Spatial Analysis Functions

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

    • 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).

    The folllowing are spatial metric functions:

    • 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.

    The folllowing are spatial aggregate functions:

    • 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.

    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.

    • 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:PeriodOverlaps(strdf:period i1, strdf:period i2): returns true if i1 overlaps with period i2.
    • 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:PeriodContains(strdf:period i1, xsd:dateTime i2)}: returns true if period i1 contains instant i2
    • 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.

    The following functions are also defined:

    • 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.

    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:

    • 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.

    Moreover, stSPARQL defines the following temporal aggregate functions:

    • 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
  • 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

  • User Guide: Installation Instructions for Windows
  • 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"

  • User Guide: Install Strabon Endpoint
  • 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).

  • User Guide: Store/Query Instructions
  • Configure Database

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

    1. The name of the spatially-enabled database that was created previously
    2. The username used to connect to the database
    3. The password used to connect to the database
    4. The port where the PostgreSQL connection listens to (usually 5432)
    5. The name of the database host (e.g., localhost)

    Store

    1. Go to tab Explore/Modify Operations-->Store
    2. Specify the RDF format of the dataset
    3. 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)

    Query

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

  • Developer Guide
  • Installation Guide

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

    1. Install PostgreSQL from http://www.postgresql.org/download/. At the time of this writing the latest PostgreSQL version is 9.1.
    2. Install PostGIS from http://postgis.refractions.net/download/. At the time of this writing we have tested Strabon with PostGIS 1.5.3.
    3. Install Maven from http://maven.apache.org/download.html. At the time of this writing the latest Maven version is 3.0.4.
    4. Install Eclipse from http://www.eclipse.org/downloads/. At the time of this writing the latest Eclipse version is 3.7.2.
    5. Install the m2e plugin for Eclipse from http://www.eclipse.org/m2e/.
    6. 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.

    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.

News

Our team will present a tutorial on "ReQuLGD: Representation and Querying for Linked Geospatial Data" at ISWC 2017 in Vienna on October 21st. Don't miss it! Until then, make sure that you check the tutorial page to stay tuned.

Our team will present our work on tools for storing, querying, publishing and visualizing linked geospatial data at FOSS4G-Europe. See you in Paris!

Check out another great MELODIES use-case in which Strabon is used to store and query timeseries data.

Check out a very interesting blog post about using Strabon and Silk to store, query and interlink soil moisture data in the context of the EU project MELODIES.

Our team, in collaboration with CWI gave a tutorial on Publishing and Interlinking Linked Geospatial Data at ESWC 2015.

Our team will present a paper on a Benchmark for Geospatial RDF Stores and a demo on Visualizing Time-Evolving Linked Geospatial Data at ISWC 2013.

Our team won the best demonstration award at ESWC 2013 for Sextant. Check out the demo.

Our team will present a paper on the temporal features of Strabon at ESWC 2013.

Our submission to the Semantic Web Challenge won the third place! Thanks! Check out the real-time fire monitoring operational service.

Our team presented a paper on Strabon, a paper on Querying Linked Geospatial Data with Incomplete Information, a demo paper, an invited demo and our submission to the Semantic Web Challenge at ISWC 2012.

Tutorial on Data Models and Query Languages for Linked Geospatial Data at RW 2012.

Tutorial on Linked Geospatial Data at ESWC 2012.