protected boolean nextStreamingTripleKeyValue() throws IOException, InterruptedException {
    if(rdfIter == null) return false;
    setKey();
    write("<sem:triples xmlns:sem='http://marklogic.com/semantics'>");
    int max = MAXTRIPLESPERDOCUMENT;
    while (max > 0 && rdfIter.hasNext()) {
        Triple triple = (Triple) rdfIter.next();
        write("<sem:triple>");
        write(subject(triple.getSubject()));
        write(predicate(triple.getPredicate()));
        write(object(triple.getObject()));
        write("</sem:triple>");
        notifyUser();
        max--;
    }
    write("</sem:triples>\n");

    if (!rdfIter.hasNext()) {
        pos = 1;
    }

    writeValue();
    return true;
}
 

@Override
public Var evaluate(NodeSelector nodeSelector, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) {
    TestingSelector testingSelector = (TestingSelector) nodeSelector;
    FunctionTest functionTest = (FunctionTest) testingSelector.getTest();

    if(functionTest.getArgSelectors().get(0) instanceof PropertySelector) {
        PropertySelector arg = (PropertySelector) functionTest.getArgSelectors().get(0);
        PropertySelector delegate = (PropertySelector) testingSelector.getDelegate();

        Var target = Var.alloc(VarIDGenerator.createID());
        elementGroup.addTriplePattern(new Triple(var.asNode(), NodeFactory.createURI(delegate.getProperty().toString()), target));

        Var selector = Var.alloc(VarIDGenerator.createID());
        elementGroup.addTriplePattern(new Triple(target.asNode(), NodeFactory.createURI(arg.getProperty().toString()), selector.asNode()));

        elementGroup.addElementFilter(new ElementFilter(new E_IsLiteral(new ExprVar(selector))));

        return selector;
    } else {
        throw new IllegalStateException("Argument of function isLiteral has to be a PropertySelector");
    }
}
 

public BindingQueryPlan prepareBindings(GraphQuery q, Node[] variables) {   
	this.variables = variables;
	this.indexes = new HashMap<Node,Integer>();
	for (int i = 0; i < variables.length; i++) {
		indexes.put(variables[i], new Integer(i));
	}
	BasicPattern pattern = new BasicPattern();
	for (Triple t: q.getPattern()) {
		pattern.add(t);
	}
	Plan plan = QueryEngineD2RQ.getFactory().create(new OpBGP(pattern), dataset, null, null);
	final ExtendedIterator<Domain> queryIterator = new Map1Iterator<Binding,Domain>(new BindingToDomain(), plan.iterator());
	return new BindingQueryPlan() {
		public ExtendedIterator<Domain> executeBindings() {
			return queryIterator;
		}
	};
}
 

@Override
	public Triple next() {
		//System.out.println("ExecutionResultIterator#next");
		try(Transaction tx = graphdb.beginTx()) {
		Map<String,Object> row = delegate.next();
		//System.out.println("In execution iterator subject: " + row.get("subject") + row.get("subject").getClass());
		
		//Node nsubject = (Node) row.get("subject");
//		JenaNeoNode neonode = new JenaNeoNode(nsubject);
//		System.out.println("Node is uri:" + neonode.isURI());
		
		//System.out.println("Subject: "+ new JenaNeoNode((Node)row.get("subject")));
		
		Triple t = new Triple(new JenaNeoNode((Node)row.get("subject")),
				ResourceFactory.createProperty((String)row.get("type(predicate)")).asNode(),
				new JenaNeoNode((Node)row.get("object")));
		return t;
		}
	}
 

/**
 * Delete the given triple from the graph.
 */
@Override
public void delete(Triple triple) throws DeleteDeniedException {
	Transaction tx=graphdb.beginTx();
	org.neo4j.graphdb.Node subject = nodeFactory.get(triple.getSubject());
	System.out.println("Subject node:" + subject.getProperty("uri"));
	if(subject!=null) {
		org.neo4j.graphdb.Node object = nodeFactory.get(triple.getObject());
		System.out.println("Object node:" + object.getProperty("uri"));
		if(object!=null) {
			Relationship relation = relationshipFactory.get(subject, triple.getPredicate().getURI(), object);
			System.out.println("Relationship:" +relation.getProperty("uri"));
			if(!subject.hasRelationship())
				subject.delete();
			if(triple.getObject().isLiteral())
				object.delete();
			else if(!object.hasRelationship())
				object.delete();
		}
		tx.success();
	}	
}
 

