/** * Checker for the auto-commit status, if auto-commit is off then commit() is called on the {@link EntityManager} */ public static void checkAutoCommit(EntityManager entityManager) { try { // I found that during testing the commit is not always executed leaving the check to be only in the cache // So calling the commit method manually in case auto-commit is off if (!entityManager.getProvider().getConnection().getAutoCommit()) { logger.debug("Auto-commit is off, calling commit() manually..."); entityManager.getProvider().getConnection().commit(); } } catch (Exception e) { logger.error("Failed to check auto-commit status and/or manually commiting the changes", e); } }
private TypeManager getTypeManager() { return manager.getProvider().getTypeManager(); }
/** * Renders the specified foreign key representation into the * database-specific DDL. The implementation <i>must</i> name the * foreign key according to the <code>DDLForeignKey#getFKName()</code> * value otherwise migrations will no longer function appropriately. * * @param key The database-agnostic foreign key representation. * @return The database-pecific DDL fragment corresponding to the * foreign key in question. */ protected String renderForeignKey(DDLForeignKey key) { StringBuilder back = new StringBuilder(); back.append("CONSTRAINT ").append(processID(key.getFKName())); back.append(" FOREIGN KEY (").append(processID(key.getField())).append(") REFERENCES "); back.append(withSchema(key.getTable())).append('(').append(processID(key.getForeignField())).append(")"); return back.toString(); }
/** * Processes the table name as {@link #processID(String)} but use * #shouldQuoteTableName(String) to check if the table name should * be quoted or not. * * @param tableName The table name to process. * @return A unique identifier corresponding with the input which is * guaranteed to function within the underlying database. * @see #getMaxIDLength() * @see #shouldQuoteTableName(String) */ public final String processTableName(String tableName) { return quoteTableName(shorten(tableName)); }
public final String withSchema(String tableName) { final String processedTableName = processID(tableName); return isSchemaNotEmpty() ? schema + "." + processedTableName : processedTableName; }
public final Connection startTransaction() throws SQLException { final Connection c = getConnection(); setCloseable(c, false); c.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE); c.setAutoCommit(false); transactionThreadLocal.set(c); return c; }
ResultSet res = null; try { conn = provider.getConnection(); StringBuilder sql = new StringBuilder(); String returnField; } else { for (String field : selectFields) { sql.append(provider.processID(field)).append(','); sql.append(" FROM ").append(provider.withSchema(table)); sql.append(" WHERE ").append(provider.processID(inMapFields[0])).append(" = ?"); sql.append(" AND (").append(manager.getProvider().processWhereClause(where)).append(")"); sql.append(" AND ").append(provider.processID(name)).append(" = ?"); returnField = manager.getProvider().shorten(finalTable + "__aointernal__id"); throughField = manager.getProvider().shorten(table + "__aointernal__id"); sql.append(finalTableAlias).append('.').append(provider.processID(finalPKField)); sql.append(" AS ").append(provider.quote(returnField)).append(','); sql.append(tableAlias).append('.').append(provider.processID(Common.getPrimaryKeyField(type, getFieldNameConverter()))); sql.append(" AS ").append(provider.quote(throughField)).append(','); sql.append(finalTableAlias).append('.').append(provider.processID(field)).append(',');
final TypeManager typeManager = provider.getTypeManager(); Connection conn = null; PreparedStatement stmt = null; try { conn = provider.getConnection(); StringBuilder sql = new StringBuilder("UPDATE " + provider.withSchema(table) + " SET "); sql.append(provider.processID(name)); sql.append(" WHERE ").append(provider.processID(entityInfo.getPrimaryKey().getName())).append(" = ?"); stmt = provider.preparedStatement(conn, sql); this.manager.getProvider().putNull(stmt, index++); } else { Class javaType = value.getClass();
private <V> V pullFromDatabase(FieldInfo<V> fieldInfo) throws SQLException { Class<V> type = fieldInfo.getJavaType(); String name = fieldInfo.getName(); final DatabaseProvider provider = manager.getProvider(); Connection conn = null; PreparedStatement stmt = null; ResultSet res = null; V back = null; try { conn = provider.getConnection(); StringBuilder sql = new StringBuilder("SELECT "); sql.append(provider.processID(name)); String polyName = fieldInfo.getPolymorphicName(); if (polyName != null) { sql.append(',').append(provider.processID(polyName)); } sql.append(" FROM ").append(provider.withSchema(entityInfo.getName())).append(" WHERE "); sql.append(provider.processID(entityInfo.getPrimaryKey().getName())).append(" = ?"); stmt = provider.preparedStatement(conn, sql); TypeInfo<K> pkType = entityInfo.getPrimaryKey().getTypeInfo(); pkType.getLogicalType().putToDatabase(manager, stmt, 1, getKey(), pkType.getJdbcWriteType()); res = stmt.executeQuery(); if (res.next()) { back = convertValue(res, provider.shorten(name), provider.shorten(polyName), type); } } finally { closeQuietly(res, stmt, conn); } return back; }
int rowCount = 0; StringBuilder sql = new StringBuilder("DELETE FROM "); sql.append(provider.withSchema(nameConverters.getTableNameConverter().getName(type))); sql.append(provider.processWhereClause(criteria)); final Connection connection = provider.getConnection(); try { final PreparedStatement stmt = provider.preparedStatement(connection, sql); try { putStatementParameters(stmt, parameters);
/** * Counts all entities of the specified type matching the given {@link Query} instance. The SQL runs as a * <code>SELECT COUNT(*)</code> to ensure maximum performance. * * @param type The type of the entities which should be counted. * @param query The {@link Query} instance used to determine the result set which will be counted. * @return The number of entities of the given type which match the specified query. */ public <K> int count(Class<? extends RawEntity<K>> type, Query query) throws SQLException { EntityInfo entityInfo = resolveEntityInfo(type); Connection connection = null; PreparedStatement stmt = null; ResultSet res = null; try { connection = provider.getConnection(); final String sql = query.toSQL(entityInfo, provider, getTableNameConverter(), true); stmt = provider.preparedStatement(connection, sql); provider.setQueryStatementProperties(stmt, query); query.setParameters(this, stmt); res = stmt.executeQuery(); return res.next() ? res.getInt(1) : -1; } finally { closeQuietly(res); closeQuietly(stmt); closeQuietly(connection); } }
Connection c = null; try { c = provider.startTransaction(); state = TransactionState.RUNNING; final T back = run(); provider.commitTransaction(c); state = TransactionState.COMMITTED; return back; } finally { if (state == TransactionState.RUNNING && c != null) { provider.rollbackTransaction(c); manager.flushAll(); provider.setCloseable(c, true); closeQuietly(c);
@Override public String apply(String field) { return processID(field); } },
protected SQLAction renderInsert(DDLTable ddlTable, DDLValue[] ddlValues) { final StringBuilder columns = new StringBuilder(); final StringBuilder values = new StringBuilder(); for (DDLValue v : ddlValues) { columns.append(processID(v.getField().getName())).append(","); values.append(renderValue(v.getValue())).append(","); } columns.deleteCharAt(columns.length() - 1); values.deleteCharAt(values.length() - 1); return SQLAction.of(new StringBuilder() .append("INSERT INTO ").append(withSchema(ddlTable.getName())) .append("(").append(columns).append(")") .append(" VALUES (").append(values).append(")")); }
protected boolean hasIndex(String tableName, String indexName) { Connection connection = null; try { connection = getConnection(); ResultSet indexes = getIndexes(connection, tableName); while (indexes.next()) { if (indexName.equalsIgnoreCase(indexes.getString("INDEX_NAME"))) { return true; } } return false; } catch (SQLException e) { throw new ActiveObjectsException(e); } finally { closeQuietly(connection); } }
public static void migrate(DatabaseProvider provider, SchemaConfiguration schemaConfiguration, NameConverters nameConverters, final boolean executeDestructiveUpdates, Class<? extends RawEntity<?>>... classes) throws SQLException { final Iterable<Iterable<SQLAction>> actionGroups = generateImpl(provider, schemaConfiguration, nameConverters, executeDestructiveUpdates, classes); final Connection conn = provider.getConnection(); try { final Statement stmt = conn.createStatement(); try { Set<String> completedStatements = new HashSet<String>(); for (Iterable<SQLAction> actionGroup : actionGroups) { addAll(completedStatements, provider.executeUpdatesForActions(stmt, actionGroup, completedStatements)); } } finally { stmt.close(); } } finally { conn.close(); } }
public Iterable<? extends Field> getFields(DatabaseMetaData databaseMetaData, String tableName) { final TypeManager manager = databaseProvider.getTypeManager(); final List<String> sequenceNames = getSequenceNames(databaseMetaData); final Set<String> uniqueFields = getUniqueFields(databaseMetaData, tableName); throw new IllegalStateException("Could not find column '" + columnName + "' in previously parsed query!"); current.setDefaultValue(databaseProvider.parseValue(current.getDatabaseType().getJdbcWriteType(), parseStringValue(rs, "COLUMN_DEF"))); current.setNotNull(current.isNotNull() || parseStringValue(rs, "IS_NULLABLE").equals("NO")); rs = databaseMetaData.getPrimaryKeys(null, databaseProvider.getSchema(), tableName); while (rs.next()) { final String fieldName = parseStringValue(rs, "COLUMN_NAME");
ResultSet res = null; try { connection = provider.getConnection(); stmt = provider.preparedStatement(connection, sql); putStatementParameters(stmt, parameters);
/** * Get the table name of the given class entity * * @param entityType the class of the entity * @param escape whether or not to escape the table name * @return the table name */ public static String getTableName(EntityManager em, Class<? extends RawEntity<?>> entityType, boolean escape) { final String tableName = em.getProvider().shorten(em.getTableNameConverter().getName(entityType)); return escape ? em.getProvider().withSchema(tableName) : tableName; }
/** * Render "SELECT * FROM <tableName> LIMIT 1" in the database specific dialect */ public String renderMetadataQuery(final String tableName) { return "SELECT * FROM " + withSchema(tableName) + " LIMIT 1"; }