Java tutorial
package org.apache.tika.parser.jdbc; /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import java.io.IOException; import java.io.InputStream; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.util.List; import java.util.Set; import org.apache.commons.io.IOExceptionWithCause; import org.apache.tika.exception.TikaException; import org.apache.tika.metadata.Database; import org.apache.tika.metadata.Metadata; import org.apache.tika.mime.MediaType; import org.apache.tika.parser.AbstractParser; import org.apache.tika.parser.ParseContext; import org.apache.tika.sax.XHTMLContentHandler; import org.xml.sax.ContentHandler; import org.xml.sax.SAXException; /** * Abstract class that handles iterating through tables within a database. */ abstract class AbstractDBParser extends AbstractParser { private final static byte[] EMPTY_BYTE_ARR = new byte[0]; private Connection connection; @Override public Set<MediaType> getSupportedTypes(ParseContext context) { return null; } @Override public void parse(InputStream stream, ContentHandler handler, Metadata metadata, ParseContext context) throws IOException, SAXException, TikaException { connection = getConnection(stream, metadata, context); XHTMLContentHandler xHandler = null; List<String> tableNames = null; try { tableNames = getTableNames(connection, metadata, context); } catch (SQLException e) { try { close(); } catch (SQLException sqlE) { //swallow } throw new IOExceptionWithCause(e); } for (String tableName : tableNames) { //add table names to parent metadata metadata.add(Database.TABLE_NAME, tableName); } xHandler = new XHTMLContentHandler(handler, metadata); xHandler.startDocument(); try { for (String tableName : tableNames) { JDBCTableReader tableReader = getTableReader(connection, tableName, context); xHandler.startElement("table", "name", tableReader.getTableName()); xHandler.startElement("thead"); xHandler.startElement("tr"); for (String header : tableReader.getHeaders()) { xHandler.startElement("th"); xHandler.characters(header); xHandler.endElement("th"); } xHandler.endElement("tr"); xHandler.endElement("thead"); xHandler.startElement("tbody"); while (tableReader.nextRow(xHandler, context)) { //no-op } xHandler.endElement("tbody"); xHandler.endElement("table"); } } finally { try { close(); } catch (IOException | SQLException e) { //swallow } if (xHandler != null) { xHandler.endDocument(); } } } /** * Override this for any special handling of closing the connection. * * @throws java.sql.SQLException * @throws java.io.IOException */ protected void close() throws SQLException, IOException { connection.close(); } /** * Override this for special configuration of the connection, such as limiting * the number of rows to be held in memory. * * @param stream stream to use * @param metadata metadata that could be used in parameterizing the connection * @param context parsecontext that could be used in parameterizing the connection * @return connection * @throws java.io.IOException * @throws org.apache.tika.exception.TikaException */ protected Connection getConnection(InputStream stream, Metadata metadata, ParseContext context) throws IOException, TikaException { String connectionString = getConnectionString(stream, metadata, context); Connection connection = null; try { Class.forName(getJDBCClassName()); } catch (ClassNotFoundException e) { throw new TikaException(e.getMessage()); } try { connection = DriverManager.getConnection(connectionString); } catch (SQLException e) { throw new IOExceptionWithCause(e); } return connection; } /** * Implement for db specific connection information, e.g. "jdbc:sqlite:/docs/mydb.db" * <p/> * Include any optimization settings, user name, password, etc. * <p/> * * @param stream stream for processing * @param metadata metadata might be useful in determining connection info * @param parseContext context to use to help create connectionString * @return connection string to be used by {@link #getConnection}. * @throws java.io.IOException */ abstract protected String getConnectionString(InputStream stream, Metadata metadata, ParseContext parseContext) throws IOException; /** * JDBC class name, e.g. org.sqlite.JDBC * * @return jdbc class name */ abstract protected String getJDBCClassName(); /** * Returns the names of the tables to process * * @param connection Connection to use to make the sql call(s) to get the names of the tables * @param metadata Metadata to use (potentially) in decision about which tables to extract * @param context ParseContext to use (potentially) in decision about which tables to extract * @return * @throws java.sql.SQLException */ abstract protected List<String> getTableNames(Connection connection, Metadata metadata, ParseContext context) throws SQLException; /** * Given a connection and a table name, return the JDBCTableReader for this db. * * @param connection * @param tableName * @return */ abstract protected JDBCTableReader getTableReader(Connection connection, String tableName, ParseContext parseContext); }