localrepository.java

这是外国一个开源推理机

/*  Sesame - Storage and Querying architecture for RDF and RDF Schema
 *  Copyright (C) 2001-2005 Aduna
 *
 *  Contact: 
 *  	Aduna
 *  	Prinses Julianaplein 14 b
 *  	3817 CS Amersfoort
 *  	The Netherlands
 *  	tel. [phone]
 *  	fax. [phone]
 *
 *  	http://aduna.biz/
 *  	http://www.openrdf.org/
 *  
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package org.openrdf.sesame.repository.local;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.openrdf.model.BNode;
import org.openrdf.model.Graph;
import org.openrdf.model.Resource;
import org.openrdf.model.Statement;
import org.openrdf.model.URI;
import org.openrdf.model.Value;
import org.openrdf.model.ValueFactory;
import org.openrdf.model.impl.GraphImpl;

import org.openrdf.rio.RdfDocumentWriter;
import org.openrdf.rio.n3.N3Writer;
import org.openrdf.rio.ntriples.NTriplesWriter;
import org.openrdf.rio.rdfxml.RdfXmlWriter;
import org.openrdf.rio.turtle.TurtleWriter;

import org.openrdf.sesame.admin.AdminListener;
import org.openrdf.sesame.admin.RdfAdmin;
import org.openrdf.sesame.admin.UpdateException;
import org.openrdf.sesame.config.AccessDeniedException;
import org.openrdf.sesame.config.UnknownRepositoryException;
import org.openrdf.sesame.constants.QueryLanguage;
import org.openrdf.sesame.constants.RDFFormat;
import org.openrdf.sesame.export.RdfExport;
import org.openrdf.sesame.query.GraphQuery;
import org.openrdf.sesame.query.GraphQueryResultListener;
import org.openrdf.sesame.query.MalformedQueryException;
import org.openrdf.sesame.query.QueryEvaluationException;
import org.openrdf.sesame.query.QueryResultsGraphBuilder;
import org.openrdf.sesame.query.QueryResultsTable;
import org.openrdf.sesame.query.QueryResultsTableBuilder;
import org.openrdf.sesame.query.TableQuery;
import org.openrdf.sesame.query.TableQueryResultListener;
import org.openrdf.sesame.query.rdql.RdqlEngine;
import org.openrdf.sesame.query.rql.RqlEngine;
import org.openrdf.sesame.query.serql.SerqlEngine;
import org.openrdf.sesame.repository.SesameRepository;
import org.openrdf.sesame.sail.RdfRepository;
import org.openrdf.sesame.sail.RdfSchemaSource;
import org.openrdf.sesame.sail.RdfSource;
import org.openrdf.sesame.sail.Sail;
import org.openrdf.sesame.sail.SailChangedEvent;
import org.openrdf.sesame.sail.SailChangedListener;
import org.openrdf.sesame.sail.SailInternalException;
import org.openrdf.sesame.sail.SailUpdateException;
import org.openrdf.sesame.sail.StatementIterator;

/**
 * Entry point for access to a local Sesame repository. Create this object
 * using a LocalService.
 *
 * @see LocalService
 *
 * @author Jeen Broekstra
 * @author Arjohn Kampman
 */
public class LocalRepository implements SesameRepository, SailChangedListener {

	/*----------+
	| Constants |
	+----------*/

	/**
	 * Constant defining default behavior of add methods: by default identical
	 * blank nodes will be 'joined'.
	 */
	private static final boolean JOIN_BLANKNODES_DEFAULT = true;
	
	/*---------------------+
	 | Variables            |
	 +---------------------*/

	private RdfSource _rdfSource;

	private String _id;

	private SerqlEngine _serqlQueryEngine;

	private RqlEngine _rqlQueryEngine;

	private RdqlEngine _rdqlQueryEngine;

	private RdfAdmin _rdfAdmin;

	private RdfExport _rdfExport;

	private LocalService _service;

	private List _listeners;

	/*---------------------+
	 | Constructors         |
	 +---------------------*/

	/**
	 * Creates a LocalRepository for the supplied Sail.
	 **/
	protected LocalRepository(String id, RdfSource rdfSource,
			LocalService service)
	{
		_id = id;
		_rdfSource = rdfSource;
		_service = service;

		_listeners = new ArrayList(0);

		if (_rdfSource instanceof RdfRepository) {
			((RdfRepository)_rdfSource).addListener(this);
		}
	}