@Override
public Triple next() {
	try {
		final int nextDocId = iterator().nextDoc();
		
		Triple triple = null;
		if (consumer.requireTripleBuild()) { 
			final Document document = searcher.doc(nextDocId, TRIPLE_FIELDS);
			triple = Triple.create(
					NTriples.asURIorBlankNode((String) document.get(Field.S)), 
					NTriples.asURI((String) document.get(Field.P)),
					NTriples.asNode((String) document.get(Field.O)));
		} else {
			triple = DUMMY_TRIPLE;
		}
		consumer.afterTripleHasBeenBuilt(triple, nextDocId);
		return triple;
	} catch (final IOException exception) {
		throw new RuntimeException(exception);
	}
}
 

@Override
public Triple next() {
	final SolrDocument document = iterator().next();
	
	Triple triple = null;
	if (consumer.requireTripleBuild()) { 
		triple = Triple.create(
				NTriples.asURIorBlankNode((String) document.getFieldValue(Field.S)), 
				NTriples.asURI((String) document.getFieldValue(Field.P)),
				NTriples.asNode((String) document.getFieldValue(Field.O)));
	} else {
		triple = DUMMY_TRIPLE;
	}
	// FIXME
	// consumer.afterTripleHasBeenBuilt(triple, nextDocId);
	return triple;
}
 

@Override
public Var evaluate(NodeSelector nodeSelector, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) {
    TestingSelector testingSelector = (TestingSelector) nodeSelector;
    NodeTest nodeTest = testingSelector.getTest();
    Var delVar = LDPathEvaluator.evaluate(testingSelector.getDelegate(), elementGroup, var, evaluatorConfiguration);

    IsATest isATest = (IsATest) nodeTest;
    elementGroup.addTriplePattern(new Triple(delVar.asNode(), RDF.type.asNode(), NodeFactory.createURI(isATest.getPathExpression(new SesameValueBackend()).replace("<", "").replace(">", "").replaceFirst("is-a ", ""))));

    return delVar;
}
 

@Override
public Expr evaluate(NodeTest nodeTest, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) {
    IsATest isATest = (IsATest) nodeTest;
    Var tmpVar = Var.alloc(Var.alloc(VarIDGenerator.createID()));
    elementGroup.addTriplePattern(new Triple(var.asNode(), RDF.type.asNode(), tmpVar.asNode()));
    return new E_Equals(new ExprVar(tmpVar.asNode()), new NodeValueNode(NodeFactory.createURI(isATest.getPathExpression(new SesameValueBackend()).replace("<", "").replace(">", "").replaceFirst("is-a ", ""))));
}
 

@Override
public Var evaluate(NodeSelector nodeSelector, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) {
    PropertySelector propertySelector = (PropertySelector) nodeSelector;
    if (propertySelector instanceof WildcardSelector) {
        throw new IllegalStateException(propertySelector.getClass() + " is not supported.");
    }

    Var id = Var.alloc(VarIDGenerator.createID());
    elementGroup.addTriplePattern(new Triple(var.asNode(), NodeFactory.createURI(propertySelector.getProperty().toString()), id.asNode()));

    return id;
}
 

public static <T extends ResourceObject> Query evaluate(QueryServiceConfiguration queryServiceDTO, URI rootType) throws ParseException {

        Query query = QueryFactory.make();
        query.setQuerySelectType();

        ElementGroup elementGroup = new ElementGroup();

        Var objectVar = Var.alloc("root");

        // Creating and adding the first triple - could be something like: "?objectVar rdf:type oa:Annotation
        Triple t1 = new Triple(objectVar, RDF.type.asNode(), NodeFactory.createURI(rootType.toString()));
        elementGroup.addTriplePattern(t1);

        // Evaluating the criteria
        for (Criteria c : queryServiceDTO.getCriteria()) {
            SesameValueBackend backend = new SesameValueBackend();

            LdPathParser parser = new LdPathParser(backend, queryServiceDTO.getConfiguration(), new StringReader(c.getLdpath()));
            Var var = LDPathEvaluator.evaluate(parser.parseSelector(queryServiceDTO.getPrefixes()), elementGroup, objectVar, queryServiceDTO.getEvaluatorConfiguration());

            if (c.getConstraint() != null) {
                String resolvedConstraint = resolveConstraintPrefix(c.getConstraint(), queryServiceDTO, parser);
                EvalComparison.evaluate(elementGroup, c, var, resolvedConstraint);
            }
        }

        // Adding all generated patterns to the query object
        query.setQueryPattern(elementGroup);

        // Choose what we want so select - SELECT ?annotation in this case
        query.addResultVar(objectVar);

        // Setting the default prefixes, like rdf: or dc:
        query.getPrefixMapping().setNsPrefixes(queryServiceDTO.getPrefixes());

        return query;
    }
 

