GenericSparql::listConceptGroupContents() - Code Metrics - Inspection of "cache SPARQL query results to avoid repeated ident..." - NatLibFi/Skosmos - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — sparql-query-cache-skosmos-2 ( 3aec9d )

by Osma
created 2025-08-19 13:08 UTC
GenericSparql::listConceptGroupContents() A

↳ Parent: GenericSparql
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	3
nc	1
nop	4
dl	0
loc	4
rs	10
c	0
b	0
f	0
<?php

/**
 * Generates SPARQL queries and provides access to the SPARQL endpoint.
 */
class GenericSparql {
    /**
     * SPARQL endpoint URL
     * @property string $endpoint
     */
    protected $endpoint;
    /**
     * A SPARQL Client eg. an EasyRDF instance.
     * @property EasyRdf\Sparql\Client $client
     */
    protected $client;
    /**
     * Graph uri.
     * @property object $graph
     */
    protected $graph;
    /**
     * A SPARQL query graph part template.
     * @property string $graphClause
     */
    protected $graphClause;
    /**
     * Model instance.
     * @property Model $model
     */
    protected $model;

    /**
     * Cache used to avoid expensive shorten() calls
     * @property array $qnamecache
     */
    private $qnamecache = array();

    /**
     * Cache used to avoid duplicate SPARQL queries. The cache must be
     * static so that all GenericSparql instances have access to the
     * same shared cache.
     * @property array $querycache
     */
    private static $querycache = array();

    /**
     * Requires the following three parameters.
     * @param string $endpoint SPARQL endpoint address.
     * @param string|null $graph Which graph to query: Either an URI, the special value "?graph"
     *                           to use the default graph, or NULL to not use a GRAPH clause.
     * @param object $model a Model instance.
     */
    public function __construct($endpoint, $graph, $model)
    {
        $this->endpoint = $endpoint;
        $this->graph = $graph;
        $this->model = $model;

        // create the EasyRDF SPARQL client instance to use
        $this->initializeHttpClient();
        $this->client = new EasyRdf\Sparql\Client($endpoint);

        // set graphClause so that it can be used by all queries
        if ($this->isDefaultEndpoint()) // default endpoint; query any graph (and catch it in a variable)
        {
            $this->graphClause = "GRAPH $graph";
        } elseif ($graph !== null) // query a specific graph
        {
            $this->graphClause = "GRAPH <$graph>";
        } else // query the default graph
        {
            $this->graphClause = "";
        }

    }

    /**
     * Returns prefix-definitions for a query
     *
     * @param string $query
     * @return string
    */
    protected function generateQueryPrefixes($query)
    {
        // Check for undefined prefixes
        $prefixes = '';
        foreach (EasyRdf\RdfNamespace::namespaces() as $prefix => $uri) {
            if (strpos($query, "{$prefix}:") !== false and
                strpos($query, "PREFIX {$prefix}:") === false
            ) {
                $prefixes .= "PREFIX {$prefix}: <{$uri}>\n";
            }
        }
        return $prefixes;
    }

    /**
     * Execute the SPARQL query using the SPARQL client, logging it as well.
     * @param string $query SPARQL query to perform
     * @return \EasyRdf\Sparql\Result|\EasyRdf\Graph query result
filter:
    dependency_paths: ["lib/*"]
     */
    protected function doQuery($query)
    {
        $queryId = sprintf("%05d", rand(0, 99999));
        $logger = $this->model->getLogger();
        $logger->info("[qid $queryId] SPARQL query:\n" . $this->generateQueryPrefixes($query) . "\n$query\n");
        $starttime = microtime(true);
        $result = $this->client->query($query);
        $elapsed = intval(round((microtime(true) - $starttime) * 1000));
        if(method_exists($result, 'numRows')) {
            $numRows = $result->numRows();
            $logger->info("[qid $queryId] result: $numRows rows returned in $elapsed ms");
        } else { // graph result
            $numTriples = $result->countTriples();
            $logger->info("[qid $queryId] result: $numTriples triples returned in $elapsed ms");
        }
        return $result;
    }


    /**
     * Execute the SPARQL query, if not found in query cache.
     * @param string $query SPARQL query to perform
     * @return \EasyRdf\Sparql\Result|\EasyRdf\Graph query result
     */
    protected function query($query)
    {
        $key = $this->endpoint . " " . $query;
        if (!array_key_exists($key, self::$querycache)) {
            self::$querycache[$key] = $this->doQuery($query);
        }
        return self::$querycache[$key];
    }


    /**
     * Generates FROM clauses for the queries
     * @param Vocabulary[]|null $vocabs
     * @return string
     */
    protected function generateFromClause($vocabs=null) {
        $clause = '';
        if (!$vocabs) {
            return $this->graph !== '?graph' && $this->graph !== NULL ? "FROM <$this->graph>" : '';
        }
        $graphs = $this->getVocabGraphs($vocabs);
        foreach ($graphs as $graph) {
            $clause .= "FROM NAMED <$graph> ";
        }
        return $clause;
    }

    protected function initializeHttpClient() {
        // configure the HTTP client used by EasyRdf\Sparql\Client
        $httpclient = EasyRdf\Http::getDefaultHttpClient();
        $httpclient->setConfig(array('timeout' => $this->model->getConfig()->getSparqlTimeout()));

        // if special cache control (typically no-cache) was requested by the
        // client, set the same type of cache control headers also in subsequent
        // in the SPARQL requests (this is useful for performance testing)
        // @codeCoverageIgnoreStart
        $cacheControl = filter_input(INPUT_SERVER, 'HTTP_CACHE_CONTROL', FILTER_SANITIZE_FULL_SPECIAL_CHARS);

        $pragma = filter_input(INPUT_SERVER, 'HTTP_PRAGMA', FILTER_SANITIZE_FULL_SPECIAL_CHARS);
        if ($cacheControl !== null || $pragma !== null) {
            $val = $pragma !== null ? $pragma : $cacheControl;
            $httpclient->setHeaders('Cache-Control', $val);
        }
        // @codeCoverageIgnoreEnd

        EasyRdf\Http::setDefaultHttpClient($httpclient); // actually redundant..
    }

    /**
     * Return true if this is the default SPARQL endpoint, used as the facade to query
     * all vocabularies.
     */

    protected function isDefaultEndpoint() {
        return !is_null($this->graph) && $this->graph[0] == '?';
    }

    /**
     * Returns the graph instance
     * @return object EasyRDF graph instance.
     */
    public function getGraph() {
        return $this->graph;

    }

    /**
     * Shorten a URI
     * @param string $uri URI to shorten
     * @return string shortened URI, or original URI if it cannot be shortened
     */
    private function shortenUri($uri) {
        if (!array_key_exists($uri, $this->qnamecache)) {
            $res = new EasyRdf\Resource($uri);
            $qname = $res->shorten(); // returns null on failure
            // only URIs in the SKOS namespace are shortened
            $this->qnamecache[$uri] = ($qname !== null && strpos($qname, "skos:") === 0) ? $qname : $uri;
        }
        return $this->qnamecache[$uri];
    }


    /**
     * Generates the sparql query for retrieving concept and collection counts in a vocabulary.
     * @return string sparql query
     */
    private function generateCountConceptsQuery($array, $group) {
        $fcl = $this->generateFromClause();
        $optional = $array ? "(<$array>) " : '';
        $optional .= $group ? "(<$group>)" : '';
        $query = <<<EOQ
      SELECT (COUNT(DISTINCT(?conc)) as ?c) ?type ?typelabel (COUNT(?depr) as ?deprcount) $fcl WHERE {
        VALUES (?value) { (skos:Concept) (skos:Collection) $optional }
  	    ?type rdfs:subClassOf* ?value
        { ?type ^a ?conc .
          OPTIONAL { ?conc owl:deprecated ?depr .
  		    FILTER (?depr = True)
          }
        } UNION {SELECT * WHERE {
            ?type rdfs:label ?typelabel
          }
        }
      } GROUP BY ?type ?typelabel
EOQ;
        return $query;
    }

    /**
     * Used for transforming the concept count query results.
     * @param EasyRdf\Sparql\Result $result query results to be transformed
     * @param string $lang language of labels
     * @return Array containing the label counts
     */
    private function transformCountConceptsResults($result, $lang) {
        $ret = array();
        foreach ($result as $row) {
            if (!isset($row->type)) {
                continue;
            }
            $typeURI = $row->type->getUri();
            $ret[$typeURI]['type'] = $typeURI;

            if (!isset($row->typelabel)) {
                $ret[$typeURI]['count'] = $row->c->getValue();
                $ret[$typeURI]['deprecatedCount'] = $row->deprcount->getValue();
            }

            if (isset($row->typelabel) && $row->typelabel->getLang() === $lang) {
                $ret[$typeURI]['label'] = $row->typelabel->getValue();
            }

        }
        return $ret;
    }

    /**
     * Used for counting number of concepts and collections in a vocabulary.
     * @param string $lang language of labels
     * @param string $array the uri of the concept array class, eg. isothes:ThesaurusArray
     * @param string $group the uri of the  concept group class, eg. isothes:ConceptGroup
     * @return array with number of concepts in this vocabulary per label
     */
    public function countConcepts($lang = null, $array = null, $group = null) {
        $query = $this->generateCountConceptsQuery($array, $group);
        $result = $this->query($query);
        return $this->transformCountConceptsResults($result, $lang);
    }

    /**
     * @param array $langs Languages to query for
     * @param string[] $props property names
     * @return string sparql query
     */
    private function generateCountLangConceptsQuery($langs, $classes, $props) {
        $gcl = $this->graphClause;
        $classes = ($classes) ? $classes : array('http://www.w3.org/2004/02/skos/core#Concept');

	$quote_string = function($val) { return "'$val'"; };
	$quoted_values = array_map($quote_string, $langs);
	$langFilter = "FILTER(?lang IN (" . implode(',', $quoted_values) . "))";

        $values = $this->formatValues('?type', $classes, 'uri');
        $valuesProp = $this->formatValues('?prop', $props, null);

        $query = <<<EOQ
SELECT ?lang ?prop
  (COUNT(?label) as ?count)
WHERE {
  $gcl {
    $values
    $valuesProp
    ?conc a ?type .
    ?conc ?prop ?label .
    BIND(LANG(?label) AS ?lang)
    $langFilter
  }
}
GROUP BY ?lang ?prop ?type
EOQ;
        return $query;
    }