	/*---------------------+
	 | Query methods        |
	 +---------------------*/

	/**
	 * Checks whether the current user has read access to this repository.
	 * @return <tt>true</tt> if the user has read access, <tt>false</tt> otherwise.
	 **/
	public boolean hasReadAccess() {
		try {
			return _service.hasReadAccess(_id);
		}
		catch (UnknownRepositoryException e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * Checks whether the current user has write access to this repository.
	 * @return <tt>true</tt> if the user has write access, <tt>false</tt> otherwise.
	 **/
	public boolean hasWriteAccess() {
		try {
			return _service.hasWriteAccess(_id);
		}
		catch (UnknownRepositoryException e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * Ensures that the current user has read access. If the user does not have
	 * read access, an <tt>AccessDeniedException</tt> will be thrown.
	 **/
	protected void _ensureReadAccess()
		throws AccessDeniedException
	{
		if (!hasReadAccess()) {
			throw new AccessDeniedException("Need read access");
		}
	}

	/**
	 * Ensures that the current user has write access. If the user does not have
	 * write access, an <tt>AccessDeniedException</tt> will be thrown.
	 **/
	protected void _ensureWriteAccess()
		throws AccessDeniedException
	{
		if (!hasWriteAccess()) {
			throw new AccessDeniedException("Need write access");
		}
	}

	// implements SesameRepository.performTableQuery(QueryLanguage, String)
	public QueryResultsTable performTableQuery(QueryLanguage language,
			String query)
		throws IOException, MalformedQueryException, QueryEvaluationException,
		AccessDeniedException
	{
		QueryResultsTableBuilder builder = new QueryResultsTableBuilder();

		performTableQuery(language, query, builder);

		return builder.getQueryResultsTable();
	}

	// implements SesameRepository.performTableQuery(QueryLanguage, String, TableQueryResultListener)
	public void performTableQuery(QueryLanguage language, String query,
			TableQueryResultListener listener)
		throws IOException, MalformedQueryException, QueryEvaluationException,
		AccessDeniedException
	{
		_ensureReadAccess();

		if (QueryLanguage.SERQL.equals(language)) {
			// SeRQL select query
			_performSeRQLSelectQuery(query, listener);
		}
		else if (QueryLanguage.RQL.equals(language)) {
			// RQL query
			_performRqlQuery(query, listener);
		}
		else if (QueryLanguage.RDQL.equals(language)) {
			// RDQL query
			_performRdqlQuery(query, listener);
		}
		else {
			throw new IllegalArgumentException("Unknown query language: "
					+ language);
		}
	}

	// implements SesameRepository.performGraphQuery(QueryLanguage, String, GraphQueryResultListener)
	public void performGraphQuery(QueryLanguage language, String query,
			GraphQueryResultListener listener)
		throws IOException, MalformedQueryException, QueryEvaluationException,
		AccessDeniedException
	{
		_ensureReadAccess();

		if (QueryLanguage.SERQL.equals(language)) {
			// SeRQL construct query
			_performSeRQLConstructQuery(query, listener);
		}
		else {
			// no other query language supports graph queries.
			throw new IllegalArgumentException("Query language "
					+ language.toString() + " does not support graph queries");
		}
	}

	public Graph performGraphQuery(QueryLanguage language, String query)
		throws IOException, MalformedQueryException, QueryEvaluationException,
		AccessDeniedException
	{
		_ensureReadAccess();

		QueryResultsGraphBuilder listener = new QueryResultsGraphBuilder();

		if (QueryLanguage.SERQL.equals(language)) {
			// SeRQL construct query
			_performSeRQLConstructQuery(query, listener);

			return listener.getGraph();
		}
		else {
			// no other query language supports graph queries.
			throw new IllegalArgumentException("Query language "
					+ language.toString() + " does not support graph queries");
		}
	}

	/**
	 * Performs an RQL-select query.
	 **/
	protected void _performRqlQuery(String query,
			TableQueryResultListener listener)
		throws IOException, MalformedQueryException, QueryEvaluationException
	{
		if (_rqlQueryEngine == null) {
			try {
				RdfSchemaSource rss = (RdfSchemaSource)_rdfSource;
				_rqlQueryEngine = new RqlEngine(rss);
			}
			catch (ClassCastException e) {
				throw new UnsupportedOperationException(
						"Repository is not an RdfSchemaSource");
			}
		}

		org.openrdf.sesame.query.rql.model.Query queryModel = _rqlQueryEngine.parseQuery(query);

		_rqlQueryEngine.evaluateQuery(queryModel, listener);
	}

	/**
	 * Performs an RDQL-select query.
	 **/
	protected void _performRdqlQuery(String query,
			TableQueryResultListener listener)
		throws IOException, MalformedQueryException, QueryEvaluationException
	{
		if (_rdqlQueryEngine == null) {
			_rdqlQueryEngine = new RdqlEngine(_rdfSource);
		}

		TableQuery tableQuery = _rdqlQueryEngine.parseQuery(query);

		_rdqlQueryEngine.evaluateQuery(tableQuery, listener);
	}

	/**
	 * Performs a SeRQL-select query.
	 **/
	protected void _performSeRQLSelectQuery(String query,
			TableQueryResultListener listener)
		throws IOException, MalformedQueryException, QueryEvaluationException
	{
		if (_serqlQueryEngine == null) {
			_serqlQueryEngine = new SerqlEngine(_rdfSource);
		}

		TableQuery tableQuery = _serqlQueryEngine.parseTableQuery(query);

		_serqlQueryEngine.evaluateSelectQuery(tableQuery, listener);
	}

	/**
	 * Performs a SeRQL-construct query.
	 **/
	protected void _performSeRQLConstructQuery(String query,
			GraphQueryResultListener listener)
		throws IOException, MalformedQueryException, QueryEvaluationException
	{
		if (_serqlQueryEngine == null) {
			_serqlQueryEngine = new SerqlEngine(_rdfSource);
		}

		GraphQuery graphQuery = _serqlQueryEngine.parseGraphQuery(query);

		_serqlQueryEngine.evaluateConstructQuery(graphQuery, listener);
	}

	/*---------------------+
	 | Update methods       |
	 +---------------------*/

	/**
	 * Creates an RdfAdmin object and assigns it to _rdfAdmin, if no _rdfAdmin
	 * object exists yet.
	 **/
	protected void _ensureRdfAdminCreated() {
		if (_rdfAdmin == null) {
			try {
				RdfRepository rdfRepository = (RdfRepository)_rdfSource;
				_rdfAdmin = new RdfAdmin(rdfRepository, _service);
			}
			catch (ClassCastException e) {
				throw new UnsupportedOperationException(
						"Repository is not an RdfRepository");
			}
		}
	}

	// implements SesameRepository.addData(URL, String, RDFFormat, boolean, AdminListener)
	public void addData(URL dataURL, String baseURI, RDFFormat format,
			boolean verifyData, AdminListener listener)
		throws IOException, AccessDeniedException
	{
		if (baseURI == null) {
			baseURI = dataURL.toExternalForm();
		}

		InputStream inputStream = dataURL.openStream();
		try {
			addData(inputStream, baseURI, format, verifyData, listener);
		}
		finally {
			inputStream.close();
		}
	}

	// implements SesameRepository.addData(File, String, RDFFormat, boolean, AdminListener)
	public void addData(File dataFile, String baseURI, RDFFormat format,
			boolean verifyData, AdminListener listener)
		throws FileNotFoundException, IOException, AccessDeniedException
	{
		InputStream inputStream = new FileInputStream(dataFile);
		try {
			addData(inputStream, baseURI, format, verifyData, listener);
		}
		finally {
			inputStream.close();
		}
	}

	// implements SesameRepository.addData(String, String, RDFFormat, boolean, AdminListener)
	public void addData(String data, String baseURI, RDFFormat format,
			boolean verifyData, AdminListener listener)
		throws IOException, AccessDeniedException
	{
		addData(new StringReader(data), baseURI, format, verifyData, listener);
	}

	// implements SesameRepository.addData(SesameRepository, AdminListener)
	public void addData(SesameRepository repository, AdminListener listener)