public GeneralTripleRelation selectTriple(Triple t) {
	GeneralNodeRelation r = this;
	r = GeneralNodeRelationUtil.select(r, SUBJECT, t.getSubject());
	r = GeneralNodeRelationUtil.select(r, PREDICATE, t.getPredicate());
	r = GeneralNodeRelationUtil.select(r, OBJECT, t.getObject());
	r = GeneralNodeRelationUtil.project(r, SPO);
	if (t.getObject().isConcrete() && !t.getSubject().isConcrete()) {
	    r = new GeneralNodeRelation(getConnection(), 
	    		LimitOp.swapLimits(r.getBaseTabular()), r.getBindingMaker());
	}
	return fromNodeRelation(r);
}
 

@Override
public ExtendedIterator<Triple> graphBaseFind(TripleMatch m) {
	checkOpen();
	Triple t = m.asTriple();
	if (log.isDebugEnabled()) {
		log.debug("Find: " + PrettyPrinter.toString(t, getPrefixMapping()));
	}
	ExecutionContext context = new ExecutionContext(mapping.getContext(), this, null, null);
	GeneralFindQuery query = new GeneralFindQuery(t, mapping.getTripleRelations(), context);
	ExtendedIterator<Triple> result = TripleQueryIter.create(query.iterator());
	result = result.andThen(mapping.getAdditionalTriples().find(t));
	return result;
   }
 

public Model getInventoryModel(int limit) {
	log.info("Listing entity set: " + entityMaker);
	Model result = ModelFactory.createDefaultModel();
	result.setNsPrefixes(mapping.getPrefixes());
	GeneralFindQuery query = new GeneralFindQuery(Triple.ANY, inventory, limit, 
			new ExecutionContext(mapping.getContext(), null, null, null));
	Iterator<Triple> it = TripleQueryIter.create(query.iterator());
	while (it.hasNext()) {
		result.getGraph().add(it.next());
	}
	return result;
}
 

private Collection<GeneralTripleRelation> filterTripleRelations(Collection<GeneralTripleRelation> entityDescription) {
	List<GeneralTripleRelation> result = new ArrayList<GeneralTripleRelation>();
	for (GeneralTripleRelation triples: entityDescription) {
		triples = triples.orderBy(TripleRelation.SUBJECT, true);
		if (triples.selectTriple(new Triple(Node.ANY, RDF.Nodes.type, Node.ANY)) != null) {
			result.add(triples);
		}
		// TODO: The list of label properties is redundantly specified in PageServlet
		if (triples.selectTriple(new Triple(Node.ANY, RDFS.label.asNode(), Node.ANY)) != null) {
			result.add(triples);
		} else if (triples.selectTriple(new Triple(Node.ANY, SKOS.prefLabel.asNode(), Node.ANY)) != null) {
			result.add(triples);
		} else if (triples.selectTriple(new Triple(Node.ANY, DC.title.asNode(), Node.ANY)) != null) {
			result.add(triples);					
		} else if (triples.selectTriple(new Triple(Node.ANY, DCTerms.title.asNode(), Node.ANY)) != null) {
			result.add(triples);					
		} else if (triples.selectTriple(new Triple(Node.ANY, FOAF.name.asNode(), Node.ANY)) != null) {
			result.add(triples);					
		}
	}
	if (result.isEmpty()) {
		result.add(new GeneralTripleRelation(connection, entityTable, 
				entityMaker, 
				new FixedNodeMaker(RDF.type.asNode()), 
				new FixedNodeMaker(RDFS.Resource.asNode())));
	}
	return result;
}
 

