public SQLQuery toSQLQuery(ITypeDesc typeDesc) { List preparedValues = new LinkedList(); StringBuilder b = new StringBuilder(); for (ICustomQuery query : _subQueries) { SQLQuery sqlQuery = query.toSQLQuery(typeDesc); if (b.length() > 0) b.append(DefaultSQLQueryBuilder.AND); b.append(sqlQuery.getQuery()); if (sqlQuery.getParameters() == null) continue; for (int i = 0; i < sqlQuery.getParameters().length; i++) { preparedValues.add(sqlQuery.getParameters()[i]); } } return new SQLQuery(typeDesc.getTypeName(), b.toString(), preparedValues.toArray()); }
@Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (!(obj instanceof SQLQueryToDataSourceSQLQueryAdapter)) return false; SQLQueryToDataSourceSQLQueryAdapter adapter = (SQLQueryToDataSourceSQLQueryAdapter) obj; return _sqlQuery.equals(adapter._sqlQuery); }
/** * Returns a string representation of this SQLQuery, in the form of: <p> SELECT count(*) FROM * <tt>table name</tt> WHERE <tt>query expression</tt> <p> * * @return a string representation of the object. */ public String getSelectCountQuery() { return "SELECT count(*) " + getFromQuery(); }
private String getUniqueKey(SQLQuery<?> sqlQuery) { return sqlQuery.getTypeName() + ":" + sqlQuery.getQuery(); }
private boolean preProcessQuery() { if (_query == null) return false; if (_query instanceof SQLQuery<?>) { SQLQuery<?> sqlQuery = (SQLQuery<?>) _query; // Use the query is is was defined or no template was provided if (sqlQuery.isNullExpression() && sqlQuery.getObject() != null) { // Handle SQLQuery with null expression - use the entry instead _query = sqlQuery.getObject(); return false; } return true; } if (_query instanceof SQLQueryTemplatePacket) return true; return false; }
private QueryResultTypeInternal getSqlQueryResultType(SQLQuery<?> sqlQuery) { switch (sqlQuery.getQueryResultType()) { case OBJECT: return QueryResultTypeInternal.OBJECT_JAVA; case DOCUMENT: return QueryResultTypeInternal.DOCUMENT_ENTRY; case DEFAULT: case NOT_SET: final Object template = sqlQuery.getObject(); if (template instanceof ITemplatePacket) return ((ITemplatePacket) template).getQueryResultType(); return QueryResultTypeInternal.NOT_SET; default: throw new IllegalStateException("Unsupported query result type: " + sqlQuery.getQueryResultType()); } }
private static void getSqlQueryDescription(SQLQuery<?> query, StringBuilder sb) { sb.append("SQL Query").append(StringUtils.NEW_LINE); appendTypeName(sb, query.getTypeName()); appendValue(sb, "Criteria", query.getQuery()); final Object[] parameters = query.getParameters(); appendValue(sb, "Parameters", parameters == null ? 0 : parameters.length); if (parameters != null) for (int i = 0; i < parameters.length; i++) appendValueWithType(sb, "\t#" + (i + 1), parameters[i]); appendValueWithTypeIfNotNull(sb, "Template", query.getObject()); appendRouting(sb, query.getRouting()); appendQueryResultType(sb, query.getQueryResultType()); appendProjections(sb, query.getProjections()); }
@Override public SQLQuery toSQLQuery(ITypeDesc typeDesc) { // TODO Auto-generated method stub // Empty query since EDS can't handle this operation and therefore should return all entries. return new SQLQuery(typeDesc.getTypeName(), ""); }
@Override public int countClear(CountClearProxyActionInfo actionInfo) { SQLQuery<?> sqlQuery = ((SQLQueryTemplatePacket) actionInfo.queryPacket).getQuery(); try { SqlQueryParser parser = actionInfo.isTake ? _takeQueryParser : _countQueryParser; AbstractDMLQuery query = parser.parseSqlQuery(sqlQuery, _proxy); query.assignParameters(sqlQuery, _proxy); query.setReadModifier(actionInfo.modifiers); query.setOperationID(actionInfo.queryPacket.getOperationID()); query.setQueryResultType(actionInfo.queryPacket.getQueryResultType()); query.setRouting(sqlQuery.getRouting()); query.setReturnResult(!actionInfo.isTake); query.setConvertResultToArray(!actionInfo.isTake); query.setExplainPlan(sqlQuery.getExplainPlan()); ResponsePacket responsePacket = query.executeOnSpace(_proxy, actionInfo.txn); return actionInfo.isTake ? responsePacket.getIntResult() : (Integer) responsePacket.getFirst(); } catch (SQLException e) { throw new SQLQueryException("Failed to execute SQLQuery : [" + sqlQuery.getQuery() + "]" + " cause: " + e.toString(), e); } }
public SQLQuery toSQLQuery(ITypeDesc typeDesc) { StringBuilder sqlQuerybuilder = new StringBuilder(getPath()); sqlQuerybuilder.append(" in ("); for (Iterator iterator = getInValues().iterator(); iterator.hasNext(); ) { iterator.next(); sqlQuerybuilder.append(BIND_PARAMETER); if (iterator.hasNext()) sqlQuerybuilder.append(","); } sqlQuerybuilder.append(")"); SQLQuery query = new SQLQuery(typeDesc.getTypeName(), sqlQuerybuilder.toString()); int index = 0; for (Object inValue : getInValues()) { query.setParameter(++index, inValue); } return query; }
public SQLQuery<?> build(IEntryPacket entry, ITypeDesc typeDesc) { Object id = null; String idPropertyName = typeDesc.getIdPropertyName(); if (idPropertyName == null) idPropertyName = typeDesc.getDefaultPropertyName(); //if no fields are defined - create an empty query if (idPropertyName == null) return new SQLQuery<Object>(entry.getTypeName(), ""); if (typeDesc.getIdPropertyName() != null && typeDesc.isAutoGenerateId()) id = entry.getUID(); else id = entry.getPropertyValue(idPropertyName); StringBuilder wherePart = new StringBuilder(); wherePart.append(idPropertyName); wherePart.append(mapCodeToSign(TemplateMatchCodes.EQ)); wherePart.append(BIND_PARAMETER); // Add the field values to the prepared values List<Object> preparedValues = new LinkedList<Object>(); preparedValues.add(id); SQLQuery<?> query = new SQLQuery<Object>(entry.getTypeName(), wherePart.toString()); query.setParameters(preparedValues.toArray()); return query; }
public void assignParameters(SQLQuery<?> sqlQuery, IDirectSpaceProxy proxy) { // If the query has parameters, set them anyway since they might // only relate to a sub query if (sqlQuery.hasParameters()) { setPreparedValues(sqlQuery.getParameters()); } // Otherwise, for prepared query the template values are used as values else if (isPrepared()) { Object dataEntry = sqlQuery.getObject(); ITemplatePacket packet; if (dataEntry instanceof ITemplatePacket) { packet = (ITemplatePacket) dataEntry; proxy.getTypeManager().loadTypeDescToPacket(packet); } else { ObjectType objectType = ObjectType.fromObject(dataEntry); packet = proxy.getTypeManager().getTemplatePacketFromObject(dataEntry, objectType); packet.setSerializeTypeDesc(true); } setTemplatePreparedValues(packet.getTypeDescriptor(), packet.getFieldValues()); } }
public static ITemplatePacket readSqlQuery(PbsInputStream input, ISpaceProxy spaceProxy, ITypeDesc typeDescriptor) { // Read query arguments: String typeName = input.readRepetitiveString(); QueryResultTypeInternal queryResultType = readQueryResultType(input); ITypeDesc implicitTypeDesc = PbsEntryFormatter.readTypeDescIfExists(input, typeName, queryResultType.getEntryType()); String expression = input.readString(); Object[] parameters = readPrimitiveArray(input, spaceProxy); Object routing = PbsEntryFormatter.readFieldValue(input, spaceProxy); PbsProjectionTemplate projectionTemplate = readProjectionTemplate(input); // Create query: SQLQuery<Object> sqlQuery = new SQLQuery<Object>(typeName, expression, parameters); sqlQuery.setRouting(routing); if (typeDescriptor == null) typeDescriptor = implicitTypeDesc; if (typeDescriptor != null) spaceProxy.getDirectProxy().getTypeManager().registerTypeDesc(typeDescriptor); return getTemplatePacketFromSqlQuery(sqlQuery, spaceProxy, projectionTemplate, queryResultType); }
public ITypeDesc getTypeDescBySQLQuery(SQLQuery<?> sqlQuery) { final String typeName = sqlQuery.getTypeName(); logEnter("ClientTypeDescRepository.getTypeDescBySQLQuery", "typeName", typeName); try { final Object template = sqlQuery.getObject(); if (template == null) return getTypeDescByName(sqlQuery.getTypeName(), null); return getTypeDescByObject(template, ObjectType.fromObject(template)); } finally { logExit("ClientTypeDescRepository.getTypeDescBySQLQuery", "typeName", sqlQuery.getTypeName()); } }
@Override public ITemplatePacket getSQLTemplate(SQLQueryTemplatePacket template, Transaction txn) { SQLQuery<?> sqlQuery = template.getQuery(); try { AbstractDMLQuery query = _readQueryParser.parseSqlQuery(sqlQuery, _proxy); query.assignParameters(sqlQuery, _proxy); query.setBuildOnly(true); query.setConvertResultToArray(false); query.validateQuery(_proxy); query.setRouting(sqlQuery.getRouting()); ResponsePacket rPacket = query.executeOnSpace(_proxy, txn); QueryTemplatePacket resultPacket = (QueryTemplatePacket) rPacket.getFirst(); resultPacket.setEntryType(template.getEntryType()); resultPacket.setQueryResultType(template.getQueryResultType()); resultPacket.setRouting(sqlQuery.getRouting()); resultPacket.setProjectionTemplate(template.getProjectionTemplate()); resultPacket.setOperationID(template.getOperationID()); return resultPacket; } catch (SQLException e) { throw new SQLQueryException("Failed to create template from SQLQuery : [" + sqlQuery.getQuery() + "]", e); } }
public SpaceIterator(ISpaceProxy spaceProxy, Object query, Transaction txn, int batchSize, ReadModifiers modifiers) { if (query instanceof SQLQuery && ((SQLQuery)query).getExplainPlan() != null) { throw new UnsupportedOperationException("Sql explain plan does not support space iterator"); } this.iterator = new SpaceEntryPacketIterator(spaceProxy, query, txn, batchSize, modifiers.getCode()); }
@Override public Object[] getQueryParameters() { return _sqlQuery.getParameters(); }
@Override public String getQuery() { return _sqlQuery.getQuery(); }
public SQLQueryTemplatePacket(SQLQuery<?> sqlQuery, ITypeDesc typeDesc, QueryResultTypeInternal resultType) { super(typeDesc, resultType); _query = sqlQuery; if (sqlQuery.getProjections() != null) _projectionTemplate = ProjectionTemplate.create(sqlQuery.getProjections(), typeDesc); }
@Override public void configure(LocalViewDefinition localView) { localView.addViewQuery(new SQLQuery<LunchRestaurant>()); } }