/** * Returns a ProcedureQuery. */ public Query getQuery() { ProcedureQuery query = new ProcedureQuery(); Object root = getRoot(); if (root != null) { query.setRoot(root); } query.setName(name); query.setResultEntityName(resultEntity); query.initWithProperties(properties); return query; }
/** * Creates and returns a new ProcedureQuery built using this query as a prototype and * substituting template parameters with the values from the map. * * @since 1.1 */ public Query createQuery(Map<String, ?> parameters) { // create a query replica ProcedureQuery query = new ProcedureQuery(); if (root != null) { query.setRoot(root); } query.setResultEntityName(resultEntityName); query.metaData.copyFromInfo(this.metaData); query.setParameters(parameters); // TODO: implement algorithm for building the name based on the original name and // the hashcode of the map of parameters. This way query clone can take advantage // of caching. return query; }
@Override protected Query createReplacementQuery(EntityResolver resolver) { ProcedureQuery procedureQuery = new ProcedureQuery(procedureName); procedureQuery.setFetchingDataRows(fetchingDataRows); procedureQuery.setFetchLimit(fetchLimit); procedureQuery.setFetchOffset(fetchOffset); procedureQuery.addResultDescriptor(resultDescriptor); procedureQuery.setColumnNamesCapitalization(capsStrategy); procedureQuery.setParameters(params);
/** * @since 1.1 */ public ProcedureQuery(Procedure procedure, Class resultType) { setRoot(procedure); this.resultClass = resultType; // call this for backwards compatibility setResultClassName(resultType != null ? resultType.getName() : null); }
/** * @since 1.1 */ public ProcedureQuery(String procedureName, Class<?> resultType) { setRoot(procedureName); this.resultClass = resultType; }
Map<String, ?> parameters = query.getParameters(); if (!parameters.isEmpty()) { if (query.getFetchOffset() > 0 || query.getFetchLimit() > 0) { key.append('/'); if (query.getFetchOffset() > 0) { key.append('o').append(query.getFetchOffset()); if (query.getFetchLimit() > 0) { key.append('l').append(query.getFetchLimit());
List<ColumnDescriptor[]> descriptors = query.getResultDescriptors(); switch (query.getColumnNamesCapitalization()) { case LOWER: builder.useLowercaseColumnNames();
encoder.print(getName()); encoder.print("\" factory=\""); encoder.print("org.apache.cayenne.map.ProcedureQueryBuilder"); if (getColumnNamesCapitalization() != CapsStrategy.DEFAULT) { encoder.printProperty( COLUMN_NAME_CAPITALIZATION_PROPERTY, getColumnNamesCapitalization().name());
/** * @since 1.2 */ public QueryMetadata getMetaData(EntityResolver resolver) { metaData.resolve(root, resultClass != null ? (Object) resultClass : resultEntityName, resolver, getName()); return metaData; }
protected void initValues() { Map queryValues = getProcedureQuery().getParameters(); // match values with parameters in the correct order. // make an assumption that a missing value is NULL // Any reason why this is bad? Iterator it = callParams.iterator(); while (it.hasNext()) { ProcedureParameter param = (ProcedureParameter) it.next(); if (param.getDirection() == ProcedureParameter.OUT_PARAMETER) { values.add(OUT_PARAM); } else { values.add(queryValues.get(param.getName())); } } }
/** * Creates a RowDescriptor for result set. * * @param resultSet JDBC ResultSet * @param setIndex a zero-based index of the ResultSet in the query results. */ protected RowDescriptor describeResultSet(ResultSet resultSet, int setIndex) { if (setIndex < 0) { throw new IllegalArgumentException( "Expected a non-negative result set index. Got: " + setIndex); } List descriptors = query.getResultDescriptors(); if (descriptors.isEmpty()) { // failover to default JDBC result descriptor return new RowDescriptor(resultSet, getAdapter().getExtendedTypes()); } // if one result is described, all of them must be present... if (setIndex >= descriptors.size() || descriptors.get(setIndex) == null) { throw new CayenneRuntimeException("No descriptor for result set at index '" + setIndex + "' configured."); } ColumnDescriptor[] columns = (ColumnDescriptor[]) descriptors.get(setIndex); return new RowDescriptor(columns, getAdapter().getExtendedTypes()); }
/** * @since 1.1 */ public ProcedureQuery(Procedure procedure, Class<?> resultType) { setRoot(procedure); this.resultClass = resultType; }
/** * <p> * Performance Note: with current EntityResolver implementation it is preferrable to * use Procedure object instead of String as a query root. String root can cause * unneeded EntityResolver reindexing on every call. See this mailing list thread: <a * href="http://objectstyle.org/cayenne/lists/cayenne-user/2005/01/0109.html"> * http://objectstyle.org/cayenne/lists/cayenne-user/2005/01/0109.html</a> * </p> * * @since 1.1 */ public ProcedureQuery(String procedureName, Class resultType) { setRoot(procedureName); this.resultClass = resultType; setResultClassName(resultType != null ? resultType.getName() : null); }
encoder.print(getName()); encoder.print("\" factory=\""); encoder.print("org.apache.cayenne.map.ProcedureQueryBuilder");
protected void initValues() { Map<String, ?> queryValues = getProcedureQuery().getParameters(); // match values with parameters in the correct order. // make an assumption that a missing value is NULL // Any reason why this is bad? for (ProcedureParameter param : callParams) { if (param.getDirection() == ProcedureParameter.OUT_PARAMETER) { values.add(OUT_PARAM); } else { values.add(queryValues.get(param.getName())); } } }
@Override public ProcedureQuery buildQuery() { ProcedureQuery procedureQuery = new ProcedureQuery(); if (root != null) { procedureQuery.setRoot(root); } procedureQuery.setName(this.getName()); procedureQuery.setDataMap(dataMap); procedureQuery.setResultEntityName(this.getResultEntityName()); procedureQuery.initWithProperties(this.getProperties()); return procedureQuery; }
/** * Creates and returns a new ProcedureQuery built using this query as a prototype and * substituting template parameters with the values from the map. * * @since 1.1 */ public Query createQuery(Map parameters) { // create a query replica ProcedureQuery query = new ProcedureQuery(); if (root != null) { query.setRoot(root); } query.setResultClassName(resultClassName); query.setResultEntityName(resultEntityName); query.metaData.copyFromInfo(this.metaData); query.setParameters(parameters); // TODO: implement algorithm for building the name based on the original name and // the hashcode of the map of parameters. This way query clone can take advantage // of caching. return query; }
/** * Creates a ProcedureQuery based on a Procedure object. */ public ProcedureQuery(Procedure procedure) { // for backwards compatibility we go against usual default... metaData.setFetchingDataRows(true); setRoot(procedure); }
/** * Creates a ProcedureQuery based on a Procedure object. The query would fetch * DataRows. Fetching Persistent objects can be achieved either by using * {@link #ProcedureQuery(String, Class)} constructor or by calling * {@link #setFetchingDataRows(boolean)} and {@link #setResultEntityName(String)} * methods. */ public ProcedureQuery(Procedure procedure) { // for backwards compatibility we go against usual default... metaData.setFetchingDataRows(true); setRoot(procedure); }
/** * Creates a ProcedureQuery based on a stored procedure. The query would fetch * DataRows. Fetching Persistent objects can be achieved either by using * {@link #ProcedureQuery(String, Class)} constructor or by calling * {@link #setFetchingDataRows(boolean)} and {@link #setResultEntityName(String)} * methods. * * @param procedureName A name of the stored procedure. For this query to work, a * procedure with this name must be mapped in Cayenne. */ public ProcedureQuery(String procedureName) { // for backwards compatibility we go against usual default... metaData.setFetchingDataRows(true); setRoot(procedureName); }