Java tutorial
/* * Copyright (c) 2006-2011 Nuxeo SA (http://nuxeo.com/) and others. * * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * Florent Guillaume * Benoit Delbosc */ package org.nuxeo.ecm.core.storage.sql.jdbc; import java.io.Serializable; import java.security.MessageDigest; import java.sql.Array; import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.sql.Types; import java.util.ArrayList; import java.util.Arrays; import java.util.Calendar; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.concurrent.Callable; import javax.resource.ResourceException; import javax.sql.XADataSource; import javax.transaction.xa.XAException; import javax.transaction.xa.XAResource; import javax.transaction.xa.Xid; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.nuxeo.common.utils.StringUtils; import org.nuxeo.ecm.core.api.IterableQueryResult; import org.nuxeo.ecm.core.api.Lock; import org.nuxeo.ecm.core.query.QueryFilter; import org.nuxeo.ecm.core.storage.ConnectionResetException; import org.nuxeo.ecm.core.storage.PartialList; import org.nuxeo.ecm.core.storage.StorageException; import org.nuxeo.ecm.core.storage.binary.BinaryGarbageCollector; import org.nuxeo.ecm.core.storage.sql.ColumnType; import org.nuxeo.ecm.core.storage.sql.ColumnType.WrappedId; import org.nuxeo.ecm.core.storage.sql.Invalidations; import org.nuxeo.ecm.core.storage.sql.Mapper; import org.nuxeo.ecm.core.storage.sql.Model; import org.nuxeo.ecm.core.storage.sql.RepositoryImpl; import org.nuxeo.ecm.core.storage.sql.Row; import org.nuxeo.ecm.core.storage.sql.RowId; import org.nuxeo.ecm.core.storage.sql.Session.PathResolver; import org.nuxeo.ecm.core.storage.sql.jdbc.SQLInfo.SQLInfoSelect; import org.nuxeo.ecm.core.storage.sql.jdbc.db.Column; import org.nuxeo.ecm.core.storage.sql.jdbc.db.Database; import org.nuxeo.ecm.core.storage.sql.jdbc.db.Table; import org.nuxeo.ecm.core.storage.sql.jdbc.dialect.Dialect; import org.nuxeo.ecm.core.storage.sql.jdbc.dialect.DialectOracle; import org.nuxeo.runtime.api.Framework; /** * A {@link JDBCMapper} maps objects to and from a JDBC database. It is specific * to a given database connection, as it computes statements. * <p> * The {@link JDBCMapper} does the mapping according to the policy defined by a * {@link Model}, and generates SQL statements recorded in the {@link SQLInfo}. */ public class JDBCMapper extends JDBCRowMapper implements Mapper { private static final Log log = LogFactory.getLog(JDBCMapper.class); public static Map<String, Serializable> testProps = new HashMap<String, Serializable>(); public static final String TEST_UPGRADE = "testUpgrade"; // property in sql.txt file public static final String TEST_UPGRADE_VERSIONS = "testUpgradeVersions"; public static final String TEST_UPGRADE_LAST_CONTRIBUTOR = "testUpgradeLastContributor"; public static final String TEST_UPGRADE_LOCKS = "testUpgradeLocks"; public static final String TEST_UPGRADE_FULLTEXT = "testUpgradeFulltext"; protected TableUpgrader tableUpgrader; private final QueryMakerService queryMakerService; private final PathResolver pathResolver; private final RepositoryImpl repository; protected boolean clusteringEnabled; /** * Creates a new Mapper. * * @param model the model * @param pathResolver the path resolver (used for startswith queries) * @param sqlInfo the sql info * @param xadatasource the XA datasource to use to get connections * @param clusterNodeHandler the cluster node handler * @param connectionPropagator the connection propagator * @param repository */ public JDBCMapper(Model model, PathResolver pathResolver, SQLInfo sqlInfo, XADataSource xadatasource, ClusterNodeHandler clusterNodeHandler, JDBCConnectionPropagator connectionPropagator, boolean noSharing, RepositoryImpl repository) throws StorageException { super(model, sqlInfo, xadatasource, clusterNodeHandler, connectionPropagator, noSharing); this.pathResolver = pathResolver; this.repository = repository; clusteringEnabled = clusterNodeHandler != null; try { queryMakerService = Framework.getService(QueryMakerService.class); } catch (Exception e) { throw new StorageException(e); } tableUpgrader = new TableUpgrader(this); tableUpgrader.add(Model.VERSION_TABLE_NAME, Model.VERSION_IS_LATEST_KEY, "upgradeVersions", TEST_UPGRADE_VERSIONS); tableUpgrader.add("dublincore", "lastContributor", "upgradeLastContributor", TEST_UPGRADE_LAST_CONTRIBUTOR); tableUpgrader.add(Model.LOCK_TABLE_NAME, Model.LOCK_OWNER_KEY, "upgradeLocks", TEST_UPGRADE_LOCKS); } @Override public int getTableSize(String tableName) { return sqlInfo.getDatabase().getTable(tableName).getColumns().size(); } /* * ----- Root ----- */ @Override public void createDatabase() throws StorageException { try { createTables(); } catch (Exception e) { checkConnectionReset(e); throw new StorageException(e); } } protected String getTableName(String origName) { if (dialect instanceof DialectOracle) { if (origName.length() > 30) { StringBuilder sb = new StringBuilder(origName.length()); try { MessageDigest digest = MessageDigest.getInstance("MD5"); sb.append(origName.substring(0, 15)); sb.append('_'); digest.update(origName.getBytes()); sb.append(Dialect.toHexString(digest.digest()).substring(0, 12)); return sb.toString(); } catch (Exception e) { throw new RuntimeException("Error", e); } } } return origName; } protected void createTables() throws SQLException { sqlInfo.executeSQLStatements(null, this); // for missing category sqlInfo.executeSQLStatements("first", this); sqlInfo.executeSQLStatements("beforeTableCreation", this); if (testProps.containsKey(TEST_UPGRADE)) { // create "old" tables sqlInfo.executeSQLStatements("testUpgrade", this); } String schemaName = dialect.getConnectionSchema(connection); DatabaseMetaData metadata = connection.getMetaData(); Set<String> tableNames = findTableNames(metadata, schemaName); Database database = sqlInfo.getDatabase(); Map<String, List<Column>> added = new HashMap<String, List<Column>>(); Statement st = null; try { st = connection.createStatement(); for (Table table : database.getTables()) { String tableName = getTableName(table.getPhysicalName()); if (tableNames.contains(tableName.toUpperCase())) { dialect.existingTableDetected(connection, table, model, sqlInfo.database); } else { /* * Create missing table. */ boolean create = dialect.preCreateTable(connection, table, model, sqlInfo.database); if (!create) { log.warn("Creation skipped for table: " + tableName); continue; } String sql = table.getCreateSql(); logger.log(sql); try { st.execute(sql); countExecute(); } catch (SQLException e) { try { closeStatement(st); } finally { throw new SQLException("Error creating table: " + sql + " : " + e.getMessage(), e); } } for (String s : table.getPostCreateSqls(model)) { logger.log(s); try { st.execute(s); countExecute(); } catch (SQLException e) { throw new SQLException("Error post creating table: " + s + " : " + e.getMessage(), e); } } for (String s : dialect.getPostCreateTableSqls(table, model, sqlInfo.database)) { logger.log(s); try { st.execute(s); countExecute(); } catch (SQLException e) { throw new SQLException("Error post creating table: " + s + " : " + e.getMessage(), e); } } added.put(table.getKey(), null); // null = table created } /* * Get existing columns. */ ResultSet rs = metadata.getColumns(null, schemaName, tableName, "%"); Map<String, Integer> columnTypes = new HashMap<String, Integer>(); Map<String, String> columnTypeNames = new HashMap<String, String>(); Map<String, Integer> columnTypeSizes = new HashMap<String, Integer>(); while (rs.next()) { String schema = rs.getString("TABLE_SCHEM"); if (schema != null) { // null for MySQL, doh! if ("INFORMATION_SCHEMA".equals(schema.toUpperCase())) { // H2 returns some system tables (locks) continue; } } String columnName = rs.getString("COLUMN_NAME").toUpperCase(); columnTypes.put(columnName, Integer.valueOf(rs.getInt("DATA_TYPE"))); columnTypeNames.put(columnName, rs.getString("TYPE_NAME")); columnTypeSizes.put(columnName, Integer.valueOf(rs.getInt("COLUMN_SIZE"))); } /* * Update types and create missing columns. */ List<Column> addedColumns = new LinkedList<Column>(); for (Column column : table.getColumns()) { String upperName = column.getPhysicalName().toUpperCase(); Integer type = columnTypes.remove(upperName); if (type == null) { log.warn("Adding missing column in database: " + column.getFullQuotedName()); String sql = table.getAddColumnSql(column); logger.log(sql); try { st.execute(sql); countExecute(); } catch (SQLException e) { throw new SQLException("Error adding column: " + sql + " : " + e.getMessage(), e); } for (String s : table.getPostAddSqls(column, model)) { logger.log(s); try { st.execute(s); countExecute(); } catch (SQLException e) { throw new SQLException("Error post adding column: " + s + " : " + e.getMessage(), e); } } addedColumns.add(column); } else { int expected = column.getJdbcType(); int actual = type.intValue(); String actualName = columnTypeNames.get(upperName); Integer actualSize = columnTypeSizes.get(upperName); if (!column.setJdbcType(actual, actualName, actualSize.intValue())) { log.error(String.format( "SQL type mismatch for %s: expected %s, database has %s / %s (%s)", column.getFullQuotedName(), Integer.valueOf(expected), type, actualName, actualSize)); } } } for (String col : dialect.getIgnoredColumns(table)) { columnTypes.remove(col.toUpperCase()); } if (!columnTypes.isEmpty()) { log.warn("Database contains additional unused columns for table " + table.getQuotedName() + ": " + StringUtils.join(new ArrayList<String>(columnTypes.keySet()), ", ")); } if (!addedColumns.isEmpty()) { if (added.containsKey(table.getKey())) { throw new AssertionError(); } added.put(table.getKey(), addedColumns); } } } finally { if (st != null) { try { closeStatement(st); } catch (SQLException e) { log.error(e.getMessage(), e); } } } if (testProps.containsKey(TEST_UPGRADE)) { // create "old" content in tables sqlInfo.executeSQLStatements("testUpgradeOldTables", this); } // run upgrade for each table if added columns or test for (Entry<String, List<Column>> en : added.entrySet()) { List<Column> addedColumns = en.getValue(); String tableKey = en.getKey(); upgradeTable(tableKey, addedColumns); } sqlInfo.executeSQLStatements("afterTableCreation", this); sqlInfo.executeSQLStatements("last", this); dialect.performAdditionalStatements(connection); } protected void upgradeTable(String tableKey, List<Column> addedColumns) throws SQLException { tableUpgrader.upgrade(tableKey, addedColumns); } /** Finds uppercase table names. */ protected static Set<String> findTableNames(DatabaseMetaData metadata, String schemaName) throws SQLException { Set<String> tableNames = new HashSet<String>(); ResultSet rs = metadata.getTables(null, schemaName, "%", new String[] { "TABLE" }); while (rs.next()) { String tableName = rs.getString("TABLE_NAME"); tableNames.add(tableName.toUpperCase()); } return tableNames; } @Override public String createClusterNode() throws StorageException { Statement st = null; try { // get the cluster node id from the database, if necessary String sql = dialect.getClusterNodeIdSql(); String nodeId; if (sql == null) { nodeId = null; } else { st = connection.createStatement(); if (logger.isLogEnabled()) { logger.log(sql); } ResultSet rs = st.executeQuery(sql); if (!rs.next()) { throw new StorageException("Cannot get cluster node id"); } nodeId = rs.getString(1); if (logger.isLogEnabled()) { logger.log(" -> cluster node id: " + nodeId); } } // add the cluster node sqlInfo.executeSQLStatements("addClusterNode", this); return nodeId; } catch (Exception e) { checkConnectionReset(e); throw new StorageException(e); } finally { if (st != null) { try { closeStatement(st); } catch (SQLException e) { log.error(e.getMessage(), e); } } } } @Override public void removeClusterNode() throws StorageException { try { sqlInfo.executeSQLStatements("removeClusterNode", this); } catch (Exception e) { checkConnectionReset(e); throw new StorageException(e); } } @Override public void insertClusterInvalidations(Invalidations invalidations, String nodeId) throws StorageException { String sql = dialect.getClusterInsertInvalidations(); if (nodeId != null) { sql = String.format(sql, nodeId); } List<Column> columns = sqlInfo.getClusterInvalidationsColumns(); PreparedStatement ps = null; try { ps = connection.prepareStatement(sql); int kind = Invalidations.MODIFIED; while (true) { Set<RowId> rowIds = invalidations.getKindSet(kind); // reorganize by id Map<Serializable, Set<String>> res = new HashMap<Serializable, Set<String>>(); for (RowId rowId : rowIds) { Set<String> tableNames = res.get(rowId.id); if (tableNames == null) { res.put(rowId.id, tableNames = new HashSet<String>()); } tableNames.add(rowId.tableName); } // do inserts for (Entry<Serializable, Set<String>> en : res.entrySet()) { Serializable id = en.getKey(); String fragments = join(en.getValue(), ' '); if (logger.isLogEnabled()) { logger.logSQL(sql, Arrays.<Serializable>asList(id, fragments, Long.valueOf(kind))); } Serializable frags; if (dialect.supportsArrays() && columns.get(1).getJdbcType() == Types.ARRAY) { frags = fragments.split(" "); } else { frags = fragments; } columns.get(0).setToPreparedStatement(ps, 1, id); columns.get(1).setToPreparedStatement(ps, 2, frags); columns.get(2).setToPreparedStatement(ps, 3, Long.valueOf(kind)); ps.execute(); countExecute(); } if (kind == Invalidations.MODIFIED) { kind = Invalidations.DELETED; } else { break; } } } catch (Exception e) { checkConnectionReset(e); throw new StorageException("Could not invalidate", e); } finally { if (ps != null) { try { closeStatement(ps); } catch (SQLException e) { log.error(e.getMessage(), e); } } } } // join that works on a set protected static final String join(Collection<String> strings, char sep) { if (strings.isEmpty()) { throw new RuntimeException(); } if (strings.size() == 1) { return strings.iterator().next(); } int size = 0; for (String word : strings) { size += word.length() + 1; } StringBuilder buf = new StringBuilder(size); for (String word : strings) { buf.append(word); buf.append(sep); } buf.setLength(size - 1); return buf.toString(); } @Override public Invalidations getClusterInvalidations(String nodeId) throws StorageException { Invalidations invalidations = new Invalidations(); String sql = dialect.getClusterGetInvalidations(); String sqldel = dialect.getClusterDeleteInvalidations(); if (nodeId != null) { sql = String.format(sql, nodeId); sqldel = String.format(sqldel, nodeId); } List<Column> columns = sqlInfo.getClusterInvalidationsColumns(); Statement st = null; try { st = connection.createStatement(); if (logger.isLogEnabled()) { logger.log(sql); } ResultSet rs = st.executeQuery(sql); countExecute(); int n = 0; while (rs.next()) { n++; Serializable id = columns.get(0).getFromResultSet(rs, 1); Serializable frags = columns.get(1).getFromResultSet(rs, 2); int kind = ((Long) columns.get(2).getFromResultSet(rs, 3)).intValue(); String[] fragments; if (dialect.supportsArrays() && frags instanceof String[]) { fragments = (String[]) frags; } else { fragments = ((String) frags).split(" "); } invalidations.add(id, fragments, kind); } if (logger.isLogEnabled()) { // logCount(n); logger.log(" -> " + invalidations); } if (dialect.isClusteringDeleteNeeded()) { if (logger.isLogEnabled()) { logger.log(sqldel); } n = st.executeUpdate(sqldel); countExecute(); if (logger.isLogEnabled()) { logger.logCount(n); } } return invalidations; } catch (Exception e) { checkConnectionReset(e, true); throw new StorageException("Could not invalidate", e); } finally { if (st != null) { try { closeStatement(st); } catch (SQLException e) { log.error(e.getMessage(), e); } } } } @Override public Serializable getRootId(String repositoryId) throws StorageException { String sql = sqlInfo.getSelectRootIdSql(); try { if (logger.isLogEnabled()) { logger.logSQL(sql, Collections.<Serializable>singletonList(repositoryId)); } PreparedStatement ps = connection.prepareStatement(sql); try { ps.setString(1, repositoryId); ResultSet rs = ps.executeQuery(); countExecute(); if (!rs.next()) { if (logger.isLogEnabled()) { logger.log(" -> (none)"); } return null; } Column column = sqlInfo.getSelectRootIdWhatColumn(); Serializable id = column.getFromResultSet(rs, 1); if (logger.isLogEnabled()) { logger.log(" -> " + Model.MAIN_KEY + '=' + id); } // check that we didn't get several rows if (rs.next()) { throw new StorageException("Row query for " + repositoryId + " returned several rows: " + sql); } return id; } finally { closeStatement(ps); } } catch (Exception e) { checkConnectionReset(e); throw new StorageException("Could not select: " + sql, e); } } @Override public void setRootId(Serializable repositoryId, Serializable id) throws StorageException { String sql = sqlInfo.getInsertRootIdSql(); try { PreparedStatement ps = connection.prepareStatement(sql); try { List<Column> columns = sqlInfo.getInsertRootIdColumns(); List<Serializable> debugValues = null; if (logger.isLogEnabled()) { debugValues = new ArrayList<Serializable>(2); } int i = 0; for (Column column : columns) { i++; String key = column.getKey(); Serializable v; if (key.equals(Model.MAIN_KEY)) { v = id; } else if (key.equals(Model.REPOINFO_REPONAME_KEY)) { v = repositoryId; } else { throw new RuntimeException(key); } column.setToPreparedStatement(ps, i, v); if (debugValues != null) { debugValues.add(v); } } if (debugValues != null) { logger.logSQL(sql, debugValues); debugValues.clear(); } ps.execute(); countExecute(); } finally { closeStatement(ps); } } catch (Exception e) { checkConnectionReset(e); throw new StorageException("Could not insert: " + sql, e); } } protected QueryMaker findQueryMaker(String queryType) throws StorageException { for (Class<? extends QueryMaker> klass : queryMakerService.getQueryMakers()) { QueryMaker queryMaker; try { queryMaker = klass.newInstance(); } catch (Exception e) { throw new StorageException(e); } if (queryMaker.accepts(queryType)) { return queryMaker; } } return null; } protected void prepareUserReadAcls(QueryFilter queryFilter) throws StorageException { String sql = dialect.getPrepareUserReadAclsSql(); Serializable principals = queryFilter.getPrincipals(); if (sql == null || principals == null) { return; } if (!dialect.supportsArrays()) { principals = StringUtils.join((String[]) principals, Dialect.ARRAY_SEP); } PreparedStatement ps = null; try { ps = connection.prepareStatement(sql); if (logger.isLogEnabled()) { logger.logSQL(sql, Collections.singleton(principals)); } setToPreparedStatement(ps, 1, principals); ps.execute(); countExecute(); } catch (Exception e) { checkConnectionReset(e); throw new StorageException("Failed to prepare user read acl cache", e); } finally { if (ps != null) { try { closeStatement(ps); } catch (SQLException e) { log.error(e.getMessage(), e); } } } } @Override public PartialList<Serializable> query(String query, String queryType, QueryFilter queryFilter, boolean countTotal) throws StorageException { return query(query, queryType, queryFilter, countTotal ? -1 : 0); } @Override public PartialList<Serializable> query(String query, String queryType, QueryFilter queryFilter, long countUpTo) throws StorageException { if (dialect.needsPrepareUserReadAcls()) { prepareUserReadAcls(queryFilter); } QueryMaker queryMaker = findQueryMaker(queryType); if (queryMaker == null) { throw new StorageException("No QueryMaker accepts query: " + queryType + ": " + query); } QueryMaker.Query q = queryMaker.buildQuery(sqlInfo, model, pathResolver, query, queryFilter); if (q == null) { logger.log("Query cannot return anything due to conflicting clauses"); return new PartialList<Serializable>(Collections.<Serializable>emptyList(), 0); } long limit = queryFilter.getLimit(); long offset = queryFilter.getOffset(); if (logger.isLogEnabled()) { String sql = q.selectInfo.sql; if (limit != 0) { sql += " -- LIMIT " + limit + " OFFSET " + offset; } if (countUpTo != 0) { sql += " -- COUNT TOTAL UP TO " + countUpTo; } logger.logSQL(sql, q.selectParams); } String sql = q.selectInfo.sql; if (countUpTo == 0 && limit > 0 && dialect.supportsPaging()) { // full result set not needed for counting sql = dialect.addPagingClause(sql, limit, offset); limit = 0; offset = 0; } else if (countUpTo > 0 && dialect.supportsPaging()) { // ask one more row sql = dialect.addPagingClause(sql, Math.max(countUpTo + 1, limit + offset), 0); } PreparedStatement ps = null; try { ps = connection.prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY); int i = 1; for (Serializable object : q.selectParams) { setToPreparedStatement(ps, i++, object); } ResultSet rs = ps.executeQuery(); countExecute(); // limit/offset long totalSize = -1; boolean available; if ((limit == 0) || (offset == 0)) { available = rs.first(); if (!available) { totalSize = 0; } if (limit == 0) { limit = -1; // infinite } } else { available = rs.absolute((int) offset + 1); } Column column = q.selectInfo.whatColumns.get(0); List<Serializable> ids = new LinkedList<Serializable>(); int rowNum = 0; while (available && (limit != 0)) { Serializable id = column.getFromResultSet(rs, 1); ids.add(id); rowNum = rs.getRow(); available = rs.next(); limit--; } // total size if (countUpTo != 0 && (totalSize == -1)) { if (!available && (rowNum != 0)) { // last row read was the actual last totalSize = rowNum; } else { // available if limit reached with some left // rowNum == 0 if skipped too far rs.last(); totalSize = rs.getRow(); } if (countUpTo > 0 && totalSize > countUpTo) { // the result where truncated we don't know the total size totalSize = -2; } } if (logger.isLogEnabled()) { logger.logIds(ids, countUpTo != 0, totalSize); } return new PartialList<Serializable>(ids, totalSize); } catch (Exception e) { checkConnectionReset(e); throw new StorageException("Invalid query: " + query, e); } finally { if (ps != null) { try { closeStatement(ps); } catch (SQLException e) { log.error("Cannot close connection", e); } } } } public int setToPreparedStatement(PreparedStatement ps, int i, Serializable object) throws SQLException { if (object instanceof Calendar) { Calendar cal = (Calendar) object; ps.setTimestamp(i, dialect.getTimestampFromCalendar(cal), cal); } else if (object instanceof java.sql.Date) { ps.setDate(i, (java.sql.Date) object); } else if (object instanceof Long) { ps.setLong(i, ((Long) object).longValue()); } else if (object instanceof WrappedId) { dialect.setId(ps, i, object.toString()); } else if (object instanceof Object[]) { int jdbcType; if (object instanceof String[]) { jdbcType = dialect.getJDBCTypeAndString(ColumnType.STRING).jdbcType; } else if (object instanceof Boolean[]) { jdbcType = dialect.getJDBCTypeAndString(ColumnType.BOOLEAN).jdbcType; } else if (object instanceof Long[]) { jdbcType = dialect.getJDBCTypeAndString(ColumnType.LONG).jdbcType; } else if (object instanceof Double[]) { jdbcType = dialect.getJDBCTypeAndString(ColumnType.DOUBLE).jdbcType; } else if (object instanceof java.sql.Date[]) { jdbcType = Types.DATE; } else if (object instanceof java.sql.Clob[]) { jdbcType = Types.CLOB; } else if (object instanceof Calendar[]) { jdbcType = dialect.getJDBCTypeAndString(ColumnType.TIMESTAMP).jdbcType; object = dialect.getTimestampFromCalendar((Calendar) object); } else if (object instanceof Integer[]) { jdbcType = dialect.getJDBCTypeAndString(ColumnType.INTEGER).jdbcType; } else { jdbcType = dialect.getJDBCTypeAndString(ColumnType.CLOB).jdbcType; } Array array = dialect.createArrayOf(jdbcType, (Object[]) object, connection); ps.setArray(i, array); } else { ps.setObject(i, object); } return i; } // queryFilter used for principals and permissions @Override public IterableQueryResult queryAndFetch(String query, String queryType, QueryFilter queryFilter, Object... params) throws StorageException { if (dialect.needsPrepareUserReadAcls()) { prepareUserReadAcls(queryFilter); } QueryMaker queryMaker = findQueryMaker(queryType); if (queryMaker == null) { throw new StorageException("No QueryMaker accepts query: " + queryType + ": " + query); } try { return new ResultSetQueryResult(queryMaker, query, queryFilter, pathResolver, this, params); } catch (Exception e) { checkConnectionReset(e); throw new StorageException("Invalid query: " + queryType + ": " + query, e); } } @Override public Set<Serializable> getAncestorsIds(Collection<Serializable> ids) throws StorageException { SQLInfoSelect select = sqlInfo.getSelectAncestorsIds(); if (select == null) { return getAncestorsIdsIterative(ids); } Serializable whereIds = newIdArray(ids); Set<Serializable> res = new HashSet<Serializable>(); PreparedStatement ps = null; try { if (logger.isLogEnabled()) { logger.logSQL(select.sql, Collections.singleton(whereIds)); } Column what = select.whatColumns.get(0); ps = connection.prepareStatement(select.sql); setToPreparedStatementIdArray(ps, 1, whereIds); ResultSet rs = ps.executeQuery(); countExecute(); List<Serializable> debugIds = null; if (logger.isLogEnabled()) { debugIds = new LinkedList<Serializable>(); } while (rs.next()) { if (dialect.supportsArraysReturnInsteadOfRows()) { Serializable[] resultIds = dialect.getArrayResult(rs.getArray(1)); for (Serializable id : resultIds) { if (id != null) { res.add(id); if (logger.isLogEnabled()) { debugIds.add(id); } } } } else { Serializable id = what.getFromResultSet(rs, 1); if (id != null) { res.add(id); if (logger.isLogEnabled()) { debugIds.add(id); } } } } if (logger.isLogEnabled()) { logger.logIds(debugIds, false, 0); } return res; } catch (Exception e) { checkConnectionReset(e); throw new StorageException("Failed to get ancestors ids", e); } finally { if (ps != null) { try { closeStatement(ps); } catch (SQLException e) { log.error(e.getMessage(), e); } } } } /** * Uses iterative parentid selection. */ protected Set<Serializable> getAncestorsIdsIterative(Collection<Serializable> ids) throws StorageException { PreparedStatement ps = null; try { LinkedList<Serializable> todo = new LinkedList<Serializable>(ids); Set<Serializable> done = new HashSet<Serializable>(); Set<Serializable> res = new HashSet<Serializable>(); while (!todo.isEmpty()) { done.addAll(todo); SQLInfoSelect select = sqlInfo.getSelectParentIds(todo.size()); if (logger.isLogEnabled()) { logger.logSQL(select.sql, todo); } Column what = select.whatColumns.get(0); Column where = select.whereColumns.get(0); ps = connection.prepareStatement(select.sql); int i = 1; for (Serializable id : todo) { where.setToPreparedStatement(ps, i++, id); } ResultSet rs = ps.executeQuery(); countExecute(); todo = new LinkedList<Serializable>(); List<Serializable> debugIds = null; if (logger.isLogEnabled()) { debugIds = new LinkedList<Serializable>(); } while (rs.next()) { Serializable id = what.getFromResultSet(rs, 1); if (id != null) { res.add(id); if (!done.contains(id)) { todo.add(id); } if (logger.isLogEnabled()) { debugIds.add(id); } } } if (logger.isLogEnabled()) { logger.logIds(debugIds, false, 0); } ps.close(); ps = null; } return res; } catch (Exception e) { checkConnectionReset(e); throw new StorageException("Failed to get ancestors ids", e); } finally { if (ps != null) { try { closeStatement(ps); } catch (SQLException e) { log.error(e.getMessage(), e); } } } } @Override public void updateReadAcls() throws StorageException { if (!dialect.supportsReadAcl()) { return; } if (log.isDebugEnabled()) { log.debug("updateReadAcls: updating"); } Statement st = null; try { st = connection.createStatement(); String sql = dialect.getUpdateReadAclsSql(); if (logger.isLogEnabled()) { logger.log(sql); } st.execute(sql); countExecute(); } catch (Exception e) { checkConnectionReset(e); throw new StorageException("Failed to update read acls", e); } finally { if (st != null) { try { closeStatement(st); } catch (SQLException e) { log.error(e.getMessage(), e); } } } if (log.isDebugEnabled()) { log.debug("updateReadAcls: done."); } } @Override public void rebuildReadAcls() throws StorageException { if (!dialect.supportsReadAcl()) { return; } log.debug("rebuildReadAcls: rebuilding ..."); Statement st = null; try { st = connection.createStatement(); String sql = dialect.getRebuildReadAclsSql(); logger.log(sql); st.execute(sql); countExecute(); } catch (Exception e) { checkConnectionReset(e); throw new StorageException("Failed to rebuild read acls", e); } finally { if (st != null) { try { closeStatement(st); } catch (SQLException e) { log.error(e.getMessage(), e); } } } log.debug("rebuildReadAcls: done."); } /* * ----- Locking ----- */ protected Connection connection(boolean autocommit) throws StorageException { checkConnectionValid(); try { connection.setAutoCommit(autocommit); } catch (SQLException e) { throw new StorageException("Cannot set auto commit mode onto " + this + "'s connection", e); } return connection; } /** * Calls the callable, inside a transaction if in cluster mode. * <p> * Called under {@link #serializationLock}. */ protected Lock callInTransaction(Callable<Lock> callable, boolean tx) throws StorageException { boolean ok = false; checkConnectionValid(); try { if (log.isDebugEnabled()) { log.debug("callInTransaction setAutoCommit " + !tx); } connection.setAutoCommit(!tx); } catch (SQLException e) { throw new StorageException("Cannot set auto commit mode onto " + this + "'s connection", e); } try { Lock result; try { result = callable.call(); } catch (StorageException e) { throw e; } catch (Exception e) { throw new StorageException(e); } ok = true; return result; } finally { if (tx) { try { try { if (ok) { if (log.isDebugEnabled()) { log.debug("callInTransaction commit"); } connection.commit(); } else { if (log.isDebugEnabled()) { log.debug("callInTransaction rollback"); } connection.rollback(); } } finally { // restore autoCommit=true if (log.isDebugEnabled()) { log.debug("callInTransaction restoring autoCommit=true"); } connection.setAutoCommit(true); } } catch (SQLException e) { throw new StorageException(e); } } } } @Override public Lock getLock(Serializable id) throws StorageException { if (log.isDebugEnabled()) { try { log.debug("getLock " + id + " while autoCommit=" + connection.getAutoCommit()); } catch (SQLException e) { throw new RuntimeException(e); } } RowId rowId = new RowId(Model.LOCK_TABLE_NAME, id); Row row; try { row = readSimpleRow(rowId); } catch (ConnectionResetException e) { // retry once row = readSimpleRow(rowId); } return row == null ? null : new Lock((String) row.get(Model.LOCK_OWNER_KEY), (Calendar) row.get(Model.LOCK_CREATED_KEY)); } @Override public Lock setLock(final Serializable id, final Lock lock) throws StorageException { if (log.isDebugEnabled()) { log.debug("setLock " + id + " owner=" + lock.getOwner()); } SetLock call = new SetLock(id, lock); return callInTransaction(call, clusteringEnabled); } protected class SetLock implements Callable<Lock> { protected final Serializable id; protected final Lock lock; protected SetLock(Serializable id, Lock lock) { super(); this.id = id; this.lock = lock; } @Override public Lock call() throws StorageException { Lock oldLock = getLock(id); if (oldLock == null) { Row row = new Row(Model.LOCK_TABLE_NAME, id); row.put(Model.LOCK_OWNER_KEY, lock.getOwner()); row.put(Model.LOCK_CREATED_KEY, lock.getCreated()); insertSimpleRows(Model.LOCK_TABLE_NAME, Collections.singletonList(row)); } return oldLock; } } @Override public Lock removeLock(final Serializable id, final String owner, final boolean force) throws StorageException { if (log.isDebugEnabled()) { log.debug("removeLock " + id + " owner=" + owner + " force=" + force); } RemoveLock call = new RemoveLock(id, owner, force); return callInTransaction(call, !force); } protected class RemoveLock implements Callable<Lock> { protected final Serializable id; protected final String owner; protected final boolean force; protected RemoveLock(Serializable id, String owner, boolean force) { super(); this.id = id; this.owner = owner; this.force = force; } @Override public Lock call() throws StorageException { Lock oldLock = force ? null : getLock(id); if (!force && owner != null) { if (oldLock == null) { // not locked, nothing to do return null; } if (!repository.getLockManager().canLockBeRemoved(oldLock, owner)) { // existing mismatched lock, flag failure return new Lock(oldLock, true); } } if (force || oldLock != null) { deleteRows(Model.LOCK_TABLE_NAME, Collections.singleton(id)); } return oldLock; } } @Override public void markReferencedBinaries(BinaryGarbageCollector gc) throws StorageException { log.debug("Starting binaries GC mark"); Statement st = null; try { st = connection.createStatement(); int i = -1; for (String sql : sqlInfo.getBinariesSql) { i++; Column col = sqlInfo.getBinariesColumns.get(i); if (logger.isLogEnabled()) { logger.log(sql); } ResultSet rs = st.executeQuery(sql); countExecute(); int n = 0; while (rs.next()) { n++; String digest = (String) col.getFromResultSet(rs, 1); if (digest != null) { gc.mark(digest); } } if (logger.isLogEnabled()) { logger.logCount(n); } } } catch (Exception e) { checkConnectionReset(e); throw new RuntimeException("Failed to mark binaries for gC", e); } finally { if (st != null) { try { closeStatement(st); } catch (SQLException e) { log.error(e.getMessage(), e); } } } log.debug("End of binaries GC mark"); } /* * ----- XAResource ----- */ protected static String systemToString(Object o) { return o.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(o)); } @Override public void start(Xid xid, int flags) throws XAException { try { checkConnectionValid(); xaresource.start(xid, flags); if (logger.isLogEnabled()) { logger.log("XA start on " + systemToString(xid)); } } catch (StorageException e) { throw (XAException) new XAException(XAException.XAER_RMERR).initCause(e); } catch (XAException e) { checkConnectionReset(e); logger.error("XA start error on " + systemToString(xid), e); throw e; } } @Override public void end(Xid xid, int flags) throws XAException { try { xaresource.end(xid, flags); if (logger.isLogEnabled()) { logger.log("XA end on " + systemToString(xid)); } } catch (NullPointerException e) { // H2 when no active transaction logger.error("XA end error on " + systemToString(xid), e); throw (XAException) new XAException(XAException.XAER_RMERR).initCause(e); } catch (XAException e) { if (flags != XAResource.TMFAIL) { logger.error("XA end error on " + systemToString(xid), e); } throw e; } } @Override public int prepare(Xid xid) throws XAException { try { return xaresource.prepare(xid); } catch (XAException e) { logger.error("XA prepare error on " + systemToString(xid), e); throw e; } } @Override public void commit(Xid xid, boolean onePhase) throws XAException { try { xaresource.commit(xid, onePhase); } catch (XAException e) { logger.error("XA commit error on " + systemToString(xid), e); throw e; } } // rollback interacts with caches so is in RowMapper @Override public void forget(Xid xid) throws XAException { xaresource.forget(xid); } @Override public Xid[] recover(int flag) throws XAException { return xaresource.recover(flag); } @Override public boolean setTransactionTimeout(int seconds) throws XAException { return xaresource.setTransactionTimeout(seconds); } @Override public int getTransactionTimeout() throws XAException { return xaresource.getTransactionTimeout(); } @Override public boolean isSameRM(XAResource xares) throws XAException { throw new UnsupportedOperationException(); } @Override public boolean isConnected() { return connection != null; } @Override public void connect() throws StorageException { openConnections(); } @Override public void disconnect() { closeConnections(); } }