The IGLO system - an introduction

The IGLO-system is an API to a simple prototype triple store, designed to allow multiple applications to share data. It operates via a single web-API, to be found at www.keesvanoverveld.com/iglo/php/iglo_main.php . It takes 3 arguments: igloDebug (values 1 or 0, to switch debugging on or off (=default)) is optional and igloInstruction and igloArg are mandatory. The parameter igloInstruction tells IGLO what to do.

The main IGLO functions are
  • authorisation to control access to non-public data
  • selection for retrieving triples
  • creating a triple where a triple is the unit of information stored in IGLO
  • removing a triple which is actually hiding a triple (triples are never really removed from the system, because other triples may refer to them. A triple that is hidden, however, will not show up in a selection)

Although in standard use, IGLO functions are accessed via the web-API, with this tool the various IGLO functions are put under direct user control, as follows:
  • tab authorisation serves logging in and setting session-specific parameters (language, mapstring, ...);
  • tab selection serves performing selection-queries on the IGLO repository. Selected triples can also be removed, provided the user has sufficient permission;
  • tab creating a triple serves creating a triple;
  • tab IGLO url allows triples to be copied-and-pasted into the browser address bar.

How to get access to the iglo system

For part of the functionality of IGLO, access verification is necessary. This is true for accessing non-public triples, for creating non-public triples, and for deleting any triples. Accessing and creating public triples does not require access verification. Part of the information in the IGLO repositorry is seen as 'public domain'; this includes a (growing) folkonomy.

In order to get access tot non-public features, IGLO uses a standard userId-password-sessionId system. UserId's always have the form "root:[prefix][email]. The [prefix] depends on the IGLO client. Valid prefixes are, for instance, "root:jigsaw:" for the jigSaw application, "root:assist:" for the assist application, et cetera. This form of constructing userIds allows the same individual to have accounts in more than one IGLO application.

Functionality for making an account, obtaining a new password and logging in are part of the IGLO system.

prefix (=distinguishes IGLO-clients)

usercode (=email address)

password
choose language:
dut
eng
xxx



map string

How to retrieve tuples from the IGLO system

Retrieving triples from IGLO is done by means of the function multiMatch. It takes a query as one of its arguments. This query consists of three parts. Below we use as an example the query: 'give all things, and their material, that are breakable or can give stains according to the folkonomy'.
  • alias defines the fields that are to be retrieved and how they are to be called. In this example[*] the name 'thing' is assigned to the from-field of the first triple in a joined triple expression, 'disadvantage' to the to-field of the first triple, and 'material' to the to-field of the second triple.
  • constant defines lists of values for some of the to-, from-, func- or map-fields of triples in a joined triple expression. In this example, the func-value 'disadvantage' and the to-value 'breakable', 'break or shatter', or 'stains' have to hold for the first triple, and the func-value 'material' for the second triple.
  • constraint defines a list of restrictions that apply to the joined triples. In this example, the from-values of both triples must be the same.
Further parameters are:
  • random: when set to 1, the order of the resulting tuples is shuffled
  • limit: imposes a limit to the number of returned tuples
  • maxWildcardExpansion: imposes a limit to the number of terms substituted for any wildcard expression
  • rec: when set to 1, hierarchical triples are expanded recursively

[*] Notice: the syntax in these examples is different from the actual syntax to be used in IGLO web-API calls. The syntax here has been chosen to easily compose IGLO calls. A consequence is, that in this tool, strings cannot contain semi colons (;) or equal signs (=). For the genuine syntax, check the query in the IGLO url tab. The actual query can be copied and pasted into a browser for further perusing.

How to add a triple to the IGLO repository

Triples are the information elements that IGLO operates upon. A triple is a relation between three strings, to be called t_from, t_func, t_to. The standard example is ('tomato','colour','red'). If two triples share a string, this string is assumed to be unique. For this reason, strings can never be changed: changing a string would affect all triples in which this string occurs. Instead, updating information amounts to deleting (actually: hiding) triples and creating new ones.

Triples can be publically visible or not publically visible. Contributors who are not logged in can only create publically visible triples. Logged in contributors may choose to add triples that are not in the public domain: this is controlled by the setting of the checkbox 'show new triples publically' in the authorisation tab.

Triples reside in maps. By default, a triple is created in the map called 'public'. Logged in contributors can choose to use other maps: these form a hierarchically ordered set; the root map is called 'root'. A user's default map is the highest map for a contributor to store his triples into. Users can create submaps.

The strings in a triple can be atomic strings; in the form (a,b,c), however, a, b and/or c can also be triples. For instance, ((x,y,z),b,(p,q,r)) is a valid triple. This is called hierarchy; when a hierarchical triple is created, all subtriples are automatically created first.

Below, new triples can be created:
  • new triple's from term:
  • new triple's func term:
  • new triple's to term:

Actual IGLO URL



Below the actual web-API URL of the most recent IGLO call is given. This can be copied and pasted into the address bar of a browser in order to evoke an actual IGLO call.

Notice: for reasons of security, the IGLO web-API requests related to logging in and other authorisation-related processing are not disclosed here.
For quickly entering triples consisting of existing strings, or filling in constant values in a select query, substrings can be typed below. These are matched against the strings in the IGLO repository (using the language as set in the authorisation tab). Next you can click on one of the links to the right to copy a found string to the from-, func- or to-field in a triple-to-be-created, or to the constant-field in a select query.