tables) {
switch (loginCredentials.getDbType()) {
case POSTGRESQL:
// Locking tables is not supported.
break;
case MYSQL:
executeStatement("UNLOCK TABLES");
break;
default:
throw createUnknownDbTypeException();
}
}
/**
* Gets the last inserted identity column value. This is a global value and may not work
* correctly if the database uses triggers.
*
* @return The last inserted identity column value.
*/
public long getLastInsertId() {
return identityValueLoader.getLastInsertId();
}
/**
* Gets the last retrieved sequence value. This is specific to the current connection only.
*
* @param sequenceName
* The name of the sequence.
* @return The last inserted identity column value.
*/
public long getLastSequenceId(String sequenceName) {
return identityValueLoader.getLastSequenceId(sequenceName);
}
/**
* Executes a sql statement against the database.
*
* @param sql The sql statement to be invoked.
*/
public void executeStatement(String sql) {
try {
if (statement != null) {
statement.close();
}
statement = getConnection().createStatement();
statement.execute(sql);
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to execute statement.", e);
}
}
/**
* Creates a new database prepared statement.
*
* @param sql
* The statement to be created.
* @return The newly created statement.
*/
public PreparedStatement prepareStatement(String sql) {
try {
PreparedStatement preparedStatement;
preparedStatement = getConnection().prepareStatement(sql);
return preparedStatement;
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to create database prepared statement.", e);
}
}
private void setStatementFetchSizeForStreaming(Statement streamingStatement) {
try {
switch (loginCredentials.getDbType()) {
case POSTGRESQL:
streamingStatement.setFetchSize(10000);
break;
case MYSQL:
streamingStatement.setFetchSize(Integer.MIN_VALUE);
break;
default:
throw createUnknownDbTypeException();
}
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to update statement fetch size.", e);
}
}
/**
* Creates a new database statement that is configured so that any result sets created using it
* will stream data from the database instead of returning all records at once and storing in
* memory.
*
* If no input parameters need to be set on the statement, use the executeStreamingQuery method
* instead.
*
* @param sql
* The statement to be created. This must be a select statement.
* @return The newly created statement.
*/
public PreparedStatement prepareStatementForStreaming(String sql) {
try {
PreparedStatement newStatement;
// Create a statement for returning streaming results.
newStatement = getConnection().prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY,
ResultSet.CONCUR_READ_ONLY);
setStatementFetchSizeForStreaming(newStatement);
return newStatement;
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to create streaming resultset statement.", e);
}
}
/**
* Executes a query and returns a result set. The returned result set must be closed by the
* caller.
*
* @param sql The query to execute.
* @return The newly created result set.
*/
public ResultSet executeQuery(String sql) {
try {
ResultSet resultSet;
LOG.finest("Executing query {" + sql + "}");
if (statement != null) {
statement.close();
}
statement = getConnection().createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
setStatementFetchSizeForStreaming(statement);
resultSet = statement.executeQuery(sql);
return resultSet;
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to create resultset.", e);
}
}
/**
* Commits any outstanding transaction.
*/
public void commit() {
if (connection != null) {
try {
connection.commit();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to commit changes.", e);
}
}
}
/**
* Releases all database resources. This method is guaranteed not to throw transactions and
* should always be called in a finally block whenever this class is used.
*
* @deprecated Use {@link #close()} instead.
*/
@Deprecated
public void release() {
close();
}
/**
* Releases all database resources. This method is guaranteed not to throw transactions and
* should always be called in a finally or try-with-resources block whenever this class is used.
*/
public void close() {
identityValueLoader.close();
if (statement != null) {
try {
statement.close();
} catch (SQLException e) {
// We cannot throw an exception within a release statement.
LOG.log(Level.WARNING, "Unable to close existing statement.", e);
}
statement = null;
}
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
// We cannot throw an exception within a release statement.
LOG.log(Level.WARNING, "Unable to close database connection.", e);
}
connection = null;
}
}
/**
* Sets the auto-commit property on the underlying connection.
*
* @param autoCommit The new auto commit value.
*/
public void setAutoCommit(boolean autoCommit) {
if (connection != null) {
try {
LOG.finest("Setting auto commit to " + autoCommit + ".");
connection.setAutoCommit(autoCommit);
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to commit changes.", e);
}
}
this.autoCommit = autoCommit;
}
/**
* Indicates if the specified column exists in the database.
*
* @param tableName The table to check for.
* @param columnName The column to check for.
* @return True if the column exists, false otherwise.
*/
public boolean doesColumnExist(String tableName, String columnName) {
LOG.finest("Checking if column {" + columnName + "} in table {" + tableName + "} exists.");
try (ResultSet resultSet = getConnection().getMetaData().getColumns(null, null, tableName, columnName)) {
return resultSet.next();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to check for the existence of column " + tableName + "."
+ columnName + ".", e);
}
}
/**
* Indicates if the specified table exists in the database.
*
* @param tableName The table to check for.
* @return True if the table exists, false otherwise.
*/
public boolean doesTableExist(String tableName) {
try (ResultSet resultSet =
getConnection().getMetaData().getTables(null, null, tableName, new String[] {"TABLE"})) {
LOG.finest("Checking if table {" + tableName + "} exists.");
return resultSet.next();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to check for the existence of table " + tableName + ".", e);
}
}
}
DatabaseContext2.java 0000664 0000000 0000000 00000023215 14532772205 0034160 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/common // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.common;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.dbcp.BasicDataSource;
import org.openstreetmap.osmosis.core.OsmosisRuntimeException;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.DatabaseType;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.DataSourceUtils;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;
/**
* This class manages the lifecycle of JDBC objects to minimise the risk of connection leaks and to
* support a consistent approach to database access.
*
* @author Brett Henderson
*/
public class DatabaseContext2 implements AutoCloseable {
private static final Logger LOG = Logger.getLogger(DatabaseContext.class.getName());
private BasicDataSource dataSource;
private PlatformTransactionManager txnManager;
private TransactionTemplate txnTemplate;
private JdbcTemplate jdbcTemplate;
private DatabaseType dbType;
private IdentityValueLoader identityValueLoader;
/**
* Creates a new instance.
*
* @param loginCredentials Contains all information required to connect to the database.
*/
public DatabaseContext2(DatabaseLoginCredentials loginCredentials) {
dataSource = DataSourceFactory.createDataSource(loginCredentials);
txnManager = new DataSourceTransactionManager(dataSource);
txnTemplate = new TransactionTemplate(txnManager);
jdbcTemplate = new JdbcTemplate(dataSource);
this.dbType = loginCredentials.getDbType();
setStatementFetchSizeForStreaming();
switch (loginCredentials.getDbType()) {
case POSTGRESQL:
identityValueLoader = new PostgresqlIdentityValueLoader2(this);
break;
case MYSQL:
identityValueLoader = new MysqlIdentityValueLoader2(this);
break;
default:
throw createUnknownDbTypeException();
}
}
private OsmosisRuntimeException createUnknownDbTypeException() {
return new OsmosisRuntimeException("Unknown database type " + dbType + ".");
}
/**
* Gets the jdbc template which provides access to database functions.
*
* @return The jdbc template.
*/
public JdbcTemplate getJdbcTemplate() {
return jdbcTemplate;
}
/**
* Invokes the provided callback code within a transaction.
*
* @param txnCallback
* The logic to be invoked within a transaction.
* @param
* The return type of the transaction callback.
*
* @return The result.
*/
public Object executeWithinTransaction(TransactionCallback txnCallback) {
return txnTemplate.execute(txnCallback);
}
/**
* Returns the database type currently in use. This should only be used when it is not possible
* to write database agnostic statements.
*
* @return The database type.
*/
public DatabaseType getDatabaseType() {
return dbType;
}
private void setStatementFetchSizeForStreaming() {
switch (dbType) {
case POSTGRESQL:
jdbcTemplate.setFetchSize(10000);
break;
case MYSQL:
jdbcTemplate.setFetchSize(Integer.MIN_VALUE);
break;
default:
throw createUnknownDbTypeException();
}
}
/**
* Truncates the contents of the specified tables.
*
* @param tables
* The tables to be truncated.
*/
public void truncateTables(List tables) {
switch (dbType) {
case POSTGRESQL:
StringBuilder statementBuilder = new StringBuilder();
for (String table : tables) {
if (statementBuilder.length() == 0) {
statementBuilder.append("TRUNCATE ");
} else {
statementBuilder.append(", ");
}
statementBuilder.append(table);
}
jdbcTemplate.update(statementBuilder.toString());
break;
case MYSQL:
for (String table : tables) {
jdbcTemplate.update("TRUNCATE " + table);
}
break;
default:
throw createUnknownDbTypeException();
}
}
/**
* Disables the indexes of the specified tables.
*
* @param tables
* The tables to disable indexes on.
*/
public void disableIndexes(List tables) {
switch (dbType) {
case POSTGRESQL:
// There is no way to automatically disable all indexes for a table.
break;
case MYSQL:
for (String table : tables) {
jdbcTemplate.update("ALTER TABLE " + table + " DISABLE KEYS");
}
break;
default:
throw createUnknownDbTypeException();
}
}
/**
* Enables the indexes of the specified tables.
*
* @param tables
* The tables to enable indexes on.
*/
public void enableIndexes(List tables) {
switch (dbType) {
case POSTGRESQL:
// There is no way to automatically disable all indexes for a table.
break;
case MYSQL:
for (String table : tables) {
jdbcTemplate.update("ALTER TABLE " + table + " ENABLE KEYS");
}
break;
default:
throw createUnknownDbTypeException();
}
}
/**
* Locks the specified tables for exclusive access.
*
* @param tables
* The tables to lock.
*/
public void lockTables(List tables) {
switch (dbType) {
case POSTGRESQL:
// Locking tables is not supported.
break;
case MYSQL:
StringBuilder statementBuilder = new StringBuilder();
for (String table : tables) {
if (statementBuilder.length() == 0) {
statementBuilder.append("LOCK TABLES ");
} else {
statementBuilder.append(", ");
}
statementBuilder.append(table);
statementBuilder.append(" WRITE");
}
jdbcTemplate.update(statementBuilder.toString());
break;
default:
throw createUnknownDbTypeException();
}
}
/**
* Unlocks the specified tables.
*
* @param tables
* The tables to unlock.
*/
public void unlockTables(List tables) {
switch (dbType) {
case POSTGRESQL:
// Locking tables is not supported.
break;
case MYSQL:
jdbcTemplate.update("UNLOCK TABLES");
break;
default:
throw createUnknownDbTypeException();
}
}
/**
* Gets the last inserted identity column value. This is a global value and may not work
* correctly if the database uses triggers.
*
* @return The last inserted identity column value.
*/
public long getLastInsertId() {
return identityValueLoader.getLastInsertId();
}
/**
* Gets the last retrieved sequence value. This is specific to the current connection only.
*
* @param sequenceName
* The name of the sequence.
* @return The last inserted identity column value.
*/
public long getLastSequenceId(String sequenceName) {
return identityValueLoader.getLastSequenceId(sequenceName);
}
/**
* Releases all database resources. This method is guaranteed not to throw transactions and
* should always be called in a finally block whenever this class is used.
*
* @deprecated Use {@link #close()} instead.
*/
@Deprecated
public void release() {
close();
}
/**
* Releases all database resources. This method is guaranteed not to throw transactions and
* should always be called in a finally or try-with-resources block whenever this class is used.
*/
public void close() {
identityValueLoader.close();
try {
dataSource.close();
} catch (SQLException e) {
LOG.log(Level.WARNING, "Unable to cleanup the database connection pool.", e);
}
}
/**
* Indicates if the specified column exists in the database.
*
* @param tableName The table to check for.
* @param columnName The column to check for.
* @return True if the column exists, false otherwise.
*/
public boolean doesColumnExist(String tableName, String columnName) {
Connection connection;
LOG.finest("Checking if column {" + columnName + "} in table {" + tableName + "} exists.");
connection = DataSourceUtils.getConnection(dataSource);
try {
try (ResultSet resultSet = connection.getMetaData().getColumns(null, null, tableName, columnName)) {
return resultSet.next();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to check for the existence of column " + tableName + "."
+ columnName + ".", e);
}
} finally {
DataSourceUtils.releaseConnection(connection, dataSource);
}
}
/**
* Indicates if the specified table exists in the database.
*
* @param tableName The table to check for.
* @return True if the table exists, false otherwise.
*/
public boolean doesTableExist(String tableName) {
Connection connection;
LOG.finest("Checking if table {" + tableName + "} exists.");
connection = DataSourceUtils.getConnection(dataSource);
try (ResultSet resultSet =
connection.getMetaData().getTables(null, null, tableName, new String[] {"TABLE"})) {
return resultSet.next();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to check for the existence of table " + tableName + ".", e);
} finally {
DataSourceUtils.releaseConnection(connection, dataSource);
}
}
}
IdentityValueLoader.java 0000664 0000000 0000000 00000001661 14532772205 0034743 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/common // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.common;
import org.openstreetmap.osmosis.core.lifecycle.Closeable;
/**
* Retrieves last inserted identity columns. This examines global connection values and may not work
* correctly if the database uses triggers. It will however work correctly in a multi-threaded
* environment.
*
* @author Brett Henderson
*/
public interface IdentityValueLoader extends Closeable {
/**
* Returns the id of the most recently inserted row on the current
* connection.
*
* @return The newly inserted id.
*/
long getLastInsertId();
/**
* Returns the most recently returned value from the specified sequence on the current
* connection.
*
* @param sequenceName
* The name of the sequence to query.
* @return The most recent sequence id.
*/
long getLastSequenceId(String sequenceName);
}
MysqlIdentityValueLoader.java 0000664 0000000 0000000 00000003621 14532772205 0035767 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/common // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.common;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.openstreetmap.osmosis.core.OsmosisRuntimeException;
import org.openstreetmap.osmosis.core.database.ReleasableStatementContainer;
/**
* Mysql implementation of an identity value loader.
*
* @author Brett Henderson
*/
public class MysqlIdentityValueLoader implements IdentityValueLoader {
private static final String SQL_SELECT_LAST_INSERT_ID =
"SELECT LAST_INSERT_ID() AS lastInsertId FROM DUAL";
private DatabaseContext dbCtx;
private ReleasableStatementContainer statementContainer;
private PreparedStatement selectInsertIdStatement;
/**
* Creates a new instance.
*
* @param dbCtx
* The database context to use for all database access.
*/
public MysqlIdentityValueLoader(DatabaseContext dbCtx) {
this.dbCtx = dbCtx;
statementContainer = new ReleasableStatementContainer();
}
/**
* Returns the id of the most recently inserted row on the current
* connection.
*
* @return The newly inserted id.
*/
public long getLastInsertId() {
if (selectInsertIdStatement == null) {
selectInsertIdStatement = statementContainer.add(dbCtx
.prepareStatementForStreaming(SQL_SELECT_LAST_INSERT_ID));
}
try (ResultSet lastInsertQuery = selectInsertIdStatement.executeQuery()) {
lastInsertQuery.next();
return lastInsertQuery.getLong("lastInsertId");
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to retrieve the id of the newly inserted record.", e);
}
}
/**
* {@inheritDoc}
*/
@Override
public long getLastSequenceId(String sequenceName) {
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*/
@Override
public void close() {
statementContainer.close();
}
}
MysqlIdentityValueLoader2.java 0000664 0000000 0000000 00000002336 14532772205 0036053 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/common // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.common;
import java.util.Objects;
/**
* Mysql implementation of an identity value loader.
*
* @author Brett Henderson
*/
public class MysqlIdentityValueLoader2 implements IdentityValueLoader {
private static final String SQL_SELECT_LAST_INSERT_ID =
"SELECT LAST_INSERT_ID() AS lastInsertId FROM DUAL";
private DatabaseContext2 dbCtx;
/**
* Creates a new instance.
*
* @param dbCtx
* The database context to use for all database access.
*/
public MysqlIdentityValueLoader2(DatabaseContext2 dbCtx) {
this.dbCtx = dbCtx;
}
/**
* Returns the id of the most recently inserted row on the current
* connection.
*
* @return The newly inserted id.
*/
public long getLastInsertId() {
return Objects.requireNonNull(
dbCtx.getJdbcTemplate().queryForObject(SQL_SELECT_LAST_INSERT_ID, Long.class),
"Last insert ID was not found"
);
}
/**
* {@inheritDoc}
*/
@Override
public long getLastSequenceId(String sequenceName) {
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*/
@Override
public void close() {
// Do nothing.
}
}
PostgresqlIdentityValueLoader.java 0000664 0000000 0000000 00000005036 14532772205 0037027 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/common // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.common;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.openstreetmap.osmosis.core.OsmosisRuntimeException;
import org.openstreetmap.osmosis.core.database.ReleasableStatementContainer;
/**
* Postgresql implementation of an identity value loader.
*
* @author Brett Henderson
*/
public class PostgresqlIdentityValueLoader implements IdentityValueLoader {
private static final String SQL_SELECT_LAST_INSERT_ID =
"SELECT lastval() AS lastInsertId";
private static final String SQL_SELECT_LAST_SEQUENCE_ID =
"SELECT currval(?) AS lastSequenceId";
private DatabaseContext dbCtx;
private ReleasableStatementContainer statementContainer;
private PreparedStatement selectInsertIdStatement;
private PreparedStatement selectSequenceIdStatement;
/**
* Creates a new instance.
*
* @param dbCtx
* The database context to use for all database access.
*/
public PostgresqlIdentityValueLoader(DatabaseContext dbCtx) {
this.dbCtx = dbCtx;
statementContainer = new ReleasableStatementContainer();
}
/**
* Returns the id of the most recently inserted row on the current
* connection.
*
* @return The newly inserted id.
*/
public long getLastInsertId() {
if (selectInsertIdStatement == null) {
selectInsertIdStatement =
statementContainer.add(dbCtx.prepareStatementForStreaming(SQL_SELECT_LAST_INSERT_ID));
}
try (ResultSet lastInsertQuery = selectInsertIdStatement.executeQuery()) {
lastInsertQuery.next();
return lastInsertQuery.getLong("lastInsertId");
} catch (SQLException e) {
throw new OsmosisRuntimeException(
"Unable to retrieve the id of the newly inserted record.",
e
);
}
}
/**
* {@inheritDoc}
*/
@Override
public long getLastSequenceId(String sequenceName) {
if (selectSequenceIdStatement == null) {
selectSequenceIdStatement =
statementContainer.add(dbCtx.prepareStatementForStreaming(SQL_SELECT_LAST_SEQUENCE_ID));
}
try {
selectSequenceIdStatement.setString(1, sequenceName);
try (ResultSet lastSequenceQuery = selectSequenceIdStatement.executeQuery()) {
lastSequenceQuery.next();
return lastSequenceQuery.getLong("lastSequenceId");
}
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to retrieve the last sequence id.", e);
}
}
/**
* {@inheritDoc}
*/
@Override
public void close() {
statementContainer.close();
}
}
PostgresqlIdentityValueLoader2.java 0000664 0000000 0000000 00000002573 14532772205 0037114 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/common // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.common;
import java.util.Objects;
/**
* Postgresql implementation of an identity value loader.
*
* @author Brett Henderson
*/
public class PostgresqlIdentityValueLoader2 implements IdentityValueLoader {
private static final String SQL_SELECT_LAST_INSERT_ID =
"SELECT lastval() AS lastInsertId";
private static final String SQL_SELECT_LAST_SEQUENCE_ID =
"SELECT currval(?) AS lastSequenceId";
private DatabaseContext2 dbCtx;
/**
* Creates a new instance.
*
* @param dbCtx
* The database context to use for all database access.
*/
public PostgresqlIdentityValueLoader2(DatabaseContext2 dbCtx) {
this.dbCtx = dbCtx;
}
/**
* Returns the id of the most recently inserted row on the current
* connection.
*
* @return The newly inserted id.
*/
public long getLastInsertId() {
return Objects.requireNonNull(
dbCtx.getJdbcTemplate().queryForObject(SQL_SELECT_LAST_INSERT_ID, Long.class),
"Last insert ID was not found"
);
}
/**
* {@inheritDoc}
*/
@Override
public long getLastSequenceId(String sequenceName) {
return dbCtx.getJdbcTemplate().queryForObject(SQL_SELECT_LAST_SEQUENCE_ID, Long.class, sequenceName);
}
/**
* {@inheritDoc}
*/
@Override
public void close() {
// Do nothing.
}
}
osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/ 0000775 0000000 0000000 00000000000 14532772205 0027520 5 ustar 00root root 0000000 0000000 ApidbChangeReader.java 0000664 0000000 0000000 00000010056 14532772205 0033556 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
import java.util.Collections;
import java.util.Date;
import org.openstreetmap.osmosis.apidb.common.DatabaseContext2;
import org.openstreetmap.osmosis.apidb.v0_6.impl.AllEntityDao;
import org.openstreetmap.osmosis.apidb.v0_6.impl.DeltaToDiffReader;
import org.openstreetmap.osmosis.apidb.v0_6.impl.SchemaVersionValidator;
import org.openstreetmap.osmosis.core.container.v0_6.ChangeContainer;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.DatabasePreferences;
import org.openstreetmap.osmosis.core.lifecycle.ReleasableIterator;
import org.openstreetmap.osmosis.core.task.v0_6.ChangeSink;
import org.openstreetmap.osmosis.core.task.v0_6.RunnableChangeSource;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
/**
* A change source reading from database history tables. This aims to be suitable for running at
* regular intervals with database overhead proportional to changeset size.
*
* @author Brett Henderson
*/
public class ApidbChangeReader implements RunnableChangeSource {
private ChangeSink changeSink;
private DatabaseLoginCredentials loginCredentials;
private DatabasePreferences preferences;
private Date intervalBegin;
private Date intervalEnd;
private boolean fullHistory;
/**
* Creates a new instance.
*
* @param loginCredentials
* Contains all information required to connect to the database.
* @param preferences
* Contains preferences configuring database behaviour.
* @param intervalBegin
* Marks the beginning (inclusive) of the time interval to be checked.
* @param intervalEnd
* Marks the end (exclusive) of the time interval to be checked.
* @param fullHistory
* Specifies if full version history should be returned, or just a single change per
* entity for the interval.
*/
public ApidbChangeReader(DatabaseLoginCredentials loginCredentials, DatabasePreferences preferences,
Date intervalBegin, Date intervalEnd, boolean fullHistory) {
this.loginCredentials = loginCredentials;
this.preferences = preferences;
this.intervalBegin = intervalBegin;
this.intervalEnd = intervalEnd;
this.fullHistory = fullHistory;
}
/**
* {@inheritDoc}
*/
public void setChangeSink(ChangeSink changeSink) {
this.changeSink = changeSink;
}
/**
* Runs the task implementation. This is called by the run method within a transaction.
*
* @param dbCtx
* Used to access the database.
*/
protected void runImpl(DatabaseContext2 dbCtx) {
try {
changeSink.initialize(Collections.emptyMap());
new SchemaVersionValidator(loginCredentials, preferences)
.validateVersion(ApidbVersionConstants.SCHEMA_MIGRATIONS);
try (ReleasableIterator i = getHistory(dbCtx)) {
while (i.hasNext()) {
changeSink.process(i.next());
}
}
changeSink.complete();
} finally {
changeSink.close();
}
}
private ReleasableIterator getHistory(DatabaseContext2 dbCtx) {
AllEntityDao entityDao = new AllEntityDao(dbCtx.getJdbcTemplate());
ReleasableIterator reader = entityDao.getHistory(intervalBegin, intervalEnd);
if (fullHistory) {
return reader;
} else {
return new DeltaToDiffReader(reader);
}
}
/**
* Reads all data from the database and send it to the sink.
*/
public void run() {
try (DatabaseContext2 dbCtx = new DatabaseContext2(loginCredentials)) {
dbCtx.executeWithinTransaction(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus arg0) {
runImpl(dbCtx);
} });
}
}
}
ApidbChangeReaderFactory.java 0000664 0000000 0000000 00000003554 14532772205 0035113 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
import java.util.Date;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.DatabasePreferences;
import org.openstreetmap.osmosis.core.database.DatabaseTaskManagerFactory;
import org.openstreetmap.osmosis.core.pipeline.common.TaskConfiguration;
import org.openstreetmap.osmosis.core.pipeline.common.TaskManager;
import org.openstreetmap.osmosis.core.pipeline.v0_6.RunnableChangeSourceManager;
/**
* The task manager factory for a database change reader.
*
* @author Brett Henderson
*/
public class ApidbChangeReaderFactory extends DatabaseTaskManagerFactory {
private static final String ARG_INTERVAL_BEGIN = "intervalBegin";
private static final String ARG_INTERVAL_END = "intervalEnd";
private static final String ARG_READ_FULL_HISTORY = "readFullHistory";
private static final boolean DEFAULT_READ_FULL_HISTORY = false;
/**
* {@inheritDoc}
*/
@Override
protected TaskManager createTaskManagerImpl(TaskConfiguration taskConfig) {
DatabaseLoginCredentials loginCredentials;
DatabasePreferences preferences;
Date intervalBegin;
Date intervalEnd;
boolean fullHistory;
// Get the task arguments.
loginCredentials = getDatabaseLoginCredentials(taskConfig);
preferences = getDatabasePreferences(taskConfig);
intervalBegin = getDateArgument(taskConfig, ARG_INTERVAL_BEGIN, new Date(0));
intervalEnd = getDateArgument(taskConfig, ARG_INTERVAL_END, new Date());
fullHistory = getBooleanArgument(taskConfig, ARG_READ_FULL_HISTORY, DEFAULT_READ_FULL_HISTORY);
return new RunnableChangeSourceManager(
taskConfig.getId(),
new ApidbChangeReader(loginCredentials, preferences, intervalBegin, intervalEnd, fullHistory),
taskConfig.getPipeArgs()
);
}
}
ApidbChangeWriter.java 0000664 0000000 0000000 00000006307 14532772205 0033634 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
import java.util.HashMap;
import java.util.Map;
import org.openstreetmap.osmosis.core.OsmosisRuntimeException;
import org.openstreetmap.osmosis.apidb.v0_6.impl.ActionChangeWriter;
import org.openstreetmap.osmosis.apidb.v0_6.impl.ChangeWriter;
import org.openstreetmap.osmosis.apidb.v0_6.impl.SchemaVersionValidator;
import org.openstreetmap.osmosis.core.container.v0_6.ChangeContainer;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.DatabasePreferences;
import org.openstreetmap.osmosis.core.task.common.ChangeAction;
import org.openstreetmap.osmosis.core.task.v0_6.ChangeSink;
/**
* A change sink writing to database tables. This aims to be suitable for running at regular
* intervals with database overhead proportional to changeset size.
*
* @author Brett Henderson
*/
public class ApidbChangeWriter implements ChangeSink {
private final ChangeWriter changeWriter;
private final Map actionWriterMap;
private final SchemaVersionValidator schemaVersionValidator;
/**
* Creates a new instance.
*
* @param loginCredentials Contains all information required to connect to the database.
* @param preferences Contains preferences configuring database behaviour.
* @param populateCurrentTables If true, the current tables will be populated as well as history
* tables.
*/
public ApidbChangeWriter(DatabaseLoginCredentials loginCredentials, DatabasePreferences preferences,
boolean populateCurrentTables) {
changeWriter = new ChangeWriter(loginCredentials, populateCurrentTables);
actionWriterMap = new HashMap();
actionWriterMap.put(ChangeAction.Create, new ActionChangeWriter(changeWriter, ChangeAction.Create));
actionWriterMap.put(ChangeAction.Modify, new ActionChangeWriter(changeWriter, ChangeAction.Modify));
actionWriterMap.put(ChangeAction.Delete, new ActionChangeWriter(changeWriter, ChangeAction.Delete));
schemaVersionValidator = new SchemaVersionValidator(loginCredentials, preferences);
}
/**
* {@inheritDoc}
*/
public void initialize(Map metaData) {
// Do nothing.
}
/**
* {@inheritDoc}
*/
public void process(ChangeContainer change) {
ChangeAction action;
// Verify that the schema version is supported.
schemaVersionValidator.validateVersion(ApidbVersionConstants.SCHEMA_MIGRATIONS);
action = change.getAction();
if (!actionWriterMap.containsKey(action)) {
throw new OsmosisRuntimeException("The action " + action + " is unrecognized.");
}
// Process the entity using the action writer appropriate for the change
// action.
change.getEntityContainer().process(actionWriterMap.get(action));
}
/**
* {@inheritDoc}
*/
public void complete() {
changeWriter.complete();
}
/**
* {@inheritDoc}
*/
public void close() {
changeWriter.close();
}
}
ApidbChangeWriterFactory.java 0000664 0000000 0000000 00000003056 14532772205 0035162 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.DatabasePreferences;
import org.openstreetmap.osmosis.core.database.DatabaseTaskManagerFactory;
import org.openstreetmap.osmosis.core.pipeline.common.TaskConfiguration;
import org.openstreetmap.osmosis.core.pipeline.common.TaskManager;
import org.openstreetmap.osmosis.core.pipeline.v0_6.ChangeSinkManager;
/**
* The task manager factory for a database change writer.
*
* @author Brett Henderson
*/
public class ApidbChangeWriterFactory extends DatabaseTaskManagerFactory {
private static final String ARG_POPULATE_CURRENT_TABLES = "populateCurrentTables";
private static final boolean DEFAULT_POPULATE_CURRENT_TABLES = true;
/**
* {@inheritDoc}
*/
@Override
protected TaskManager createTaskManagerImpl(TaskConfiguration taskConfig) {
DatabaseLoginCredentials loginCredentials;
DatabasePreferences preferences;
boolean populateCurrentTables;
// Get the task arguments.
loginCredentials = getDatabaseLoginCredentials(taskConfig);
preferences = getDatabasePreferences(taskConfig);
populateCurrentTables = getBooleanArgument(
taskConfig, ARG_POPULATE_CURRENT_TABLES, DEFAULT_POPULATE_CURRENT_TABLES);
return new ChangeSinkManager(
taskConfig.getId(),
new ApidbChangeWriter(
loginCredentials,
preferences,
populateCurrentTables
),
taskConfig.getPipeArgs()
);
}
}
ApidbCurrentReader.java 0000664 0000000 0000000 00000006374 14532772205 0034023 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
import java.util.Collections;
import org.openstreetmap.osmosis.core.OsmosisConstants;
import org.openstreetmap.osmosis.apidb.common.DatabaseContext2;
import org.openstreetmap.osmosis.apidb.v0_6.impl.AllEntityDao;
import org.openstreetmap.osmosis.apidb.v0_6.impl.SchemaVersionValidator;
import org.openstreetmap.osmosis.core.container.v0_6.BoundContainer;
import org.openstreetmap.osmosis.core.container.v0_6.EntityContainer;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.DatabasePreferences;
import org.openstreetmap.osmosis.core.domain.v0_6.Bound;
import org.openstreetmap.osmosis.core.lifecycle.ReleasableIterator;
import org.openstreetmap.osmosis.core.task.v0_6.RunnableSource;
import org.openstreetmap.osmosis.core.task.v0_6.Sink;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
/**
* An OSM data source reading from a databases current tables. The entire contents of the database
* are read.
*
* @author Brett Henderson
*/
public class ApidbCurrentReader implements RunnableSource {
private Sink sink;
private DatabaseLoginCredentials loginCredentials;
private DatabasePreferences preferences;
/**
* Creates a new instance.
*
* @param loginCredentials
* Contains all information required to connect to the database.
* @param preferences
* Contains preferences configuring database behaviour.
*/
public ApidbCurrentReader(DatabaseLoginCredentials loginCredentials, DatabasePreferences preferences) {
this.loginCredentials = loginCredentials;
this.preferences = preferences;
}
/**
* {@inheritDoc}
*/
public void setSink(Sink sink) {
this.sink = sink;
}
/**
* Runs the task implementation. This is called by the run method within a transaction.
*
* @param dbCtx
* Used to access the database.
*/
protected void runImpl(DatabaseContext2 dbCtx) {
try {
AllEntityDao entityDao;
sink.initialize(Collections.emptyMap());
new SchemaVersionValidator(loginCredentials, preferences)
.validateVersion(ApidbVersionConstants.SCHEMA_MIGRATIONS);
entityDao = new AllEntityDao(dbCtx.getJdbcTemplate());
sink.process(new BoundContainer(new Bound("Osmosis " + OsmosisConstants.VERSION)));
try (ReleasableIterator reader = entityDao.getCurrent()) {
while (reader.hasNext()) {
sink.process(reader.next());
}
}
sink.complete();
} finally {
sink.close();
}
}
/**
* Reads all data from the database and send it to the sink.
*/
public void run() {
try (DatabaseContext2 dbCtx = new DatabaseContext2(loginCredentials)) {
dbCtx.executeWithinTransaction(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus arg0) {
runImpl(dbCtx);
} });
}
}
}
ApidbCurrentReaderFactory.java 0000664 0000000 0000000 00000002317 14532772205 0035344 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.DatabasePreferences;
import org.openstreetmap.osmosis.core.database.DatabaseTaskManagerFactory;
import org.openstreetmap.osmosis.core.pipeline.common.TaskConfiguration;
import org.openstreetmap.osmosis.core.pipeline.common.TaskManager;
import org.openstreetmap.osmosis.core.pipeline.v0_6.RunnableSourceManager;
/**
* The task manager factory for a database reader.
*
* @author Brett Henderson
*/
public class ApidbCurrentReaderFactory extends DatabaseTaskManagerFactory {
/**
* {@inheritDoc}
*/
@Override
protected TaskManager createTaskManagerImpl(TaskConfiguration taskConfig) {
DatabaseLoginCredentials loginCredentials;
DatabasePreferences preferences;
// Get the task arguments.
loginCredentials = getDatabaseLoginCredentials(taskConfig);
preferences = getDatabasePreferences(taskConfig);
return new RunnableSourceManager(
taskConfig.getId(),
new ApidbCurrentReader(loginCredentials, preferences),
taskConfig.getPipeArgs()
);
}
}
ApidbFileReplicator.java 0000664 0000000 0000000 00000006611 14532772205 0034154 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
import org.openstreetmap.osmosis.apidb.common.DatabaseContext2;
import org.openstreetmap.osmosis.apidb.v0_6.impl.AllEntityDao;
import org.openstreetmap.osmosis.apidb.v0_6.impl.ReplicationSource;
import org.openstreetmap.osmosis.apidb.v0_6.impl.Replicator;
import org.openstreetmap.osmosis.apidb.v0_6.impl.SchemaVersionValidator;
import org.openstreetmap.osmosis.apidb.v0_6.impl.SystemTimeLoader;
import org.openstreetmap.osmosis.apidb.v0_6.impl.TimeDao;
import org.openstreetmap.osmosis.apidb.v0_6.impl.TransactionDao;
import org.openstreetmap.osmosis.apidb.v0_6.impl.TransactionManager;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.DatabasePreferences;
import org.openstreetmap.osmosis.core.task.v0_6.ChangeSink;
import org.openstreetmap.osmosis.core.task.v0_6.RunnableChangeSource;
/**
* Performs replication from an API database into change files.
*/
public class ApidbFileReplicator implements RunnableChangeSource {
private DatabaseLoginCredentials loginCredentials;
private DatabasePreferences preferences;
private int iterations;
private int minInterval;
private int maxInterval;
private ChangeSink changeSink;
/**
* Creates a new instance.
*
* @param loginCredentials
* Contains all information required to connect to the database.
* @param preferences
* Contains preferences configuring database behaviour.
* @param iterations
* The number of replication intervals to execute. 0 means
* infinite.
* @param minInterval
* The minimum number of milliseconds between intervals.
* @param maxInterval
* The maximum number of milliseconds between intervals if no new
* data is available. This isn't a hard limit because proces
*/
public ApidbFileReplicator(DatabaseLoginCredentials loginCredentials, DatabasePreferences preferences,
int iterations, int minInterval, int maxInterval) {
this.loginCredentials = loginCredentials;
this.preferences = preferences;
this.iterations = iterations;
this.minInterval = minInterval;
this.maxInterval = maxInterval;
}
/**
* {@inheritDoc}
*/
@Override
public void setChangeSink(ChangeSink changeSink) {
this.changeSink = changeSink;
}
/**
* Runs the task implementation. This is called by the run method within a transaction.
*
* @param dbCtx
* Used to access the database.
*/
protected void runImpl(DatabaseContext2 dbCtx) {
Replicator replicator;
ReplicationSource source;
TransactionManager txnSnapshotLoader;
SystemTimeLoader systemTimeLoader;
new SchemaVersionValidator(loginCredentials, preferences)
.validateVersion(ApidbVersionConstants.SCHEMA_MIGRATIONS);
source = new AllEntityDao(dbCtx.getJdbcTemplate());
txnSnapshotLoader = new TransactionDao(dbCtx);
systemTimeLoader = new TimeDao(dbCtx.getJdbcTemplate());
replicator = new Replicator(source, changeSink, txnSnapshotLoader, systemTimeLoader, iterations, minInterval,
maxInterval);
replicator.replicate();
}
/**
* {@inheritDoc}
*/
@Override
public void run() {
try (DatabaseContext2 dbCtx = new DatabaseContext2(loginCredentials)) {
runImpl(dbCtx);
}
}
}
ApidbFileReplicatorFactory.java 0000664 0000000 0000000 00000003574 14532772205 0035511 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.DatabasePreferences;
import org.openstreetmap.osmosis.core.database.DatabaseTaskManagerFactory;
import org.openstreetmap.osmosis.core.pipeline.common.TaskConfiguration;
import org.openstreetmap.osmosis.core.pipeline.common.TaskManager;
import org.openstreetmap.osmosis.core.pipeline.v0_6.RunnableChangeSourceManager;
/**
* The task factory for a file-based database replicator.
*/
public class ApidbFileReplicatorFactory extends DatabaseTaskManagerFactory {
private static final String ARG_ITERATIONS = "iterations";
private static final String ARG_MIN_INTERVAL = "minInterval";
private static final String ARG_MAX_INTERVAL = "maxInterval";
private static final int DEFAULT_ITERATIONS = 1;
private static final int DEFAULT_MIN_INTERVAL = 0;
private static final int DEFAULT_MAX_INTERVAL = 0;
/**
* {@inheritDoc}
*/
@Override
protected TaskManager createTaskManagerImpl(TaskConfiguration taskConfig) {
DatabaseLoginCredentials loginCredentials;
DatabasePreferences preferences;
int iterations;
int minInterval;
int maxInterval;
// Get the task arguments.
loginCredentials = getDatabaseLoginCredentials(taskConfig);
preferences = getDatabasePreferences(taskConfig);
iterations = getIntegerArgument(taskConfig, ARG_ITERATIONS, DEFAULT_ITERATIONS);
minInterval = getIntegerArgument(taskConfig, ARG_MIN_INTERVAL, DEFAULT_MIN_INTERVAL);
maxInterval = getIntegerArgument(taskConfig, ARG_MAX_INTERVAL, DEFAULT_MAX_INTERVAL);
return new RunnableChangeSourceManager(
taskConfig.getId(),
new ApidbFileReplicator(loginCredentials, preferences, iterations, minInterval, maxInterval),
taskConfig.getPipeArgs()
);
}
}
osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/ApidbReader.java 0000664 0000000 0000000 00000007173 14532772205 0032535 0 ustar 00root root 0000000 0000000 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
import java.util.Collections;
import java.util.Date;
import org.openstreetmap.osmosis.core.OsmosisConstants;
import org.openstreetmap.osmosis.apidb.common.DatabaseContext2;
import org.openstreetmap.osmosis.apidb.v0_6.impl.AllEntityDao;
import org.openstreetmap.osmosis.apidb.v0_6.impl.EntitySnapshotReader;
import org.openstreetmap.osmosis.apidb.v0_6.impl.SchemaVersionValidator;
import org.openstreetmap.osmosis.core.container.v0_6.BoundContainer;
import org.openstreetmap.osmosis.core.container.v0_6.EntityContainer;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.DatabasePreferences;
import org.openstreetmap.osmosis.core.domain.v0_6.Bound;
import org.openstreetmap.osmosis.core.lifecycle.ReleasableIterator;
import org.openstreetmap.osmosis.core.task.v0_6.RunnableSource;
import org.openstreetmap.osmosis.core.task.v0_6.Sink;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
/**
* An OSM data source reading from a database. The entire contents of the database are read.
*
* @author Brett Henderson
*/
public class ApidbReader implements RunnableSource {
private Sink sink;
private DatabaseLoginCredentials loginCredentials;
private DatabasePreferences preferences;
private Date snapshotInstant;
/**
* Creates a new instance.
*
* @param loginCredentials Contains all information required to connect to the database.
* @param preferences Contains preferences configuring database behaviour.
* @param snapshotInstant The state of the node table at this point in time will be dumped. This
* ensures a consistent snapshot.
*/
public ApidbReader(DatabaseLoginCredentials loginCredentials, DatabasePreferences preferences,
Date snapshotInstant) {
this.loginCredentials = loginCredentials;
this.preferences = preferences;
this.snapshotInstant = snapshotInstant;
}
/**
* {@inheritDoc}
*/
public void setSink(Sink sink) {
this.sink = sink;
}
/**
* Runs the task implementation. This is called by the run method within a transaction.
*
* @param dbCtx
* Used to access the database.
*/
protected void runImpl(DatabaseContext2 dbCtx) {
try {
AllEntityDao entityDao;
sink.initialize(Collections.emptyMap());
new SchemaVersionValidator(loginCredentials, preferences)
.validateVersion(ApidbVersionConstants.SCHEMA_MIGRATIONS);
entityDao = new AllEntityDao(dbCtx.getJdbcTemplate());
sink.process(new BoundContainer(new Bound("Osmosis " + OsmosisConstants.VERSION)));
try (ReleasableIterator reader =
new EntitySnapshotReader(entityDao.getHistory(), snapshotInstant)) {
while (reader.hasNext()) {
sink.process(reader.next());
}
}
sink.complete();
} finally {
sink.close();
}
}
/**
* Reads all data from the database and send it to the sink.
*/
public void run() {
try (DatabaseContext2 dbCtx = new DatabaseContext2(loginCredentials)) {
dbCtx.executeWithinTransaction(new TransactionCallbackWithoutResult() {
@Override
protected void doInTransactionWithoutResult(TransactionStatus arg0) {
runImpl(dbCtx);
}
});
}
}
}
ApidbReaderFactory.java 0000664 0000000 0000000 00000002636 14532772205 0034005 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
import java.util.Date;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.DatabasePreferences;
import org.openstreetmap.osmosis.core.database.DatabaseTaskManagerFactory;
import org.openstreetmap.osmosis.core.pipeline.common.TaskConfiguration;
import org.openstreetmap.osmosis.core.pipeline.common.TaskManager;
import org.openstreetmap.osmosis.core.pipeline.v0_6.RunnableSourceManager;
/**
* The task manager factory for a database reader.
*
* @author Brett Henderson
*/
public class ApidbReaderFactory extends DatabaseTaskManagerFactory {
private static final String ARG_SNAPSHOT_INSTANT = "snapshotInstant";
/**
* {@inheritDoc}
*/
@Override
protected TaskManager createTaskManagerImpl(TaskConfiguration taskConfig) {
DatabaseLoginCredentials loginCredentials;
DatabasePreferences preferences;
Date snapshotInstant;
// Get the task arguments.
loginCredentials = getDatabaseLoginCredentials(taskConfig);
preferences = getDatabasePreferences(taskConfig);
snapshotInstant = getDateArgument(taskConfig, ARG_SNAPSHOT_INSTANT, new Date());
return new RunnableSourceManager(
taskConfig.getId(),
new ApidbReader(loginCredentials, preferences, snapshotInstant),
taskConfig.getPipeArgs()
);
}
}
osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/ApidbTruncator.java 0000664 0000000 0000000 00000004131 14532772205 0033303 0 ustar 00root root 0000000 0000000 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
import java.util.Arrays;
import java.util.List;
import org.openstreetmap.osmosis.apidb.common.DatabaseContext;
import org.openstreetmap.osmosis.apidb.v0_6.impl.SchemaVersionValidator;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.DatabasePreferences;
import org.openstreetmap.osmosis.core.task.common.RunnableTask;
/**
* A standalone OSM task with no inputs or outputs that truncates tables in a apidb database. This
* is used for removing all existing data from tables.
*
* @author Brett Henderson
*/
public class ApidbTruncator implements RunnableTask {
// These tables will be truncated by the sql query.
private static final List TRUNCATE_TABLES = Arrays.asList(new String[] {
"current_relation_members",
"current_relation_tags", "current_relations", "current_way_nodes",
"current_way_tags", "current_ways", "current_node_tags",
"current_nodes", "relation_members", "relation_tags", "relations",
"way_nodes", "way_tags", "ways", "node_tags", "nodes",
"changeset_tags", "changesets", "users"});
private DatabaseLoginCredentials loginCredentials;
private final SchemaVersionValidator schemaVersionValidator;
/**
* Creates a new instance.
*
* @param loginCredentials
* Contains all information required to connect to the database.
* @param preferences
* Contains preferences configuring database behaviour.
*/
public ApidbTruncator(DatabaseLoginCredentials loginCredentials, DatabasePreferences preferences) {
this.loginCredentials = loginCredentials;
schemaVersionValidator = new SchemaVersionValidator(loginCredentials, preferences);
}
/**
* Truncates all data from the database.
*/
public void run() {
try (DatabaseContext dbCtx = new DatabaseContext(loginCredentials)) {
schemaVersionValidator.validateVersion(ApidbVersionConstants.SCHEMA_MIGRATIONS);
dbCtx.truncateTables(TRUNCATE_TABLES);
dbCtx.commit();
}
}
}
ApidbTruncatorFactory.java 0000664 0000000 0000000 00000001627 14532772205 0034563 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
import org.openstreetmap.osmosis.core.database.DatabaseTaskManagerFactory;
import org.openstreetmap.osmosis.core.pipeline.common.RunnableTaskManager;
import org.openstreetmap.osmosis.core.pipeline.common.TaskConfiguration;
import org.openstreetmap.osmosis.core.pipeline.common.TaskManager;
/**
* The task manager factory for a database table truncator.
*
* @author Brett Henderson
*/
public class ApidbTruncatorFactory extends DatabaseTaskManagerFactory {
/**
* {@inheritDoc}
*/
@Override
protected TaskManager createTaskManagerImpl(TaskConfiguration taskConfig) {
return new RunnableTaskManager(
taskConfig.getId(),
new ApidbTruncator(
getDatabaseLoginCredentials(taskConfig),
getDatabasePreferences(taskConfig)
),
taskConfig.getPipeArgs()
);
}
}
ApidbVersionConstants.java 0000664 0000000 0000000 00000003271 14532772205 0034571 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
/**
* Defines constants specific to the specific schema version.
*
* @author Brett Henderson
*/
public final class ApidbVersionConstants {
/**
* Defines the schema migrations expected to be in the database.
*/
public static final String[] SCHEMA_MIGRATIONS = {
"1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
"11", "12", "13", "14", "15", "16", "17", "18", "19", "20",
"21", "22", "23", "24", "25", "26", "27", "28", "29", "30",
"31", "32", "33", "34", "35", "36", "37", "38", "39", "40",
"41", "42", "43", "44", "45", "46", "47", "48", "49", "50",
"51", "52", "53", "54", "55", "56", "57", "20100513171259",
"20100516124737", "20100910084426", "20101114011429",
"20110322001319", "20110508145337", "20110521142405",
"20110925112722", "20111116184519", "20111212183945",
"20120123184321", "20120208122334", "20120208194454",
"20120214210114", "20120219161649", "20120318201948",
"20120328090602", "20120404205604", "20120808231205",
"20121005195010", "20121012044047", "20121119165817",
"20121202155309", "20121203124841", "20130328184137",
"20131212124700", "20140115192822", "20140117185510",
"20140210003018", "20140507110937", "20140519141742",
"20150110152606", "20150111192335", "20150222101847",
"20150818224516", "20160822153055", "20161002153425",
"20161011010929", "20170222134109", "20180204153242",
"20181020114000", "20181031113522", "20190518115041",
"20190623093642", "20190702193519", "20190716173946",
"20191120140058"
};
/**
* This class cannot be instantiated.
*/
private ApidbVersionConstants() {
}
}
osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/ApidbWriter.java 0000664 0000000 0000000 00000146435 14532772205 0032614 0 ustar 00root root 0000000 0000000 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import org.openstreetmap.osmosis.apidb.common.DatabaseContext;
import org.openstreetmap.osmosis.apidb.v0_6.impl.ChangesetManager;
import org.openstreetmap.osmosis.apidb.v0_6.impl.MemberTypeRenderer;
import org.openstreetmap.osmosis.apidb.v0_6.impl.SchemaVersionValidator;
import org.openstreetmap.osmosis.apidb.v0_6.impl.UserManager;
import org.openstreetmap.osmosis.core.OsmosisRuntimeException;
import org.openstreetmap.osmosis.core.container.v0_6.BoundContainer;
import org.openstreetmap.osmosis.core.container.v0_6.EntityContainer;
import org.openstreetmap.osmosis.core.container.v0_6.EntityProcessor;
import org.openstreetmap.osmosis.core.container.v0_6.NodeContainer;
import org.openstreetmap.osmosis.core.container.v0_6.RelationContainer;
import org.openstreetmap.osmosis.core.container.v0_6.WayContainer;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.DatabasePreferences;
import org.openstreetmap.osmosis.core.database.DbFeature;
import org.openstreetmap.osmosis.core.database.DbFeatureHistory;
import org.openstreetmap.osmosis.core.database.DbOrderedFeature;
import org.openstreetmap.osmosis.core.domain.v0_6.Entity;
import org.openstreetmap.osmosis.core.domain.v0_6.Node;
import org.openstreetmap.osmosis.core.domain.v0_6.Relation;
import org.openstreetmap.osmosis.core.domain.v0_6.RelationMember;
import org.openstreetmap.osmosis.core.domain.v0_6.Tag;
import org.openstreetmap.osmosis.core.domain.v0_6.Way;
import org.openstreetmap.osmosis.core.domain.v0_6.WayNode;
import org.openstreetmap.osmosis.core.task.v0_6.Sink;
import org.openstreetmap.osmosis.core.util.FixedPrecisionCoordinateConvertor;
import org.openstreetmap.osmosis.core.util.TileCalculator;
/**
* An OSM data sink for storing all data to a database. This task is intended for writing to an
* empty database.
*
* @author Brett Henderson
*/
public class ApidbWriter implements Sink, EntityProcessor {
// These SQL strings are the prefix to statements that will be built based
// on how many rows of data are to be inserted at a time.
private static final String INSERT_SQL_NODE_COLUMNS =
"INSERT INTO nodes(node_id, timestamp, version, visible, changeset_id, latitude, longitude, tile)";
private static final String INSERT_SQL_NODE_PARAMS = createParamPlaceholders(8);
private static final int INSERT_PRM_COUNT_NODE = 8;
private static final String INSERT_SQL_NODE_TAG_COLUMNS = "INSERT INTO node_tags (node_id, k, v, version)";
private static final String INSERT_SQL_NODE_TAG_PARAMS = createParamPlaceholders(4);
private static final int INSERT_PRM_COUNT_NODE_TAG = 4;
private static final String INSERT_SQL_WAY_COLUMNS =
"INSERT INTO ways (way_id, timestamp, version, visible, changeset_id)";
private static final String INSERT_SQL_WAY_PARAMS = createParamPlaceholders(5);
private static final int INSERT_PRM_COUNT_WAY = 5;
private static final String INSERT_SQL_WAY_TAG_COLUMNS = "INSERT INTO way_tags (way_id, k, v, version)";
private static final String INSERT_SQL_WAY_TAG_PARAMS = createParamPlaceholders(4);
private static final int INSERT_PRM_COUNT_WAY_TAG = 4;
private static final String INSERT_SQL_WAY_NODE_COLUMNS =
"INSERT INTO way_nodes (way_id, node_id, sequence_id, version)";
private static final String INSERT_SQL_WAY_NODE_PARAMS = createParamPlaceholders(4);
private static final int INSERT_PRM_COUNT_WAY_NODE = 4;
private static final String INSERT_SQL_RELATION_COLUMNS =
"INSERT INTO relations (relation_id, timestamp, version, visible, changeset_id)";
private static final String INSERT_SQL_RELATION_PARAMS =
"?, ?, ?, ?, ?";
private static final int INSERT_PRM_COUNT_RELATION = 5;
private static final String INSERT_SQL_RELATION_TAG_COLUMNS =
"INSERT INTO relation_tags (relation_id, k, v, version)";
private static final String INSERT_SQL_RELATION_TAG_PARAMS = createParamPlaceholders(4);
private static final int INSERT_PRM_COUNT_RELATION_TAG = 4;
private static final String INSERT_SQL_RELATION_MEMBER_COLUMNS =
"INSERT INTO relation_members (relation_id, member_type, member_id, sequence_id, member_role, version)";
private static final String INSERT_SQL_RELATION_MEMBER_PARAMS_MYSQL =
"?, ?, ?, ?, ?, ?";
private static final String INSERT_SQL_RELATION_MEMBER_PARAMS_PGSQL =
"?, ?::nwr_enum, ?, ?, ?, ?";
private static final int INSERT_PRM_COUNT_RELATION_MEMBER = 6;
// These tables will have indexes disabled during loading data.
private static final List DISABLE_KEY_TABLES = Arrays.asList(new String[] {"nodes",
"node_tags", "ways", "way_tags",
"way_nodes", "relations",
"relation_tags", "relation_members"});
// These SQL statements will be invoked after loading history tables to
// populate the current tables.
private static final int LOAD_CURRENT_NODE_ROW_COUNT = 1000000;
private static final int LOAD_CURRENT_WAY_ROW_COUNT = 100000;
private static final int LOAD_CURRENT_RELATION_ROW_COUNT = 100000;
private static final String LOAD_CURRENT_NODES =
"INSERT INTO current_nodes SELECT node_id, latitude, longitude, changeset_id, visible, timestamp, tile, version"
+ " FROM nodes WHERE node_id >= ? AND node_id < ?";
private static final String LOAD_CURRENT_NODE_TAGS =
"INSERT INTO current_node_tags SELECT node_id, k, v FROM node_tags WHERE node_id >= ? AND node_id < ?";
private static final String WHERE_WAY_ID_IN_RANGE = " WHERE way_id >= ? AND way_id < ?";
private static final String LOAD_CURRENT_WAYS =
"INSERT INTO current_ways SELECT way_id, changeset_id, timestamp, visible, version FROM ways"
+ WHERE_WAY_ID_IN_RANGE;
private static final String LOAD_CURRENT_WAY_TAGS =
"INSERT INTO current_way_tags SELECT way_id, k, v FROM way_tags"
+ WHERE_WAY_ID_IN_RANGE;
private static final String LOAD_CURRENT_WAY_NODES =
"INSERT INTO current_way_nodes SELECT way_id, node_id, sequence_id FROM way_nodes"
+ WHERE_WAY_ID_IN_RANGE;
private static final String LOAD_CURRENT_RELATIONS =
"INSERT INTO current_relations SELECT relation_id, changeset_id, timestamp, visible, version"
+ " FROM relations WHERE relation_id >= ? AND relation_id < ?";
private static final String LOAD_CURRENT_RELATION_TAGS =
"INSERT INTO current_relation_tags SELECT relation_id, k, v FROM relation_tags"
+ " WHERE relation_id >= ? AND relation_id < ?";
private static final String LOAD_CURRENT_RELATION_MEMBERS =
"INSERT INTO current_relation_members (relation_id, member_id, member_role, member_type, sequence_id)"
+ " SELECT relation_id, member_id, member_role, member_type, sequence_id"
+ " FROM relation_members WHERE relation_id >= ? AND relation_id < ?";
// These tables will be locked for exclusive access while loading data.
private static final List LOCK_TABLES = Arrays.asList(new String[] {"nodes", "node_tags", "ways",
"way_tags", "way_nodes", "relations", "relation_tags", "relation_members", "current_nodes",
"current_node_tags", "current_ways", "current_way_tags", "current_way_nodes", "current_relations",
"current_relation_tags", "current_relation_members", "users", "changesets", "changeset_tags" });
// These constants define how many rows of each data type will be inserted
// with single insert statements.
private static final int INSERT_BULK_ROW_COUNT_NODE = 100;
private static final int INSERT_BULK_ROW_COUNT_NODE_TAG = 100;
private static final int INSERT_BULK_ROW_COUNT_WAY = 100;
private static final int INSERT_BULK_ROW_COUNT_WAY_TAG = 100;
private static final int INSERT_BULK_ROW_COUNT_WAY_NODE = 100;
private static final int INSERT_BULK_ROW_COUNT_RELATION = 100;
private static final int INSERT_BULK_ROW_COUNT_RELATION_TAG = 100;
private static final int INSERT_BULK_ROW_COUNT_RELATION_MEMBER = 100;
private static final int TRANSACTION_SIZE = 100000;
private String insertSqlSingleNode;
private String insertSqlBulkNode;
private String insertSqlSingleNodeTag;
private String insertSqlBulkNodeTag;
private String insertSqlSingleWay;
private String insertSqlBulkWay;
private String insertSqlSingleWayTag;
private String insertSqlBulkWayTag;
private String insertSqlSingleWayNode;
private String insertSqlBulkWayNode;
private String insertSqlSingleRelation;
private String insertSqlBulkRelation;
private String insertSqlSingleRelationTag;
private String insertSqlBulkRelationTag;
private String insertSqlSingleRelationMember;
private String insertSqlBulkRelationMember;
private final DatabaseContext dbCtx;
private final UserManager userManager;
private final ChangesetManager changesetManager;
private final SchemaVersionValidator schemaVersionValidator;
private final boolean lockTables;
private final boolean populateCurrentTables;
private final List nodeBuffer;
private final List>> nodeTagBuffer;
private final List wayBuffer;
private final List>> wayTagBuffer;
private final List>> wayNodeBuffer;
private final List relationBuffer;
private final List>> relationTagBuffer;
private final List>> relationMemberBuffer;
private long maxNodeId;
private long minNodeId;
private long maxWayId;
private long minWayId;
private long maxRelationId;
private long minRelationId;
private long transactionSizeCount;
private final TileCalculator tileCalculator;
private final MemberTypeRenderer memberTypeRenderer;
private boolean initialized;
private PreparedStatement singleNodeStatement;
private PreparedStatement bulkNodeStatement;
private PreparedStatement singleNodeTagStatement;
private PreparedStatement bulkNodeTagStatement;
private PreparedStatement singleWayStatement;
private PreparedStatement bulkWayStatement;
private PreparedStatement singleWayTagStatement;
private PreparedStatement bulkWayTagStatement;
private PreparedStatement singleWayNodeStatement;
private PreparedStatement bulkWayNodeStatement;
private PreparedStatement singleRelationStatement;
private PreparedStatement bulkRelationStatement;
private PreparedStatement singleRelationTagStatement;
private PreparedStatement bulkRelationTagStatement;
private PreparedStatement singleRelationMemberStatement;
private PreparedStatement bulkRelationMemberStatement;
private PreparedStatement loadCurrentNodesStatement;
private PreparedStatement loadCurrentNodeTagsStatement;
private PreparedStatement loadCurrentWaysStatement;
private PreparedStatement loadCurrentWayTagsStatement;
private PreparedStatement loadCurrentWayNodesStatement;
private PreparedStatement loadCurrentRelationsStatement;
private PreparedStatement loadCurrentRelationTagsStatement;
private PreparedStatement loadCurrentRelationMembersStatement;
/**
* Creates a new instance.
*
* @param loginCredentials Contains all information required to connect to the database.
* @param preferences Contains preferences configuring database behaviour.
* @param lockTables If true, all tables will be locked during loading.
* @param populateCurrentTables If true, the current tables will be populated as well as history
* tables.
*/
public ApidbWriter(DatabaseLoginCredentials loginCredentials, DatabasePreferences preferences, boolean lockTables,
boolean populateCurrentTables) {
dbCtx = new DatabaseContext(loginCredentials);
userManager = new UserManager(dbCtx);
changesetManager = new ChangesetManager(dbCtx);
schemaVersionValidator = new SchemaVersionValidator(loginCredentials, preferences);
this.lockTables = lockTables;
this.populateCurrentTables = populateCurrentTables;
nodeBuffer = new ArrayList();
nodeTagBuffer = new ArrayList>>();
wayBuffer = new ArrayList();
wayTagBuffer = new ArrayList>>();
wayNodeBuffer = new ArrayList>>();
relationBuffer = new ArrayList();
relationTagBuffer = new ArrayList>>();
relationMemberBuffer = new ArrayList>>();
maxNodeId = Long.MIN_VALUE;
minNodeId = Long.MAX_VALUE;
maxWayId = Long.MIN_VALUE;
minWayId = Long.MAX_VALUE;
maxRelationId = Long.MIN_VALUE;
minRelationId = Long.MAX_VALUE;
transactionSizeCount = 0;
tileCalculator = new TileCalculator();
memberTypeRenderer = new MemberTypeRenderer();
initialized = false;
}
/**
* Builds a multi-row SQL insert statement.
*
* @param columnSql
* The basic query without value bind variables.
* @param parametersSql
* The SQL parameters portion of the query.
* @param rowCount
* The number of rows to insert in a single query.
* @return The generated SQL statement.
*/
private static String buildSqlInsertStatement(String columnSql, String parametersSql, int rowCount) {
StringBuilder buffer;
buffer = new StringBuilder();
buffer.append(columnSql).append(" VALUES ");
for (int i = 0; i < rowCount; i++) {
if (i > 0) {
buffer.append(", ");
}
buffer.append("(");
buffer.append(parametersSql);
buffer.append(")");
}
return buffer.toString();
}
private void buildSqlStatements() {
insertSqlSingleNode = buildSqlInsertStatement(INSERT_SQL_NODE_COLUMNS, INSERT_SQL_NODE_PARAMS, 1);
insertSqlBulkNode = buildSqlInsertStatement(INSERT_SQL_NODE_COLUMNS, INSERT_SQL_NODE_PARAMS,
INSERT_BULK_ROW_COUNT_NODE);
insertSqlSingleNodeTag = buildSqlInsertStatement(
INSERT_SQL_NODE_TAG_COLUMNS, INSERT_SQL_NODE_TAG_PARAMS, 1);
insertSqlBulkNodeTag = buildSqlInsertStatement(INSERT_SQL_NODE_TAG_COLUMNS, INSERT_SQL_NODE_TAG_PARAMS,
INSERT_BULK_ROW_COUNT_NODE_TAG);
insertSqlSingleWay = buildSqlInsertStatement(INSERT_SQL_WAY_COLUMNS, INSERT_SQL_WAY_PARAMS, 1);
insertSqlBulkWay = buildSqlInsertStatement(INSERT_SQL_WAY_COLUMNS, INSERT_SQL_WAY_PARAMS,
INSERT_BULK_ROW_COUNT_WAY);
insertSqlSingleWayTag = buildSqlInsertStatement(INSERT_SQL_WAY_TAG_COLUMNS, INSERT_SQL_WAY_TAG_PARAMS, 1);
insertSqlBulkWayTag = buildSqlInsertStatement(INSERT_SQL_WAY_TAG_COLUMNS, INSERT_SQL_WAY_TAG_PARAMS,
INSERT_BULK_ROW_COUNT_WAY_TAG);
insertSqlSingleWayNode = buildSqlInsertStatement(
INSERT_SQL_WAY_NODE_COLUMNS, INSERT_SQL_WAY_NODE_PARAMS, 1);
insertSqlBulkWayNode = buildSqlInsertStatement(INSERT_SQL_WAY_NODE_COLUMNS, INSERT_SQL_WAY_NODE_PARAMS,
INSERT_BULK_ROW_COUNT_WAY_NODE);
insertSqlSingleRelation = buildSqlInsertStatement(INSERT_SQL_RELATION_COLUMNS, INSERT_SQL_RELATION_PARAMS,
1);
insertSqlBulkRelation = buildSqlInsertStatement(INSERT_SQL_RELATION_COLUMNS, INSERT_SQL_RELATION_PARAMS,
INSERT_BULK_ROW_COUNT_RELATION);
insertSqlSingleRelationTag = buildSqlInsertStatement(INSERT_SQL_RELATION_TAG_COLUMNS,
INSERT_SQL_RELATION_TAG_PARAMS, 1);
insertSqlBulkRelationTag = buildSqlInsertStatement(INSERT_SQL_RELATION_TAG_COLUMNS,
INSERT_SQL_RELATION_TAG_PARAMS, INSERT_BULK_ROW_COUNT_RELATION_TAG);
}
private OsmosisRuntimeException createUnknownDbTypeException() {
return new OsmosisRuntimeException("Unknown database type " + dbCtx.getDatabaseType() + ".");
}
/**
* Initialises prepared statements and obtains database locks. Can be called multiple times.
*/
private void initialize() {
if (!initialized) {
schemaVersionValidator.validateVersion(ApidbVersionConstants.SCHEMA_MIGRATIONS);
buildSqlStatements();
switch (dbCtx.getDatabaseType()) {
case POSTGRESQL:
insertSqlSingleRelationMember = buildSqlInsertStatement(INSERT_SQL_RELATION_MEMBER_COLUMNS,
INSERT_SQL_RELATION_MEMBER_PARAMS_PGSQL, 1);
insertSqlBulkRelationMember = buildSqlInsertStatement(INSERT_SQL_RELATION_MEMBER_COLUMNS,
INSERT_SQL_RELATION_MEMBER_PARAMS_PGSQL, INSERT_BULK_ROW_COUNT_RELATION_MEMBER);
break;
case MYSQL:
insertSqlSingleRelationMember = buildSqlInsertStatement(INSERT_SQL_RELATION_MEMBER_COLUMNS,
INSERT_SQL_RELATION_MEMBER_PARAMS_MYSQL, 1);
insertSqlBulkRelationMember = buildSqlInsertStatement(INSERT_SQL_RELATION_MEMBER_COLUMNS,
INSERT_SQL_RELATION_MEMBER_PARAMS_MYSQL, INSERT_BULK_ROW_COUNT_RELATION_MEMBER);
break;
default:
throw createUnknownDbTypeException();
}
bulkNodeStatement = dbCtx.prepareStatement(insertSqlBulkNode);
singleNodeStatement = dbCtx.prepareStatement(insertSqlSingleNode);
bulkNodeTagStatement = dbCtx.prepareStatement(insertSqlBulkNodeTag);
singleNodeTagStatement = dbCtx.prepareStatement(insertSqlSingleNodeTag);
bulkWayStatement = dbCtx.prepareStatement(insertSqlBulkWay);
singleWayStatement = dbCtx.prepareStatement(insertSqlSingleWay);
bulkWayTagStatement = dbCtx.prepareStatement(insertSqlBulkWayTag);
singleWayTagStatement = dbCtx.prepareStatement(insertSqlSingleWayTag);
bulkWayNodeStatement = dbCtx.prepareStatement(insertSqlBulkWayNode);
singleWayNodeStatement = dbCtx.prepareStatement(insertSqlSingleWayNode);
bulkRelationStatement = dbCtx.prepareStatement(insertSqlBulkRelation);
singleRelationStatement = dbCtx.prepareStatement(insertSqlSingleRelation);
bulkRelationTagStatement = dbCtx.prepareStatement(insertSqlBulkRelationTag);
singleRelationTagStatement = dbCtx.prepareStatement(insertSqlSingleRelationTag);
bulkRelationMemberStatement = dbCtx.prepareStatement(insertSqlBulkRelationMember);
singleRelationMemberStatement = dbCtx.prepareStatement(insertSqlSingleRelationMember);
loadCurrentNodesStatement = dbCtx.prepareStatement(LOAD_CURRENT_NODES);
loadCurrentNodeTagsStatement = dbCtx.prepareStatement(LOAD_CURRENT_NODE_TAGS);
loadCurrentWaysStatement = dbCtx.prepareStatement(LOAD_CURRENT_WAYS);
loadCurrentWayTagsStatement = dbCtx.prepareStatement(LOAD_CURRENT_WAY_TAGS);
loadCurrentWayNodesStatement = dbCtx.prepareStatement(LOAD_CURRENT_WAY_NODES);
loadCurrentRelationsStatement = dbCtx.prepareStatement(LOAD_CURRENT_RELATIONS);
loadCurrentRelationTagsStatement = dbCtx.prepareStatement(LOAD_CURRENT_RELATION_TAGS);
loadCurrentRelationMembersStatement = dbCtx.prepareStatement(LOAD_CURRENT_RELATION_MEMBERS);
// Disable indexes to improve load performance.
dbCtx.disableIndexes(DISABLE_KEY_TABLES);
// Lock tables if required to improve load performance.
if (lockTables) {
dbCtx.lockTables(LOCK_TABLES);
}
initialized = true;
}
}
private void assertEntityHasTimestamp(Entity entity) {
if (entity.getTimestamp() == null) {
throw new OsmosisRuntimeException(
entity.getType().toString() + " " + entity.getId() + " does not have a timestamp set.");
}
}
/**
* Sets node values as bind variable parameters to a node insert query.
*
* @param statement The prepared statement to add the values to.
* @param initialIndex The offset index of the first variable to set.
* @param node The node containing the data to be inserted.
*/
private void populateNodeParameters(PreparedStatement statement, int initialIndex, Node node) {
int prmIndex;
prmIndex = initialIndex;
assertEntityHasTimestamp(node);
try {
statement.setLong(prmIndex++, node.getId());
statement.setTimestamp(prmIndex++, new Timestamp(node.getTimestamp().getTime()));
statement.setInt(prmIndex++, node.getVersion());
statement.setBoolean(prmIndex++, true);
statement.setLong(prmIndex++, node.getChangesetId());
statement.setInt(prmIndex++, FixedPrecisionCoordinateConvertor.convertToFixed(node.getLatitude()));
statement.setInt(prmIndex++, FixedPrecisionCoordinateConvertor.convertToFixed(node.getLongitude()));
statement.setLong(prmIndex++, tileCalculator.calculateTile(node.getLatitude(), node.getLongitude()));
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to set a prepared statement parameter for a node.", e);
}
}
private static String createParamPlaceholders(int amount) {
StringBuilder questionMarks = new StringBuilder();
for (int i = 0; i < amount; i++) {
questionMarks.append("?");
if (i != amount - 1) {
questionMarks.append(", ");
}
}
return questionMarks.toString();
}
/**
* Sets way values as bind variable parameters to a way insert query.
*
* @param statement The prepared statement to add the values to.
* @param initialIndex The offset index of the first variable to set.
* @param way The way containing the data to be inserted.
*/
private void populateWayParameters(PreparedStatement statement, int initialIndex, Way way) {
int prmIndex;
prmIndex = initialIndex;
assertEntityHasTimestamp(way);
try {
statement.setLong(prmIndex++, way.getId());
statement.setTimestamp(prmIndex++, new Timestamp(way.getTimestamp().getTime()));
statement.setInt(prmIndex++, way.getVersion());
statement.setBoolean(prmIndex++, true);
statement.setLong(prmIndex++, way.getChangesetId());
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to set a prepared statement parameter for a way.", e);
}
}
/**
* Sets tag values as bind variable parameters to a tag insert query.
*
* @param statement The prepared statement to add the values to.
* @param initialIndex The offset index of the first variable to set.
* @param dbEntityTag The entity tag containing the data to be inserted.
*/
private void populateEntityTagParameters(PreparedStatement statement, int initialIndex,
DbFeatureHistory> dbEntityTag) {
int prmIndex;
Tag tag;
prmIndex = initialIndex;
tag = dbEntityTag.getFeature().getFeature();
try {
statement.setLong(prmIndex++, dbEntityTag.getFeature().getEntityId());
statement.setString(prmIndex++, tag.getKey());
statement.setString(prmIndex++, tag.getValue());
statement.setInt(prmIndex++, dbEntityTag.getVersion());
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to set a prepared statement parameter for an entity tag.", e);
}
}
/**
* Sets node reference values as bind variable parameters to a way node insert query.
*
* @param statement The prepared statement to add the values to.
* @param initialIndex The offset index of the first variable to set.
* @param dbWayNode The way node containing the data to be inserted.
*/
private void populateWayNodeParameters(PreparedStatement statement, int initialIndex,
DbFeatureHistory> dbWayNode) {
int prmIndex;
prmIndex = initialIndex;
try {
statement.setLong(prmIndex++, dbWayNode.getFeature().getEntityId());
statement.setLong(prmIndex++, dbWayNode.getFeature().getFeature().getNodeId());
statement.setInt(prmIndex++, dbWayNode.getFeature().getSequenceId());
statement.setInt(prmIndex++, dbWayNode.getVersion());
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to set a prepared statement parameter for a way node.", e);
}
}
/**
* Sets relation values as bind variable parameters to a relation insert query.
*
* @param statement The prepared statement to add the values to.
* @param initialIndex The offset index of the first variable to set.
* @param relation The way containing the data to be inserted.
*/
private void populateRelationParameters(PreparedStatement statement, int initialIndex, Relation relation) {
int prmIndex;
prmIndex = initialIndex;
assertEntityHasTimestamp(relation);
try {
statement.setLong(prmIndex++, relation.getId());
statement.setTimestamp(prmIndex++, new Timestamp(relation.getTimestamp().getTime()));
statement.setInt(prmIndex++, relation.getVersion());
statement.setBoolean(prmIndex++, true);
statement.setLong(prmIndex++, relation.getChangesetId());
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to set a prepared statement parameter for a relation.", e);
}
}
/**
* Sets member reference values as bind variable parameters to a relation member insert query.
*
* @param statement The prepared statement to add the values to.
* @param initialIndex The offset index of the first variable to set.
* @param dbRelationMember The relation member containing the data to be inserted.
*/
private void populateRelationMemberParameters(PreparedStatement statement, int initialIndex,
DbFeatureHistory> dbRelationMember) {
int prmIndex;
RelationMember relationMember;
prmIndex = initialIndex;
relationMember = dbRelationMember.getFeature().getFeature();
try {
statement.setLong(prmIndex++, dbRelationMember.getFeature().getEntityId());
statement.setString(prmIndex++, memberTypeRenderer.render(relationMember.getMemberType()));
statement.setLong(prmIndex++, relationMember.getMemberId());
statement.setInt(prmIndex++, dbRelationMember.getFeature().getSequenceId());
statement.setString(prmIndex++, relationMember.getMemberRole());
statement.setInt(prmIndex++, dbRelationMember.getVersion());
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to set a prepared statement parameter for a relation member.", e);
}
}
/**
* Flushes nodes to the database. If complete is false, this will only write nodes until the
* remaining node count is less than the multi-row insert statement row count. If complete is
* true, all remaining rows will be written using single row insert statements.
*
* @param complete If true, all data will be written to the database. If false, some data may be
* left until more data is available.
*/
private void flushNodes(boolean complete) {
while (nodeBuffer.size() >= INSERT_BULK_ROW_COUNT_NODE) {
int prmIndex;
List processedNodes;
processedNodes = new ArrayList(INSERT_BULK_ROW_COUNT_NODE);
prmIndex = 1;
for (int i = 0; i < INSERT_BULK_ROW_COUNT_NODE; i++) {
Node node;
node = nodeBuffer.remove(0);
processedNodes.add(node);
populateNodeParameters(bulkNodeStatement, prmIndex, node);
prmIndex += INSERT_PRM_COUNT_NODE;
transactionSizeCount++;
}
try {
bulkNodeStatement.executeUpdate();
if (transactionSizeCount % TRANSACTION_SIZE == 0) {
dbCtx.commit();
}
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to bulk insert nodes into the database.", e);
}
for (Node node : processedNodes) {
addNodeTags(node);
}
}
if (complete) {
while (nodeBuffer.size() > 0) {
Node node;
node = nodeBuffer.remove(0);
populateNodeParameters(singleNodeStatement, 1, node);
try {
singleNodeStatement.executeUpdate();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert a node into the database.", e);
}
addNodeTags(node);
}
}
dbCtx.commit();
}
/**
* Flushes node tags to the database. If complete is false, this will only write node tags until
* the remaining node tag count is less than the multi-row insert statement row count. If
* complete is true, all remaining rows will be written using single row insert statements.
*
* @param complete If true, all data will be written to the database. If false, some data may be
* left until more data is available.
*/
private void flushNodeTags(boolean complete) {
while (nodeTagBuffer.size() >= INSERT_BULK_ROW_COUNT_NODE_TAG) {
int prmIndex;
prmIndex = 1;
for (int i = 0; i < INSERT_BULK_ROW_COUNT_NODE_TAG; i++) {
populateEntityTagParameters(bulkNodeTagStatement, prmIndex, nodeTagBuffer.remove(0));
prmIndex += INSERT_PRM_COUNT_NODE_TAG;
transactionSizeCount++;
}
try {
bulkNodeTagStatement.executeUpdate();
if (transactionSizeCount % TRANSACTION_SIZE == 0) {
dbCtx.commit();
}
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to bulk insert node tags into the database.", e);
}
}
if (complete) {
while (nodeTagBuffer.size() > 0) {
populateEntityTagParameters(singleNodeTagStatement, 1, nodeTagBuffer.remove(0));
try {
singleNodeTagStatement.executeUpdate();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert a node tag into the database.", e);
}
}
}
dbCtx.commit();
}
/**
* Flushes ways to the database. If complete is false, this will only write ways until the
* remaining way count is less than the multi-row insert statement row count. If complete is
* true, all remaining rows will be written using single row insert statements.
*
* @param complete If true, all data will be written to the database. If false, some data may be
* left until more data is available.
*/
private void flushWays(boolean complete) {
while (wayBuffer.size() >= INSERT_BULK_ROW_COUNT_WAY) {
List processedWays;
int prmIndex;
processedWays = new ArrayList(INSERT_BULK_ROW_COUNT_WAY);
prmIndex = 1;
for (int i = 0; i < INSERT_BULK_ROW_COUNT_WAY; i++) {
Way way;
way = wayBuffer.remove(0);
processedWays.add(way);
populateWayParameters(bulkWayStatement, prmIndex, way);
prmIndex += INSERT_PRM_COUNT_WAY;
transactionSizeCount++;
}
try {
bulkWayStatement.executeUpdate();
if (transactionSizeCount % TRANSACTION_SIZE == 0) {
dbCtx.commit();
}
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to bulk insert ways into the database.", e);
}
for (Way way : processedWays) {
addWayTags(way);
addWayNodes(way);
}
}
if (complete) {
while (wayBuffer.size() > 0) {
Way way;
way = wayBuffer.remove(0);
populateWayParameters(singleWayStatement, 1, way);
try {
singleWayStatement.executeUpdate();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert a way into the database.", e);
}
addWayTags(way);
addWayNodes(way);
}
}
dbCtx.commit();
}
/**
* Flushes way tags to the database. If complete is false, this will only write way tags until
* the remaining way tag count is less than the multi-row insert statement row count. If
* complete is true, all remaining rows will be written using single row insert statements.
*
* @param complete If true, all data will be written to the database. If false, some data may be
* left until more data is available.
*/
private void flushWayTags(boolean complete) {
while (wayTagBuffer.size() >= INSERT_BULK_ROW_COUNT_WAY_TAG) {
int prmIndex;
prmIndex = 1;
for (int i = 0; i < INSERT_BULK_ROW_COUNT_WAY_TAG; i++) {
populateEntityTagParameters(bulkWayTagStatement, prmIndex, wayTagBuffer.remove(0));
prmIndex += INSERT_PRM_COUNT_WAY_TAG;
transactionSizeCount++;
}
try {
bulkWayTagStatement.executeUpdate();
if (transactionSizeCount % TRANSACTION_SIZE == 0) {
dbCtx.commit();
}
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to bulk insert way tags into the database.", e);
}
}
if (complete) {
while (wayTagBuffer.size() > 0) {
populateEntityTagParameters(singleWayTagStatement, 1, wayTagBuffer.remove(0));
try {
singleWayTagStatement.executeUpdate();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert a way tag into the database.", e);
}
}
}
dbCtx.commit();
}
/**
* Flushes way nodes to the database. If complete is false, this will only write way nodes until
* the remaining way node count is less than the multi-row insert statement row count. If
* complete is true, all remaining rows will be written using single row insert statements.
*
* @param complete If true, all data will be written to the database. If false, some data may be
* left until more data is available.
*/
private void flushWayNodes(boolean complete) {
while (wayNodeBuffer.size() >= INSERT_BULK_ROW_COUNT_WAY_NODE) {
int prmIndex;
prmIndex = 1;
for (int i = 0; i < INSERT_BULK_ROW_COUNT_WAY_NODE; i++) {
populateWayNodeParameters(bulkWayNodeStatement, prmIndex, wayNodeBuffer.remove(0));
prmIndex += INSERT_PRM_COUNT_WAY_NODE;
transactionSizeCount++;
}
try {
bulkWayNodeStatement.executeUpdate();
if (transactionSizeCount % TRANSACTION_SIZE == 0) {
dbCtx.commit();
}
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to bulk insert way nodes into the database.", e);
}
}
if (complete) {
while (wayNodeBuffer.size() > 0) {
populateWayNodeParameters(singleWayNodeStatement, 1, wayNodeBuffer.remove(0));
try {
singleWayNodeStatement.executeUpdate();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert a way node into the database.", e);
}
}
}
dbCtx.commit();
}
/**
* Flushes relations to the database. If complete is false, this will only write relations until
* the remaining way count is less than the multi-row insert statement row count. If complete is
* true, all remaining rows will be written using single row insert statements.
*
* @param complete If true, all data will be written to the database. If false, some data may be
* left until more data is available.
*/
private void flushRelations(boolean complete) {
while (relationBuffer.size() >= INSERT_BULK_ROW_COUNT_RELATION) {
List processedRelations;
int prmIndex;
processedRelations = new ArrayList(INSERT_BULK_ROW_COUNT_RELATION);
prmIndex = 1;
for (int i = 0; i < INSERT_BULK_ROW_COUNT_RELATION; i++) {
Relation relation;
relation = relationBuffer.remove(0);
processedRelations.add(relation);
populateRelationParameters(bulkRelationStatement, prmIndex, relation);
prmIndex += INSERT_PRM_COUNT_RELATION;
transactionSizeCount++;
}
try {
bulkRelationStatement.executeUpdate();
if (transactionSizeCount % TRANSACTION_SIZE == 0) {
dbCtx.commit();
}
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to bulk insert relations into the database.", e);
}
for (Relation relation : processedRelations) {
addRelationTags(relation);
addRelationMembers(relation);
}
}
if (complete) {
while (relationBuffer.size() > 0) {
Relation relation;
relation = relationBuffer.remove(0);
populateRelationParameters(singleRelationStatement, 1, relation);
try {
singleRelationStatement.executeUpdate();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert a relation into the database.", e);
}
addRelationTags(relation);
addRelationMembers(relation);
}
}
dbCtx.commit();
}
/**
* Flushes relation tags to the database. If complete is false, this will only write relation
* tags until the remaining relation tag count is less than the multi-row insert statement row
* count. If complete is true, all remaining rows will be written using single row insert
* statements.
*
* @param complete If true, all data will be written to the database. If false, some data may be
* left until more data is available.
*/
private void flushRelationTags(boolean complete) {
while (relationTagBuffer.size() >= INSERT_BULK_ROW_COUNT_RELATION_TAG) {
int prmIndex;
prmIndex = 1;
for (int i = 0; i < INSERT_BULK_ROW_COUNT_RELATION_TAG; i++) {
populateEntityTagParameters(bulkRelationTagStatement, prmIndex, relationTagBuffer.remove(0));
prmIndex += INSERT_PRM_COUNT_RELATION_TAG;
transactionSizeCount++;
}
try {
bulkRelationTagStatement.executeUpdate();
if (transactionSizeCount % TRANSACTION_SIZE == 0) {
dbCtx.commit();
}
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to bulk insert relation tags into the database.", e);
}
}
if (complete) {
while (relationTagBuffer.size() > 0) {
populateEntityTagParameters(singleRelationTagStatement, 1, relationTagBuffer.remove(0));
try {
singleRelationTagStatement.executeUpdate();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert a relation tag into the database.", e);
}
}
}
dbCtx.commit();
}
/**
* Flushes relation members to the database. If complete is false, this will only write relation
* members until the remaining relation member count is less than the multi-row insert statement
* row count. If complete is true, all remaining rows will be written using single row insert
* statements.
*
* @param complete If true, all data will be written to the database. If false, some data may be
* left until more data is available.
*/
private void flushRelationMembers(boolean complete) {
while (relationMemberBuffer.size() >= INSERT_BULK_ROW_COUNT_RELATION_MEMBER) {
int prmIndex;
prmIndex = 1;
for (int i = 0; i < INSERT_BULK_ROW_COUNT_RELATION_MEMBER; i++) {
populateRelationMemberParameters(bulkRelationMemberStatement, prmIndex, relationMemberBuffer.remove(0));
prmIndex += INSERT_PRM_COUNT_RELATION_MEMBER;
transactionSizeCount++;
}
try {
bulkRelationMemberStatement.executeUpdate();
if (transactionSizeCount % TRANSACTION_SIZE == 0) {
dbCtx.commit();
}
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to bulk insert relation members into the database.", e);
}
}
if (complete) {
while (relationMemberBuffer.size() > 0) {
populateRelationMemberParameters(singleRelationMemberStatement, 1, relationMemberBuffer.remove(0));
try {
singleRelationMemberStatement.executeUpdate();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert a relation member into the database.", e);
}
}
}
dbCtx.commit();
}
private void populateCurrentNodes() {
// Copy data into the current node tables.
for (long i = minNodeId; i < maxNodeId; i += LOAD_CURRENT_NODE_ROW_COUNT) {
// Node
try {
loadCurrentNodesStatement.setLong(1, i);
loadCurrentNodesStatement.setLong(2, i + LOAD_CURRENT_NODE_ROW_COUNT);
loadCurrentNodesStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to load current nodes.", e);
}
// Node tags
try {
loadCurrentNodeTagsStatement.setLong(1, i);
loadCurrentNodeTagsStatement.setLong(2, i + LOAD_CURRENT_NODE_ROW_COUNT);
loadCurrentNodeTagsStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to load current node tags.", e);
}
dbCtx.commit();
}
}
private void populateCurrentWays() {
for (long i = minWayId; i < maxWayId; i += LOAD_CURRENT_WAY_ROW_COUNT) {
// Way
try {
loadCurrentWaysStatement.setLong(1, i);
loadCurrentWaysStatement.setLong(2, i + LOAD_CURRENT_WAY_ROW_COUNT);
loadCurrentWaysStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to load current ways.", e);
}
// Way tags
try {
loadCurrentWayTagsStatement.setLong(1, i);
loadCurrentWayTagsStatement.setLong(2, i + LOAD_CURRENT_WAY_ROW_COUNT);
loadCurrentWayTagsStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to load current way tags.", e);
}
// Way nodes
try {
loadCurrentWayNodesStatement.setLong(1, i);
loadCurrentWayNodesStatement.setLong(2, i + LOAD_CURRENT_WAY_ROW_COUNT);
loadCurrentWayNodesStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to load current way nodes.", e);
}
dbCtx.commit();
}
}
private void populateCurrentRelations() {
for (long i = minRelationId; i < maxRelationId; i += LOAD_CURRENT_RELATION_ROW_COUNT) {
// Way
try {
loadCurrentRelationsStatement.setLong(1, i);
loadCurrentRelationsStatement.setLong(2, i + LOAD_CURRENT_RELATION_ROW_COUNT);
loadCurrentRelationsStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to load current relations.", e);
}
// Relation tags
try {
loadCurrentRelationTagsStatement.setLong(1, i);
loadCurrentRelationTagsStatement.setLong(2, i + LOAD_CURRENT_RELATION_ROW_COUNT);
loadCurrentRelationTagsStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to load current relation tags.", e);
}
// Relation members
try {
loadCurrentRelationMembersStatement.setLong(1, i);
loadCurrentRelationMembersStatement.setLong(2, i + LOAD_CURRENT_RELATION_ROW_COUNT);
loadCurrentRelationMembersStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to load current relation members.", e);
}
dbCtx.commit();
}
}
private void populateCurrentTables() {
if (populateCurrentTables) {
populateCurrentNodes();
populateCurrentWays();
populateCurrentRelations();
}
}
/**
* {@inheritDoc}
*/
public void initialize(Map metaData) {
// Do nothing.
}
/**
* Writes any buffered data to the database and commits.
*/
@Override
public void complete() {
initialize();
flushNodes(true);
flushNodeTags(true);
flushWays(true);
flushWayTags(true);
flushWayNodes(true);
flushRelations(true);
flushRelationTags(true);
flushRelationMembers(true);
// Re-enable indexes now that the load has completed.
dbCtx.enableIndexes(DISABLE_KEY_TABLES);
populateCurrentTables();
// Unlock tables (if they were locked) now that we have completed.
if (lockTables) {
dbCtx.unlockTables(LOCK_TABLES);
}
dbCtx.commit();
}
/**
* Releases all database resources.
*/
public void close() {
userManager.close();
dbCtx.close();
}
/**
* {@inheritDoc}
*/
public void process(EntityContainer entityContainer) {
Entity entity;
initialize();
entity = entityContainer.getEntity();
userManager.addOrUpdateUser(entityContainer.getEntity().getUser());
changesetManager.addChangesetIfRequired(entity.getChangesetId(), entity.getUser());
entityContainer.process(this);
}
/**
* {@inheritDoc}
*/
public void process(BoundContainer boundContainer) {
// Do nothing.
}
/**
* {@inheritDoc}
*/
public void process(NodeContainer nodeContainer) {
Node node;
long nodeId;
node = nodeContainer.getEntity();
nodeId = node.getId();
if (nodeId >= maxNodeId) {
maxNodeId = nodeId + 1;
}
if (nodeId < minNodeId) {
minNodeId = nodeId;
}
nodeBuffer.add(node);
flushNodes(false);
}
/**
* Process the node tags.
*
* @param node The node to be processed.
*/
private void addNodeTags(Node node) {
for (Tag tag : node.getTags()) {
nodeTagBuffer.add(new DbFeatureHistory>(new DbFeature(node.getId(), tag), node
.getVersion()));
}
flushNodeTags(false);
}
/**
* {@inheritDoc}
*/
public void process(WayContainer wayContainer) {
Way way;
long wayId;
flushNodes(true);
way = wayContainer.getEntity();
wayId = way.getId();
if (wayId >= maxWayId) {
maxWayId = wayId + 1;
}
if (wayId < minWayId) {
minWayId = wayId;
}
wayBuffer.add(way);
flushWays(false);
}
/**
* Process the way tags.
*
* @param way The way to be processed.
*/
private void addWayTags(Way way) {
for (Tag tag : way.getTags()) {
wayTagBuffer.add(new DbFeatureHistory>(new DbFeature(way.getId(), tag), way
.getVersion()));
}
flushWayTags(false);
}
/**
* Process the way nodes.
*
* @param way The way to be processed.
*/
private void addWayNodes(Way way) {
List nodeReferenceList;
nodeReferenceList = way.getWayNodes();
for (int i = 0; i < nodeReferenceList.size(); i++) {
wayNodeBuffer.add(new DbFeatureHistory>(new DbOrderedFeature(
way.getId(), nodeReferenceList.get(i), i + 1), way.getVersion()));
}
flushWayNodes(false);
}
/**
* {@inheritDoc}
*/
public void process(RelationContainer relationContainer) {
Relation relation;
long relationId;
flushWays(true);
relation = relationContainer.getEntity();
relationId = relation.getId();
if (relationId >= maxRelationId) {
maxRelationId = relationId + 1;
}
if (relationId < minRelationId) {
minRelationId = relationId;
}
relationBuffer.add(relation);
flushRelations(false);
}
/**
* Process the relation tags.
*
* @param relation The relation to be processed.
*/
private void addRelationTags(Relation relation) {
for (Tag tag : relation.getTags()) {
relationTagBuffer.add(new DbFeatureHistory>(new DbFeature(relation.getId(), tag),
relation.getVersion()));
}
flushRelationTags(false);
}
/**
* Process the relation members.
*
* @param relation The relation to be processed.
*/
private void addRelationMembers(Relation relation) {
List memberReferenceList;
memberReferenceList = relation.getMembers();
for (int i = 0; i < memberReferenceList.size(); i++) {
relationMemberBuffer.add(new DbFeatureHistory>(
new DbOrderedFeature(relation.getId(), memberReferenceList.get(i), i + 1), relation
.getVersion()));
}
flushRelationMembers(false);
}
}
ApidbWriterFactory.java 0000664 0000000 0000000 00000003354 14532772205 0034055 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.DatabasePreferences;
import org.openstreetmap.osmosis.core.database.DatabaseTaskManagerFactory;
import org.openstreetmap.osmosis.core.pipeline.common.TaskConfiguration;
import org.openstreetmap.osmosis.core.pipeline.common.TaskManager;
import org.openstreetmap.osmosis.core.pipeline.v0_6.SinkManager;
/**
* The task manager factory for a database writer.
*
* @author Brett Henderson
*/
public class ApidbWriterFactory extends DatabaseTaskManagerFactory {
private static final String ARG_LOCK_TABLES = "lockTables";
private static final String ARG_POPULATE_CURRENT_TABLES = "populateCurrentTables";
private static final boolean DEFAULT_LOCK_TABLES = true;
private static final boolean DEFAULT_POPULATE_CURRENT_TABLES = true;
/**
* {@inheritDoc}
*/
@Override
protected TaskManager createTaskManagerImpl(TaskConfiguration taskConfig) {
DatabaseLoginCredentials loginCredentials;
DatabasePreferences preferences;
boolean lockTables;
boolean populateCurrentTables;
// Get the task arguments.
loginCredentials = getDatabaseLoginCredentials(taskConfig);
preferences = getDatabasePreferences(taskConfig);
lockTables = getBooleanArgument(taskConfig, ARG_LOCK_TABLES, DEFAULT_LOCK_TABLES);
populateCurrentTables = getBooleanArgument(
taskConfig, ARG_POPULATE_CURRENT_TABLES, DEFAULT_POPULATE_CURRENT_TABLES);
return new SinkManager(
taskConfig.getId(),
new ApidbWriter(loginCredentials, preferences, lockTables, populateCurrentTables),
taskConfig.getPipeArgs()
);
}
}
osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/impl/ 0000775 0000000 0000000 00000000000 14532772205 0030461 5 ustar 00root root 0000000 0000000 ActionChangeWriter.java 0000664 0000000 0000000 00000003202 14532772205 0034762 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/impl // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6.impl;
import org.openstreetmap.osmosis.core.container.v0_6.BoundContainer;
import org.openstreetmap.osmosis.core.container.v0_6.EntityProcessor;
import org.openstreetmap.osmosis.core.container.v0_6.NodeContainer;
import org.openstreetmap.osmosis.core.container.v0_6.RelationContainer;
import org.openstreetmap.osmosis.core.container.v0_6.WayContainer;
import org.openstreetmap.osmosis.core.task.common.ChangeAction;
/**
* Writes entities to a database according to a specific action.
*
* @author Brett Henderson
*/
public class ActionChangeWriter implements EntityProcessor {
private ChangeWriter changeWriter;
private ChangeAction action;
/**
* Creates a new instance.
*
* @param changeWriter
* The underlying change writer.
* @param action
* The action to apply to all writes.
*/
public ActionChangeWriter(ChangeWriter changeWriter, ChangeAction action) {
this.changeWriter = changeWriter;
this.action = action;
}
/**
* {@inheritDoc}
*/
public void process(BoundContainer bound) {
// Do nothing.
}
/**
* {@inheritDoc}
*/
public void process(NodeContainer nodeContainer) {
changeWriter.write(nodeContainer.getEntity(), action);
}
/**
* {@inheritDoc}
*/
public void process(WayContainer wayContainer) {
changeWriter.write(wayContainer.getEntity(), action);
}
/**
* {@inheritDoc}
*/
public void process(RelationContainer relationContainer) {
changeWriter.write(relationContainer.getEntity(), action);
}
}
AllEntityDao.java 0000664 0000000 0000000 00000011406 14532772205 0033600 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/impl // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6.impl;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.openstreetmap.osmosis.core.container.v0_6.ChangeContainer;
import org.openstreetmap.osmosis.core.container.v0_6.EntityContainer;
import org.openstreetmap.osmosis.core.lifecycle.ReleasableContainer;
import org.openstreetmap.osmosis.core.lifecycle.ReleasableIterator;
import org.openstreetmap.osmosis.core.store.MultipleSourceIterator;
import org.springframework.jdbc.core.JdbcTemplate;
/**
* Provides operations that act on on all entity types by combining operations from the underlying
* DAO implementations.
*/
public class AllEntityDao implements ReplicationSource {
private NodeDao nodeDao;
private WayDao wayDao;
private RelationDao relationDao;
/**
* Creates a new instance.
*
* @param jdbcTemplate
* Used to access the database.
*/
public AllEntityDao(JdbcTemplate jdbcTemplate) {
nodeDao = new NodeDao(jdbcTemplate);
wayDao = new WayDao(jdbcTemplate);
relationDao = new RelationDao(jdbcTemplate);
}
/**
* Retrieves the changes that have were made by a set of transactions.
*
* @param predicates
* Contains the predicates defining the transactions to be queried.
* @return An iterator pointing at the identified records.
*/
public ReleasableIterator getHistory(ReplicationQueryPredicates predicates) {
try (ReleasableContainer releasableContainer = new ReleasableContainer()) {
List> sources;
MultipleSourceIterator resultIterator;
sources = new ArrayList>();
sources.add(releasableContainer.add(nodeDao.getHistory(predicates)));
sources.add(releasableContainer.add(wayDao.getHistory(predicates)));
sources.add(releasableContainer.add(relationDao.getHistory(predicates)));
resultIterator = new MultipleSourceIterator(sources);
releasableContainer.clear();
return resultIterator;
}
}
/**
* Retrieves the changes that have were made between two points in time.
*
* @param intervalBegin
* Marks the beginning (inclusive) of the time interval to be checked.
* @param intervalEnd
* Marks the end (exclusive) of the time interval to be checked.
* @return An iterator pointing at the identified records.
*/
public ReleasableIterator getHistory(Date intervalBegin, Date intervalEnd) {
try (ReleasableContainer releasableContainer = new ReleasableContainer()) {
List> sources;
MultipleSourceIterator resultIterator;
sources = new ArrayList>();
sources.add(releasableContainer.add(nodeDao.getHistory(intervalBegin, intervalEnd)));
sources.add(releasableContainer.add(wayDao.getHistory(intervalBegin, intervalEnd)));
sources.add(releasableContainer.add(relationDao.getHistory(intervalBegin, intervalEnd)));
resultIterator = new MultipleSourceIterator(sources);
releasableContainer.clear();
return resultIterator;
}
}
/**
* Retrieves all changes in the database.
*
* @return An iterator pointing at the identified records.
*/
public ReleasableIterator getHistory() {
try (ReleasableContainer releasableContainer = new ReleasableContainer()) {
List> sources;
MultipleSourceIterator resultIterator;
sources = new ArrayList>();
sources.add(releasableContainer.add(nodeDao.getHistory()));
sources.add(releasableContainer.add(wayDao.getHistory()));
sources.add(releasableContainer.add(relationDao.getHistory()));
resultIterator = new MultipleSourceIterator(sources);
releasableContainer.clear();
return resultIterator;
}
}
/**
* Retrieves all current data in the database.
*
* @return An iterator pointing at the current records.
*/
public ReleasableIterator getCurrent() {
try (ReleasableContainer releasableContainer = new ReleasableContainer()) {
List> sources;
MultipleSourceIterator resultIterator;
sources = new ArrayList>();
sources.add(releasableContainer.add(nodeDao.getCurrent()));
sources.add(releasableContainer.add(wayDao.getCurrent()));
sources.add(releasableContainer.add(relationDao.getCurrent()));
resultIterator = new MultipleSourceIterator(sources);
releasableContainer.clear();
return resultIterator;
}
}
}
ChangeReader.java 0000664 0000000 0000000 00000006077 14532772205 0033567 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/impl // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6.impl;
import org.openstreetmap.osmosis.core.container.v0_6.ChangeContainer;
import org.openstreetmap.osmosis.core.container.v0_6.EntityContainer;
import org.openstreetmap.osmosis.core.container.v0_6.EntityContainerFactory;
import org.openstreetmap.osmosis.core.domain.v0_6.Entity;
import org.openstreetmap.osmosis.core.lifecycle.ReleasableIterator;
import org.openstreetmap.osmosis.core.task.common.ChangeAction;
/**
* Creates change records based on the data provided by an underlying entity history iterator.
*
* @param
* The type of entity provided by this iterator.
*/
public class ChangeReader implements ReleasableIterator {
private ReleasableIterator> source;
private EntityContainerFactory containerFactory;
/**
* Creates a new instance.
*
* @param source
* The entity history source.
* @param containerFactory
* The factory for wrapping entity objects into containers.
*/
public ChangeReader(ReleasableIterator> source, EntityContainerFactory containerFactory) {
this.source = source;
this.containerFactory = containerFactory;
}
/**
* {@inheritDoc}
*/
@Override
public boolean hasNext() {
return source.hasNext();
}
/**
* {@inheritDoc}
*/
@Override
public ChangeContainer next() {
EntityHistory entityHistory;
T entity;
EntityContainer entityContainer;
boolean createdPreviously;
// Get the entity from the underlying source.
entityHistory = source.next();
entity = entityHistory.getEntity();
// Wrap the entity in a container.
entityContainer = containerFactory.createContainer(entity);
// This is only a create if the version is 1.
createdPreviously = (entityHistory.getEntity().getVersion() > 1);
// The entity has been modified if it is visible and was created previously.
// It is a create if it is visible and was NOT created previously.
// It is a delete if it is NOT visible and was created previously.
// No action if it is NOT visible and was NOT created previously.
if (entityHistory.isVisible() && createdPreviously) {
return new ChangeContainer(entityContainer, ChangeAction.Modify);
} else if (entityHistory.isVisible() && !createdPreviously) {
return new ChangeContainer(entityContainer, ChangeAction.Create);
} else if (!entityHistory.isVisible() && createdPreviously) {
return new ChangeContainer(entityContainer, ChangeAction.Delete);
} else {
// This is an unusual case in that an initial version has been marked as not visible.
// The production database contains many examples of this, presumably due to the original
// TIGER import not being deleted properly.
return new ChangeContainer(entityContainer, ChangeAction.Delete);
}
}
/**
* {@inheritDoc}
*/
@Override
public void remove() {
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*/
@Override
public void close() {
source.close();
}
}
ChangeWriter.java 0000664 0000000 0000000 00000137657 14532772205 0033652 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/impl // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6.impl;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.util.List;
import org.openstreetmap.osmosis.apidb.common.DatabaseContext;
import org.openstreetmap.osmosis.core.OsmosisRuntimeException;
import org.openstreetmap.osmosis.core.database.DatabaseLoginCredentials;
import org.openstreetmap.osmosis.core.database.ReleasableStatementContainer;
import org.openstreetmap.osmosis.core.domain.v0_6.Entity;
import org.openstreetmap.osmosis.core.domain.v0_6.Node;
import org.openstreetmap.osmosis.core.domain.v0_6.Relation;
import org.openstreetmap.osmosis.core.domain.v0_6.RelationMember;
import org.openstreetmap.osmosis.core.domain.v0_6.Tag;
import org.openstreetmap.osmosis.core.domain.v0_6.Way;
import org.openstreetmap.osmosis.core.domain.v0_6.WayNode;
import org.openstreetmap.osmosis.core.lifecycle.Completable;
import org.openstreetmap.osmosis.core.task.common.ChangeAction;
import org.openstreetmap.osmosis.core.util.FixedPrecisionCoordinateConvertor;
import org.openstreetmap.osmosis.core.util.TileCalculator;
/**
* Writes changes to a database.
*
* @author Brett Henderson
*/
public class ChangeWriter implements Completable {
private static final String INSERT_SQL_NODE =
"INSERT INTO nodes (node_id, version, timestamp, visible, changeset_id, latitude, longitude, tile)"
+ " VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
private static final String UPDATE_SQL_NODE =
"UPDATE nodes SET timestamp = ?, visible = ?, changeset_id = ?, latitude = ?, longitude = ?, tile = ?"
+ " WHERE node_id = ? AND version = ?";
private static final String SELECT_SQL_NODE_COUNT =
"SELECT Count(node_id) AS rowCount FROM nodes WHERE node_id = ? AND version = ?";
private static final String INSERT_SQL_NODE_CURRENT =
"INSERT INTO current_nodes (id, version, timestamp, visible, changeset_id, latitude, longitude, tile)"
+ " VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
private static final String UPDATE_SQL_NODE_CURRENT =
"UPDATE current_nodes SET version = ?, timestamp = ?, visible = ?, changeset_id = ?, latitude = ?,"
+ " longitude = ?, tile = ? WHERE id = ?";
private static final String SELECT_SQL_NODE_CURRENT_COUNT =
"SELECT Count(id) AS rowCount FROM current_nodes WHERE id = ?";
private static final String INSERT_SQL_NODE_TAG =
"INSERT INTO node_tags (node_id, version, k, v) VALUES (?, ?, ?, ?)";
private static final String DELETE_SQL_NODE_TAG = "DELETE FROM node_tags WHERE node_id = ? AND version = ?";
private static final String INSERT_SQL_NODE_TAG_CURRENT =
"INSERT INTO current_node_tags (node_id, k, v) VALUES (?, ?, ?)";
private static final String DELETE_SQL_NODE_TAG_CURRENT = "DELETE FROM current_node_tags WHERE node_id = ?";
private static final String INSERT_SQL_WAY =
"INSERT INTO ways (way_id, version, timestamp, visible, changeset_id) VALUES (?, ?, ?, ?, ?)";
private static final String UPDATE_SQL_WAY =
"UPDATE ways SET timestamp = ?, visible = ?, changeset_id = ? WHERE way_id = ? AND version = ?";
private static final String SELECT_SQL_WAY_COUNT =
"SELECT Count(way_id) AS rowCount FROM ways WHERE way_id = ? AND version = ?";
private static final String INSERT_SQL_WAY_CURRENT =
"INSERT INTO current_ways (id, version, timestamp, visible, changeset_id) VALUES (?, ?, ?, ?, ?)";
private static final String UPDATE_SQL_WAY_CURRENT =
"UPDATE current_ways SET version = ?, timestamp = ?, visible = ?, changeset_id = ? WHERE id = ?";
private static final String SELECT_SQL_WAY_CURRENT_COUNT =
"SELECT Count(id) AS rowCount FROM current_ways WHERE id = ?";
private static final String INSERT_SQL_WAY_TAG = "INSERT INTO way_tags (way_id, version, k, v) VALUES (?, ?, ?, ?)";
private static final String DELETE_SQL_WAY_TAG = "DELETE FROM way_tags WHERE way_id = ? AND version = ?";
private static final String INSERT_SQL_WAY_TAG_CURRENT =
"INSERT INTO current_way_tags (way_id, k, v) VALUES (?, ?, ?)";
private static final String DELETE_SQL_WAY_TAG_CURRENT = "DELETE FROM current_way_tags WHERE way_id = ?";
private static final String INSERT_SQL_WAY_NODE =
"INSERT INTO way_nodes (way_id, version, node_id, sequence_id) VALUES (?, ?, ?, ?)";
private static final String DELETE_SQL_WAY_NODE = "DELETE FROM way_nodes WHERE way_id = ? AND version = ?";
private static final String INSERT_SQL_WAY_NODE_CURRENT =
"INSERT INTO current_way_nodes (way_id, node_id, sequence_id) VALUES (?, ?, ?)";
private static final String DELETE_SQL_WAY_NODE_CURRENT = "DELETE FROM current_way_nodes WHERE way_id = ?";
private static final String INSERT_SQL_RELATION =
"INSERT INTO relations (relation_id, version, timestamp, visible, changeset_id) VALUES (?, ?, ?, ?, ?)";
private static final String UPDATE_SQL_RELATION =
"UPDATE relations SET timestamp = ?, visible = ?, changeset_id = ? WHERE relation_id = ? AND version = ?";
private static final String SELECT_SQL_RELATION_COUNT =
"SELECT Count(id) AS rowCount FROM current_relations WHERE id = ? AND version = ?";
private static final String INSERT_SQL_RELATION_CURRENT =
"INSERT INTO current_relations (id, version, timestamp, visible, changeset_id) VALUES (?, ?, ?, ?, ?)";
private static final String UPDATE_SQL_RELATION_CURRENT =
"UPDATE current_relations SET version = ?, timestamp = ?, visible = ?, changeset_id = ? WHERE id = ?";
private static final String SELECT_SQL_RELATION_CURRENT_COUNT =
"SELECT Count(id) AS rowCount FROM current_relations WHERE id = ?";
private static final String INSERT_SQL_RELATION_TAG =
"INSERT INTO relation_tags (relation_id, version, k, v) VALUES (?, ?, ?, ?)";
private static final String DELETE_SQL_RELATION_TAG =
"DELETE FROM relation_tags WHERE relation_id = ? AND version = ?";
private static final String INSERT_SQL_RELATION_TAG_CURRENT =
"INSERT INTO current_relation_tags (relation_id, k, v) VALUES (?, ?, ?)";
private static final String DELETE_SQL_RELATION_TAG_CURRENT =
"DELETE FROM current_relation_tags WHERE relation_id = ?";
private static final String INSERT_SQL_RELATION_MEMBER_MYSQL =
"INSERT INTO relation_members (relation_id, version, member_type, member_id, member_role, sequence_id)"
+ " VALUES (?, ?, ?, ?, ?, ?)";
private static final String INSERT_SQL_RELATION_MEMBER_PGSQL =
"INSERT INTO relation_members (relation_id, version, member_type, member_id, member_role, sequence_id)"
+ " VALUES (?, ?, ?::nwr_enum, ?, ?, ?)";
private static final String DELETE_SQL_RELATION_MEMBER =
"DELETE FROM relation_members WHERE relation_id = ? AND version = ?";
private static final String INSERT_SQL_RELATION_MEMBER_CURRENT_MYSQL =
"INSERT INTO current_relation_members (relation_id, member_type, member_id, member_role, sequence_id)"
+ " VALUES (?, ?, ?, ?, ?)";
private static final String INSERT_SQL_RELATION_MEMBER_CURRENT_PGSQL =
"INSERT INTO current_relation_members (relation_id, member_type, member_id, member_role, sequence_id)"
+ " VALUES (?, ?::nwr_enum, ?, ?, ?)";
private static final String DELETE_SQL_RELATION_MEMBER_CURRENT =
"DELETE FROM current_relation_members WHERE relation_id = ?";
private final DatabaseContext dbCtx;
private final UserManager userManager;
private final ChangesetManager changesetManager;
private final boolean populateCurrentTables;
private final ReleasableStatementContainer statementContainer;
private PreparedStatement insertNodeStatement;
private PreparedStatement updateNodeStatement;
private PreparedStatement selectNodeCountStatement;
private PreparedStatement insertNodeCurrentStatement;
private PreparedStatement updateNodeCurrentStatement;
private PreparedStatement selectNodeCurrentCountStatement;
private PreparedStatement insertNodeTagStatement;
private PreparedStatement deleteNodeTagStatement;
private PreparedStatement insertNodeTagCurrentStatement;
private PreparedStatement deleteNodeTagCurrentStatement;
private PreparedStatement insertWayStatement;
private PreparedStatement updateWayStatement;
private PreparedStatement selectWayCountStatement;
private PreparedStatement insertWayCurrentStatement;
private PreparedStatement updateWayCurrentStatement;
private PreparedStatement selectWayCurrentCountStatement;
private PreparedStatement insertWayTagStatement;
private PreparedStatement deleteWayTagStatement;
private PreparedStatement insertWayTagCurrentStatement;
private PreparedStatement deleteWayTagCurrentStatement;
private PreparedStatement insertWayNodeStatement;
private PreparedStatement deleteWayNodeStatement;
private PreparedStatement insertWayNodeCurrentStatement;
private PreparedStatement deleteWayNodeCurrentStatement;
private PreparedStatement insertRelationStatement;
private PreparedStatement updateRelationStatement;
private PreparedStatement selectRelationCountStatement;
private PreparedStatement insertRelationCurrentStatement;
private PreparedStatement updateRelationCurrentStatement;
private PreparedStatement selectRelationCurrentCountStatement;
private PreparedStatement insertRelationTagStatement;
private PreparedStatement deleteRelationTagStatement;
private PreparedStatement insertRelationTagCurrentStatement;
private PreparedStatement deleteRelationTagCurrentStatement;
private PreparedStatement insertRelationMemberStatement;
private PreparedStatement deleteRelationMemberStatement;
private PreparedStatement insertRelationMemberCurrentStatement;
private PreparedStatement deleteRelationMemberCurrentStatement;
private final MemberTypeRenderer memberTypeRenderer;
private final TileCalculator tileCalculator;
/**
* Creates a new instance.
*
* @param loginCredentials Contains all information required to connect to the database.
* @param populateCurrentTables If true, the current tables will be populated as well as history
* tables.
*/
public ChangeWriter(DatabaseLoginCredentials loginCredentials, boolean populateCurrentTables) {
dbCtx = new DatabaseContext(loginCredentials);
statementContainer = new ReleasableStatementContainer();
userManager = new UserManager(dbCtx);
changesetManager = new ChangesetManager(dbCtx);
this.populateCurrentTables = populateCurrentTables;
tileCalculator = new TileCalculator();
memberTypeRenderer = new MemberTypeRenderer();
}
/**
* Checks to see if the specified entity exists.
*
* @param statement The statement used to perform the check.
* @param id The entity identifier.
* @return True if the entity exists, false otherwise.
* @throws SQLException if an error occurs accessing the database.
*/
private boolean checkIfEntityExists(PreparedStatement statement, long id) throws SQLException {
statement.setLong(1, id);
try (ResultSet resultSet = statement.executeQuery()) {
resultSet.next();
return (resultSet.getInt("rowCount") != 0);
}
}
/**
* Checks to see if the specified entity history item exists.
*
* @param statement The statement used to perform the check.
* @param id The entity identifier.
* @param version The entity version.
* @return True if the entity exists, false otherwise.
* @throws SQLException if an error occurs accessing the database.
*/
private boolean checkIfEntityHistoryExists(PreparedStatement statement, long id, int version) throws SQLException {
int prmIndex = 1;
statement.setLong(prmIndex++, id);
statement.setInt(prmIndex++, version);
try (ResultSet resultSet = statement.executeQuery()) {
resultSet.next();
return (resultSet.getInt("rowCount") != 0);
}
}
private void assertEntityHasTimestamp(Entity entity) {
if (entity.getTimestamp() == null) {
throw new OsmosisRuntimeException(
entity.getType().toString() + " " + entity.getId() + " does not have a timestamp set.");
}
}
/**
* Writes the specified node change to the database.
*
* @param node The node to be written.
* @param action The change to be applied.
*/
public void write(Node node, ChangeAction action) {
boolean visible;
boolean exists;
int prmIndex;
assertEntityHasTimestamp(node);
// Add or update the user in the database.
userManager.addOrUpdateUser(node.getUser());
// Create the changeset in the database.
changesetManager.addChangesetIfRequired(node.getChangesetId(), node.getUser());
// If this is a deletion, the entity is not visible.
visible = !action.equals(ChangeAction.Delete);
// Create the prepared statements for node creation if necessary.
if (insertNodeStatement == null) {
insertNodeStatement = statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_NODE));
updateNodeStatement = statementContainer.add(dbCtx.prepareStatement(UPDATE_SQL_NODE));
selectNodeCountStatement = statementContainer.add(dbCtx.prepareStatement(SELECT_SQL_NODE_COUNT));
insertNodeCurrentStatement = statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_NODE_CURRENT));
updateNodeCurrentStatement = statementContainer.add(dbCtx.prepareStatement(UPDATE_SQL_NODE_CURRENT));
selectNodeCurrentCountStatement = statementContainer.add(dbCtx
.prepareStatement(SELECT_SQL_NODE_CURRENT_COUNT));
insertNodeTagStatement = statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_NODE_TAG));
deleteNodeTagStatement = statementContainer.add(dbCtx.prepareStatement(DELETE_SQL_NODE_TAG));
insertNodeTagCurrentStatement = statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_NODE_TAG_CURRENT));
deleteNodeTagCurrentStatement = statementContainer.add(dbCtx.prepareStatement(DELETE_SQL_NODE_TAG_CURRENT));
}
// Remove the existing tags of the node history item.
try {
prmIndex = 1;
deleteNodeTagStatement.setLong(prmIndex++, node.getId());
deleteNodeTagStatement.setInt(prmIndex++, node.getVersion());
deleteNodeTagStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to delete node history tags for node with id=" + node.getId()
+ ".", e);
}
// Update the node if it already exists in the history table, otherwise insert it.
try {
exists = checkIfEntityHistoryExists(selectNodeCountStatement, node.getId(), node.getVersion());
} catch (SQLException e) {
throw new OsmosisRuntimeException(
"Unable to check if current node with id=" + node.getId() + " exists.", e);
}
if (exists) {
// Update the node in the history table.
try {
prmIndex = 1;
updateNodeStatement.setTimestamp(prmIndex++, new Timestamp(node.getTimestamp().getTime()));
updateNodeStatement.setBoolean(prmIndex++, visible);
updateNodeStatement.setLong(prmIndex++, node.getChangesetId());
updateNodeStatement.setInt(prmIndex++, FixedPrecisionCoordinateConvertor.convertToFixed(node
.getLatitude()));
updateNodeStatement.setInt(prmIndex++, FixedPrecisionCoordinateConvertor.convertToFixed(node
.getLongitude()));
updateNodeStatement.setLong(prmIndex++, tileCalculator.calculateTile(node.getLatitude(), node
.getLongitude()));
updateNodeStatement.setLong(prmIndex++, node.getId());
updateNodeStatement.setInt(prmIndex++, node.getVersion());
updateNodeStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to update history node with id=" + node.getId() + ".", e);
}
} else {
// Insert the new node into the history table.
try {
prmIndex = 1;
insertNodeStatement.setLong(prmIndex++, node.getId());
insertNodeStatement.setInt(prmIndex++, node.getVersion());
insertNodeStatement.setTimestamp(prmIndex++, new Timestamp(node.getTimestamp().getTime()));
insertNodeStatement.setBoolean(prmIndex++, visible);
insertNodeStatement.setLong(prmIndex++, node.getChangesetId());
insertNodeStatement.setInt(prmIndex++, FixedPrecisionCoordinateConvertor.convertToFixed(node
.getLatitude()));
insertNodeStatement.setInt(prmIndex++, FixedPrecisionCoordinateConvertor.convertToFixed(node
.getLongitude()));
insertNodeStatement.setLong(prmIndex++, tileCalculator.calculateTile(node.getLatitude(), node
.getLongitude()));
insertNodeStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert history node with id=" + node.getId() + ".", e);
}
}
// Insert the tags of the new node into the history table.
for (Tag tag : node.getTags()) {
try {
prmIndex = 1;
insertNodeTagStatement.setLong(prmIndex++, node.getId());
insertNodeTagStatement.setInt(prmIndex++, node.getVersion());
insertNodeTagStatement.setString(prmIndex++, tag.getKey());
insertNodeTagStatement.setString(prmIndex++, tag.getValue());
insertNodeTagStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert history node tag with id=" + node.getId()
+ " and key=(" + tag.getKey() + ").", e);
}
}
if (populateCurrentTables) {
// Delete the existing node tags from the current table.
try {
deleteNodeTagCurrentStatement.setLong(1, node.getId());
deleteNodeTagCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException(
"Unable to delete current node tags with id=" + node.getId() + ".", e);
}
// Update the node if it already exists in the current table, otherwise insert it.
try {
exists = checkIfEntityExists(selectNodeCurrentCountStatement, node.getId());
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to check if current node with id=" + node.getId()
+ " exists.", e);
}
if (exists) {
// Update the node in the current table.
try {
prmIndex = 1;
updateNodeCurrentStatement.setInt(prmIndex++, node.getVersion());
updateNodeCurrentStatement.setTimestamp(prmIndex++, new Timestamp(node.getTimestamp().getTime()));
updateNodeCurrentStatement.setBoolean(prmIndex++, visible);
updateNodeCurrentStatement.setLong(prmIndex++, node.getChangesetId());
updateNodeCurrentStatement.setInt(prmIndex++, FixedPrecisionCoordinateConvertor.convertToFixed(node
.getLatitude()));
updateNodeCurrentStatement.setInt(prmIndex++, FixedPrecisionCoordinateConvertor.convertToFixed(node
.getLongitude()));
updateNodeCurrentStatement.setLong(prmIndex++, tileCalculator.calculateTile(node.getLatitude(),
node.getLongitude()));
updateNodeCurrentStatement.setLong(prmIndex++, node.getId());
updateNodeCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to update current node with id=" + node.getId() + ".", e);
}
} else {
// Insert the new node into the current table.
try {
prmIndex = 1;
insertNodeCurrentStatement.setLong(prmIndex++, node.getId());
insertNodeCurrentStatement.setInt(prmIndex++, node.getVersion());
insertNodeCurrentStatement.setTimestamp(prmIndex++, new Timestamp(node.getTimestamp().getTime()));
insertNodeCurrentStatement.setBoolean(prmIndex++, visible);
insertNodeCurrentStatement.setLong(prmIndex++, node.getChangesetId());
insertNodeCurrentStatement.setInt(prmIndex++, FixedPrecisionCoordinateConvertor.convertToFixed(node
.getLatitude()));
insertNodeCurrentStatement.setInt(prmIndex++, FixedPrecisionCoordinateConvertor.convertToFixed(node
.getLongitude()));
insertNodeCurrentStatement.setLong(prmIndex++, tileCalculator.calculateTile(node.getLatitude(),
node.getLongitude()));
insertNodeCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert current node with id=" + node.getId() + ".", e);
}
}
// Insert the tags of the new node into the current table.
for (Tag tag : node.getTags()) {
try {
prmIndex = 1;
insertNodeTagCurrentStatement.setLong(prmIndex++, node.getId());
insertNodeTagCurrentStatement.setString(prmIndex++, tag.getKey());
insertNodeTagCurrentStatement.setString(prmIndex++, tag.getValue());
insertNodeTagCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert current node tag with id=" + node.getId()
+ " and key=(" + tag.getKey() + ").", e);
}
}
}
}
/**
* Writes the specified way change to the database.
*
* @param way The way to be written.
* @param action The change to be applied.
*/
public void write(Way way, ChangeAction action) {
boolean visible;
boolean exists;
int prmIndex;
List nodeReferenceList;
assertEntityHasTimestamp(way);
// Add or update the user in the database.
userManager.addOrUpdateUser(way.getUser());
// Create the changeset in the database.
changesetManager.addChangesetIfRequired(way.getChangesetId(), way.getUser());
nodeReferenceList = way.getWayNodes();
// If this is a deletion, the entity is not visible.
visible = !action.equals(ChangeAction.Delete);
// Create the prepared statements for way creation if necessary.
if (insertWayStatement == null) {
insertWayStatement = statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_WAY));
updateWayStatement = statementContainer.add(dbCtx.prepareStatement(UPDATE_SQL_WAY));
selectWayCountStatement = statementContainer.add(dbCtx.prepareStatement(SELECT_SQL_WAY_COUNT));
insertWayCurrentStatement = statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_WAY_CURRENT));
updateWayCurrentStatement = statementContainer.add(dbCtx.prepareStatement(UPDATE_SQL_WAY_CURRENT));
selectWayCurrentCountStatement = statementContainer.add(dbCtx
.prepareStatement(SELECT_SQL_WAY_CURRENT_COUNT));
insertWayTagStatement = statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_WAY_TAG));
deleteWayTagStatement = statementContainer.add(dbCtx.prepareStatement(DELETE_SQL_WAY_TAG));
insertWayTagCurrentStatement = statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_WAY_TAG_CURRENT));
deleteWayTagCurrentStatement = statementContainer.add(dbCtx.prepareStatement(DELETE_SQL_WAY_TAG_CURRENT));
insertWayNodeStatement = statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_WAY_NODE));
deleteWayNodeStatement = statementContainer.add(dbCtx.prepareStatement(DELETE_SQL_WAY_NODE));
insertWayNodeCurrentStatement = statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_WAY_NODE_CURRENT));
deleteWayNodeCurrentStatement = statementContainer.add(dbCtx.prepareStatement(DELETE_SQL_WAY_NODE_CURRENT));
}
// Remove the existing tags of the way history item.
try {
prmIndex = 1;
deleteWayTagStatement.setLong(prmIndex++, way.getId());
deleteWayTagStatement.setInt(prmIndex++, way.getVersion());
deleteWayTagStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to delete way history tags for way with id=" + way.getId() + ".",
e);
}
// Remove the existing way nodes of the way history item.
try {
prmIndex = 1;
deleteWayNodeStatement.setLong(prmIndex++, way.getId());
deleteWayNodeStatement.setInt(prmIndex++, way.getVersion());
deleteWayNodeStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException(
"Unable to delete way history nodes for way with id=" + way.getId() + ".", e);
}
// Update the way if it already exists in the history table, otherwise insert it.
try {
exists = checkIfEntityHistoryExists(selectWayCountStatement, way.getId(), way.getVersion());
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to check if current way with id=" + way.getId() + " exists.", e);
}
if (exists) {
// Update the way in the history table.
try {
prmIndex = 1;
updateWayStatement.setTimestamp(prmIndex++, new Timestamp(way.getTimestamp().getTime()));
updateWayStatement.setBoolean(prmIndex++, visible);
updateWayStatement.setLong(prmIndex++, way.getChangesetId());
updateWayStatement.setLong(prmIndex++, way.getId());
updateWayStatement.setInt(prmIndex++, way.getVersion());
updateWayStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to update history way with id=" + way.getId() + ".", e);
}
} else {
// Insert the new way into the history table.
try {
prmIndex = 1;
insertWayStatement.setLong(prmIndex++, way.getId());
insertWayStatement.setInt(prmIndex++, way.getVersion());
insertWayStatement.setTimestamp(prmIndex++, new Timestamp(way.getTimestamp().getTime()));
insertWayStatement.setBoolean(prmIndex++, visible);
insertWayStatement.setLong(prmIndex++, way.getChangesetId());
insertWayStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert history way with id=" + way.getId() + ".", e);
}
}
// Insert the tags of the new way into the history table.
for (Tag tag : way.getTags()) {
try {
prmIndex = 1;
insertWayTagStatement.setLong(prmIndex++, way.getId());
insertWayTagStatement.setInt(prmIndex++, way.getVersion());
insertWayTagStatement.setString(prmIndex++, tag.getKey());
insertWayTagStatement.setString(prmIndex++, tag.getValue());
insertWayTagStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert history way tag with id=" + way.getId()
+ " and key=(" + tag.getKey() + ").", e);
}
}
// Insert the nodes of the new way into the history table.
for (int i = 0; i < nodeReferenceList.size(); i++) {
WayNode nodeReference;
nodeReference = nodeReferenceList.get(i);
try {
prmIndex = 1;
insertWayNodeStatement.setLong(prmIndex++, way.getId());
insertWayNodeStatement.setInt(prmIndex++, way.getVersion());
insertWayNodeStatement.setLong(prmIndex++, nodeReference.getNodeId());
insertWayNodeStatement.setLong(prmIndex++, i + 1);
insertWayNodeStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert history way node with way id=" + way.getId()
+ " and node id=" + nodeReference.getNodeId() + ".", e);
}
}
if (populateCurrentTables) {
// Delete the existing way tags from the current table.
try {
deleteWayTagCurrentStatement.setLong(1, way.getId());
deleteWayTagCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to delete current way tags with id=" + way.getId() + ".", e);
}
// Delete the existing way nodes from the current table.
try {
deleteWayNodeCurrentStatement.setLong(1, way.getId());
deleteWayNodeCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to delete current way nodes with id=" + way.getId() + ".", e);
}
// Update the node if it already exists in the current table, otherwise insert it.
try {
exists = checkIfEntityExists(selectWayCurrentCountStatement, way.getId());
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to check if current way with id=" + way.getId() + " exists.",
e);
}
if (exists) {
// Update the way in the current table.
try {
prmIndex = 1;
updateWayCurrentStatement.setInt(prmIndex++, way.getVersion());
updateWayCurrentStatement.setTimestamp(prmIndex++, new Timestamp(way.getTimestamp().getTime()));
updateWayCurrentStatement.setBoolean(prmIndex++, visible);
updateWayCurrentStatement.setLong(prmIndex++, way.getChangesetId());
updateWayCurrentStatement.setLong(prmIndex++, way.getId());
updateWayCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to update current way with id=" + way.getId() + ".", e);
}
} else {
// Insert the new way into the current table.
try {
prmIndex = 1;
insertWayCurrentStatement.setLong(prmIndex++, way.getId());
insertWayCurrentStatement.setInt(prmIndex++, way.getVersion());
insertWayCurrentStatement.setTimestamp(prmIndex++, new Timestamp(way.getTimestamp().getTime()));
insertWayCurrentStatement.setBoolean(prmIndex++, visible);
insertWayCurrentStatement.setLong(prmIndex++, way.getChangesetId());
insertWayCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert current way with id=" + way.getId() + ".", e);
}
}
// Insert the tags of the new way into the current table.
for (Tag tag : way.getTags()) {
try {
prmIndex = 1;
insertWayTagCurrentStatement.setLong(prmIndex++, way.getId());
insertWayTagCurrentStatement.setString(prmIndex++, tag.getKey());
insertWayTagCurrentStatement.setString(prmIndex++, tag.getValue());
insertWayTagCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert current way tag with id=" + way.getId()
+ " and key=(" + tag.getKey() + ").", e);
}
}
// Insert the nodes of the new way into the current table.
for (int i = 0; i < nodeReferenceList.size(); i++) {
WayNode nodeReference;
nodeReference = nodeReferenceList.get(i);
try {
prmIndex = 1;
insertWayNodeCurrentStatement.setLong(prmIndex++, way.getId());
insertWayNodeCurrentStatement.setLong(prmIndex++, nodeReference.getNodeId());
insertWayNodeCurrentStatement.setLong(prmIndex++, i);
insertWayNodeCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert current way node with way id=" + way.getId()
+ " and node id=" + nodeReference.getNodeId() + ".", e);
}
}
}
}
/**
* Writes the specified relation change to the database.
*
* @param relation The relation to be written.
* @param action The change to be applied.
*/
public void write(Relation relation, ChangeAction action) {
boolean visible;
boolean exists;
int prmIndex;
List relationMemberList;
assertEntityHasTimestamp(relation);
// Add or update the user in the database.
userManager.addOrUpdateUser(relation.getUser());
// Create the changeset in the database.
changesetManager.addChangesetIfRequired(relation.getChangesetId(), relation.getUser());
relationMemberList = relation.getMembers();
// If this is a deletion, the entity is not visible.
visible = !action.equals(ChangeAction.Delete);
// Create the prepared statements for relation creation if necessary.
if (insertRelationStatement == null) {
insertRelationStatement = statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_RELATION));
updateRelationStatement = statementContainer.add(dbCtx.prepareStatement(UPDATE_SQL_RELATION));
selectRelationCountStatement = statementContainer.add(dbCtx.prepareStatement(SELECT_SQL_RELATION_COUNT));
insertRelationCurrentStatement = statementContainer
.add(dbCtx.prepareStatement(INSERT_SQL_RELATION_CURRENT));
updateRelationCurrentStatement = statementContainer
.add(dbCtx.prepareStatement(UPDATE_SQL_RELATION_CURRENT));
selectRelationCurrentCountStatement = statementContainer.add(dbCtx
.prepareStatement(SELECT_SQL_RELATION_CURRENT_COUNT));
insertRelationTagStatement = statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_RELATION_TAG));
deleteRelationTagStatement = statementContainer.add(dbCtx.prepareStatement(DELETE_SQL_RELATION_TAG));
insertRelationTagCurrentStatement = statementContainer.add(dbCtx
.prepareStatement(INSERT_SQL_RELATION_TAG_CURRENT));
deleteRelationTagCurrentStatement = statementContainer.add(dbCtx
.prepareStatement(DELETE_SQL_RELATION_TAG_CURRENT));
switch (dbCtx.getDatabaseType()) {
case POSTGRESQL:
insertRelationMemberStatement =
statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_RELATION_MEMBER_PGSQL));
break;
case MYSQL:
insertRelationMemberStatement =
statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_RELATION_MEMBER_MYSQL));
break;
default:
throw new OsmosisRuntimeException("Unknown database type " + dbCtx.getDatabaseType() + ".");
}
deleteRelationMemberStatement = statementContainer.add(dbCtx.prepareStatement(DELETE_SQL_RELATION_MEMBER));
switch (dbCtx.getDatabaseType()) {
case POSTGRESQL:
insertRelationMemberCurrentStatement =
statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_RELATION_MEMBER_CURRENT_PGSQL));
break;
case MYSQL:
insertRelationMemberCurrentStatement =
statementContainer.add(dbCtx.prepareStatement(INSERT_SQL_RELATION_MEMBER_CURRENT_MYSQL));
break;
default:
throw new OsmosisRuntimeException("Unknown database type " + dbCtx.getDatabaseType() + ".");
}
deleteRelationMemberCurrentStatement = statementContainer.add(dbCtx
.prepareStatement(DELETE_SQL_RELATION_MEMBER_CURRENT));
}
// Remove the existing tags of the relation history item.
try {
prmIndex = 1;
deleteRelationTagStatement.setLong(prmIndex++, relation.getId());
deleteRelationTagStatement.setInt(prmIndex++, relation.getVersion());
deleteRelationTagStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to delete relation history tags for relation with id="
+ relation.getId() + ".", e);
}
// Remove the existing relation members of the relation history item.
try {
prmIndex = 1;
deleteRelationMemberStatement.setLong(prmIndex++, relation.getId());
deleteRelationMemberStatement.setInt(prmIndex++, relation.getVersion());
deleteRelationMemberStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to delete relation history members for relation with id="
+ relation.getId() + ".", e);
}
// Update the relation if it already exists in the history table, otherwise insert it.
try {
exists = checkIfEntityHistoryExists(selectRelationCountStatement, relation.getId(), relation.getVersion());
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to check if current relation with id=" + relation.getId()
+ " exists.", e);
}
if (exists) {
// Update the relation in the history table.
try {
prmIndex = 1;
updateRelationStatement.setTimestamp(prmIndex++, new Timestamp(relation.getTimestamp().getTime()));
updateRelationStatement.setBoolean(prmIndex++, visible);
updateRelationStatement.setLong(prmIndex++, relation.getChangesetId());
updateRelationStatement.setLong(prmIndex++, relation.getId());
updateRelationStatement.setInt(prmIndex++, relation.getVersion());
updateRelationStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException(
"Unable to update history relation with id=" + relation.getId() + ".", e);
}
} else {
// Insert the new relation into the history table.
try {
prmIndex = 1;
insertRelationStatement.setLong(prmIndex++, relation.getId());
insertRelationStatement.setInt(prmIndex++, relation.getVersion());
insertRelationStatement.setTimestamp(prmIndex++, new Timestamp(relation.getTimestamp().getTime()));
insertRelationStatement.setBoolean(prmIndex++, visible);
insertRelationStatement.setLong(prmIndex++, relation.getChangesetId());
insertRelationStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException(
"Unable to insert history relation with id=" + relation.getId() + ".", e);
}
}
// Insert the tags of the new relation into the history table.
for (Tag tag : relation.getTags()) {
try {
prmIndex = 1;
insertRelationTagStatement.setLong(prmIndex++, relation.getId());
insertRelationTagStatement.setInt(prmIndex++, relation.getVersion());
insertRelationTagStatement.setString(prmIndex++, tag.getKey());
insertRelationTagStatement.setString(prmIndex++, tag.getValue());
insertRelationTagStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert history relation tag with id=" + relation.getId()
+ " and key=(" + tag.getKey() + ").", e);
}
}
// Insert the members of the new relation into the history table.
for (int i = 0; i < relationMemberList.size(); i++) {
RelationMember relationMember;
relationMember = relationMemberList.get(i);
try {
prmIndex = 1;
insertRelationMemberStatement.setLong(prmIndex++, relation.getId());
insertRelationMemberStatement.setInt(prmIndex++, relation.getVersion());
insertRelationMemberStatement.setString(prmIndex++, memberTypeRenderer.render(relationMember
.getMemberType()));
insertRelationMemberStatement.setLong(prmIndex++, relationMember.getMemberId());
insertRelationMemberStatement.setString(prmIndex++, relationMember.getMemberRole());
insertRelationMemberStatement.setInt(prmIndex++, i + 1);
insertRelationMemberStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert history relation member with relation id="
+ relation.getId() + ", member type=" + relationMember.getMemberId() + " and member id="
+ relationMember.getMemberId() + ".", e);
}
}
if (populateCurrentTables) {
// Delete the existing relation tags from the current table.
try {
deleteRelationTagCurrentStatement.setLong(1, relation.getId());
deleteRelationTagCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to delete current relation tags with id=" + relation.getId()
+ ".", e);
}
// Delete the existing relation members from the current table.
try {
deleteRelationMemberCurrentStatement.setLong(1, relation.getId());
deleteRelationMemberCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to delete current relation members with id="
+ relation.getId() + ".", e);
}
// Update the relation if it already exists in the current table, otherwise insert it.
try {
exists = checkIfEntityExists(selectRelationCurrentCountStatement, relation.getId());
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to check if current relation with id=" + relation.getId()
+ " exists.", e);
}
if (exists) {
// Update the relation in the current table.
try {
prmIndex = 1;
updateRelationCurrentStatement.setInt(prmIndex++, relation.getVersion());
updateRelationCurrentStatement.setTimestamp(prmIndex++, new Timestamp(relation.getTimestamp()
.getTime()));
updateRelationCurrentStatement.setBoolean(prmIndex++, visible);
updateRelationCurrentStatement.setLong(prmIndex++, relation.getChangesetId());
updateRelationCurrentStatement.setLong(prmIndex++, relation.getId());
updateRelationCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to update current relation with id=" + relation.getId()
+ ".", e);
}
} else {
// Insert the new node into the current table.
try {
prmIndex = 1;
insertRelationCurrentStatement.setLong(prmIndex++, relation.getId());
insertRelationCurrentStatement.setInt(prmIndex++, relation.getVersion());
insertRelationCurrentStatement.setTimestamp(prmIndex++, new Timestamp(relation.getTimestamp()
.getTime()));
insertRelationCurrentStatement.setBoolean(prmIndex++, visible);
insertRelationCurrentStatement.setLong(prmIndex++, relation.getChangesetId());
insertRelationCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert current relation with id=" + relation.getId()
+ ".", e);
}
}
// Insert the tags of the new relation into the current table.
for (Tag tag : relation.getTags()) {
try {
prmIndex = 1;
insertRelationTagCurrentStatement.setLong(prmIndex++, relation.getId());
insertRelationTagCurrentStatement.setString(prmIndex++, tag.getKey());
insertRelationTagCurrentStatement.setString(prmIndex++, tag.getValue());
insertRelationTagCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert current relation tag with id="
+ relation.getId() + " and key=(" + tag.getKey() + ").", e);
}
}
// Insert the members of the new relation into the current table.
for (int i = 0; i < relationMemberList.size(); i++) {
RelationMember relationMember;
relationMember = relationMemberList.get(i);
try {
prmIndex = 1;
insertRelationMemberCurrentStatement.setLong(prmIndex++, relation.getId());
insertRelationMemberCurrentStatement.setString(prmIndex++, memberTypeRenderer.render(relationMember
.getMemberType()));
insertRelationMemberCurrentStatement.setLong(prmIndex++, relationMember.getMemberId());
insertRelationMemberCurrentStatement.setString(prmIndex++, relationMember.getMemberRole());
insertRelationMemberCurrentStatement.setInt(prmIndex++, i + 1);
insertRelationMemberCurrentStatement.execute();
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert current relation member with relation id="
+ relation.getId() + ", member type=" + relationMember.getMemberId() + " and member id="
+ relationMember.getMemberId() + ".", e);
}
}
}
}
/**
* Flushes all changes to the database.
*/
public void complete() {
dbCtx.commit();
}
/**
* Releases all database resources.
*/
public void close() {
statementContainer.close();
userManager.close();
changesetManager.close();
dbCtx.close();
}
}
ChangesetManager.java 0000664 0000000 0000000 00000013524 14532772205 0034446 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/impl // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6.impl;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import org.openstreetmap.osmosis.apidb.common.DatabaseContext;
import org.openstreetmap.osmosis.core.OsmosisConstants;
import org.openstreetmap.osmosis.core.OsmosisRuntimeException;
import org.openstreetmap.osmosis.core.database.ReleasableStatementContainer;
import org.openstreetmap.osmosis.core.domain.v0_6.OsmUser;
import org.openstreetmap.osmosis.core.lifecycle.Closeable;
import org.openstreetmap.osmosis.core.lifecycle.ReleasableContainer;
import org.openstreetmap.osmosis.core.util.FixedPrecisionCoordinateConvertor;
/**
* Creates and maintains changesets for a database conversation. This will create a separate
* changeset for each user id making changes.
*
* @author Brett Henderson
*/
public class ChangesetManager implements Closeable {
private static final int MAX_CHANGESET_ID_CACHE_SIZE = 32768;
private static final String SQL_INSERT_CHANGESET = "INSERT INTO changesets"
+ " (id, user_id, created_at, min_lat, max_lat, min_lon, max_lon, closed_at, num_changes)" + " VALUES"
+ " (?, ?, NOW(), " + FixedPrecisionCoordinateConvertor.convertToFixed(-90) + ", "
+ FixedPrecisionCoordinateConvertor.convertToFixed(90) + ", "
+ FixedPrecisionCoordinateConvertor.convertToFixed(-180) + ", "
+ FixedPrecisionCoordinateConvertor.convertToFixed(180) + ", NOW(), 0)";
private static final String SQL_INSERT_CHANGESET_TAG = "INSERT INTO changeset_tags (changeset_id, k, v)"
+ " VALUES (?, 'created_by', 'Osmosis " + OsmosisConstants.VERSION + "'), (?, 'replication', 'true')";
private static final String SQL_SELECT_CHANGESET_COUNT =
"SELECT Count(*) AS changesetCount FROM changesets WHERE id = ?";
private final DatabaseContext dbCtx;
private final ReleasableContainer releasableContainer;
private final ReleasableStatementContainer statementContainer;
private PreparedStatement insertStatement;
private PreparedStatement insertTagStatement;
private PreparedStatement selectCountStatement;
private Set knownChangesetIds;
/**
* Creates a new instance.
*
* @param dbCtx The database context to use for all database access.
*/
public ChangesetManager(DatabaseContext dbCtx) {
this.dbCtx = dbCtx;
releasableContainer = new ReleasableContainer();
statementContainer = new ReleasableStatementContainer();
releasableContainer.add(statementContainer);
knownChangesetIds = new LinkedHashSet(32768);
}
private int readChangesetCount(ResultSet countSet) {
try (ResultSet resultSet = countSet) {
resultSet.next();
return resultSet.getInt("changesetCount");
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to read the changeset count.", e);
}
}
private boolean doesChangesetExist(long changesetId) {
if (knownChangesetIds.contains(changesetId)) {
return true;
}
if (selectCountStatement == null) {
selectCountStatement = statementContainer.add(dbCtx
.prepareStatementForStreaming(SQL_SELECT_CHANGESET_COUNT));
}
try {
int prmIndex;
boolean changesetExists;
// Check if the changeset exists.
prmIndex = 1;
selectCountStatement.setLong(prmIndex++, changesetId);
changesetExists = readChangesetCount(selectCountStatement.executeQuery()) > 0;
return changesetExists;
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to check if a changeset " + changesetId + " exists.", e);
}
}
private void addChangeset(long changesetId, long userId) {
if (insertStatement == null) {
insertStatement = statementContainer.add(dbCtx.prepareStatement(SQL_INSERT_CHANGESET));
insertTagStatement = statementContainer.add(dbCtx.prepareStatement(SQL_INSERT_CHANGESET_TAG));
}
try {
int prmIndex;
// Insert the new changeset record.
prmIndex = 1;
insertStatement.setLong(prmIndex++, changesetId);
insertStatement.setLong(prmIndex++, userId);
insertStatement.executeUpdate();
// Insert the changeset tags.
prmIndex = 1;
insertTagStatement.setLong(prmIndex++, changesetId);
insertTagStatement.setLong(prmIndex++, changesetId);
insertTagStatement.executeUpdate();
// Add the changeset to the cache, and trim the cache if required.
knownChangesetIds.add(changesetId);
if (knownChangesetIds.size() > MAX_CHANGESET_ID_CACHE_SIZE) {
Iterator i = knownChangesetIds.iterator();
i.next();
i.remove();
}
} catch (SQLException e) {
throw new OsmosisRuntimeException("Unable to insert a new changeset for user with id " + userId + ".", e);
}
}
/**
* Checks to see if the changeset already exists and adds it if it doesn't.
*
* @param changesetId
* The changeset identifier.
* @param user
* The user who created the changeset.
*/
public void addChangesetIfRequired(long changesetId, OsmUser user) {
if (!doesChangesetExist(changesetId)) {
addChangeset(changesetId, user.getId());
}
}
/**
* {@inheritDoc}
*/
@Override
public void close() {
releasableContainer.close();
}
}
DeltaToDiffReader.java 0000664 0000000 0000000 00000006510 14532772205 0034517 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/impl // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6.impl;
import java.util.List;
import java.util.NoSuchElementException;
import org.openstreetmap.osmosis.core.container.v0_6.ChangeContainer;
import org.openstreetmap.osmosis.core.lifecycle.ReleasableIterator;
import org.openstreetmap.osmosis.core.store.PeekableIterator;
import org.openstreetmap.osmosis.core.task.common.ChangeAction;
/**
* Takes an underlying full history delta stream and converts it into a diff stream. The difference
* between the two is that a delta stream may contain multiple changes for a single entity, a diff
* stream will contain a single change for the entity to get from the beginning to end point.
*/
public class DeltaToDiffReader implements ReleasableIterator {
private PeekableIterator> sourceIterator;
private ChangeContainer nextValue;
private boolean nextValueLoaded;
/**
* Creates a new instance.
*
* @param sourceIterator
* An iterator containing the full history for entities.
*/
public DeltaToDiffReader(
ReleasableIterator sourceIterator) {
this.sourceIterator = new PeekableIterator>(new EntityHistoryListReader(sourceIterator));
nextValueLoaded = false;
}
/**
* {@inheritDoc}
*/
public boolean hasNext() {
while (!nextValueLoaded && sourceIterator.hasNext()) {
List changeList;
ChangeContainer changeContainer;
boolean createdPreviously;
// Get the next change list from the underlying stream.
changeList = sourceIterator.next();
// Check the first node, if it has a version greater than 1 the node
// existed prior to the interval beginning and therefore cannot be a
// create.
createdPreviously = (changeList.get(0).getEntityContainer().getEntity().getVersion() > 1);
// Get the most current change.
changeContainer = changeList.get(changeList.size() - 1);
// The entity has been modified if it is a create/modify and was created previously.
// It is a create if it is create/modify and was NOT created previously.
// It is a delete if it is a delete and was created previously.
// No action if it is a delete and was NOT created previously.
if (!ChangeAction.Delete.equals(changeContainer.getAction()) && createdPreviously) {
nextValue = new ChangeContainer(changeContainer.getEntityContainer(), ChangeAction.Modify);
nextValueLoaded = true;
} else if (!ChangeAction.Delete.equals(changeContainer.getAction()) && !createdPreviously) {
nextValue = new ChangeContainer(changeContainer.getEntityContainer(), ChangeAction.Create);
nextValueLoaded = true;
} else if (ChangeAction.Delete.equals(changeContainer.getAction()) && createdPreviously) {
nextValue = new ChangeContainer(changeContainer.getEntityContainer(), ChangeAction.Delete);
nextValueLoaded = true;
}
}
return nextValueLoaded;
}
/**
* {@inheritDoc}
*/
public ChangeContainer next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
nextValueLoaded = false;
return nextValue;
}
/**
* {@inheritDoc}
*/
public void remove() {
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*/
public void close() {
sourceIterator.close();
}
}
EntityContainerReader.java 0000664 0000000 0000000 00000004072 14532772205 0035512 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/impl // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6.impl;
import java.util.NoSuchElementException;
import org.openstreetmap.osmosis.core.container.v0_6.EntityContainer;
import org.openstreetmap.osmosis.core.container.v0_6.EntityContainerFactory;
import org.openstreetmap.osmosis.core.domain.v0_6.Entity;
import org.openstreetmap.osmosis.core.lifecycle.ReleasableIterator;
/**
* Wraps a stream of entity history objects into entity containers. Only visible items will be returned.
*
* @param
* The type of entity provided by this iterator.
*/
public class EntityContainerReader implements ReleasableIterator {
private ReleasableIterator> source;
private EntityContainerFactory containerFactory;
private EntityContainer nextValue;
private boolean nextValueLoaded;
/**
* Creates a new instance.
*
* @param source
* The entity history source.
* @param containerFactory
* The factory for wrapping entity objects into containers.
*/
public EntityContainerReader(
ReleasableIterator> source, EntityContainerFactory containerFactory) {
this.source = source;
this.containerFactory = containerFactory;
}
/**
* {@inheritDoc}
*/
@Override
public boolean hasNext() {
while (!nextValueLoaded && source.hasNext()) {
T entity;
// Get the entity from the underlying source.
entity = source.next().getEntity();
// Wrap the entity in a container.
nextValue = containerFactory.createContainer(entity);
nextValueLoaded = true;
}
return nextValueLoaded;
}
/**
* {@inheritDoc}
*/
@Override
public EntityContainer next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
nextValueLoaded = false;
return nextValue;
}
/**
* {@inheritDoc}
*/
@Override
public void remove() {
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*/
@Override
public void close() {
source.close();
}
}
osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/impl/EntityDao.java 0000664 0000000 0000000 00000050127 14532772205 0033231 0 ustar 00root root 0000000 0000000 // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6.impl;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.openstreetmap.osmosis.core.container.v0_6.ChangeContainer;
import org.openstreetmap.osmosis.core.container.v0_6.EntityContainer;
import org.openstreetmap.osmosis.core.container.v0_6.EntityContainerFactory;
import org.openstreetmap.osmosis.core.database.DbFeature;
import org.openstreetmap.osmosis.core.database.DbFeatureHistory;
import org.openstreetmap.osmosis.core.database.DbFeatureHistoryComparator;
import org.openstreetmap.osmosis.core.database.DbFeatureHistoryRowMapper;
import org.openstreetmap.osmosis.core.database.DbFeatureRowMapper;
import org.openstreetmap.osmosis.core.database.RowMapperListener;
import org.openstreetmap.osmosis.core.database.SortingStoreRowMapperListener;
import org.openstreetmap.osmosis.core.domain.v0_6.CommonEntityData;
import org.openstreetmap.osmosis.core.domain.v0_6.Entity;
import org.openstreetmap.osmosis.core.domain.v0_6.Tag;
import org.openstreetmap.osmosis.core.lifecycle.ReleasableContainer;
import org.openstreetmap.osmosis.core.lifecycle.ReleasableIterator;
import org.openstreetmap.osmosis.core.sort.common.FileBasedSort;
import org.openstreetmap.osmosis.core.store.SingleClassObjectSerializationFactory;
import org.openstreetmap.osmosis.core.store.StoreReleasingIterator;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
/**
* Provides functionality common to all top level entity daos.
*
* @param
* The entity type to be supported.
*/
public abstract class EntityDao {
private static final Logger LOG = Logger.getLogger(EntityDao.class.getName());
private JdbcTemplate jdbcTemplate;
private NamedParameterJdbcTemplate namedParamJdbcTemplate;
private String entityName;
/**
* Creates a new instance.
*
* @param jdbcTemplate
* Used to access the database.
* @param entityName
* The name of the entity. Used for building dynamic sql queries.
*/
protected EntityDao(JdbcTemplate jdbcTemplate, String entityName) {
this.jdbcTemplate = jdbcTemplate;
this.namedParamJdbcTemplate = new NamedParameterJdbcTemplate(jdbcTemplate);
this.entityName = entityName;
}
/**
* Provides access to the named parameter jdbc template.
*
* @return The jdbc template.
*/
protected NamedParameterJdbcTemplate getNamedParamJdbcTemplate() {
return namedParamJdbcTemplate;
}
/**
* Produces an array of additional column names specific to this entity type to be returned by
* entity queries.
*
* @return The column names.
*/
protected abstract String[] getTypeSpecificFieldNames();
/**
* Creates a row mapper that receives common entity data objects and produces full entity
* objects.
*
* @param entityListener
* The full entity object listener.
* @return The full entity row mapper.
*/
protected abstract RowMapperListener getEntityRowMapper(RowMapperListener entityListener);
/**
* Gets the entity container factory for the entity type.
*
* @return The factory.
*/
protected abstract EntityContainerFactory getContainerFactory();
/**
* Gets the history feature populators for the entity type.
*
* @param selectedEntityStatement
* The statement for obtaining the id and version pairs of entity records selected.
* @param parameterSource
* The parameters required to execute the selected entity statement.
* @return The history feature populators.
*/
protected abstract List> getFeatureHistoryPopulators(
String selectedEntityStatement, MapSqlParameterSource parameterSource);
private String buildFeaturelessEntityHistoryQuery(String selectedEntityStatement) {
StringBuilder sql;
sql = new StringBuilder();
sql.append("SELECT e.");
sql.append(entityName);
sql.append("_id AS id, e.version, e.timestamp, e.visible, u.data_public,");
sql.append(" u.id AS user_id, u.display_name, e.changeset_id");
for (String fieldName : getTypeSpecificFieldNames()) {
sql.append(", e.");
sql.append(fieldName);
}
sql.append(" FROM ");
sql.append(entityName);
sql.append("s e");
sql.append(" INNER JOIN ");
sql.append(selectedEntityStatement);
sql.append(" t ON e.");
sql.append(entityName);
sql.append("_id = t.");
sql.append(entityName);
sql.append("_id AND e.version = t.version");
sql.append(" INNER JOIN changesets c ON e.changeset_id = c.id INNER JOIN users u ON c.user_id = u.id");
LOG.log(Level.FINER, "Entity history query: " + sql);
return sql.toString();
}
private ReleasableIterator> getFeaturelessEntityHistory(
String selectedEntityStatement, MapSqlParameterSource parameterSource) {
FileBasedSort> sortingStore =
new FileBasedSort>(
new SingleClassObjectSerializationFactory(EntityHistory.class),
new EntityHistoryComparator(), true);
try {
String sql;
SortingStoreRowMapperListener> storeListener;
EntityHistoryRowMapper entityHistoryRowMapper;
RowMapperListener entityRowMapper;
EntityDataRowMapper entityDataRowMapper;
ReleasableIterator> resultIterator;
sql = buildFeaturelessEntityHistoryQuery(selectedEntityStatement);
// Sends all received data into the object store.
storeListener = new SortingStoreRowMapperListener>(sortingStore);
// Retrieves the visible attribute allowing modifies to be distinguished
// from deletes.
entityHistoryRowMapper = new EntityHistoryRowMapper(storeListener);
// Retrieves the entity type specific columns and builds the entity objects.
entityRowMapper = getEntityRowMapper(entityHistoryRowMapper);
// Retrieves the common entity information.
entityDataRowMapper = new EntityDataRowMapper(entityRowMapper, false);
// Perform the query passing the row mapper chain to process rows in a streamy fashion.
namedParamJdbcTemplate.query(sql, parameterSource, entityDataRowMapper);
// Open a iterator on the store that will release the store upon completion.
resultIterator = new StoreReleasingIterator>(sortingStore.iterate(), sortingStore);
// The store itself shouldn't be released now that it has been attached to the iterator.
sortingStore = null;
return resultIterator;
} finally {
if (sortingStore != null) {
sortingStore.close();
}
}
}
private ReleasableIterator>> getTagHistory(String selectedEntityStatement,
MapSqlParameterSource parameterSource) {
FileBasedSort>> sortingStore =
new FileBasedSort>>(
new SingleClassObjectSerializationFactory(DbFeatureHistory.class),
new DbFeatureHistoryComparator(), true);
try {
String sql;
SortingStoreRowMapperListener>> storeListener;
DbFeatureHistoryRowMapper> dbFeatureHistoryRowMapper;
DbFeatureRowMapper dbFeatureRowMapper;
TagRowMapper tagRowMapper;
ReleasableIterator>> resultIterator;
sql =
"SELECT et."
+ entityName
+ "_id AS id, et.k, et.v, et.version"
+ " FROM "
+ entityName
+ "_tags et"
+ " INNER JOIN "
+ selectedEntityStatement
+ " t ON et."
+ entityName
+ "_id = t."
+ entityName
+ "_id AND et.version = t.version";
LOG.log(Level.FINER, "Tag history query: " + sql);
// Sends all received data into the object store.
storeListener = new SortingStoreRowMapperListener>>(sortingStore);
// Retrieves the version information associated with the tag.
dbFeatureHistoryRowMapper = new DbFeatureHistoryRowMapper>(storeListener);
// Retrieves the entity information associated with the tag.
dbFeatureRowMapper = new DbFeatureRowMapper(dbFeatureHistoryRowMapper);
// Retrieves the basic tag information.
tagRowMapper = new TagRowMapper(dbFeatureRowMapper);
// Perform the query passing the row mapper chain to process rows in a streamy fashion.
namedParamJdbcTemplate.query(sql, parameterSource, tagRowMapper);
// Open a iterator on the store that will release the store upon completion.
resultIterator = new StoreReleasingIterator>>(sortingStore.iterate(),
sortingStore);
// The store itself shouldn't be released now that it has been attached to the iterator.
sortingStore = null;
return resultIterator;
} finally {
if (sortingStore != null) {
sortingStore.close();
}
}
}
private ReleasableIterator> getEntityHistory(
String selectedEntityStatement, MapSqlParameterSource parameterSource) {
ReleasableContainer releasableContainer;
releasableContainer = new ReleasableContainer();
try {
ReleasableIterator> entityIterator;
ReleasableIterator>> tagIterator;
List> featurePopulators;
EntityHistoryReader entityHistoryReader;
entityIterator = releasableContainer.add(
getFeaturelessEntityHistory(selectedEntityStatement, parameterSource));
tagIterator = releasableContainer.add(
getTagHistory(selectedEntityStatement, parameterSource));
featurePopulators = getFeatureHistoryPopulators(selectedEntityStatement, parameterSource);
for (FeatureHistoryPopulator featurePopulator : featurePopulators) {
releasableContainer.add(featurePopulator);
}
entityHistoryReader = new EntityHistoryReader(entityIterator, tagIterator, featurePopulators);
// The sources are now all attached to the history reader so we don't want to release
// them in the finally block.
releasableContainer.clear();
return entityHistoryReader;
} finally {
releasableContainer.close();
}
}
private ReleasableIterator getChangeHistory(
String selectedEntityStatement, MapSqlParameterSource parameterSource) {
return new ChangeReader(getEntityHistory(selectedEntityStatement, parameterSource), getContainerFactory());
}
private List buildTransactionRanges(long bottomTransactionId, long topTransactionId) {
List rangeValues;
int currentXid;
int finishXid;
// Begin building the values to use in the WHERE clause transaction ranges. Each pair of ids
// in this list will become a range selection.
rangeValues = new ArrayList();
// If the bottom and top values are identical then no ranges are required. If we don't add
// this check here we could end up querying for all 4 billion transaction ids or all data in
// the database.
if (bottomTransactionId == topTransactionId) {
return rangeValues;
}
// We must now convert the top and bottom long representations of xids into their integer
// format because that is how they are indexed in the database.
// The bottom id is the first transaction id that has not been read yet, so we begin reading from it.
currentXid = (int) bottomTransactionId;
rangeValues.add(currentXid);
// The top transaction id is the first unassigned transaction id, so we must stop reading one short of that.
finishXid = ((int) topTransactionId) - 1;
// Process until we have enough ranges to reach the finish xid.
do {
// Determine how to terminate the current transaction range.
if (currentXid <= 2 && finishXid >= 0) {
// The range overlaps special ids 0-2 which should never be queried on.
// Terminate the current range before the special values.
rangeValues.add(-1);
// Begin the new range after the special values.
rangeValues.add(3);
currentXid = 3;
} else if (finishXid < currentXid) {
// The range crosses the integer overflow point. Only do this check once we are
// past 2 because the xid special values 0-2 may need to be crossed first.
// Terminate the current range at the maximum int value.
rangeValues.add(Integer.MAX_VALUE);
// Begin a new range at the minimum int value.
rangeValues.add(Integer.MIN_VALUE);
currentXid = Integer.MIN_VALUE;
} else {
// There are no problematic transaction id values between the current value and
// the top transaction id so terminate the current range at the top transaction
// id.
rangeValues.add(finishXid);
currentXid = finishXid;
}
} while (currentXid != finishXid);
return rangeValues;
}
private void buildTransactionRangeWhereClause(StringBuilder sql, MapSqlParameterSource parameters,
long bottomTransactionId, long topTransactionId) {
List rangeValues;
// Determine the transaction ranges required to select all transactions between the bottom
// and top values. This takes into account transaction id wrapping issues and reserved ids.
rangeValues = buildTransactionRanges(bottomTransactionId, topTransactionId);
// Create a range clause for each range pair.
for (int i = 0; i < rangeValues.size(); i = i + 2) {
if (i > 0) {
sql.append(" OR ");
}
sql.append("(");
sql.append("xid_to_int4(xmin) >= :rangeValue").append(i);
sql.append(" AND ");
sql.append("xid_to_int4(xmin) <= :rangeValue").append(i + 1);
sql.append(")");
parameters.addValue("rangeValue" + i, rangeValues.get(i), Types.INTEGER);
parameters.addValue("rangeValue" + (i + 1), rangeValues.get(i + 1), Types.INTEGER);
}
}
private void buildTransactionIdListWhereClause(StringBuilder sql, List transactionIdList) {
for (int i = 0; i < transactionIdList.size(); i++) {
if (i > 0) {
sql.append(",");
}
// Must cast to int to allow the integer based xmin index to be used correctly.
sql.append((int) transactionIdList.get(i).longValue());
}
}
/**
* Retrieves the changes that have were made by a set of transactions.
*
* @param predicates
* Contains the predicates defining the transactions to be queried.
* @return An iterator pointing at the identified records.
*/
public ReleasableIterator getHistory(ReplicationQueryPredicates predicates) {
String selectedEntityTableName;
StringBuilder sql;
MapSqlParameterSource parameterSource;
ReleasableIterator historyIterator;
// PostgreSQL sometimes incorrectly chooses to perform full table scans, these options
// prevent this. Note that this is not recommended practice according to documentation
// but fixing this would require modifying the table statistics gathering
// configuration on the production database to produce better plans.
jdbcTemplate.execute(
"set local enable_seqscan = false;"
+ "set local enable_mergejoin = false;"
+ "set local enable_hashjoin = false");
parameterSource = new MapSqlParameterSource();
selectedEntityTableName = "tmp_" + entityName + "s";
sql = new StringBuilder();
sql.append("CREATE TEMPORARY TABLE ");
sql.append(selectedEntityTableName);
sql.append(" ON COMMIT DROP");
sql.append(" AS SELECT ");
sql.append(entityName);
sql.append("_id, version FROM ");
sql.append(entityName);
sql.append("s WHERE ((");
// Add the main transaction ranges to the where clause.
buildTransactionRangeWhereClause(sql, parameterSource, predicates.getBottomTransactionId(), predicates
.getTopTransactionId());
sql.append(")");
// If previously active transactions have become ready since the last invocation we include those as well.
if (predicates.getReadyList().size() > 0) {
sql.append(" OR xid_to_int4(xmin) IN (");
buildTransactionIdListWhereClause(sql, predicates.getReadyList());
sql.append(")");
}
sql.append(")");
// Any active transactions must be explicitly excluded.
if (predicates.getActiveList().size() > 0) {
sql.append(" AND xid_to_int4(xmin) NOT IN (");
buildTransactionIdListWhereClause(sql, predicates.getActiveList());
sql.append(")");
}
sql.append(" AND redaction_id IS NULL");
LOG.log(Level.FINER, "Entity identification query: " + sql);
namedParamJdbcTemplate.update(sql.toString(), parameterSource);
jdbcTemplate.update("ALTER TABLE ONLY " + selectedEntityTableName
+ " ADD CONSTRAINT pk_" + selectedEntityTableName
+ " PRIMARY KEY (" + entityName + "_id, version)");
jdbcTemplate.update("ANALYZE " + selectedEntityTableName);
if (LOG.isLoggable(Level.FINER)) {
LOG.log(Level.FINER,
jdbcTemplate.queryForObject("SELECT Count(" + entityName + "_id) FROM " + selectedEntityTableName,
Integer.class) + " " + entityName + " records located.");
}
// Extract the data and obtain an iterator for the results.
historyIterator = getChangeHistory(selectedEntityTableName, new MapSqlParameterSource());
// The temp table is no longer required and can be deleted.
jdbcTemplate.execute("DROP TABLE " + selectedEntityTableName);
return historyIterator;
}
/**
* Retrieves the changes that have were made between two points in time.
*
* @param intervalBegin
* Marks the beginning (inclusive) of the time interval to be checked.
* @param intervalEnd
* Marks the end (exclusive) of the time interval to be checked.
* @return An iterator pointing at the identified records.
*/
public ReleasableIterator getHistory(Date intervalBegin, Date intervalEnd) {
String selectedEntityTableName;
StringBuilder sql;
MapSqlParameterSource parameterSource;
ReleasableIterator historyIterator;
// PostgreSQL sometimes incorrectly chooses to perform full table scans, these options
// prevent this. Note that this is not recommended practice according to documentation
// but fixing this would require modifying the table statistics gathering
// configuration on the production database to produce better plans.
jdbcTemplate.execute(
"set local enable_seqscan = false;"
+ "set local enable_mergejoin = false;"
+ "set local enable_hashjoin = false");
selectedEntityTableName = "tmp_" + entityName + "s";
sql = new StringBuilder();
sql.append("CREATE TEMPORARY TABLE ");
sql.append(selectedEntityTableName);
sql.append(" ON COMMIT DROP");
sql.append(" AS SELECT ");
sql.append(entityName);
sql.append("_id, version FROM ");
sql.append(entityName);
sql.append("s WHERE timestamp > :intervalBegin AND timestamp <= :intervalEnd");
LOG.log(Level.FINER, "Entity identification query: " + sql);
parameterSource = new MapSqlParameterSource();
parameterSource.addValue("intervalBegin", intervalBegin, Types.TIMESTAMP);
parameterSource.addValue("intervalEnd", intervalEnd, Types.TIMESTAMP);
namedParamJdbcTemplate.update(sql.toString(), parameterSource);
jdbcTemplate.update("ANALYZE " + selectedEntityTableName);
// Extract the data and obtain an iterator for the results.
historyIterator = getChangeHistory(selectedEntityTableName, new MapSqlParameterSource());
// The temp table is no longer required and can be deleted.
jdbcTemplate.execute("DROP TABLE " + selectedEntityTableName);
return historyIterator;
}
/**
* Retrieves all changes in the database.
*
* @return An iterator pointing at the identified records.
*/
public ReleasableIterator getHistory() {
// Join the entity table to itself which will return all records.
return getChangeHistory(entityName + "s", new MapSqlParameterSource());
}
/**
* Retrieves all current data in the database.
*
* @return An iterator pointing at the current records.
*/
public ReleasableIterator getCurrent() {
// Join the entity table to the current version of itself which will return all current
// records.
return new EntityContainerReader(
getEntityHistory("(SELECT id AS " + entityName + "_id, version FROM current_"
+ entityName + "s WHERE visible = TRUE)",
new MapSqlParameterSource()), getContainerFactory());
}
}
EntityDataRowMapper.java 0000664 0000000 0000000 00000005516 14532772205 0035157 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/impl // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6.impl;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;
import org.openstreetmap.osmosis.core.database.RowMapperListener;
import org.openstreetmap.osmosis.core.domain.v0_6.CommonEntityData;
import org.openstreetmap.osmosis.core.domain.v0_6.OsmUser;
import org.springframework.jdbc.core.RowCallbackHandler;
/**
* Maps entity result set rows into common entity data objects.
*/
public class EntityDataRowMapper implements RowCallbackHandler {
private RowMapperListener listener;
private boolean readAllUsers;
/**
* Creates a new instance.
*
* @param listener
* The destination for result objects.
* @param readAllUsers
* If true, even anonymous users will be returned. Should be false in most cases.
*/
public EntityDataRowMapper(RowMapperListener listener, boolean readAllUsers) {
this.listener = listener;
this.readAllUsers = readAllUsers;
}
/**
* Determines the appropriate user name to add to an entity based upon the user details
* provided.
*
* @param dataPublic
* The value of the public edit flag for the user.
* @param userId
* The unique id of the user.
* @param userName
* The display name of the user.
* @return The appropriate user to add to the entity.
*/
private OsmUser readUserField(boolean dataPublic, int userId, String userName) {
if (userId == OsmUser.NONE.getId()) {
return OsmUser.NONE;
} else if (dataPublic || readAllUsers) {
String correctedUserName;
if (userName == null) {
correctedUserName = "";
} else {
correctedUserName = userName;
}
return new OsmUser(userId, correctedUserName);
} else {
return OsmUser.NONE;
}
}
/**
* {@inheritDoc}
*/
@Override
public void processRow(ResultSet resultSet) throws SQLException {
long id;
int version;
Date timestamp;
OsmUser user;
long changesetId;
CommonEntityData entityData;
id = resultSet.getLong("id");
version = resultSet.getInt("version");
timestamp = new Date(resultSet.getTimestamp("timestamp").getTime());
user = readUserField(resultSet.getBoolean("data_public"), resultSet.getInt("user_id"), resultSet
.getString("display_name"));
changesetId = resultSet.getLong("changeset_id");
//node = new Node(id, version, timestamp, user, changesetId, latitude, longitude);
entityData = new CommonEntityData(id, version, timestamp, user, changesetId);
listener.process(entityData, resultSet);
}
}
EntityHistory.java 0000664 0000000 0000000 00000003550 14532772205 0034106 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/impl // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6.impl;
import org.openstreetmap.osmosis.core.store.GenericObjectReader;
import org.openstreetmap.osmosis.core.store.GenericObjectWriter;
import org.openstreetmap.osmosis.core.store.StoreClassRegister;
import org.openstreetmap.osmosis.core.store.StoreReader;
import org.openstreetmap.osmosis.core.store.StoreWriter;
import org.openstreetmap.osmosis.core.store.Storeable;
/**
* A data class representing a history record.
*
* @author Brett Henderson
* @param
* The type of entity that this class stores history for.
*/
public class EntityHistory implements Storeable {
private T entity;
private boolean visible;
/**
* Creates a new instance.
*
* @param entity
* The contained entity.
* @param visible
* The visible field.
*/
public EntityHistory(T entity, boolean visible) {
this.entity = entity;
this.visible = visible;
}
/**
* Creates a new instance.
*
* @param sr
* The store to read state from.
* @param scr
* Maintains the mapping between classes and their identifiers
* within the store.
*/
@SuppressWarnings("unchecked")
public EntityHistory(StoreReader sr, StoreClassRegister scr) {
entity = (T) new GenericObjectReader(sr, scr).readObject();
visible = sr.readBoolean();
}
/**
* {@inheritDoc}
*/
public void store(StoreWriter sw, StoreClassRegister scr) {
new GenericObjectWriter(sw, scr).writeObject(entity);
sw.writeBoolean(visible);
}
/**
* Gets the contained entity.
*
* @return The entity.
*/
public T getEntity() {
return entity;
}
/**
* Gets the visible flag.
*
* @return The visible flag.
*/
public boolean isVisible() {
return visible;
}
}
EntityHistoryComparator.java 0000664 0000000 0000000 00000001677 14532772205 0036146 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/impl // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6.impl;
import java.util.Comparator;
import org.openstreetmap.osmosis.core.domain.v0_6.Entity;
/**
* A comparator for sorting entity history objects by entity id then entity version.
*
* @param
* The type of entity being sorted.
*/
public class EntityHistoryComparator implements Comparator> {
/**
* {@inheritDoc}
*/
@Override
public int compare(EntityHistory o1, EntityHistory o2) {
long idDelta;
int versionDelta;
idDelta = o1.getEntity().getId() - o2.getEntity().getId();
if (idDelta < 0) {
return -1;
} else if (idDelta > 0) {
return 1;
}
versionDelta = o1.getEntity().getVersion() - o2.getEntity().getVersion();
if (versionDelta < 0) {
return -1;
} else if (versionDelta > 0) {
return 1;
}
return 0;
}
}
EntityHistoryListReader.java 0000664 0000000 0000000 00000005003 14532772205 0036060 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/impl // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6.impl;
import java.util.ArrayList;
import java.util.List;
import org.openstreetmap.osmosis.core.container.v0_6.ChangeContainer;
import org.openstreetmap.osmosis.core.domain.v0_6.Entity;
import org.openstreetmap.osmosis.core.domain.v0_6.EntityType;
import org.openstreetmap.osmosis.core.lifecycle.ReleasableIterator;
import org.openstreetmap.osmosis.core.store.PeekableIterator;
/**
* Reads a history stream and groups all changes for a single entity into lists.
*/
public class EntityHistoryListReader implements ReleasableIterator> {
private PeekableIterator sourceIterator;
/**
* Creates a new instance.
*
* @param sourceIterator
* An iterator containing full entity history ordered by type, identifier and
* version.
*/
public EntityHistoryListReader(ReleasableIterator sourceIterator) {
this.sourceIterator = new PeekableIterator(sourceIterator);
}
/**
* {@inheritDoc}
*/
@Override
public boolean hasNext() {
return sourceIterator.hasNext();
}
/**
* {@inheritDoc}
*/
@Override
public List next() {
List changeList;
Entity peekEntity;
long currentId;
EntityType currentEntityType;
// Get the next change from the underlying stream.
peekEntity = sourceIterator.peekNext().getEntityContainer().getEntity();
currentId = peekEntity.getId();
currentEntityType = peekEntity.getType();
// Loop until all history values for the current element are exhausted.
changeList = new ArrayList();
while (sourceIterator.hasNext()) {
ChangeContainer tmpChangeContainer = sourceIterator.peekNext();
// Break out of the loop when we reach the next entity in the stream.
if (currentId != tmpChangeContainer.getEntityContainer().getEntity().getId()
|| !currentEntityType.equals(tmpChangeContainer.getEntityContainer().getEntity().getType())) {
break;
}
// We want the value that we have already peeked from the iterator, so remove it from the iterator.
sourceIterator.next();
// Add the change to the result list.
changeList.add(tmpChangeContainer);
}
return changeList;
}
/**
* {@inheritDoc}
*/
@Override
public void remove() {
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*/
@Override
public void close() {
sourceIterator.close();
}
}
EntityHistoryReader.java 0000664 0000000 0000000 00000006751 14532772205 0035237 0 ustar 00root root 0000000 0000000 osmosis-0.49.2/osmosis-apidb/src/main/java/org/openstreetmap/osmosis/apidb/v0_6/impl // This software is released into the Public Domain. See copying.txt for details.
package org.openstreetmap.osmosis.apidb.v0_6.impl;
import java.util.List;
import org.openstreetmap.osmosis.core.OsmosisRuntimeException;
import org.openstreetmap.osmosis.core.database.DbFeature;
import org.openstreetmap.osmosis.core.database.DbFeatureHistory;
import org.openstreetmap.osmosis.core.domain.v0_6.Entity;
import org.openstreetmap.osmosis.core.domain.v0_6.Tag;
import org.openstreetmap.osmosis.core.lifecycle.ReleasableContainer;
import org.openstreetmap.osmosis.core.lifecycle.ReleasableIterator;
/**
* Provides a single iterator based on data provided by underlying iterators from each of the
* underlying entity and feature iterators. Each underlying iterator provides one component of the
* overall entity.
*
* @param
* The type of entity provided by this iterator.
*/
public class EntityHistoryReader