rdfrepository.java

这是外国一个开源推理机

		if (newCount > 0) {
			addResourceCon.commit();
			_rdbms.optimizeTable(RESOURCES_TABLE, newCount);
		}
	}

	protected void _addNewLiterals()
		throws SQLException
	{
		Connection addLiteralCon = _rdbms.getConnection();
		addLiteralCon.setAutoCommit(false);
		PreparedStatement addLiteralSt = addLiteralCon.prepareStatement("INSERT INTO "
				+ LITERALS_TABLE + " VALUES(?, ?, ?, ?, ?)");

		String localnamesAreNullOr = _rdbms.emptyStringIsNull() ? "rt.objLname IS NULL AND dt.localname IS NULL OR "
				: "";
		String labelsAreNullOr = _rdbms.emptyStringIsNull() ? "rt.objLabel IS NULL AND l.label IS NULL OR "
				: "";

		// Get all new literals
		String query = "SELECT DISTINCT dt.id, rt.objLang, rt.objLabelHash, rt.objLabel "
				+ "FROM "
				+ RAW_TRIPLES_TABLE
				+ " rt "
				+ "LEFT JOIN "
				+ RESOURCES_TABLE
				+ " dt ON "
				+ // join with resources table for datatype
				"rt.objNs = dt.namespace AND ("
				+ localnamesAreNullOr
				+ "rt.objLname = dt.localname) "
				+ "LEFT JOIN "
				+ LITERALS_TABLE
				+ " l ON "
				+ "rt.objLabelHash = l.labelHash "
				+ // equal label hash
				"AND dt.id = l.datatype "
				+ // equal datatype
				"AND (rt.objLang IS NULL AND l.language IS NULL OR rt.objLang = l.language) "
				+ // equal language
				"AND (" + labelsAreNullOr + "rt.objLabel = l.label) " + // equal label
				"WHERE " + "rt.objIsLiteral = " + _rdbms.TRUE + " AND " + // row contains a literal
				"l.id IS NULL"; // no such literal exists yet

		Connection con = _rdbms.getConnection();
		java.sql.Statement st = con.createStatement();
		ResultSet rs = st.executeQuery(query);

		int newCount = 0;

		while (rs.next()) {
			// will return 0 in case dt.id is NULL, which is fine for us:
			int datatypeId = rs.getInt(1);
			String lang = rs.getString(2);
			long labelHash = rs.getLong(3);
			String label = rs.getString(4);

			if (label == null) {
				label = "";
			}

			addLiteralSt.setInt(1, _getNextLiteralId());
			addLiteralSt.setInt(2, datatypeId);
			addLiteralSt.setLong(3, labelHash);
			if (lang != null) {
				addLiteralSt.setString(4, lang);
			}
			else {
				addLiteralSt.setNull(4, _rdbms.LANGUAGE_TYPE);
			}
			addLiteralSt.setString(5, label);

			addLiteralSt.executeUpdate();

			newCount++;
		}
		rs.close();
		st.close();
		con.close();

		if (newCount > 0) {
			addLiteralCon.commit();
			_rdbms.optimizeTable(LITERALS_TABLE, newCount);
		}

		addLiteralSt.close();
		addLiteralCon.close();
	}

	/**
	 * Converts the resources and literals from the RAW_TRIPLES_TABLE to
	 * IDs and copies these rows to the ADDED_TRIPLES_TABLE.
	 **/
	protected void _copyRawTriplesToAddedTriples()
		throws SQLException
	{
		String subjLnamesAreNullOr = _rdbms.emptyStringIsNull() ? "rt.subjLname IS NULL AND r1.localname IS NULL OR "
				: "";
		String predLnamesAreNullOr = _rdbms.emptyStringIsNull() ? "rt.predLname IS NULL AND r2.localname IS NULL OR "
				: "";
		String objLnamesAreNullOr = _rdbms.emptyStringIsNull() ? "rt.objLname IS NULL AND r3.localname IS NULL OR "
				: "";
		String labelsAreNullOr = _rdbms.emptyStringIsNull() ? "rt.objLabel IS NULL AND l.label IS NULL OR "
				: "";

		// Case where object is a resource:
		_rdbms.executeUpdate("INSERT INTO " + ADDED_TRIPLES_TABLE + " "
				+ "SELECT rt.id, r1.id, r2.id, r3.id, " + _rdbms.TRUE + " "
				+ "FROM " + RAW_TRIPLES_TABLE + " rt, " + RESOURCES_TABLE + " r1, "
				+ RESOURCES_TABLE + " r2, " + RESOURCES_TABLE + " r3 " + "WHERE "
				+ "rt.objIsLiteral = " + _rdbms.FALSE + " AND " + // obj must be a resource

				"rt.subjNs = r1.namespace AND " + "(" + subjLnamesAreNullOr
				+ "rt.subjLname = r1.localname) AND " +

				"rt.predNs = r2.namespace AND " + "(" + predLnamesAreNullOr
				+ "rt.predLname = r2.localname) AND " +

				"rt.objNs = r3.namespace AND " + "(" + objLnamesAreNullOr
				+ "rt.objLname = r3.localname)");

		// Case where object is a literal:
		_rdbms.executeUpdate("INSERT INTO "
				+ ADDED_TRIPLES_TABLE
				+ " "
				+ "SELECT rt.id, r1.id, r2.id, l.id, "
				+ _rdbms.TRUE
				+ " "
				+ "FROM "
				+ RAW_TRIPLES_TABLE
				+ " rt, "
				+ RESOURCES_TABLE
				+ " r1, "
				+ RESOURCES_TABLE
				+ " r2, "
				+ LITERALS_TABLE
				+ " l, "
				+ RESOURCES_TABLE
				+ " r3 "
				+ "WHERE "
				+ "rt.objIsLiteral = "
				+ _rdbms.TRUE
				+ " AND "
				+ // obj must be a literal

				"rt.subjNs = r1.namespace AND "
				+ "("
				+ subjLnamesAreNullOr
				+ "rt.subjLname = r1.localname) AND "
				+

				"rt.predNs = r2.namespace AND "
				+ "("
				+ predLnamesAreNullOr
				+ "rt.predLname = r2.localname) AND "
				+

				"rt.objLabelHash = l.labelHash AND "
				+ "(rt.objLang IS NULL AND l.language IS NULL OR rt.objLang = l.language) AND "
				+ "(" + labelsAreNullOr + "rt.objLabel = l.label) AND "
				+ "l.datatype = r3.id AND " + "r3.namespace = rt.objNs AND " + "("
				+ objLnamesAreNullOr + "rt.objLname = r3.localname)");
	}

	/**
	 * Removes duplicate rows from the ADDED_TRIPLES_TABLE. Rows are duplicates
	 * if their subject, predicate and object are equal. The value of the
	 * <tt>id</tt> is ignored.
	 **/
	protected void _removeDuplicatesFromAddedTriples()
		throws SQLException
	{
		// Query for all IDs of 'duplicate' rows for which the 'original'
		// row's ID is smaller. This returns all IDs of duplicate rows,
		// except for the row with the lowest ID.
		Connection con = _rdbms.getConnection();
		java.sql.Statement st = con.createStatement();
		ResultSet rs = st.executeQuery("SELECT DISTINCT at2.id FROM "
				+ ADDED_TRIPLES_TABLE + " at1, " + ADDED_TRIPLES_TABLE + " at2 "
				+ "WHERE at1.subj = at2.subj " + "AND at1.pred = at2.pred "
				+ "AND at1.obj = at2.obj " + "AND at1.id < at2.id");

		String[] idChunks = _chunkIdSet(rs, 3500);
		rs.close();
		st.close();

		con.setAutoCommit(false);
		st = con.createStatement();

		for (int i = 0; i < idChunks.length; i++) {
			st.executeUpdate("DELETE FROM " + ADDED_TRIPLES_TABLE
					+ " WHERE id IN " + idChunks[i]);
		}

		con.commit();
		st.close();
		con.close();
	}

	/**
	 * Processes the triples from ADDED_TRIPLES_TABLE. This method copies
	 * all triples from ADDED_TRIPLES_TABLE that are not yet in
	 * TRIPLES_TABLE to NEW_TRIPLES_TABLE.
	 **/
	protected void _processAddedTriples()
		throws SQLException
	{
		_rdbms.executeUpdate("INSERT INTO " + NEW_TRIPLES_TABLE + " "
				+ "SELECT at.* " + "FROM " + ADDED_TRIPLES_TABLE + " at "
				+ "LEFT JOIN " + TRIPLES_TABLE + " t " + "ON at.subj = t.subj "
				+ "AND at.pred = t.pred " + "AND at.obj = t.obj "
				+ "WHERE t.subj IS NULL");

		_rdbms.clearTable(ADDED_TRIPLES_TABLE);

		_rdbms.optimizeTable(NEW_TRIPLES_TABLE);
	}

	/**
	 * This method is called when new statements have been added to, or some
	 * statements have been removed from this repository. The new statements
	 * are available for further processing by subclasses of this class in
	 * table NEW_TRIPLES_TABLE. This table will be cleared directly after the
	 * call to this method has returned.
	 **/
	protected void _processChangedTriples()
		throws SQLException
	{
		// Do nothing
	}

	public void clearRepository()
		throws SailUpdateException
	{
		if (!transactionStarted()) {
			throw new SailUpdateException("No transaction was started");
		}
		try {
			_rdbms.clearTable(ADDED_TRIPLES_TABLE);
			_rdbms.clearTable(NEW_TRIPLES_TABLE);
			_rdbms.clearTable(RAW_TRIPLES_TABLE);
			_rdbms.clearTable(EXPIRED_TRIPLES_TABLE);
			_rdbms.clearTable(EXPIRED_RESOURCES_TABLE);
			_rdbms.clearTable(EXPIRED_LITERALS_TABLE);

			_rdbms.clearTable(TRIPLES_TABLE);
			_rdbms.clearTable(LITERALS_TABLE);
			_rdbms.clearTable(RESOURCES_TABLE);
			_rdbms.clearTable(NAMESPACES_TABLE);

			// Reinsert the rows with ID 0 in the namespaces and resources table
			_rdbms.executeUpdate(
					"INSERT INTO " + NAMESPACES_TABLE +
					" VALUES(0, '', NULL, " + _rdbms.FALSE + ", " + _rdbms.FALSE + ")");

			_rdbms.executeUpdate(
					"INSERT INTO " + RESOURCES_TABLE +
					" VALUES(0, 0, '')");

			// Set the export status to 'up-to-date'
			_setExportStatusUpToDate(true);

			_initNamespaceCache();
			_setNextResourceId();
			_setNextLiteralId();
			_setNextStatementId();

			_updateBNodePrefix();

			_sailChangedEvent.setStatementsRemoved(true);
		}
		catch (SQLException e) {
			throw new SailInternalException(e);
		}
	}

	public void changeNamespacePrefix(String namespace, String prefix)
		throws SailUpdateException
	{
		if (!transactionStarted()) {
			throw new SailUpdateException("No transaction was started");
		}

		// Truncate prefix if it is too long
		if (prefix.length() > _rdbms.MAX_PREFIX_LENGTH) {
			ThreadLog.log("Prefix '" + prefix + "' too long, truncating it to "
					+ _rdbms.MAX_PREFIX_LENGTH + " characters");
			prefix = prefix.substring(0, _rdbms.MAX_PREFIX_LENGTH);
		}

		try {
			// Check if prefix is already used:
			RdbmsNamespace ns = _getNamespaceForPrefix(prefix);

			if (ns != null) {
				// prefix already in use

				if (ns.getName().equals(namespace)) {
					// identical mapping already exists
					return;
				}
				else {
					throw new SailUpdateException("Prefix '" + prefix
							+ "'is already used for another namespace");
				}
			}

			// Update the RDBMS.
			_rdbms.executeUpdate("UPDATE " + NAMESPACES_TABLE + " SET prefix = '"
					+ _rdbms.escapeString(prefix) + "'," + " userDefined = "
					+ _rdbms.TRUE + "," + " export = " + _rdbms.TRUE
					+ " WHERE name = '" + _rdbms.escapeString(namespace) + "'");

			// Update the cache
			ns = (RdbmsNamespace)_namespaceTable.get(namespace);
			if (ns != null) {
				ns.setPrefix(prefix);
				ns.setExported(true);
			}
		}
		catch (SQLException e) {
			throw new SailInternalException(e);
		}
	}

	/*-----------------------------------------+
	 | Methods for creating id's for namespaces |
	 +-----------------------------------------*/

	protected int _createIdForNamespace(String namespace) {
		int namespaceId = 0;

		if (namespace != null) {
			namespaceId = _getNamespaceId(namespace);

			if (namespaceId == 0) {
				// unknown namespace, create it.
				namespaceId = _addNamespace(namespace);
			}
		}

		return namespaceId;
	}

	private int _addNamespace(String namespace) {
		// Find an unused namespace prefix
		String prefix = null;
		int nsId = _getNextNamespaceId();

		while (true) {
			prefix = "ns" + nsId;
			Namespace ns = _getNamespaceForPrefix(prefix);

			if (ns == null) {
				// prefix not used yet
				break;
			}
			else {
				// prefix already used, try again
				nsId = _getNextNamespaceId();
			}
		}

		return _addNamespace(nsId, prefix, namespace);
	}

	private int _addNamespace(int nsId, String prefix, String namespace) {
		// Insert into namespaces table
		try {
			_rdbms.executeUpdate("INSERT INTO " + NAMESPACES_TABLE + " VALUES ("
					+ nsId + ", '" + _rdbms.escapeString(prefix) + "', '"
					+ _rdbms.escapeString(namespace) + "', " + _rdbms.FALSE + ", " + // userDefined
					_rdbms.FALSE + ")"); // export
		}
		catch (SQLException e) {
			throw new SailInternalException(e);
		}

		// Insert in local cache
		RdbmsNamespace ns = new RdbmsNamespace(nsId, prefix, namespace, false);
		_namespaceTable.put(namespace, ns);
		_namespaceList.add(ns);

		if (nsId >= _namespaceNames.length) {
			// Increase size of array
			int newLength = _namespaceNames.length * 2;
			newLength = Math.max(newLength, nsId + 1);

			String[] newArray = new String[newLength];
			System.arraycopy(_namespaceNames, 0, newArray, 0,
					_namespaceNames.length);
			_namespaceNames = newArray;
		}
		_namespaceNames[nsId] = namespace;

		return nsId;
	}

	/**
	 * Gets the RdbmsNamespace with the specified prefix.
	 * @return The requested RdbmsNamespace, or null if no such namespace could
	 * be found.
	 **/
	protected RdbmsNamespace _getNamespaceForPrefix(String prefix) {
		Iterator iter = _namespaceList.iterator();
		while (iter.hasNext()) {
			RdbmsNamespace ns = (RdbmsNamespace)iter.next();

			if (ns.getPrefix().equals(prefix)) {
				return ns;
			}
		}

		return null;
	}


	/* (non-Javadoc)
	 * @see org.openrdf.sesame.sail.RdfRepository#addListener(org.openrdf.sesame.sail.SailChangedListener)
	 */
	public void addListener(SailChangedListener listener) {
		synchronized(_sailChangedListeners) {
			_sailChangedListeners.add(listener);
		} // end synchronized block
	}

	/* (non-Javadoc)
	 * @see org.openrdf.sesame.sail.RdfRepository#removeListener(org.openrdf.sesame.sail.SailChangedListener)
	 */
	public void removeListener(SailChangedListener listener) {
		synchronized(_sailChangedListeners) {
			_sailChangedListeners.remove(listener);
		} // end synchronized block
	}

	protected void _notifySailChanged(SailChangedEventImpl event) {
		synchronized(_sailChangedListeners) {
			if (_sailChangedListeners.size() > 0) {
				if (event.sailChanged()) { // only notify if something actually changed
					Iterator listeners = _sailChangedListeners.iterator();

					while (listeners.hasNext()) {
						SailChangedListener listener = (SailChangedListener)listeners.next();
						listener.sailChanged(event);
					}
				}
			}
		} // end synchronized block
	}
}