    /**
     * Transforms the CountLangConcepts results into an array of label counts.
     * @param EasyRdf\Sparql\Result $result query results to be transformed
     * @param array $langs Languages to query for
     * @param string[] $props property names
     */
    private function transformCountLangConceptsResults($result, $langs, $props) {
        $ret = array();
        // set default count to zero; overridden below if query found labels
        foreach ($langs as $lang) {
            foreach ($props as $prop) {
                $ret[$lang][$prop] = 0;
            }
        }
        foreach ($result as $row) {
            if (isset($row->lang) && isset($row->prop) && isset($row->count)) {
                $ret[$row->lang->getValue()][$row->prop->shorten()] +=
                $row->count->getValue();
            }

        }
        ksort($ret);
        return $ret;
    }

    /**
     * Counts the number of concepts in a easyRDF graph with a specific language.
     * @param array $langs Languages to query for
     * @return Array containing count of concepts for each language and property.
     */
    public function countLangConcepts($langs, $classes = null) {
        $props = array('skos:prefLabel', 'skos:altLabel', 'skos:hiddenLabel');
        $query = $this->generateCountLangConceptsQuery($langs, $classes, $props);
        // Count the number of terms in each language
        $result = $this->query($query);
        return $this->transformCountLangConceptsResults($result, $langs, $props);
    }

    /**
     * Formats a VALUES clause (SPARQL 1.1) which states that the variable should be bound to one
     * of the constants given.
     * @param string $varname variable name, e.g. "?uri"
     * @param array $values the values
     * @param string $type type of values: "uri", "literal" or null (determines quoting style)
     */
    protected function formatValues($varname, $values, $type = null) {
        $constants = array();
        foreach ($values as $val) {
            if ($type == 'uri') {
                $val = "<$val>";
            }

            if ($type == 'literal') {
                $val = "'$val'";
            }

            $constants[] = "($val)";
        }
        $values = implode(" ", $constants);

        return "VALUES ($varname) { $values }";
    }

    /**
     * Filters multiple instances of the same vocabulary from the input array.
     * @param \Vocabulary[]|null $vocabs array of Vocabulary objects
     * @return \Vocabulary[]
     */
    private function filterDuplicateVocabs($vocabs) {
        // filtering duplicates
        $uniqueVocabs = array();
        if ($vocabs !== null && sizeof($vocabs) > 0) {
            foreach ($vocabs as $voc) {
                $uniqueVocabs[$voc->getId()] = $voc;
            }
        }

        return $uniqueVocabs;
    }