public GeneralFindQuery(Triple triplePattern, Collection<GeneralTripleRelation> tripleRelations, int limit,
		ExecutionContext context) {
	this.triplePattern = triplePattern;
	this.tripleRelations = tripleRelations;
	this.limitPerRelation = limit;
	this.context = context;
}
 

public Triple next() {
	Binding b = wrapped.next();
	return new Triple(
			b.get(TripleRelation.SUBJECT), 
			b.get(TripleRelation.PREDICATE), 
			b.get(TripleRelation.OBJECT));
}
 

public static void main(String[] args) {
	// Load mapping file
	Model mapModel = FileManager.get().loadModel("doc/example/mapping-iswc.ttl");
	
	// Read mapping file
	D2RQReader reader = new D2RQReader(mapModel, "http://localhost:2020/");
	Mapping mapping = reader.getMapping();
	
	// Compile mapping for D2RQ engine
	CompiledMapping compiled = mapping.compile();

	// Set up the GraphD2RQ
	GraphD2RQ g = new GraphD2RQ(compiled);

	// Create a find(spo) pattern 
	Node subject = Node.ANY;
	Node predicate = DC.date.asNode();
	Node object = Node.createLiteral("2003", null, XSDDatatype.XSDgYear);
	Triple pattern = new Triple(subject, predicate, object);

	// Query the graph
	Iterator<Triple> it = g.find(pattern);
	
	// Output query results
	while (it.hasNext()) {
		Triple t = it.next();
	    System.out.println("Published in 2003: " + t.getSubject());
	}
	g.close();
}
 

public TripleRelation selectTriple(Triple t) {
	NodeRelation r = this;
	r = NodeRelationUtil.select(r, SUBJECT, t.getSubject());
	r = NodeRelationUtil.select(r, PREDICATE, t.getPredicate());
	r = NodeRelationUtil.select(r, OBJECT, t.getObject());
	r = NodeRelationUtil.project(r, SPO);
	if (t.getObject().isConcrete() && !t.getSubject().isConcrete()) {
	    r = new NodeRelation(getSQLConnection(), 
	    		LimitOp.swapLimits(r.getBaseTabular()), r.getBindingMaker());
	}
	return fromNodeRelation(r);
}
 

public Triple next() {
	Binding b = wrapped.next();
	return new Triple(
			b.get(TripleRelation.SUBJECT), 
			b.get(TripleRelation.PREDICATE), 
			b.get(TripleRelation.OBJECT));
}
 

public FindQuery(Triple triplePattern, Collection<TripleRelation> tripleRelations, int limit,
		ExecutionContext context) {
	this.triplePattern = triplePattern;
	this.tripleRelations = tripleRelations;
	this.limitPerRelation = limit;
	this.context = context;
}
 

public Model getInventoryModel(int limit) {
	log.info("Listing entity set: " + entityMaker);
	Model result = ModelFactory.createDefaultModel();
	result.setNsPrefixes(mapping.getPrefixes());
	FindQuery query = new FindQuery(Triple.ANY, inventory, limit, 
			new ExecutionContext(mapping.getContext(), null, null, null));
	Iterator<Triple> it = TripleQueryIter.create(query.iterator());
	while (it.hasNext()) {
		result.getGraph().add(it.next());
	}
	return result;
}
 

private Collection<TripleRelation> filterTripleRelations(Collection<TripleRelation> entityDescription) {
	List<TripleRelation> result = new ArrayList<TripleRelation>();
	for (TripleRelation triples: entityDescription) {
		triples = triples.orderBy(TripleRelation.SUBJECT, true);
		if (triples.selectTriple(new Triple(Node.ANY, RDF.Nodes.type, Node.ANY)) != null) {
			result.add(triples);
		}
		// TODO: The list of label properties is redundantly specified in PageServlet
		if (triples.selectTriple(new Triple(Node.ANY, RDFS.label.asNode(), Node.ANY)) != null) {
			result.add(triples);
		} else if (triples.selectTriple(new Triple(Node.ANY, SKOS.prefLabel.asNode(), Node.ANY)) != null) {
			result.add(triples);
		} else if (triples.selectTriple(new Triple(Node.ANY, DC.title.asNode(), Node.ANY)) != null) {
			result.add(triples);					
		} else if (triples.selectTriple(new Triple(Node.ANY, DCTerms.title.asNode(), Node.ANY)) != null) {
			result.add(triples);					
		} else if (triples.selectTriple(new Triple(Node.ANY, FOAF.name.asNode(), Node.ANY)) != null) {
			result.add(triples);					
		}
	}
	if (result.isEmpty()) {
		result.add(new TripleRelation(sqlConnection, entityTable, 
				entityMaker, 
				new FixedNodeMaker(RDF.type.asNode()), 
				new FixedNodeMaker(RDFS.Resource.asNode())));
	}
	return result;
}
 

