private void insert(String table, String columns, String values) { String insertSql = "INSERT INTO utest." + table + " (" + columns + ") VALUES (" + values + ")"; objectContext.performGenericQuery(new SQLTemplate(table, insertSql)); }
/** * Returns a new query built using this query as a prototype and a new set * of parameters. */ public SQLTemplate queryWithParameters(Map<String, ?>... parameters) { // create a query replica SQLTemplate query = new SQLTemplate(); query.setRoot(root); query.setDefaultTemplate(getDefaultTemplate()); if (templates != null) { query.templates = new HashMap<>(templates); } query.metaData.copyFromInfo(this.metaData); query.setParameters(parameters); query.setColumnNamesCapitalization(this.getColumnNamesCapitalization()); return query; }
resultSetMapping = query.getResult() != null ? query.getResult().getResolvedComponents(resolver) : null; if (query.getDefaultTemplate() != null) { key.append('/').append(query.getDefaultTemplate()); Map<String, ?> parameters = query.getParams(); if (!parameters.isEmpty()) { for (Object parameter : query.getPositionalParams()) { key.append("/p:").append(parameter); 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());
/** * @since 1.2 */ public SQLTemplate(ObjEntity rootEntity, String defaultTemplate) { setDefaultTemplate(defaultTemplate); setRoot(rootEntity); }
/** * Creates a SQLTemplate without an explicit root. * * @since 4.0 */ public SQLTemplate(String defaultTemplate, boolean isFetchingDataRows) { setDefaultTemplate(defaultTemplate); setRoot(null); setFetchingDataRows(isFetchingDataRows); }
SQLTemplate template = new SQLTemplate(); template.setFetchingDataRows(isFetchingDataRows()); template.setRoot(root); template.setDefaultTemplate(getSql()); template.setCacheGroup(cacheGroup); template.setCacheStrategy(cacheStrategy); template.setParamsList(positionalParams); } else { template.setParams(params); template.setColumnNamesCapitalization(columnNameCaps); template.setFetchLimit(limit); template.setFetchOffset(offset); template.setPageSize(pageSize); template.setStatementFetchSize(statementFetchSize); template.setResult(resultMap);
@Override public SQLTemplate buildQuery() { SQLTemplate template = new SQLTemplate(); if (root != null) { template.setRoot(root); } template.setName(name); template.setDataMap(dataMap); template.initWithProperties(this.getProperties()); // init SQL template.setDefaultTemplate(this.getSql()); Map<String, String> adapterSql = this.getAdapterSql(); if (adapterSql != null) { for (Map.Entry<String, String> entry : adapterSql.entrySet()) { String key = entry.getKey(); String value = entry.getValue(); if (key != null && value != null) { template.setTemplate(key, value); } } } return template; }
/** * Creates and returns a new SQLTemplate built using this query as a * prototype and substituting template parameters with the values from the * map. * * @since 1.1 */ @Override public Query createQuery(Map<String, ?> parameters) { // create a query replica SQLTemplate query = new SQLTemplate(); query.setRoot(root); query.setDefaultTemplate(getDefaultTemplate()); if (templates != null) { query.templates = new HashMap<>(templates); } query.metaData.copyFromInfo(this.metaData); query.setParams(parameters); query.setColumnNamesCapitalization(this.getColumnNamesCapitalization()); return query; }
SQLTemplate query = new SQLTemplate(); query.setRoot(root); query.setDefaultTemplate(getDefaultTemplate()); query.setParameters(parameters); query.setName(buffer.toString());
SQLTemplate template = new SQLTemplate(); template.setRoot(root); template.setDefaultTemplate(getSql()); template.setFetchingDataRows(true); // in case result set will be returned template.setParamsList(positionalParams); } else { template.setParams(params);
public SQLTemplate getQuery() { // concatenate buffers... StringBuilder main = bufferChain.get(0); for (int i = 1; i < bufferChain.size(); i++) { main.append(bufferChain.get(i)); } String sql = main.length() > 0 ? main.toString() : null; SQLTemplate query = new SQLTemplate(compiledExpression .getRootDescriptor() .getObjectClass(), sql); query.setParams(boundParameters); return query; }
private void runWithNamedParametersBatch(Connection connection, OperationObserver callback, String template, Collection<Number> counts, boolean loggable) throws Exception { int size = query.parametersSize(); // zero size indicates a one-shot query with no parameters // so fake a single entry batch... int batchSize = (size > 0) ? size : 1; // for now supporting deprecated batch parameters... @SuppressWarnings("unchecked") Iterator<Map<String, ?>> it = (size > 0) ? query.parametersIterator() : (Iterator)Collections.singleton(Collections.emptyMap()).iterator(); for (int i = 0; i < batchSize; i++) { Map<String, ?> nextParameters = it.next(); SQLStatement compiled = dataNode.getSqlTemplateProcessor().processTemplate(template, nextParameters); bindExtendedTypes(compiled.getBindings()); if (loggable) { dataNode.getJdbcEventLogger().logQuery(compiled.getSql(), compiled.getBindings()); } execute(connection, callback, compiled, counts); } }
protected void validateDefaultSQL( SQLTemplate query, ProjectPath path, Validator validator) { if (Util.isEmptyString(query.getDefaultTemplate())) { // see if there is at least one adapter-specific template... Iterator it = query.getTemplateKeys().iterator(); while (it.hasNext()) { String key = (String) it.next(); if (!Util.isEmptyString(query.getCustomTemplate(key))) { return; } } validator.registerWarning("Query has no default SQL template", path); } }
public void encodeAsXML(XMLEncoder encoder) { encoder.print("<query name=\""); encoder.print(getName()); encoder.print("\" factory=\""); encoder.print("org.apache.cayenne.map.SQLTemplateBuilder"); if (getColumnNamesCapitalization() != CapsStrategy.DEFAULT) { encoder.printProperty(COLUMN_NAME_CAPITALIZATION_PROPERTY, getColumnNamesCapitalization().name());
/** * Extracts a template string from a SQLTemplate query. Exists mainly for * the benefit of subclasses that can customize returned template. * * @since 1.2 */ protected String extractTemplateString() { String sql = query.getTemplate(dbAdapter.getClass().getName()); // note that we MUST convert line breaks to spaces. On some databases (DB2) // queries with breaks simply won't run; the rest are affected by CAY-726. return Util.stripLineBreaks(sql, ' '); }
/** * @since 1.2 */ public QueryMetadata getMetaData(EntityResolver resolver) { selectInfo.resolve(root, resolver, getName()); return selectInfo; }
resultSet, descriptor, query.getFetchLimit());
SQLTemplate template = new SQLTemplate(); Object root = getRoot(); template.setRoot(root); template.setName(name); template.initWithProperties(properties); template.setDefaultTemplate(sql); if (adapterSql != null) { Iterator it = adapterSql.entrySet().iterator(); Object value = entry.getValue(); if (key != null && value != null) { template.setTemplate(key.toString(), value.toString());
SQLTemplate query = new SQLTemplate(joinEntity.getDataMap(), sql.toString(), true); query.setParams(snapshot);
/** * @since 1.2 */ public SQLTemplate(Class<?> rootClass, String defaultTemplate) { setDefaultTemplate(defaultTemplate); setRoot(rootClass); }