/** * Selects all entities of the specified type which match the given <code>Query</code>. This * method creates a <code>PreparedStatement</code> using the <code>Query</code> instance specified * against the table represented by the given type. This query is then executed (with the * parameters specified in the query). The method then iterates through the result set and * extracts the specified field, mapping an entity of the given type to each row. This array of * entities is returned. * * @param type The type of the entities to retrieve. * @param field The field value to use in the creation of the entities. This is usually the * primary key field of the corresponding table. * @param query The {@link Query} instance to use in determining the results. * @return An array of entities of the given type which match the specified query. */ public <T extends RawEntity<K>, K> T[] find(Class<T> type, String field, Query query) throws SQLException { List<T> back = new ArrayList<T>(); query.resolveFields(type, getFieldNameConverter()); // <ian> Version version = type.getAnnotation(Version.class); if (version != null && !version.findInitial()) { // Add initial version check to exclude // objects that have only been created and not saved yet. if (query.getWhereClause() == null) { query.where(version.value() + " != ?", version.initial()); } else { // Preserve existing WHERE clause and parameters String whereClause = new StringBuilder() .append(query.getWhereClause()) .append(" AND ") .append(version.value()) .append(" != ?") .toString(); Object[] paramsOld = query.getWhereParams(); Object[] paramsNew = new Object[paramsOld.length + 1]; System.arraycopy(paramsOld, 0, paramsNew, 0, paramsOld.length); paramsNew[paramsNew.length - 1] = version.initial(); query.setWhereClause(whereClause); query.setWhereParams(paramsNew); } } // </ian> Preload preloadAnnotation = type.getAnnotation(Preload.class); if (preloadAnnotation != null) { if (!query.getFields()[0].equals("*") && query.getJoins().isEmpty()) { String[] oldFields = query.getFields(); List<String> newFields = new ArrayList<String>(); for (String newField : preloadAnnotation.value()) { newField = newField.trim(); int fieldLoc = -1; for (int i = 0; i < oldFields.length; i++) { if (oldFields[i].equals(newField)) { fieldLoc = i; break; } } if (fieldLoc < 0) { newFields.add(newField); } else { newFields.add(oldFields[fieldLoc]); } } if (!newFields.contains("*")) { for (String oldField : oldFields) { if (!newFields.contains(oldField)) { newFields.add(oldField); } } } query.setFields(newFields.toArray(new String[newFields.size()])); } } Connection conn = getProvider().getConnection(); try { String sql = null; tableNameConverterLock.readLock().lock(); try { sql = query.toSQL(type, provider, tableNameConverter, getFieldNameConverter(), false); } finally { tableNameConverterLock.readLock().unlock(); } Logger.getLogger("net.java.ao").log(Level.INFO, sql); PreparedStatement stmt = conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY); provider.setQueryStatementProperties(stmt, query); query.setParameters(this, stmt); ResultSet res = stmt.executeQuery(); provider.setQueryResultSetProperties(res, query); while (res.next()) { T entity = peer( type, Common.getPrimaryKeyType(type) .pullFromDatabase(this, res, Common.getPrimaryKeyClassType(type), field)); CacheLayer cacheLayer = getProxyForEntity(entity).getCacheLayer(entity); for (String cacheField : query.getCanonicalFields(type, fieldNameConverter)) { cacheLayer.put(cacheField, res.getObject(cacheField)); } back.add(entity); } res.close(); stmt.close(); } finally { conn.close(); } return back.toArray((T[]) Array.newInstance(type, back.size())); }
/** * Creates a new entity of the specified type with the optionally specified initial parameters. * This method actually inserts a row into the table represented by the entity type and returns * the entity instance which corresponds to that row. * * <p>The {@link DBParam} object parameters are designed to allow the creation of entities which * have non-null fields which have no defalut or auto-generated value. Insertion of a row without * such field values would of course fail, thus the need for db params. The db params can also be * used to set the values for any field in the row, leading to more compact code under certain * circumstances. * * <p>Unless within a transaction, this method will commit to the database immediately and exactly * once per call. Thus, care should be taken in the creation of large numbers of entities. There * doesn't seem to be a more efficient way to create large numbers of entities, however one should * still be aware of the performance implications. * * <p>This method delegates the action INSERT action to {@link * DatabaseProvider#insertReturningKey(EntityManager, Connection, Class, String, boolean, String, * DBParam...)}. This is necessary because not all databases support the JDBC <code> * RETURN_GENERATED_KEYS</code> constant (e.g. PostgreSQL and HSQLDB). Thus, the database provider * itself is responsible for handling INSERTion and retrieval of the correct primary key value. * * @param type The type of the entity to INSERT. * @param params An optional varargs array of initial values for the fields in the row. These * values will be passed to the database within the INSERT statement. * @return The new entity instance corresponding to the INSERTed row. * @see net.java.ao.DBParam * @see net.java.ao.DatabaseProvider#insertReturningKey(EntityManager, Connection, Class, String, * boolean, String, DBParam...) */ public <T extends RawEntity<K>, K> T create(Class<T> type, DBParam... params) throws SQLException { T back = null; String table = null; tableNameConverterLock.readLock().lock(); try { table = tableNameConverter.getName(type); } finally { tableNameConverterLock.readLock().unlock(); } Set<DBParam> listParams = new HashSet<DBParam>(); listParams.addAll(Arrays.asList(params)); fieldNameConverterLock.readLock().lock(); try { for (Method method : MethodFinder.getInstance().findAnnotation(Generator.class, type)) { Generator genAnno = method.getAnnotation(Generator.class); String field = fieldNameConverter.getName(method); ValueGenerator<?> generator; valGenCacheLock.writeLock().lock(); try { if (valGenCache.containsKey(genAnno.value())) { generator = valGenCache.get(genAnno.value()); } else { generator = genAnno.value().newInstance(); valGenCache.put(genAnno.value(), generator); } } catch (InstantiationException e) { continue; } catch (IllegalAccessException e) { continue; } finally { valGenCacheLock.writeLock().unlock(); } listParams.add(new DBParam(field, generator.generateValue(this))); } // <ian> Version version = type.getAnnotation(Version.class); if (version != null) { // Initialize version upon creation. String field = version.value(); int initial = version.initial(); listParams.add(new DBParam(field, initial)); } // </ian> } finally { fieldNameConverterLock.readLock().unlock(); } Connection conn = getProvider().getConnection(); try { Method pkMethod = Common.getPrimaryKeyMethod(type); back = peer( type, provider.insertReturningKey( this, conn, Common.getPrimaryKeyClassType(type), Common.getPrimaryKeyField(type, getFieldNameConverter()), pkMethod.getAnnotation(AutoIncrement.class) != null, table, listParams.toArray(new DBParam[listParams.size()]))); } finally { conn.close(); } relationsCache.remove(type); back.init(); return back; }