/**
 * Overloaded to reuse and update the cache.
 */
@Override
public ExtendedIterator<Triple> graphBaseFind(TripleMatch m) {
	List<Triple> cached = queryCache.get(m);
	if (cached != null) {
           return WrappedIterator.create(cached.iterator());
	}
	ExtendedIterator<Triple> it = super.graphBaseFind(m);
	final List<Triple> list = it.toList();
	queryCache.put(m, list);
	return WrappedIterator.create(list.iterator());
}
 

@Override
public ExtendedIterator<Triple> graphBaseFind(TripleMatch m) {
	checkOpen();
	Triple t = m.asTriple();
	if (log.isDebugEnabled()) {
		log.debug("Find: " + PrettyPrinter.toString(t, getPrefixMapping()));
	}
	FindQuery query = new FindQuery(t, mapping.getTripleRelations(), 
			new ExecutionContext(mapping.getContext(), this, null, null));
	ExtendedIterator<Triple> result = TripleQueryIter.create(query.iterator());
	result = result.andThen(mapping.getAdditionalTriples().find(t));
	return result;
   }
 

@Override
public void addStatement(org.ontoware.rdf2go.model.node.Resource subject, URI predicate,
        org.ontoware.rdf2go.model.node.Node object) throws ModelRuntimeException {
	assertModel();
	try {
		log.debug("adding a statement (" + subject + "," + predicate + "," + object + ")");
		this.modificationCount++;
		if(!(object instanceof DatatypeLiteral)) {
			this.jenaModel.getGraph().add(
			        new Triple(TypeConversion.toJenaNode(subject, this.jenaModel),
			                TypeConversion.toJenaNode(predicate, this.jenaModel),
			                TypeConversion.toJenaNode(object, this.jenaModel)));
		} else
		// DatatypeLiteral
		{
			// build Resources/Literals
			Resource s = null;
			if(subject instanceof URI) {
				s = this.jenaModel.createResource(subject.toString());
			} else
			// subject is a BlankNode
			{
				s = this.jenaModel.createResource(((Node)((AbstractBlankNodeImpl)subject)
				        .getUnderlyingBlankNode()).getBlankNodeId());
			}
			
			Property p = this.jenaModel.createProperty(predicate.toString());
			
			String datatypeValue = ((DatatypeLiteral)object).getValue();
			String datatypeURI = ((DatatypeLiteral)object).getDatatype().toString();
			Literal o = this.jenaModel.createTypedLiteral(datatypeValue, datatypeURI);
			
			// Add the statement to the model
			this.jenaModel.add(s, p, o);
		}
	} catch(BadURIException e) {
		throw new ModelRuntimeException(e);
	}
}
 

@Override
public void removeStatement(org.ontoware.rdf2go.model.node.Resource subject, URI predicate,
        org.ontoware.rdf2go.model.node.Node object) throws ModelRuntimeException {
	assertModel();
	
	log.debug("removing a statement (" + subject + "," + predicate + "," + object + ")");
	this.modificationCount++;
	this.jenaModel.getGraph().delete(
	        new Triple(
	        
	        TypeConversion.toJenaNode(subject, this.jenaModel), TypeConversion.toJenaNode(
	                predicate, this.jenaModel), TypeConversion.toJenaNode(object,
	                this.jenaModel)));
}
 

