public static boolean isHsql(EntityManager em) { return em.getProvider() instanceof HSQLDatabaseProvider; }
public static boolean isOracle(EntityManager em) { return em.getProvider() instanceof OracleDatabaseProvider; }
public static boolean isNuoDB(EntityManager em) { return em.getProvider() instanceof NuoDBDatabaseProvider; }
@Override public Object pullFromDatabase(EntityManager manager, ResultSet res, Class<Object> type, String columnName) throws SQLException { return manager.getProvider().handleBlob(res, type, columnName); }
@Override public Object pullFromDatabase(EntityManager manager, ResultSet res, Class<Object> type, String columnName) throws SQLException { return manager.getProvider().handleBlob(res, type, columnName); }
@Override public void putToDatabase(EntityManager manager, PreparedStatement stmt, int index, Boolean value, int jdbcType) throws SQLException { manager.getProvider().putBoolean(stmt, index, value); }
@Override public void putToDatabase(EntityManager manager, PreparedStatement stmt, int index, Boolean value, int jdbcType) throws SQLException { manager.getProvider().putBoolean(stmt, index, value); }
private TypeManager getTypeManager() { return manager.getProvider().getTypeManager(); }
/** * 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); } }
public static void executeUpdate(EntityManager em, String sql, UpdateCallback callback) throws Exception { Connection connection = null; PreparedStatement statement = null; try { connection = em.getProvider().getConnection(); statement = connection.prepareStatement(sql); logger.debug(sql); callback.setParameters(statement); statement.executeUpdate(); } finally { closeQuietly(statement, connection); } }
/** * 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; }
private void getInformation(EntityManager entityManager) { try (Connection connection = entityManager.getProvider().getConnection()) { if (connection != null && !connection.isClosed()) { final DatabaseMetaData metaData = connection.getMetaData(); database = getDatabase(metaData); driver = getDriver(metaData); } } catch (SQLException e) { logger.debug("Could not load database connection meta data", e); addSuppressed(e); } }
private TypeManager getTypeManager() { return getManager().getProvider().getTypeManager(); }
private TypeManager getTypeManager() { return getManager().getProvider().getTypeManager(); }
protected void after(FrameworkMethod method) { if (!useTransaction(method)) { // make sure that the next test gets a clean database final DatabaseConfiguration databaseConfiguration = DATABASES.remove(jdbc); databaseConfiguration.getEntityManager().getProvider().dispose(); } entityManager = null; }
protected void with(WithConnection w) throws Exception { Connection connection = null; try { connection = entityManager.getProvider().getConnection(); w.call(connection); } finally { closeQuietly(connection); } }
private static <T> T checkSql(EntityManager em, boolean executed, Callable<T> callable) throws Exception { final DatabaseProvider provider = em.getProvider(); final SqlTracker sqlTracker = new SqlTracker(); try { provider.addSqlListener(sqlTracker); final T t = callable.call(); assertEquals(executed, sqlTracker.isSqlExecuted()); return t; } finally { provider.removeSqlListener(sqlTracker); } } }
public static String getFieldName(EntityManager em, Class<? extends RawEntity<?>> entityType, String methodName) { return em.getProvider().shorten(em.getFieldNameConverter().getName(findMethod(entityType, methodName))); }
protected String indexName(String tableName, String indexName) { final IndexNameConverter indexNameConverter = entityManager.getNameConverters().getIndexNameConverter(); final DatabaseProvider provider = entityManager.getProvider(); return indexNameConverter.getName(provider.shorten(tableName), provider.shorten(indexName)); }
protected DDLIndexField field(String name, Class type, Class<? extends RawEntity<?>> entity) { return DDLIndexField.builder() .fieldName(getFieldName(entity, name)) .type(entityManager.getProvider().getTypeManager().getType(type)) .build(); }