public Boolean isValidParameterNames(SelectQueryDescriptor query) { if (query.getQualifier() == null) { return true; } Map<String, String> queryParameters = queriesMap.get(query.getName()); if (queryParameters == null) { try { queryParameters = getParameterNames(query.getQualifier(), query.getRoot()); } catch (Exception e) { // if we have wrong path in queryParameters return false. return false; } } for (Ordering ordering : query.getOrderings()) { // validate paths in ordering String path = ordering.getSortSpecString(); Iterator<CayenneMapEntry> it = ((ObjEntity) query.getRoot()).resolvePathComponents(path); while (it.hasNext()) { try { it.next(); } catch (ExpressionException e) { // if we have wrong path in orderings return false. return false; } } } return true; }
public void addPrefetch(String prefetch) { // check if such prefetch already exists if (!selectQuery.getPrefetches().isEmpty() && selectQuery.getPrefetches().contains(prefetch)) { return; } selectQuery.addPrefetch(prefetch); // reset the model, since it is immutable table.setModel(createTableModel()); mediator.fireQueryEvent(new QueryEvent(this, selectQuery)); }
public void setDistinct(boolean value) { setProperty(SelectQuery.DISTINCT_PROPERTY, String.valueOf(value)); }
/** * Get all parameter names that used in query qualifier. * * @param query select query descriptor * @return Parameter names. */ public Collection getParameterNames(SelectQueryDescriptor query) { if (query.getQualifier() == null) { return Collections.EMPTY_SET; } Map<String, String> queryParameters = queriesMap.get(query.getName()); if (queryParameters == null) { queryParameters = getParameterNames(query.getQualifier(), query.getRoot()); queriesMap.put(query.getName(), queryParameters); } return parseQualifier(query.getQualifier().toString()); }
@Override public SelectQuery<?> buildQuery() { SelectQuery<Object> selectQuery = new SelectQuery<>(); selectQuery.setRoot(this.getRoot()); selectQuery.setName(this.getName()); selectQuery.setDataMap(dataMap); selectQuery.setQualifier(this.getQualifier()); List<Ordering> orderings = this.getOrderings(); if (orderings != null && !orderings.isEmpty()) { selectQuery.addOrderings(orderings); } List<String> prefetches = this.getPrefetches(); if (prefetches != null && !prefetches.isEmpty()) { for (String prefetch : prefetches) { selectQuery.addPrefetch(prefetch); } } // init properties selectQuery.initWithProperties(this.getProperties()); return selectQuery; }
name.setText(query.getName()); distinct.setSelected(Boolean.valueOf(query.getProperties().get(SelectQuery.DISTINCT_PROPERTY))); qualifier.setText(query.getQualifier() != null ? query .getQualifier() .toString() : null); model.setSelectedItem(query.getRoot()); queryRoot.setModel(model);
void validate(SelectQueryDescriptor query, ValidationResult validationResult) { validateName(query, validationResult); validateCacheGroup(query, validationResult); // Resolve root to Entity for further validation Entity root = validateRoot(query, validationResult); // validate path-based parts if (root != null) { validateQualifier(root, query.getQualifier(), validationResult); for (final Ordering ordering : query.getOrderings()) { validateOrdering(query, root, ordering, validationResult); } if (query.getPrefetches() != null) { for (String prefetchPath : query.getPrefetches()) { validatePrefetch(root, prefetchPath, validationResult); } } } }
protected QueryDescriptor makeEOQueryDescriptor(ObjEntity root, Map plistMap) { SelectQueryDescriptor descriptor = QueryDescriptor.selectQueryDescriptor(); descriptor.setRoot(root); descriptor.setDistinct("YES".equalsIgnoreCase((String) plistMap.get("usesDistinct"))); try { if (fetchLimit instanceof Number) { descriptor.setProperty(QueryMetadata.FETCH_LIMIT_PROPERTY, String.valueOf(((Number) fetchLimit).intValue())); } else if (StringUtils.isNumeric(fetchLimit.toString())) { descriptor.setProperty(QueryMetadata.FETCH_LIMIT_PROPERTY, fetchLimit.toString()); String key = ordering.get("key"); if (key != null) { descriptor.addOrdering(new Ordering(key, asc ? SortOrder.ASCENDING : SortOrder.DESCENDING)); descriptor.setQualifier(EOQuery.EOFetchSpecificationParser.makeQualifier((EOObjEntity) root, qualifierMap)); Iterator it = prefetches.iterator(); while (it.hasNext()) { descriptor.addPrefetch((String) it.next()); descriptor.setProperty(QueryMetadata.FETCHING_DATA_ROWS_PROPERTY, String.valueOf(true));
String oldQualifier = convertor.valueAsString(query.getQualifier()); if (!Util.nullSafeEquals(oldQualifier, text)) { Expression exp = (Expression) convertor.stringAsValue(text); if (query.getRoot() instanceof Entity) { checkExpression((Entity) query.getRoot(), exp);
void addOrdering() { String orderingPath = getSelectedPath(); if (orderingPath == null) { return; } // check if such ordering already exists for (Ordering ord : selectQuery.getOrderings()) { if (orderingPath.equals(ord.getSortSpecString())) { return; } } selectQuery.addOrdering(new Ordering(orderingPath, SortOrder.ASCENDING)); int index = selectQuery.getOrderings().size() - 1; OrderingModel model = (OrderingModel) table.getModel(); model.fireTableRowsInserted(index, index); mediator.fireQueryEvent(new QueryEvent(SelectQueryOrderingTab.this, selectQuery)); }
Ordering getOrdering(int row) { return selectQuery.getOrderings().get(row); }
/** * Builds a Query object based on internal configuration information. */ public QueryDescriptor buildQueryDescriptor() { QueryDescriptor descriptor = QueryDescriptor.descriptor(queryType); descriptor.setName(name); descriptor.setDataMap(dataMap); descriptor.setRoot(getRoot()); descriptor.setProperties(properties); switch (queryType) { case QueryDescriptor.SELECT_QUERY: ((SelectQueryDescriptor) descriptor).setQualifier(qualifier); ((SelectQueryDescriptor) descriptor).setOrderings(orderings); ((SelectQueryDescriptor) descriptor).setPrefetches(prefetches); break; case QueryDescriptor.SQL_TEMPLATE: ((SQLTemplateDescriptor) descriptor).setSql(sql); ((SQLTemplateDescriptor) descriptor).setAdapterSql(adapterSql); break; case QueryDescriptor.EJBQL_QUERY: ((EJBQLQueryDescriptor) descriptor).setEjbql(ejbql); break; case QueryDescriptor.PROCEDURE_QUERY: ((ProcedureQueryDescriptor) descriptor).setResultEntityName(resultEntity); break; default: // no additional properties } return descriptor; }
/** * Get type of parameter for given name. * * @param query descriptor * @param name parameter name * @return Parameter type. */ public String getParameterType(SelectQueryDescriptor query, String name) { return queriesMap.get(query.getName()).get(name); }
protected void initFromModel() { QueryDescriptor query = mediator.getCurrentQuery(); if (query == null || !QueryDescriptor.SELECT_QUERY.equals(query.getType())) { processInvalidModel("Unknown query."); return; } if (!(query.getRoot() instanceof Entity)) { processInvalidModel("SelectQuery has no root set."); return; } this.selectQuery = (SelectQueryDescriptor) query; browser.setModel(createBrowserModel((Entity) selectQuery.getRoot())); table.setModel(createTableModel()); // init column sizes table.getColumnModel().getColumn(0).setPreferredWidth(250); cardLayout.show(this, REAL_PANEL); }
PrefetchModel() { if (selectQuery != null) { prefetches = new String[selectQuery.getPrefetches().size()]; for (int i = 0; i < prefetches.length; i++) { prefetches[i] = selectQuery.getPrefetches().get(i); } } }
@Override public void encodeAsXML(XMLEncoder encoder) { encoder.print("<query name=\""); encoder.print(getName()); encoder.print("\" type=\""); encoder.print(type); encodeProperties(encoder);
/** * Initializes Query qualifier from string. */ void setQueryQualifier(String text) { if (text != null && text.trim().length() == 0) { text = null; } Expression qualifier = createQualifier(text); //getQuery() is not null if we reached here getQuery().setQualifier((qualifier)); mediator.fireQueryEvent(new QueryEvent(this, getQuery())); }
public int getRowCount() { return (selectQuery != null) ? selectQuery.getOrderings().size() : 0; }
public boolean hasParameters(SelectQueryDescriptor query) { Map queryParameters = queriesMap.get(query.getName()); if (queryParameters == null) { return false; } return queryParameters.keySet().size() > 0; }
boolean isToMany(String prefetch) { if (selectQuery == null) { return false; } Object root = selectQuery.getRoot(); // totally invalid path would result in ExpressionException try { Expression exp = ExpressionFactory.exp(prefetch); Object object = exp.evaluate(root); if (object instanceof Relationship) { return ((Relationship) object).isToMany(); } else { return false; } } catch (ExpressionException e) { return false; } }