    /**
     * Generates a sparql query for one or more concept URIs
     * @param mixed $uris concept URI (string) or array of URIs
     * @param string|null $arrayClass the URI for thesaurus array class, or null if not used
     * @param \Vocabulary[]|null $vocabs array of Vocabulary objects
     * @return string sparql query
     */
    private function generateConceptInfoQuery($uris, $arrayClass, $vocabs) {
        $gcl = $this->graphClause;
        $fcl = empty($vocabs) ? '' : $this->generateFromClause($vocabs);
        $values = $this->formatValues('?uri', $uris, 'uri');
        $uniqueVocabs = $this->filterDuplicateVocabs($vocabs);
        $valuesGraph = empty($vocabs) ? $this->formatValuesGraph($uniqueVocabs) : '';

        if ($arrayClass === null) {
            $construct = $optional = "";
        } else {
            // add information that can be used to format narrower concepts by
            // the array they belong to ("milk by source animal" use case)
            $construct = "\n ?x skos:member ?o . ?x skos:prefLabel ?xl . ?x a <$arrayClass> .";
            $optional = "\n OPTIONAL {
                      ?x skos:member ?o .
                      ?x a <$arrayClass> .
                      ?x skos:prefLabel ?xl .
                      FILTER NOT EXISTS {
                        ?x skos:member ?other .
                        MINUS { ?other skos:broader ?uri }
                      }
                    }";
        }
        $query = <<<EOQ
CONSTRUCT {
 ?s ?p ?uri .
 ?sp ?uri ?op .
 ?uri ?p ?o .
 ?p rdfs:label ?proplabel .
 ?p rdfs:comment ?propcomm .
 ?p skos:definition ?propdef .
 ?p rdfs:subPropertyOf ?pp .
 ?pp rdfs:label ?plabel .
 ?o a ?ot .
 ?o skos:prefLabel ?opl .
 ?o rdfs:label ?ol .
 ?o rdf:value ?ov .
 ?o skos:notation ?on .
 ?o ?oprop ?oval .
 ?o ?xlprop ?xlval .
 ?dt rdfs:label ?dtlabel .
 ?directgroup skos:member ?uri .
 ?parent skos:member ?group .
 ?group skos:prefLabel ?grouplabel .
 ?b1 rdf:first ?item .
 ?b1 rdf:rest ?b2 .
 ?item a ?it .
 ?item skos:prefLabel ?il .
 ?group a ?grouptype . $construct
} $fcl WHERE {
 $values
 $gcl {
  {
    ?s ?p ?uri .
    FILTER(!isBlank(?s))
    FILTER(?p != skos:inScheme)
    FILTER NOT EXISTS { ?s owl:deprecated true . }
  }
  UNION
  { ?sp ?uri ?op . }
  UNION
  {
    ?directgroup skos:member ?uri .
    ?group skos:member+ ?uri .
    ?group skos:prefLabel ?grouplabel .
    ?group a ?grouptype .
    OPTIONAL { ?parent skos:member ?group }
  }
  UNION
  {
   ?uri ?p ?o .
   OPTIONAL {
     ?uri skos:notation ?nVal .
     FILTER(isLiteral(?nVal))
     BIND(datatype(?nVal) AS ?dt)
     ?dt rdfs:label ?dtlabel
   }
   OPTIONAL {
     ?o rdf:rest* ?b1 .
     ?b1 rdf:first ?item .
     ?b1 rdf:rest ?b2 .
     OPTIONAL { ?item a ?it . }
     OPTIONAL { ?item skos:prefLabel ?il . }
   }
   OPTIONAL {
     { ?p rdfs:label ?proplabel . }
     UNION
     { ?p rdfs:comment ?propcomm . }
     UNION
     { ?p skos:definition ?propdef . }
     UNION
     { ?p rdfs:subPropertyOf ?pp . }
   }
   OPTIONAL {
     { ?o a ?ot . }
     UNION
     { ?o skos:prefLabel ?opl . }
     UNION
     { ?o rdfs:label ?ol . }
     UNION
     { ?o rdf:value ?ov . 
       OPTIONAL { ?o ?oprop ?oval . }
     }
     UNION
     { ?o skos:notation ?on . }
     UNION
     { ?o a skosxl:Label .
       ?o ?xlprop ?xlval }
   } $optional
  }
 }
}
$valuesGraph
EOQ;
        return $query;
    }

    /**
     * Transforms ConceptInfo query results into an array of Concept objects
     * @param EasyRdf\Graph $result query results to be transformed
     * @param array $uris concept URIs
     * @param \Vocabulary[] $vocabs array of Vocabulary object
     * @param string|null $clang content language
     * @return Concept[] array of Concept objects
     */
    private function transformConceptInfoResults($result, $uris, $vocabs, $clang) {
        $conceptArray = array();
        foreach ($uris as $index => $uri) {
            $conc = $result->resource($uri);
            if (is_array($vocabs)) {
                $vocab = (sizeof($vocabs) == 1) ? $vocabs[0] : $vocabs[$index];
            } else {
                $vocab = null;
            }
            $conceptArray[] = new Concept($this->model, $vocab, $conc, $result, $clang);
        }
        return $conceptArray;
    }

    /**
     * Returns information (as a graph) for one or more concept URIs
     * @param mixed $uris concept URI (string) or array of URIs
     * @param string|null $arrayClass the URI for thesaurus array class, or null if not used
     * @param \Vocabulary[]|null $vocabs vocabularies to target
     * @return \EasyRdf\Graph
     */
    public function queryConceptInfoGraph($uris, $arrayClass = null, $vocabs = array()) {
        // if just a single URI is given, put it in an array regardless
        if (!is_array($uris)) {
            $uris = array($uris);
        }

        $query = $this->generateConceptInfoQuery($uris, $arrayClass, $vocabs);
        $result = $this->query($query);
        return $result;
    }

    /**
     * Returns information (as an array of Concept objects) for one or more concept URIs
     * @param mixed $uris concept URI (string) or array of URIs
     * @param string|null $arrayClass the URI for thesaurus array class, or null if not used
     * @param \Vocabulary[] $vocabs vocabularies to target
     * @param string|null $clang content language
     * @return Concept[]
     */
    public function queryConceptInfo($uris, $arrayClass = null, $vocabs = array(), $clang = null) {
        // if just a single URI is given, put it in an array regardless
        if (!is_array($uris)) {
            $uris = array($uris);
        }
        $result = $this->queryConceptInfoGraph($uris, $arrayClass, $vocabs);
        if ($result->isEmpty()) {
            return [];
        }
        return $this->transformConceptInfoResults($result, $uris, $vocabs, $clang);
    }

    /**
     * Generates the sparql query for queryTypes
     * @param string $lang
     * @return string sparql query
     */
    private function generateQueryTypesQuery($lang) {
        $fcl = $this->generateFromClause();
        $query = <<<EOQ
SELECT DISTINCT ?type ?label ?superclass $fcl
WHERE {
  {
    { BIND( skos:Concept as ?type ) }
    UNION
    { BIND( skos:Collection as ?type ) }
    UNION
    { BIND( isothes:ConceptGroup as ?type ) }
    UNION
    { BIND( isothes:ThesaurusArray as ?type ) }
    UNION
    { ?type rdfs:subClassOf/rdfs:subClassOf* skos:Concept . }
    UNION
    { ?type rdfs:subClassOf/rdfs:subClassOf* skos:Collection . }
  }
  OPTIONAL {
    ?type rdfs:label ?label .
    FILTER(langMatches(lang(?label), '$lang'))
  }
  OPTIONAL {
    ?type rdfs:subClassOf ?superclass .
  }
  FILTER EXISTS {
    ?s a ?type .
    ?s skos:prefLabel ?prefLabel .
  }
}
EOQ;
        return $query;
    }

    /**
     * Transforms the results into an array format.
     * @param EasyRdf\Sparql\Result $result
     * @return array Array with URIs (string) as key and array of (label, superclassURI) as value
     */
    private function transformQueryTypesResults($result) {
        $ret = array();
        foreach ($result as $row) {
            $type = array();
            if (isset($row->label)) {
                $type['label'] = $row->label->getValue();
            }

            if (isset($row->superclass)) {
                $type['superclass'] = $row->superclass->getUri();
            }

            $ret[$row->type->getURI()] = $type;
        }
        return $ret;
    }

    /**
     * Retrieve information about types from the endpoint
     * @param string $lang
     * @return array Array with URIs (string) as key and array of (label, superclassURI) as value
     */
    public function queryTypes($lang) {
        $query = $this->generateQueryTypesQuery($lang);
        $result = $this->query($query);
        return $this->transformQueryTypesResults($result);
    }

    /**
     * Generates the concept scheme query.
     * @param string $conceptscheme concept scheme URI
     * @return string sparql query
     */
    private function generateQueryConceptSchemeQuery($conceptscheme) {
        $fcl = $this->generateFromClause();
        $query = <<<EOQ
CONSTRUCT {
  <$conceptscheme> ?property ?value .
} $fcl WHERE {
  <$conceptscheme> ?property ?value .
  FILTER (?property != skos:hasTopConcept)
}
EOQ;
        return $query;
    }

    /**
     * Retrieves conceptScheme information from the endpoint.
     * @param string $conceptscheme concept scheme URI
     * @return \EasyRdf\Sparql\Result|\EasyRdf\Graph query result graph
     */
    public function queryConceptScheme($conceptscheme) {
        $query = $this->generateQueryConceptSchemeQuery($conceptscheme);
        return $this->query($query);
    }

    /**
     * Generates the queryConceptSchemes sparql query.
     * @param string $lang language of labels
     * @return string sparql query
     */
    private function generateQueryConceptSchemesQuery($lang) {
        $fcl = $this->generateFromClause();
        $query = <<<EOQ
SELECT ?cs ?label ?preflabel ?title ?domain ?domainLabel $fcl
WHERE {
 ?cs a skos:ConceptScheme .
 OPTIONAL{
    ?cs dcterms:subject ?domain.
    ?domain skos:prefLabel ?domainLabel.
    FILTER(langMatches(lang(?domainLabel), '$lang'))
}
 OPTIONAL {
   ?cs rdfs:label ?label .
   FILTER(langMatches(lang(?label), '$lang'))
 }
 OPTIONAL {
   ?cs skos:prefLabel ?preflabel .
   FILTER(langMatches(lang(?preflabel), '$lang'))
 }
 OPTIONAL {
   { ?cs dc11:title ?title }
   UNION
   { ?cs dc:title ?title }
   FILTER(langMatches(lang(?title), '$lang'))
 }
} 
ORDER BY ?cs
EOQ;
        return $query;
    }

    /**
     * Transforms the queryConceptScheme results into an array format.
     * @param EasyRdf\Sparql\Result $result
     * @return array
     */
    private function transformQueryConceptSchemesResults($result) {
        $ret = array();
        foreach ($result as $row) {
            $conceptscheme = array();
            if (isset($row->label)) {
                $conceptscheme['label'] = $row->label->getValue();
            }

            if (isset($row->preflabel)) {
                $conceptscheme['prefLabel'] = $row->preflabel->getValue();
            }

            if (isset($row->title)) {
                $conceptscheme['title'] = $row->title->getValue();
            }
            // add dct:subject and their labels in the result
            if(isset($row->domain) && isset($row->domainLabel)){
                $conceptscheme['subject']['uri']=$row->domain->getURI();
                $conceptscheme['subject']['prefLabel']=$row->domainLabel->getValue();
            }

            $ret[$row->cs->getURI()] = $conceptscheme;
        }
        return $ret;
    }

    /**
     * return a list of skos:ConceptScheme instances in the given graph
     * @param string $lang language of labels
     * @return array Array with concept scheme URIs (string) as keys and labels (string) as values
     */
    public function queryConceptSchemes($lang) {
        $query = $this->generateQueryConceptSchemesQuery($lang);
        $result = $this->query($query);
        return $this->transformQueryConceptSchemesResults($result);
    }

    /**
     * Generate a VALUES clause for limiting the targeted graphs.
     * @param Vocabulary[]|null $vocabs the vocabularies to target
     * @return string[] array of graph URIs
     */
    protected function getVocabGraphs($vocabs) {
        if ($vocabs === null || sizeof($vocabs) == 0) {
            // searching from all vocabularies - limit to known graphs
            $vocabs = $this->model->getVocabularies();
        }
        $graphs = array();
        foreach ($vocabs as $voc) {
            $graph = $voc->getGraph();
            if (!is_null($graph) && !in_array($graph, $graphs)) {
                $graphs[] = $graph;
            }
        }
        return $graphs;
    }

    /**
     * Generate a VALUES clause for limiting the targeted graphs.
     * @param Vocabulary[]|null $vocabs array of Vocabulary objects to target
     * @return string VALUES clause, or "" if not necessary to limit
     */
    protected function formatValuesGraph($vocabs) {
        if (!$this->isDefaultEndpoint()) {
            return "";
        }
        $graphs = $this->getVocabGraphs($vocabs);
        return $this->formatValues('?graph', $graphs, 'uri');
    }

    /**
     * Generate a FILTER clause for limiting the targeted graphs.
     * @param array $vocabs array of Vocabulary objects to target
     * @return string FILTER clause, or "" if not necessary to limit
     */
    protected function formatFilterGraph($vocabs) {
        if (!$this->isDefaultEndpoint()) {
            return "";
        }
        $graphs = $this->getVocabGraphs($vocabs);
        $values = array();
        foreach ($graphs as $graph) {
          $values[] = "<$graph>";
        }
        if (count($values)) {
          return "FILTER (?graph IN (" . implode(',', $values) . "))";
        }
    }

    /**
     * Formats combined limit and offset clauses for the sparql query
     * @param int $limit maximum number of hits to retrieve; 0 for unlimited
     * @param int $offset offset of results to retrieve; 0 for beginning of list
     * @return string sparql query clauses
     */
    protected function formatLimitAndOffset($limit, $offset) {
        $limit = ($limit) ? 'LIMIT ' . $limit : '';
        $offset = ($offset) ? 'OFFSET ' . $offset : '';
        // eliminating whitespace and line changes when the conditions aren't needed.
        $limitandoffset = '';
        if ($limit && $offset) {
            $limitandoffset = "\n" . $limit . "\n" . $offset;
        } elseif ($limit) {
            $limitandoffset = "\n" . $limit;
        } elseif ($offset) {
            $limitandoffset = "\n" . $offset;
        }

        return $limitandoffset;
    }

    /**
     * Formats a sparql query clause for limiting the search to specific concept types.
     * @param array $types limit search to concepts of the given type(s)
     * @return string sparql query clause
     */
    protected function formatTypes($types) {
        $typePatterns = array();
        if (!empty($types)) {
            foreach ($types as $type) {
                $unprefixed = EasyRdf\RdfNamespace::expand($type);
                $typePatterns[] = "{ ?s a <$unprefixed> }";
            }
        }

        return implode(' UNION ', $typePatterns);
    }

    /**
     * @param string $prop property to include in the result eg. 'broader' or 'narrower'
     * @return string sparql query clause
     */
    private function formatPropertyCsvClause($prop) {
        # This expression creates a CSV row containing pairs of (uri,prefLabel) values.
        # The REPLACE is performed for quotes (" -> "") so they don't break the CSV format.
        $clause = <<<EOV
(GROUP_CONCAT(DISTINCT CONCAT(
 '"', IF(isIRI(?$prop),STR(?$prop),''), '"', ',',
 '"', REPLACE(IF(BOUND(?{$prop}lab),?{$prop}lab,''), '"', '""'), '"', ',',
 '"', REPLACE(IF(isLiteral(?{$prop}),?{$prop},''), '"', '""'), '"'
); separator='\\n') as ?{$prop}s)
EOV;
        return $clause;
    }

    /**
     * @return string sparql query clause
     */
    private function formatPrefLabelCsvClause() {
        # This expression creates a CSV row containing pairs of (prefLabel, lang) values.
        # The REPLACE is performed for quotes (" -> "") so they don't break the CSV format.
        $clause = <<<EOV
(GROUP_CONCAT(DISTINCT CONCAT(
 '"', STR(?pref), '"', ',', '"', lang(?pref), '"'
); separator='\\n') as ?preflabels)
EOV;
        return $clause;
    }

    /**
     * @param string $lang language code of the returned labels
     * @param array|null $fields extra fields to include in the result (array of strings). (default: null = none)
     * @return array sparql query clause
     */
    protected function formatExtraFields($lang, $fields) {
        // extra variable expressions to request and extra fields to query for
        $ret = array('extravars' => '', 'extrafields' => '');

        if ($fields === null) {
            return $ret;
        }

        if (in_array('prefLabel', $fields)) {
            $ret['extravars'] .= $this->formatPreflabelCsvClause();
            $ret['extrafields'] .= <<<EOF
OPTIONAL {
  ?s skos:prefLabel ?pref .
}
EOF;
            // removing the prefLabel from the fields since it has been handled separately
            $fields = array_diff($fields, array('prefLabel'));
        }

        foreach ($fields as $field) {
            $ret['extravars'] .= $this->formatPropertyCsvClause($field);
            $ret['extrafields'] .= <<<EOF
OPTIONAL {
  ?s skos:$field ?$field .
  FILTER(!isLiteral(?$field)||langMatches(lang(?{$field}), '$lang'))
  OPTIONAL { ?$field skos:prefLabel ?{$field}lab . FILTER(langMatches(lang(?{$field}lab), '$lang')) }
}
EOF;
        }

        return $ret;
    }

    /**
     * Generate condition for matching labels in SPARQL
     * @param string $term search term
     * @param string $searchLang language code used for matching labels (null means any language)
     * @return string sparql query snippet
     */
    protected function generateConceptSearchQueryCondition($term, $searchLang)
    {
        # use appropriate matching function depending on query type: =, strstarts, strends or full regex
        if (preg_match('/^[^\*]+$/', $term)) { // exact query
            $term = str_replace('\\', '\\\\', $term); // quote slashes
            $term = str_replace('\'', '\\\'', mb_strtolower($term, 'UTF-8')); // make lowercase and escape single quotes
            $filtercond = "LCASE(STR(?match)) = '$term'";
        } elseif (preg_match('/^[^\*]+\*$/', $term)) { // prefix query
            $term = substr($term, 0, -1); // remove the final asterisk
            $term = str_replace('\\', '\\\\', $term); // quote slashes
            $term = str_replace('\'', '\\\'', mb_strtolower($term, 'UTF-8')); // make lowercase and escape single quotes
            $filtercond = "STRSTARTS(LCASE(STR(?match)), '$term')";
        } elseif (preg_match('/^\*[^\*]+$/', $term)) { // suffix query
            $term = substr($term, 1); // remove the preceding asterisk
            $term = str_replace('\\', '\\\\', $term); // quote slashes
            $term = str_replace('\'', '\\\'', mb_strtolower($term, 'UTF-8')); // make lowercase and escape single quotes
            $filtercond = "STRENDS(LCASE(STR(?match)), '$term')";
        } else { // too complicated - have to use a regex
            # make sure regex metacharacters are not passed through
            $term = str_replace('\\', '\\\\', preg_quote($term));
            $term = str_replace('\\\\*', '.*', $term); // convert asterisk to regex syntax
            $term = str_replace('\'', '\\\'', $term); // ensure single quotes are quoted
            $filtercond = "REGEX(STR(?match), '^$term$', 'i')";
        }

        $labelcondMatch = ($searchLang) ? "&& (?prop = skos:notation || LANGMATCHES(lang(?match), ?langParam))" : "";

        return "?s ?prop ?match . FILTER ($filtercond $labelcondMatch)";
    }


    /**
     * Inner query for concepts using a search term.
     * @param string $term search term
     * @param string $lang language code of the returned labels
     * @param string $searchLang language code used for matching labels (null means any language)
     * @param string[] $props properties to target e.g. array('skos:prefLabel','skos:altLabel')
     * @param boolean $unique restrict results to unique concepts (default: false)
     * @param string|null $distinguisher SPARQL property path from concept to distinguisher object in case of shared prefLabels
     * @return string sparql query
     */
    protected function generateConceptSearchQueryInner($term, $lang, $searchLang, $props, $unique, $filterGraph, $distinguisher=null)
    {
        $valuesProp = $this->formatValues('?prop', $props);
        $textcond = $this->generateConceptSearchQueryCondition($term, $searchLang);

        $rawterm = str_replace(array('\\', '*', '"'), array('\\\\', '', '\"'), $term);
        // graph clause, if necessary
        $graphClause = $filterGraph != '' ? 'GRAPH ?graph' : '';

        // extra conditions for label language, if specified
        $labelcondLabel = ($lang) ? "LANGMATCHES(lang(?label), '$lang')" : "lang(?match) = '' || LANGMATCHES(lang(?label), lang(?match))";
        // if search language and UI/display language differ, must also consider case where there is no prefLabel in
        // the display language; in that case, should use the label with the same language as the matched label
        $labelcondFallback = ($searchLang != $lang) ?
          "OPTIONAL { # in case previous OPTIONAL block gives no labels\n" .
          "?s skos:prefLabel ?label . FILTER (LANGMATCHES(LANG(?label), LANG(?match))) }" : "";

        //  Including the labels if there is no query term given.
        if ($rawterm === '') {
          $labelClause = "?s skos:prefLabel ?label .";
          $labelClause = ($lang) ? $labelClause . " FILTER (LANGMATCHES(LANG(?label), '$lang'))" : $labelClause . "";
          return $labelClause . " BIND(?label AS ?match)";
        }

        $distinguishercondLabel = "FILTER (LANG(?distLabel) = LANG(?label))";
        // Only include distinguisher labels in case of a shared prefLabel
        $distinguisherClause = $distinguisher ?
            "OPTIONAL {\n" .
            "  ?s skos:prefLabel ?label . ?s2 skos:prefLabel ?label . FILTER(?s2 != ?s)\n" .
            "  ?s $distinguisher ?distinguisher.\n" .
            "  FILTER (!isLiteral(?distinguisher) || (LANG(?distinguisher) = LANG(?label)))" .
            "  OPTIONAL {\n" .
            "    ?distinguisher skos:prefLabel ?distLabel .\n" .
            "    $distinguishercondLabel\n" .
            "  }\n" .
            "  OPTIONAL {\n" .
            "    ?distinguisher rdfs:label ?distLabel .\n" .
            "    $distinguishercondLabel\n" .
            "  }\n" .
            "} BIND(COALESCE(?distLabel,STR(?distinguisher)) AS ?distcoal) " : "";

        /*
         * This query does some tricks to obtain a list of unique concepts.
         * From each match generated by the text index, a string such as
         * "1en@example" is generated, where the first character is a number
         * encoding the property and priority, then comes the language tag and
         * finally the original literal after an @ sign. Of these, the MIN
         * function is used to pick the best match for each concept. Finally,
         * the structure is unpacked to get back the original string. Phew!
         */
        $hitvar = $unique ? '(MIN(?matchstr) AS ?hit)' : '(?matchstr AS ?hit)';
        $hitgroup = $unique ? 'GROUP BY ?s ?label ?notation ?distcoal' : '';

        $langClause = $this->generateLangClause($searchLang);

        $query = <<<EOQ
   SELECT DISTINCT ?s ?label ?notation ?distcoal $hitvar
   WHERE {
    $graphClause {
     { 
     $valuesProp
     VALUES (?prop ?pri ?langParam) { (skos:prefLabel 1 $langClause) (skos:altLabel 3 $langClause) (skos:notation 5 '') (skos:hiddenLabel 7 $langClause)}
     $textcond
     ?s ?prop ?match }
     OPTIONAL {
      ?s skos:prefLabel ?label .
      FILTER ($labelcondLabel)
     } $labelcondFallback
     BIND(IF(langMatches(LANG(?match),'$lang'), ?pri, ?pri+1) AS ?npri)
     BIND(CONCAT(STR(?npri), LANG(?match), '@', STR(?match)) AS ?matchstr)
     OPTIONAL { ?s skos:notation ?notation }
     $distinguisherClause
    }
    $filterGraph
   }
   $hitgroup
   ORDER BY LCASE(?distcoal)
EOQ;
        return $query;
    }
    /**
    *  This function can be overwritten in other SPARQL dialects for the possibility of handling the different language clauses
     * @param string $lang
     * @return string formatted language clause
     */
    protected function generateLangClause($lang) {
        return "'$lang'";
    }

    /**
     * Query for concepts using a search term.
     * @param array|null $fields extra fields to include in the result (array of strings). (default: null = none)
     * @param boolean $unique restrict results to unique concepts (default: false)
     * @param boolean $showDeprecated whether to include deprecated concepts in search results (default: false)
     * @param ConceptSearchParameters $params
     * @return string sparql query
     */
    protected function generateConceptSearchQuery($fields, $unique, $params, $showDeprecated = false) {
        $vocabs = $params->getVocabs();
        $gcl = $this->graphClause;
        $fcl = empty($vocabs) ? '' : $this->generateFromClause($vocabs);
        $formattedtype = $this->formatTypes($params->getTypeLimit());
        $formattedfields = $this->formatExtraFields($params->getLang(), $fields);
        $extravars = $formattedfields['extravars'];
        $extrafields = $formattedfields['extrafields'];
        $schemes = $params->getSchemeLimit();

        // limit the search to only requested concept schemes
        $schemecond = '';
        if (!empty($schemes)) {
            $conditions = array();
            foreach($schemes as $scheme) {
                $conditions[] = "{?s skos:inScheme <$scheme>}";
            }
            $schemecond = '{'.implode(" UNION ",$conditions).'}';
        }
        $filterDeprecated="";
        //show or hide deprecated concepts
        if(!$showDeprecated){
            $filterDeprecated="FILTER NOT EXISTS { ?s owl:deprecated true }";
        }
        // extra conditions for parent and group, if specified
        $parentcond = ($params->getParentLimit()) ? "?s skos:broader+ <" . $params->getParentLimit() . "> ." : "";
        $groupcond = ($params->getGroupLimit()) ? "<" . $params->getGroupLimit() . "> skos:member ?s ." : "";
        $pgcond = $parentcond . $groupcond;

        $orderextra = $this->isDefaultEndpoint() ? $this->graph : '';

        # make VALUES clauses
        $props = array('skos:prefLabel', 'skos:altLabel');

        // Only search for distinguisher labels if single vocabulary search has been initialized and it is set
        $distinguisher = (is_array($vocabs) && count($vocabs) === 1) ? $vocabs[0]->getConfig()->getResultDistinguisher() : '';

        //add notation into searchable data for the vocabularies which have been configured for it
        if ($vocabs) {
            $searchByNotation = false;
            foreach ($vocabs as $vocab) {
                if ($vocab->getConfig()->searchByNotation()) {
                    $searchByNotation = true;
                }
            }
            if ($searchByNotation) {
                $props[] = 'skos:notation';
            }
        }

        if ($params->getHidden()) {
            $props[] = 'skos:hiddenLabel';
        }
        $filterGraph = empty($vocabs) ? $this->formatFilterGraph($vocabs) : '';

        // remove futile asterisks from the search term
        $term = $params->getSearchTerm();
        while (strpos($term, '**') !== false) {
            $term = str_replace('**', '*', $term);
        }

        $labelpriority = <<<EOQ
  FILTER(BOUND(?s))
  BIND(STR(SUBSTR(?hit,1,1)) AS ?pri)
  BIND(IF((SUBSTR(STRBEFORE(?hit, '@'),1) != ?pri), STRLANG(STRAFTER(?hit, '@'), SUBSTR(STRBEFORE(?hit, '@'),2)), STRAFTER(?hit, '@')) AS ?match)
  BIND(IF((?pri = "1" || ?pri = "2") && ?match != ?label, ?match, ?unbound) as ?plabel)
  BIND(IF((?pri = "3" || ?pri = "4"), ?match, ?unbound) as ?alabel)
  BIND(IF((?pri = "7" || ?pri = "8"), ?match, ?unbound) as ?hlabel)
EOQ;
        $innerquery = $this->generateConceptSearchQueryInner($params->getSearchTerm(), $params->getLang(), $params->getSearchLang(), $props, $unique, $filterGraph, $distinguisher);
        if ($params->getSearchTerm() === '*' || $params->getSearchTerm() === '') {
          $labelpriority = '';
        }
        $query = <<<EOQ
SELECT DISTINCT ?s ?label ?plabel ?alabel ?hlabel ?graph ?notation (GROUP_CONCAT(DISTINCT STR(?distcoal);separator='|||') as ?distLabels) (GROUP_CONCAT(DISTINCT STR(?type);separator=' ') as ?types) $extravars
$fcl
WHERE {
 $gcl {
  {
  $innerquery
  }
  $labelpriority
  $formattedtype
  { $pgcond 
   ?s a ?type .
   $extrafields $schemecond
  }
  $filterDeprecated
 }
 $filterGraph
}
GROUP BY ?s ?match ?label ?plabel ?alabel ?hlabel ?notation ?distLabels ?graph
ORDER BY LCASE(STR(?match)) LANG(?match) LCASE(STR(?distLabels)) $orderextra
EOQ;
        return $query;
    }

    /**
     * Transform a single concept search query results into the skosmos desired return format.
     * @param $row SPARQL query result row
filter:
    dependency_paths: ["lib/*"]
     * @param array $vocabs array of Vocabulary objects to search; empty for global search
     * @return array query result object
     */
    private function transformConceptSearchResult($row, $vocabs, $fields)
    {
        $hit = array();
        $hit['uri'] = $row->s->getUri();

        if (isset($row->graph)) {
            $hit['graph'] = $row->graph->getUri();
        }

        foreach (explode(" ", $row->types->getValue()) as $typeuri) {
            $hit['type'][] = $this->shortenUri($typeuri);
        }

        if(!empty($fields)) {
            foreach ($fields as $prop) {
                $propname = $prop . 's';
                if (isset($row->$propname)) {
                    foreach (explode("\n", $row->$propname->getValue()) as $line) {
                        $rdata = str_getcsv($line, ',', '"', '"');
                        $propvals = array();
                        if ($rdata[0] != '') {
                            $propvals['uri'] = $rdata[0];
                        }
                        if ($rdata[1] != '') {
                            $propvals['prefLabel'] = $rdata[1];
                        }
                        if ($rdata[2] != '') {
                            $propvals = $rdata[2];
                        }

                        $hit['skos:' . $prop][] = $propvals;
                    }
                }
            }
        }


        if (isset($row->preflabels)) {
            foreach (explode("\n", $row->preflabels->getValue()) as $line) {
                $pref = str_getcsv($line, ',', '"', '"');
                $hit['prefLabels'][$pref[1]] = $pref[0];
            }
        }

        foreach ($vocabs as $vocab) { // looping the vocabulary objects and asking these for a localname for the concept.
            $localname = $vocab->getLocalName($hit['uri']);
            if ($localname !== $hit['uri']) { // only passing the result forward if the uri didn't boomerang right back.
                $hit['localname'] = $localname;
                break; // stopping the search when we find one that returns something valid.
            }
        }

        if (isset($row->label)) {
            $hit['prefLabel'] = $row->label->getValue();
        }

        if (isset($row->label)) {
            $hit['lang'] = $row->label->getLang();
        }

        if (isset($row->notation)) {
            $hit['notation'] = $row->notation->getValue();
        }

        if (isset($row->distLabels)) {
            $hit['distinguisherLabels'] = explode("|||", $row->distLabels->getValue());
        }

        if (isset($row->plabel)) {
            $hit['matchedPrefLabel'] = $row->plabel->getValue();
            $hit['lang'] = $row->plabel->getLang();
        } elseif (isset($row->alabel)) {
            $hit['altLabel'] = $row->alabel->getValue();
            $hit['lang'] = $row->alabel->getLang();
        } elseif (isset($row->hlabel)) {
            $hit['hiddenLabel'] = $row->hlabel->getValue();
            $hit['lang'] = $row->hlabel->getLang();
        }
        return $hit;
    }

    /**
     * Transform the concept search query results into the skosmos desired return format.
     * @param EasyRdf\Sparql\Result $results
     * @param array $vocabs array of Vocabulary objects to search; empty for global search
     * @return array query result object
     */
    private function transformConceptSearchResults($results, $vocabs, $fields) {
        $ret = array();

        foreach ($results as $row) {
            if (!isset($row->s)) {
                // don't break if query returns a single dummy result
                continue;
            }
            $ret[] = $this->transformConceptSearchResult($row, $vocabs, $fields);
        }
        return $ret;
    }

    /**
     * Query for concepts using a search term.
     * @param array $vocabs array of Vocabulary objects to search; empty for global search
     * @param array $fields extra fields to include in the result (array of strings or null).
     * @param boolean $unique restrict results to unique concepts
     * @param ConceptSearchParameters $params
     * @param boolean $showDeprecated whether to include deprecated concepts in the result (default: false)
     * @return array query result object
     */
    public function queryConcepts($vocabs, $fields, $unique, $params, $showDeprecated = false) {
        $query = $this->generateConceptSearchQuery($fields, $unique, $params,$showDeprecated);
        $results = $this->query($query);
        return $this->transformConceptSearchResults($results, $vocabs, $fields);
    }

    /**
     * Generates sparql query clauses used for creating the alphabetical index.
     * @param string $letter the letter (or special class) to search for
     * @return array of sparql query clause strings
     */
    private function formatFilterConditions($letter, $lang) {
        $useRegex = false;

        if ($letter == '*') {
            $letter = '.*';
            $useRegex = true;
        } elseif ($letter == '0-9') {
            $letter = '[0-9].*';
            $useRegex = true;
        } elseif ($letter == '!*') {
            $letter = '[^\\\\p{L}\\\\p{N}].*';
            $useRegex = true;
        }

        # make text query clause
        $lcletter = mb_strtolower($letter, 'UTF-8'); // convert to lower case, UTF-8 safe
        if ($useRegex) {
            $filtercondLabel = $lang ? "regex(str(?label), '^$letter$', 'i') && langMatches(lang(?label), '$lang')" : "regex(str(?label), '^$letter$', 'i')";
            $filtercondALabel = $lang ? "regex(str(?alabel), '^$letter$', 'i') && langMatches(lang(?alabel), '$lang')" : "regex(str(?alabel), '^$letter$', 'i')";
        } else {
            $filtercondLabel = $lang ? "strstarts(lcase(str(?label)), '$lcletter') && langMatches(lang(?label), '$lang')" : "strstarts(lcase(str(?label)), '$lcletter')";
            $filtercondALabel = $lang ? "strstarts(lcase(str(?alabel)), '$lcletter') && langMatches(lang(?alabel), '$lang')" : "strstarts(lcase(str(?alabel)), '$lcletter')";
        }
        return array('filterpref' => $filtercondLabel, 'filteralt' => $filtercondALabel);
    }

    /**
     * Generates the sparql query used for rendering the alphabetical index.
     * @param string $letter the letter (or special class) to search for
     * @param string $lang language of labels
     * @param integer $limit limits the amount of results
     * @param integer $offset offsets the result set
     * @param array|null $classes
     * @param boolean $showDeprecated whether to include deprecated concepts in the result (default: false)
     * @param \EasyRdf\Resource|null $qualifier alphabetical list qualifier resource or null (default: null)
     * @return string sparql query
     */
    protected function generateAlphabeticalListQuery($letter, $lang, $limit, $offset, $classes, $showDeprecated = false, $qualifier = null) {
        $gcl = $this->graphClause;
        $classes = ($classes) ? $classes : array('http://www.w3.org/2004/02/skos/core#Concept');
        $values = $this->formatValues('?type', $classes, 'uri');
        $limitandoffset = $this->formatLimitAndOffset($limit, $offset);
        $conditions = $this->formatFilterConditions($letter, $lang);
        $filtercondLabel = $conditions['filterpref'];
        $filtercondALabel = $conditions['filteralt'];
        $qualifierClause = $qualifier ? "OPTIONAL { ?s <" . $qualifier->getURI() . "> ?qualifier }" : "";
        $filterDeprecated="";
        if(!$showDeprecated){
            $filterDeprecated="FILTER NOT EXISTS { ?s owl:deprecated true }";
        }
        $query = <<<EOQ
SELECT DISTINCT ?s ?label ?alabel ?qualifier
WHERE {
  $gcl {
    {
      ?s skos:prefLabel ?label .
      FILTER (
        $filtercondLabel
      )
    }
    UNION
    {
      {
        ?s skos:altLabel ?alabel .
        FILTER (
          $filtercondALabel
        )
      }
      {
        ?s skos:prefLabel ?label .
        FILTER (langMatches(lang(?label), '$lang'))
      }
    }
    ?s a ?type .
    $qualifierClause
    $filterDeprecated
    $values
  }
}
ORDER BY LCASE(STR(COALESCE(?alabel, ?label))) STR(?s) LCASE(STR(?qualifier)) $limitandoffset
EOQ;
        return $query;
    }

    /**
     * Transforms the alphabetical list query results into an array format.
     * @param EasyRdf\Sparql\Result $results
     * @return array
     */
    private function transformAlphabeticalListResults($results) {
        $ret = array();

        foreach ($results as $row) {
            if (!isset($row->s)) {
                continue;
            }
            // don't break if query returns a single dummy result

            $hit = array();
            $hit['uri'] = $row->s->getUri();

            $hit['localname'] = $row->s->localName();

            $hit['prefLabel'] = $row->label->getValue();
            $hit['lang'] = $row->label->getLang();

            if (isset($row->alabel)) {
                $hit['altLabel'] = $row->alabel->getValue();
                $hit['lang'] = $row->alabel->getLang();
            }

            if (isset($row->qualifier)) {
                if ($row->qualifier instanceof EasyRdf\Literal) {
                    $hit['qualifier'] = $row->qualifier->getValue();
                }
                else {
                    $hit['qualifier'] = $row->qualifier->localName();
                }
            }

            $ret[] = $hit;
        }

        return $ret;
    }

    /**
     * Query for concepts with a term starting with the given letter. Also special classes '0-9' (digits),
     * '*!' (special characters) and '*' (everything) are accepted.
     * @param string $letter the letter (or special class) to search for
     * @param string $lang language of labels
     * @param integer $limit limits the amount of results
     * @param integer $offset offsets the result set
     * @param array $classes
     * @param boolean $showDeprecated whether to include deprecated concepts in the result (default: false)
     * @param \EasyRdf\Resource|null $qualifier alphabetical list qualifier resource or null (default: null)
     */
    public function queryConceptsAlphabetical($letter, $lang, $limit = null, $offset = null, $classes = null, $showDeprecated = false, $qualifier = null) {
        if ($letter === '') {
            return array(); // special case: no letter given, return empty list
        }
        $query = $this->generateAlphabeticalListQuery($letter, $lang, $limit, $offset, $classes, $showDeprecated, $qualifier);
        $results = $this->query($query);
        return $this->transformAlphabeticalListResults($results);
    }

    /**
     * Creates the query used for finding out which letters should be displayed in the alphabetical index.
     * Note that we force the datatype of the result variable otherwise Virtuoso does not properly interpret the DISTINCT and we have duplicated results
     * @param string $lang language
     * @return string sparql query
     */
    private function generateFirstCharactersQuery($lang, $classes) {
        $gcl = $this->graphClause;
        $classes = (isset($classes) && sizeof($classes) > 0) ? $classes : array('http://www.w3.org/2004/02/skos/core#Concept');
        $values = $this->formatValues('?type', $classes, 'uri');
        $query = <<<EOQ
SELECT DISTINCT (ucase(str(substr(?label, 1, 1))) as ?l) WHERE {
  $gcl {
    ?c skos:prefLabel ?label .
    ?c a ?type
    FILTER(langMatches(lang(?label), '$lang'))
    $values
  }
}
EOQ;
        return $query;
    }

    /**
     * Transforms the first characters query results into an array format.
     * @param EasyRdf\Sparql\Result $result
     * @return array
     */
    private function transformFirstCharactersResults($result) {
        $ret = array();
        foreach ($result as $row) {
            $ret[] = $row->l->getValue();
        }
        return $ret;
    }

    /**
     * Query for the first characters (letter or otherwise) of the labels in the particular language.
     * @param string $lang language
     * @return array array of characters
     */
    public function queryFirstCharacters($lang, $classes = null) {
        $query = $this->generateFirstCharactersQuery($lang, $classes);
        $result = $this->query($query);
        return $this->transformFirstCharactersResults($result);
    }

    /**
     * @param string $uri
     * @param string $lang
     * @return string sparql query string
     */
    private function generateLabelQuery($uri, $lang) {
        $fcl = $this->generateFromClause();
        $labelcondLabel = ($lang) ? "FILTER( langMatches(lang(?label), '$lang') )" : "";
        $query = <<<EOQ
SELECT ?label $fcl
WHERE {
  <$uri> a ?type .
  OPTIONAL {
    <$uri> skos:prefLabel ?label .
    $labelcondLabel
  }
  OPTIONAL {
    <$uri> rdfs:label ?label .
    $labelcondLabel
  }
  OPTIONAL {
    <$uri> dc:title ?label .
    $labelcondLabel
  }
  OPTIONAL {
    <$uri> dc11:title ?label .
    $labelcondLabel
  }
}
EOQ;
        return $query;
    }


    /**
     * @param string $uri
     * @param string $lang
     * @return string sparql query string
     */
    private function generateAllLabelsQuery($uri, $lang) {
        $fcl = $this->generateFromClause();
        $labelcondLabel = ($lang) ? "FILTER( langMatches(lang(?val), '$lang') )" : "";
        $query = <<<EOQ
SELECT DISTINCT ?prop ?val $fcl
WHERE {
  <$uri> a ?type .
  OPTIONAL {
      <$uri> ?prop ?val .
      $labelcondLabel
  }
  VALUES ?prop { skos:prefLabel skos:altLabel skos:hiddenLabel }
}
EOQ;
        return $query;
    }

    /**
     * Query for a label (skos:prefLabel, rdfs:label, dc:title, dc11:title) of a resource.
     * @param string $uri
     * @param string $lang
     * @return array array of labels (key: lang, val: label), or null if resource doesn't exist
     */
    public function queryLabel($uri, $lang) {
        $query = $this->generateLabelQuery($uri, $lang);
        $result = $this->query($query);
        $ret = array();
        foreach ($result as $row) {
            if (!isset($row->label)) {
                // existing concept but no labels
                return array();
            }
            $ret[$row->label->getLang()] = $row->label;
        }

        if (sizeof($ret) > 0) {
            // existing concept, with label(s)
            return $ret;
        } else {
            // nonexistent concept
            return null;
        }
    }

    /**
     * Query for skos:prefLabels, skos:altLabels and skos:hiddenLabels of a resource.
     * @param string $uri
     * @param string $lang
     * @return array array of prefLabels, altLabels and hiddenLabels - or null if resource doesn't exist
     */
    public function queryAllConceptLabels($uri, $lang) {
        $query = $this->generateAllLabelsQuery($uri, $lang);
        $result = $this->query($query);

        if ($result->numRows() == 0) {
        if ($result->/** @scrutinizer ignore-call */ numRows() == 0) {
            // nonexistent concept
            return null;
        }

        $ret = array();
        foreach ($result as $row) {
            $labelName = $row->prop->localName();
            if (isset($row->val)) {
                $ret[$labelName][] = $row->val->getValue();
            }
        }
        return $ret;
    }

    /**
     * Generates a SPARQL query to retrieve the super properties of a given property URI.
     * Note this must be executed in the graph where this information is available.
     * @param string $uri
     * @return string sparql query string
     */
    private function generateSubPropertyOfQuery($uri) {
        $fcl = $this->generateFromClause();
        $query = <<<EOQ
SELECT ?superProperty $fcl
WHERE {
  <$uri> rdfs:subPropertyOf ?superProperty
}
EOQ;
        return $query;
    }

    /**
     * Query the super properties of a provided property URI.
     * @param string $uri URI of a propertyes
     * @return array array super properties, or null if none exist
     */
    public function querySuperProperties($uri) {
        $query = $this->generateSubPropertyOfQuery($uri);
        $result = $this->query($query);
        $ret = array();
        foreach ($result as $row) {
            if (isset($row->superProperty)) {
                $ret[] = $row->superProperty->getUri();
            }

        }

        if (sizeof($ret) > 0) {
            // return result
            return $ret;
        } else {
            // no result, return null
            return null;
        }
    }


    /**
     * Generates a sparql query for queryNotation.
     * @param string $uri
     * @return string sparql query
     */
    private function generateNotationQuery($uri) {
        $fcl = $this->generateFromClause();

        $query = <<<EOQ
SELECT * $fcl
WHERE {
  <$uri> skos:notation ?notation .
}
EOQ;
        return $query;
    }

    /**
     * Query for the notation of the concept (skos:notation) of a resource.
     * @param string $uri
     * @return string notation or null if it doesn't exist
     */
    public function queryNotation($uri) {
        $query = $this->generateNotationQuery($uri);
        $result = $this->query($query);
        foreach ($result as $row) {
            if (isset($row->notation)) {
                return $row->notation->getValue();
            }
        }
        return null;
    }

    /**
     * Generates a sparql query for queryProperty.
     * @param string $uri
     * @param string $prop the name of the property eg. 'skos:broader'.
     * @param string $lang
     * @param boolean $anylang if you want a label even when it isn't available in the language you requested.
     * @return string sparql query
     */
    private function generatePropertyQuery($uri, $prop, $lang, $anylang) {
        $fcl = $this->generateFromClause();
        $anylang = $anylang ? "OPTIONAL { ?object skos:prefLabel ?label }" : "";

        $query = <<<EOQ
SELECT * $fcl
WHERE {
  <$uri> a skos:Concept .
  OPTIONAL {
    <$uri> $prop ?object .
    OPTIONAL {
      ?object skos:prefLabel ?label .
      FILTER (langMatches(lang(?label), "$lang"))
    }
    OPTIONAL {
      ?object skos:prefLabel ?label .
      FILTER (lang(?label) = "")
    }
    $anylang
  }
}
EOQ;
        return $query;
    }

    /**
     * Transforms the sparql query result into an array or null if the concept doesn't exist.
     * @param EasyRdf\Sparql\Result $result
     * @param string $lang
     * @return array array of property values (key: URI, val: label), or null if concept doesn't exist
     */
    private function transformPropertyQueryResults($result, $lang) {
        $ret = array();
        foreach ($result as $row) {
            if (!isset($row->object)) {
                return array();
            }
            // existing concept but no properties
            if (isset($row->label)) {
                if ($row->label->getLang() === $lang || array_key_exists($row->object->getUri(), $ret) === false) {
                    $ret[$row->object->getUri()]['label'] = $row->label->getValue();
                }

            } else {
                $ret[$row->object->getUri()]['label'] = null;
            }
        }
        if (sizeof($ret) > 0) {
            return $ret;
        }
        // existing concept, with properties
        else {
            return null;
        }
        // nonexistent concept
    }

    /**
     * Query a single property of a concept.
     * @param string $uri
     * @param string $prop the name of the property eg. 'skos:broader'.
     * @param string $lang
     * @param boolean $anylang if you want a label even when it isn't available in the language you requested.
     * @return array array of property values (key: URI, val: label), or null if concept doesn't exist
     */
    public function queryProperty($uri, $prop, $lang, $anylang = false) {
        $uri = is_array($uri) ? $uri[0] : $uri;

        $query = $this->generatePropertyQuery($uri, $prop, $lang, $anylang);
        $result = $this->query($query);
        return $this->transformPropertyQueryResults($result, $lang);
    }

    /**
     * Query a single transitive property of a concept.
     * @param string $uri
     * @param array $props the name of the property eg. 'skos:broader'.
     * @param string $lang
     * @param integer $limit
     * @param boolean $anylang if you want a label even when it isn't available in the language you requested.
     * @return string sparql query
     */
    private function generateTransitivePropertyQuery($uri, $props, $lang, $limit, $anylang) {
        $uri = is_array($uri) ? $uri[0] : $uri;

        $fcl = $this->generateFromClause();
        $propertyClause = implode('|', $props);
        $otherlang = $anylang ? "OPTIONAL { ?object skos:prefLabel ?label }" : "";
        // need to do a SPARQL subquery because LIMIT needs to be applied /after/
        // the direct relationships have been collapsed into one string
        $query = <<<EOQ
SELECT * $fcl
WHERE {
  SELECT ?object ?label (GROUP_CONCAT(STR(?dir);separator=' ') as ?direct)
  WHERE {
    <$uri> a skos:Concept .
    OPTIONAL {
      <$uri> $propertyClause* ?object .
      OPTIONAL {
        ?object $propertyClause ?dir .
      }
    }
    OPTIONAL {
      ?object skos:prefLabel ?label .
      FILTER (langMatches(lang(?label), "$lang"))
    }
    $otherlang
  }
  GROUP BY ?object ?label
}
LIMIT $limit
EOQ;
        return $query;
    }

    /**
     * Transforms the sparql query result object into an array.
     * @param EasyRdf\Sparql\Result $result
     * @param string $lang
     * @param string $fallbacklang language to use if label is not available in the preferred language
     * @return array of property values (key: URI, val: label), or null if concept doesn't exist
     */
    private function transformTransitivePropertyResults($result, $lang, $fallbacklang) {
        $ret = array();
        foreach ($result as $row) {
            if (!isset($row->object)) {
                return array();
            }
            // existing concept but no properties
            if (isset($row->label)) {
                $val = array('label' => $row->label->getValue());
            } else {
                $val = array('label' => null);
            }
            if (isset($row->direct) && $row->direct->getValue() != '') {
                $val['direct'] = explode(' ', $row->direct->getValue());
            }
            // Preventing labels in a non preferred language overriding the preferred language.
            if (isset($row->label) && $row->label->getLang() === $lang || array_key_exists($row->object->getUri(), $ret) === false) {

                if (!isset($row->label) || $row->label->getLang() === $lang) {
                    $ret[$row->object->getUri()] = $val;
                } elseif ($row->label->getLang() === $fallbacklang) {
                    $val['label'] .= ' (' . $row->label->getLang() . ')';
                    $ret[$row->object->getUri()] = $val;
                }
            }
        }

        // second iteration of results to find labels for the ones that didn't have one in the preferred languages
        foreach ($result as $row) {
            if (isset($row->object) && array_key_exists($row->object->getUri(), $ret) === false) {
                $val = array('label' => $row->label->getValue());
                if (isset($row->direct) && $row->direct->getValue() != '') {
                    $val['direct'] = explode(' ', $row->direct->getValue());
                }
                $ret[$row->object->getUri()] = $val;
            }
        }

        if (sizeof($ret) > 0) {
            return $ret;
        }
        // existing concept, with properties
        else {
            return null;
        }
        // nonexistent concept
    }

    /**
     * Query a single transitive property of a concept.
     * @param string $uri
     * @param array $props the property/properties.
     * @param string $lang
     * @param string $fallbacklang language to use if label is not available in the preferred language
     * @param integer $limit
     * @param boolean $anylang if you want a label even when it isn't available in the language you requested.
     * @return array array of property values (key: URI, val: label), or null if concept doesn't exist
     */
    public function queryTransitiveProperty($uri, $props, $lang, $limit, $anylang = false, $fallbacklang = '') {
        $query = $this->generateTransitivePropertyQuery($uri, $props, $lang, $limit, $anylang);
        $result = $this->query($query);
        return $this->transformTransitivePropertyResults($result, $lang, $fallbacklang);
    }

    /**
     * Generates the query for a concepts skos:narrowers.
     * @param string $uri
     * @param string $lang
     * @param string $fallback
     * @return string sparql query
     */
    private function generateChildQuery($uri, $lang, $fallback, $props) {
        $uri = is_array($uri) ? $uri[0] : $uri;

        $fcl = $this->generateFromClause();
        $propertyClause = implode('|', $props);
        $query = <<<EOQ
SELECT ?child ?label ?child ?grandchildren ?notation $fcl WHERE {
  <$uri> a skos:Concept .
  OPTIONAL {
    ?child $propertyClause <$uri> .
    OPTIONAL {
      ?child skos:prefLabel ?label .
      FILTER (langMatches(lang(?label), "$lang"))
    }
    OPTIONAL {
      ?child skos:prefLabel ?label .
      FILTER (langMatches(lang(?label), "$fallback"))
    }
    OPTIONAL { # other language case
      ?child skos:prefLabel ?label .
    }
    OPTIONAL {
      ?child skos:notation ?notation .
    }
    BIND ( EXISTS { ?a $propertyClause ?child . } AS ?grandchildren )
  }
}
EOQ;
        return $query;
    }

    /**
     * Transforms the sparql result object into an array.
     * @param EasyRdf\Sparql\Result $result
     * @param string $lang
     * @return array array of arrays describing each child concept, or null if concept doesn't exist
     */
    private function transformNarrowerResults($result, $lang) {
        $ret = array();
        foreach ($result as $row) {
            if (!isset($row->child)) {
                return array();
            }
            // existing concept but no children

            $label = null;
            if (isset($row->label)) {
                if ($row->label->getLang() == $lang || strpos($row->label->getLang(), $lang . "-") == 0) {
                    $label = $row->label->getValue();
                } else {
                    $label = $row->label->getValue() . " (" . $row->label->getLang() . ")";
                }

            }
            $childArray = array(
                'uri' => $row->child->getUri(),
                'prefLabel' => $label,
                'hasChildren' => filter_var($row->grandchildren->getValue(), FILTER_VALIDATE_BOOLEAN),
            );
            if (isset($row->notation)) {
                $childArray['notation'] = $row->notation->getValue();
            }

            $ret[] = $childArray;
        }
        if (sizeof($ret) > 0) {
            return $ret;
        }
        // existing concept, with children
        else {
            return null;
        }
        // nonexistent concept
    }

    /**
     * Query the narrower concepts of a concept.
     * @param string $uri
     * @param string $lang
     * @param string $fallback
     * @return array array of arrays describing each child concept, or null if concept doesn't exist
     */
    public function queryChildren($uri, $lang, $fallback, $props) {
        $query = $this->generateChildQuery($uri, $lang, $fallback, $props);
        $result = $this->query($query);
        return $this->transformNarrowerResults($result, $lang);
    }

    /**
     * Query the top concepts of a vocabulary.
     * @param string $conceptSchemes concept schemes whose top concepts to query for
     * @param string $lang language of labels
     * @param string $fallback language to use if label is not available in the preferred language
     */
    public function queryTopConcepts($conceptSchemes, $lang, $fallback) {
        if (!is_array($conceptSchemes)) {

            $conceptSchemes = array($conceptSchemes);
        }

        $values = $this->formatValues('?topuri', $conceptSchemes, 'uri');

        $fcl = $this->generateFromClause();
        $query = <<<EOQ
SELECT DISTINCT ?top ?topuri ?label ?notation ?children $fcl WHERE {
  ?top skos:topConceptOf ?topuri .
  OPTIONAL {
    ?top skos:prefLabel ?label .
    FILTER (langMatches(lang(?label), "$lang"))
  }
  OPTIONAL {
    ?top skos:prefLabel ?label .
    FILTER (langMatches(lang(?label), "$fallback"))
  }
  OPTIONAL { # fallback - other language case
    ?top skos:prefLabel ?label .
  }
  OPTIONAL { ?top skos:notation ?notation . }
  BIND ( EXISTS { ?top skos:narrower ?a . } AS ?children )
  $values
}
EOQ;
        $result = $this->query($query);
        $ret = array();
        foreach ($result as $row) {
            if (isset($row->top) && isset($row->label)) {
                $label = $row->label->getValue();
                if ($row->label->getLang() && $row->label->getLang() !== $lang && strpos($row->label->getLang(), $lang . "-") !== 0) {
                    $label .= ' (' . $row->label->getLang() . ')';
                }
                $top = array('uri' => $row->top->getUri(), 'topConceptOf' => $row->topuri->getUri(), 'label' => $label, 'hasChildren' => filter_var($row->children->getValue(), FILTER_VALIDATE_BOOLEAN));
                if (isset($row->notation)) {
                    $top['notation'] = $row->notation->getValue();
                }

                $ret[] = $top;
            }
        }

        return $ret;
    }

    /**
     * Generates a sparql query for finding the hierarchy for a concept.
	 * A concept may be a top concept in multiple schemes, returned as a single whitespace-separated literal.
     * @param string $uri concept uri.
     * @param string $lang
     * @param string $fallback language to use if label is not available in the preferred language
     * @return string sparql query
     */
    private function generateParentListQuery($uri, $lang, $fallback, $props) {
        $fcl = $this->generateFromClause();
        $propertyClause = implode('|', $props);
        $query = <<<EOQ
SELECT ?broad ?parent ?children ?grandchildren
(SAMPLE(?lab) as ?label) (SAMPLE(?childlab) as ?childlabel) (GROUP_CONCAT(?topcs; separator=" ") as ?tops) 
(SAMPLE(?nota) as ?notation) (SAMPLE(?childnota) as ?childnotation) $fcl
WHERE {
  <$uri> a skos:Concept .
  OPTIONAL {
    <$uri> $propertyClause* ?broad .
    OPTIONAL {
      ?broad skos:prefLabel ?lab .
      FILTER (langMatches(lang(?lab), "$lang"))
    }
    OPTIONAL {
      ?broad skos:prefLabel ?lab .
      FILTER (langMatches(lang(?lab), "$fallback"))
    }
    OPTIONAL { # fallback - other language case
      ?broad skos:prefLabel ?lab .
    }
    OPTIONAL { ?broad skos:notation ?nota . }
    OPTIONAL { ?broad $propertyClause ?parent . }
    OPTIONAL { ?broad skos:narrower ?children .
      OPTIONAL {
        ?children skos:prefLabel ?childlab .
        FILTER (langMatches(lang(?childlab), "$lang"))
      }
      OPTIONAL {
        ?children skos:prefLabel ?childlab .
        FILTER (langMatches(lang(?childlab), "$fallback"))
      }
      OPTIONAL { # fallback - other language case
        ?children skos:prefLabel ?childlab .
      }
      OPTIONAL {
        ?children skos:notation ?childnota .
      }
    }
    BIND ( EXISTS { ?children skos:narrower ?a . } AS ?grandchildren )
    OPTIONAL { ?broad skos:topConceptOf ?topcs . }
  }
}
GROUP BY ?broad ?parent ?member ?children ?grandchildren
EOQ;
        return $query;
    }

    /**
     * Transforms the result into an array.
     * @param EasyRdf\Sparql\Result
     * @param string $lang
     * @return array|null an array for the REST controller to encode.
     */
    private function transformParentListResults($result, $lang)
    {
        $ret = array();
        foreach ($result as $row) {
            if (!isset($row->broad)) {
                // existing concept but no broaders
                return array();
            }
            $uri = $row->broad->getUri();
            if (!isset($ret[$uri])) {
                $ret[$uri] = array('uri' => $uri);
            }
            if (isset($row->exact)) {
                $ret[$uri]['exact'] = $row->exact->getUri();
            }
            if (isset($row->tops)) {
               $topConceptsList=explode(" ", $row->tops->getValue());
               // sort to guarantee an alphabetical ordering of the URI
               sort($topConceptsList);
               $ret[$uri]['tops'] = $topConceptsList;
            }
            if (isset($row->children)) {
                if (!isset($ret[$uri]['narrower'])) {
                    $ret[$uri]['narrower'] = array();
                }

                $label = null;
                if (isset($row->childlabel)) {
                    $label = $row->childlabel->getValue();
                    if ($row->childlabel->getLang() !== $lang && strpos($row->childlabel->getLang(), $lang . "-") !== 0) {
                        $label .= " (" . $row->childlabel->getLang() . ")";
                    }

                }

                $childArr = array(
                    'uri' => $row->children->getUri(),
                    'label' => $label,
                    'hasChildren' => filter_var($row->grandchildren->getValue(), FILTER_VALIDATE_BOOLEAN),
                );
                if (isset($row->childnotation)) {
                    $childArr['notation'] = $row->childnotation->getValue();
                }

                if (!in_array($childArr, $ret[$uri]['narrower'])) {
                    $ret[$uri]['narrower'][] = $childArr;
                }

            }
            if (isset($row->label)) {
                $preflabel = $row->label->getValue();
                if ($row->label->getLang() && $row->label->getLang() !== $lang && strpos($row->label->getLang(), $lang . "-") !== 0) {
                    $preflabel .= ' (' . $row->label->getLang() . ')';
                }

                $ret[$uri]['prefLabel'] = $preflabel;
            }
            if (isset($row->notation)) {
                $ret[$uri]['notation'] = $row->notation->getValue();
            }

            if (isset($row->parent) && (isset($ret[$uri]['broader']) && !in_array($row->parent->getUri(), $ret[$uri]['broader']))) {
                $ret[$uri]['broader'][] = $row->parent->getUri();
            } elseif (isset($row->parent) && !isset($ret[$uri]['broader'])) {
                $ret[$uri]['broader'][] = $row->parent->getUri();
            }
        }
        if (sizeof($ret) > 0) {
            // existing concept, with children
            return $ret;
        }
        else {
            // nonexistent concept
            return null;
        }
    }

    /**
     * Query for finding the hierarchy for a concept.
     * @param string $uri concept uri.
     * @param string $lang
     * @param string $fallback language to use if label is not available in the preferred language
     * @param array $props the hierarchy property/properties to use
     * @return an array for the REST controller to encode.
     */
    public function queryParentList($uri, $lang, $fallback, $props) {
        $query = $this->generateParentListQuery($uri, $lang, $fallback, $props);
        $result = $this->query($query);
        return $this->transformParentListResults($result, $lang);

    }

    /**
     * return a list of concept group instances, sorted by label
     * @param string $groupClass URI of concept group class
     * @param string $lang language of labels to return
     * @return string sparql query
     */
    private function generateConceptGroupsQuery($groupClass, $lang) {
        $fcl = $this->generateFromClause();
        $query = <<<EOQ
SELECT ?group (GROUP_CONCAT(DISTINCT STR(?child);separator=' ') as ?children) ?label ?members ?notation $fcl
WHERE {
  ?group a <$groupClass> .
  OPTIONAL { ?group skos:member|isothes:subGroup ?child .
             ?child a <$groupClass> }
  BIND(EXISTS{?group skos:member ?submembers} as ?members)
  OPTIONAL { ?group skos:prefLabel ?label }
  OPTIONAL { ?group rdfs:label ?label }
  FILTER (langMatches(lang(?label), '$lang'))
  OPTIONAL { ?group skos:notation ?notation }
}
GROUP BY ?group ?label ?members ?notation
ORDER BY lcase(?label)
EOQ;
        return $query;
    }

    /**
     * Transforms the sparql query result into an array.
     * @param EasyRdf\Sparql\Result $result
     * @return array
     */
    private function transformConceptGroupsResults($result) {
        $ret = array();
        foreach ($result as $row) {
            if (!isset($row->group)) {
                # no groups found, see issue #357
                continue;
            }
            $group = array('uri' => $row->group->getURI());
            if (isset($row->label)) {
                $group['prefLabel'] = $row->label->getValue();
            }

            if (isset($row->children)) {
                $group['childGroups'] = explode(' ', $row->children->getValue());
            }

            if (isset($row->members)) {
                $group['hasMembers'] = $row->members->getValue();
            }

            if (isset($row->notation)) {
                $group['notation'] = $row->notation->getValue();
            }

            $ret[] = $group;
        }
        return $ret;
    }

    /**
     * return a list of concept group instances, sorted by label
     * @param string $groupClass URI of concept group class
     * @param string $lang language of labels to return
     * @return array Result array with group URI as key and group label as value
     */
    public function listConceptGroups($groupClass, $lang) {
        $query = $this->generateConceptGroupsQuery($groupClass, $lang);
        $result = $this->query($query);
        return $this->transformConceptGroupsResults($result);
    }

    /**
     * Generates the sparql query for listConceptGroupContents
     * @param string $groupClass URI of concept group class
     * @param string $group URI of the concept group instance
     * @param string $lang language of labels to return
     * @param boolean $showDeprecated whether to include deprecated in the result
     * @return string sparql query
     */
    private function generateConceptGroupContentsQuery($groupClass, $group, $lang, $showDeprecated = false) {
        $fcl = $this->generateFromClause();
        $filterDeprecated="";
        if(!$showDeprecated){
            $filterDeprecated="  FILTER NOT EXISTS { ?conc owl:deprecated true }";
        }
        $query = <<<EOQ
SELECT ?conc ?super ?label ?members ?type ?notation $fcl
WHERE {
 <$group> a <$groupClass> .
 { <$group> skos:member ?conc . } UNION { ?conc isothes:superGroup <$group> }
$filterDeprecated
 ?conc a ?type .
 OPTIONAL { ?conc skos:prefLabel ?label .
  FILTER (langMatches(lang(?label), '$lang'))
 }
 OPTIONAL { ?conc skos:prefLabel ?label . }
 OPTIONAL { ?conc skos:notation ?notation }
 BIND(EXISTS{?submembers isothes:superGroup ?conc} as ?super)
 BIND(EXISTS{?conc skos:member ?submembers} as ?members)
} ORDER BY lcase(?label)
EOQ;
        return $query;
    }

    /**
     * Transforms the sparql query result into an array.
     * @param EasyRdf\Sparql\Result $result
     * @param string $lang language of labels to return
     * @return array
     */
    private function transformConceptGroupContentsResults($result, $lang) {
        $ret = array();
        $values = array();
        foreach ($result as $row) {
            if (!array_key_exists($row->conc->getURI(), $values)) {
                $values[$row->conc->getURI()] = array(
                    'uri' => $row->conc->getURI(),
                    'isSuper' => $row->super->getValue(),
                    'hasMembers' => $row->members->getValue(),
                    'type' => array($row->type->shorten()),
                );
                if (isset($row->label)) {
                    if ($row->label->getLang() == $lang || strpos($row->label->getLang(), $lang . "-") == 0) {
                        $values[$row->conc->getURI()]['prefLabel'] = $row->label->getValue();
                    } else {
                        $values[$row->conc->getURI()]['prefLabel'] = $row->label->getValue() . " (" . $row->label->getLang() . ")";
                    }

                }
                if (isset($row->notation)) {
                    $values[$row->conc->getURI()]['notation'] = $row->notation->getValue();
                }

            } else {
                $values[$row->conc->getURI()]['type'][] = $row->type->shorten();
            }
        }

        foreach ($values as $val) {
            $ret[] = $val;
        }

        return $ret;
    }

    /**
     * return a list of concepts in a concept group
     * @param string $groupClass URI of concept group class
     * @param string $group URI of the concept group instance
     * @param string $lang language of labels to return
     * @param boolean $showDeprecated whether to include deprecated concepts in search results
     * @return array Result array with concept URI as key and concept label as value
     */
    public function listConceptGroupContents($groupClass, $group, $lang,$showDeprecated = false) {
        $query = $this->generateConceptGroupContentsQuery($groupClass, $group, $lang,$showDeprecated);
        $result = $this->query($query);
        return $this->transformConceptGroupContentsResults($result, $lang);
    }

    /**
     * Generates the sparql query for queryChangeList.
     * @param string $prop the property uri pointing to timestamps, eg. 'dc:modified'
     * @param string $lang language of labels to return
     * @param int $offset offset of results to retrieve; 0 for beginning of list
     * @param int $limit maximum number of results to return
     * @param boolean $showDeprecated whether to include deprecated concepts in the change list
     * @return string sparql query
     */
    private function generateChangeListQuery($prop, $lang, $offset, $limit=200, $showDeprecated=false) {
        $fcl = $this->generateFromClause();
        $offset = ($offset) ? 'OFFSET ' . $offset : '';

        //Additional clauses when deprecated concepts need to be included in the results
        $deprecatedOptions = '';
        $deprecatedVars = '';
        if ($showDeprecated) {
            $deprecatedVars = '?replacedBy ?deprecated ?replacingLabel';
            $deprecatedOptions = <<<EOQ
UNION {
    ?concept owl:deprecated True; dc:modified ?date2 .
    BIND(True as ?deprecated)
    BIND(COALESCE(?date2, ?date) AS ?date)
    OPTIONAL {
        ?concept dc:isReplacedBy ?replacedBy .
        OPTIONAL {
            ?replacedBy skos:prefLabel ?replacingLabel .
            FILTER (langMatches(lang(?replacingLabel), '$lang'))
        }
    }
}
EOQ;
        }

        $query = <<<EOQ
SELECT ?concept ?date ?label $deprecatedVars $fcl
WHERE {
    ?concept a skos:Concept ;
    skos:prefLabel ?label .
    FILTER (langMatches(lang(?label), '$lang'))
    {
        ?concept $prop ?date .
        MINUS { ?concept owl:deprecated True . }
    }
    $deprecatedOptions
}
ORDER BY DESC(YEAR(?date)) DESC(MONTH(?date)) LCASE(?label) DESC(?concept)
LIMIT $limit $offset
EOQ;

        return $query;
    }

    /**
     * Transforms the sparql query result into an array.
     * @param EasyRdf\Sparql\Result $result
     * @return array
     */
    private function transformChangeListResults($result) {
        $ret = array();
        foreach ($result as $row) {
            $concept = array('uri' => $row->concept->getURI());
            if (isset($row->label)) {
                $concept['prefLabel'] = $row->label->getValue();
            }

            if (isset($row->date)) {
                try {
                    $concept['date'] = $row->date->getValue();
                } catch (Exception $e) {
                    //don't record concepts with malformed dates e.g. 1986-21-00
                    continue;
                }
            }

            if (isset($row->deprecated)) {
                $concept['deprecated'] = $row->deprecated->getValue();
            } else {
                $concept['deprecated'] = false;
            }
            if (isset($row->replacedBy)) {
                $concept['replacedBy'] = $row->replacedBy->getURI();
            }
            if (isset($row->replacingLabel)) {
                $concept['replacingLabel'] = $row->replacingLabel->getValue();
            }

            $ret[] = $concept;
        }
        return $ret;
    }

    /**
     * return a list of recently changed or entirely new concepts
     * @param string $prop the property uri pointing to timestamps, eg. 'dc:modified'
     * @param string $lang language of labels to return
     * @param int $offset offset of results to retrieve; 0 for beginning of list
     * @param int $limit maximum number of results to return
     * @param boolean $showDeprecated whether to include deprecated concepts in the change list
     * @return array Result array
     */
    public function queryChangeList($prop, $lang, $offset, $limit, $showDeprecated=false) {
        $query = $this->generateChangeListQuery($prop, $lang, $offset, $limit, $showDeprecated);

        $result = $this->query($query);
        return $this->transformChangeListResults($result);
    }
}

NatLibFi / Skosmos

Push — sparql-query-cache-skosmos-2 ( 3aec9d )

GenericSparql::listConceptGroupContents() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