@Override
public void performAdd(final Triple triple) {
	final SolrInputDocument document = new SolrInputDocument();
	document.setField(Field.C, graphNodeStringified);
	document.setField(Field.S, asNt(triple.getSubject()));
	document.setField(Field.P, asNtURI(triple.getPredicate()));
	document.setField(Field.ID, UUID.nameUUIDFromBytes(
			new StringBuilder()
				.append(graphNodeStringified)
				.append(triple.getSubject())
				.append(triple.getPredicate())
				.append(triple.getObject())
				.toString().getBytes()).toString());
	
	final Node object = triple.getObject();
	final String o = asNt(object);
	document.setField(Field.O, o);

	if (object.isLiteral()) {
		final String language = object.getLiteralLanguage();
		document.setField(Field.LANG, isNotNullOrEmptyString(language) ? language : NULL_LANGUAGE);				

		final RDFDatatype dataType = object.getLiteralDatatype();
		final Object value = object.getLiteralValue();
		registry.get(dataType != null ? dataType.getURI() : null).inject(document, value);
	} else {
		registry.catchAllFieldInjector.inject(document, o);
	}			

	try {
		cloud.add(document);
	} catch (final Exception exception) {
		LOGGER.error(MessageCatalog._00113_NWS_FAILURE, exception);
		throw new AddDeniedException(exception.getMessage(), triple);
	}
}
 

/**
 * Builds a DELETE query.
 * 
 * @param triple the triple (maybe a pattern?) that must be deleted.
 * @return a DELETE query.
 */
String deleteQuery(final Triple triple) {
	final StringBuilder builder = new StringBuilder();
	if (triple.getSubject().isConcrete()) {
		and(builder).append(fq(Field.S, asNt(triple.getSubject()))); 
	}
	
	if (triple.getPredicate().isConcrete()) {
		and(builder).append(fq(Field.P, asNtURI(triple.getPredicate())));
	}
		
	if (triple.getObject().isConcrete()) {
		and(builder);
		
		final Node o = triple.getObject();
		if (o.isLiteral()) {
			final String language = o.getLiteralLanguage();
			if (Strings.isNotNullOrEmptyString(language)) {
				builder
					.append(fq(Field.LANG, language))
					.append(" AND ");
			}
			
			final String literalValue = o.getLiteralLexicalForm(); 
			final RDFDatatype dataType = o.getLiteralDatatype();
			registry.get(dataType != null ? dataType.getURI() : null).addConstraint(builder, literalValue);
		} else {
			registry.catchAllInjector().addConstraint(builder, asNt(o));
		}
	}
	
	return and(builder).append(fq(Field.C, graphNodeStringified)).toString();
}
 

/**
 * It executes a SELECT SPARQL query on the SPARQL endpoint, 
 * to get the discovered links.
 *
 * @param sparqlEndpointURI		the SPARQL endpoint URI.  
 * @param graphName 			the graphName, null in case of default graph.
 * @param user					the user name for the SPARQl endpoint.
 * @param password				the password for the SPARQl endpoint.
 * @param offset				causes the solutions generated to start after 
 *                              the specified number of solutions.
 * @param limit					upper bound on the number of solutions returned.
 * @return a list of triples with the discovered links.
 * @since 2.0
 */
public Triple[] getDiscoveredLinks(final String sparqlEndpointURI, final String graphName, final String user, final String password, final int offset, final int limit) {
	final String query = "select * FROM <" + graphName + "> " + 
					"where {?source ?rel ?target }" +
					" ORDER BY ?source ?target" +
					" OFFSET " + offset + " LIMIT " + limit;
  	ArrayList<Triple> linksList = new ArrayList<Triple>();
 	try {
        // Execute the query and obtain results
        final QueryExecution qexec = QueryExecutionFactory.sparqlService(
        		sparqlEndpointURI, 
        		QueryFactory.create(query), 
				auth(sparqlEndpointURI, user, password));
        qexec.setTimeout(2000, 5000);
           final ResultSet results = qexec.execSelect() ;
           while (results.hasNext())
           {
           	final QuerySolution soln = results.nextSolution() ;
           	final Resource sourceResType = soln.getResource("source");
           	final Resource targetResType = soln.getResource("target");
           	final Resource relResType = soln.getResource("rel");
       		final Triple triple = new Triple(sourceResType.asNode(), relResType.asNode(), targetResType.asNode());
       		linksList.add(triple);
           }
        qexec.close() ;
      } catch (Exception exception) {
		LOGGER.error(MessageCatalog._00035_SPARQL_FAILED, exception, query);
	}
	if (linksList.isEmpty()) {
		return new Triple[0];
	}
	return (Triple[]) linksList.toArray(new Triple[linksList.size()]);
}