/** * Create a SELECT statement in the proper join syntax for the given * instance. */ public SQLBuffer toSelect(Select sel, boolean forUpdate, JDBCFetchConfiguration fetch) { sel.addJoinClassConditions(); boolean update = forUpdate && sel.getFromSelect() == null; SQLBuffer select = getSelects(sel, false, update); SQLBuffer ordering = null; if (!sel.isAggregate() || sel.getGrouping() != null) ordering = sel.getOrdering(); SQLBuffer from; if (sel.getFromSelect() != null) from = getFromSelect(sel, forUpdate); else from = getFrom(sel, update); SQLBuffer where = getWhere(sel, update); return toSelect(select, fetch, from, where, sel.getGrouping(), sel.getHaving(), ordering, sel.isDistinct(), forUpdate, sel.getStartIndex(), sel.getEndIndex(), sel); }
public ExpState initialize(Select sel, ExpContext ctx, int flags) { ExpState s1 = _val1.initialize(sel, ctx, 0); ExpState s2 = _val2.initialize(sel, ctx, 0); return new BinaryOpExpState(sel.and(s1.joins, s2.joins), s1, s2); }
public void appendTo(Select sel, ExpContext ctx, ExpState state, SQLBuffer sql, int index) { _listener.appendTo(sql, getArgs(sel, ctx, state), _candidate, ctx.store); sel.append(sql, state.joins); }
public Result[] getResults(OpenJPAStateManager sm, JDBCStore store, JDBCFetchConfiguration fetch, int eagerMode, Joins[] joins, boolean lrs) throws SQLException { Select sel = store.getSQLFactory().newSelect(); sel.setLRS(lrs); sel.select(_kcols); sel.select(_vcols); sel.whereForeignKey(field.getJoinForeignKey(), sm.getObjectId(), field.getDefiningMapping(), store); Result res = sel.execute(store, fetch); return new Result[]{ res, res }; }
/** * Select the data for the given instance and return the result. Return * null if there is no data in the current fetch groups to select. */ private Result getInitializeStateResult(OpenJPAStateManager sm, ClassMapping mapping, JDBCFetchConfiguration fetch, int subs) throws SQLException { Select sel = _sql.newSelect(); if (!select(sel, mapping, subs, sm, null, fetch, JDBCFetchConfiguration.EAGER_JOIN, true, false)) return null; sel.wherePrimaryKey(sm.getObjectId(), mapping, this); sel.setExpectedResultCount(1, false); return sel.execute(this, fetch); }
sel.addJoinClassConditions(); if (sel.getTableAliases().size() == 1 && supportsSubselect && allowsAliasInBulkClause) { SQLBuffer from; if (sel.getFromSelect() != null) from = getFromSelect(sel, false); else SQLBuffer where = sel.getWhere(); if (where != null && !where.isEmpty()) { sql.append(" WHERE "); if (sel.getWhere() == null || sel.getWhere().isEmpty()) { sql.append(tableName); appendUpdates(sel, store, sql, params, updateParams, false); sel.clearSelects(); sel.setDistinct(true); sel.select(pks[0]); sql.append(tableName); appendUpdates(sel, store, sql, params, updateParams, false); sql.append(" WHERE "). append(pks[0]).append(" IN ("). append(sel.toSelect(false, null)).append(")"); } else { sel.clearSelects(); sel.setDistinct(false);
SQLBuffer selectSQL = new SQLBuffer(this); SQLBuffer from; sel.addJoinClassConditions(); if (sel.getFromSelect() != null) from = getFromSelect(sel, false); else if (sel.getGrouping() == null && sel.getStartIndex() == 0 && sel.getEndIndex() == Long.MAX_VALUE) { List aliases = (!sel.isDistinct()) ? Collections.EMPTY_LIST : sel.getIdentifierAliases(); if (useWildCardForCount || aliases.isEmpty()) { selectSQL.append("COUNT(*)"); from.append("("); from.append(toSelect(subSelect, null, subFrom, where, sel.getGrouping(), sel.getHaving(), null, sel.isDistinct(), false, sel.getStartIndex(), sel.getEndIndex(), true, sel)); from.append(")"); if (requiresAliasForSubselect)
boolean inEagerJoin = sel.hasEagerJoin(false); int sels; int jtype; if (mode != EagerFetchModes.EAGER_PARALLEL && !fms[i].isEagerSelectToMany() && fms[i].supportsSelect(sel, jtype, sm, this, fetch) > 0 && sel.eagerClone(fms[i], jtype, false, 1) != null) continue; && fms[i].isEagerSelectToMany() && !inEagerJoin && !sel.hasEagerJoin(true) && (!sel.getAutoDistinct() || (!sel.isLRS() && sel.getStartIndex() == 0 && sel.getEndIndex() == Long.MAX_VALUE)) && fms[i].supportsSelect(sel, jtype, sm, this, fetch) > 0) { if (sel.eagerClone(fms[i], jtype, true, 1) != null) eagerToMany = fms[i]; else && (sels = fms[i].supportsSelect(sel, Select.EAGER_PARALLEL, sm, this, fetch)) != 0) sel.eagerClone(fms[i], Select.EAGER_PARALLEL, fms[i].isEagerSelectToMany(), sels);
Select sel = parent != null ? subselect : ctx.store.getSQLFactory().newSelect(); sel.setAutoDistinct((exps.distinct & exps.DISTINCT_AUTO) != 0); sel.setJoinSyntax(ctx.fetch.getJoinSyntax()); sel.setParent(parent, alias); if (sel.ctx() == null) sel.setContext(lctx); Select subsel = (Select) subselCtx.getSelect(); Subquery subquery = subselCtx.getSubquery(); subsel.setParent(sel, subquery.getCandidateAlias()); sel.setHasSubselect(true); if (!sel.getAutoDistinct()) { if ((exps.distinct & exps.DISTINCT_TRUE) != 0) sel.setDistinct(true); else if ((exps.distinct & exps.DISTINCT_FALSE) != 0) sel.setDistinct(false); } else if (exps.projections.length > 0) { if (!sel.isDistinct() && (exps.distinct & exps.DISTINCT_TRUE) != 0){ sel.setDistinct(true); } else if (sel.isDistinct()) { sel.setParent(parent, alias); sel.setDistinct(agg && (exps.distinct & exps.DISTINCT_TRUE) != 0);
String alias, QueryExpressions exps, QueryExpressionsState state) { Select sel = ctx.store.getSQLFactory().newSelect(); sel.setAutoDistinct((exps.distinct & exps.DISTINCT_AUTO) != 0); sel.setJoinSyntax(ctx.fetch.getJoinSyntax()); sel.setParent(parent, alias); initialize(sel, ctx, exps, state); if (!sel.getAutoDistinct()) { if ((exps.distinct & exps.DISTINCT_TRUE) != 0) sel.setDistinct(true); else if ((exps.distinct & exps.DISTINCT_FALSE) != 0) sel.setDistinct(false); } else if (exps.projections.length > 0) { if (!sel.isDistinct() && (exps.distinct & exps.DISTINCT_TRUE) != 0){ sel.setDistinct(true); } else if (sel.isDistinct()) { sel.setParent(parent, alias); sel.setDistinct(agg && (exps.distinct & exps.DISTINCT_TRUE) != 0); sel.setFromSelect(inner); sel.setDistinct(false);
evaluate(ctx, null, null, exps[i], states[i]); if (optHint != null) sel.setExpectedResultCount(optHint.intValue(), true); else if (this.ctx.isUnique()) sel.setExpectedResultCount(1, false); if (j == size - 1) { nextBits.set(sels.size()); sel.select(vert.getPrimaryKeyColumns(), null); sels.add(sel); } else { SelectImpl selClone = (SelectImpl)sel.fullClone(1); selClone.select(vert.getPrimaryKeyColumns(), null); sels.add(selClone); sels.add(sel); } else sels.add(sel.fullClone(1)); if (verts.length > 1 || size > 1 || sel.getFromSelect() != null) unionable = false;
public SQLBuffer getClassConditions(Select sel, Joins joins, ClassMapping base, boolean subclasses) { // add conditions making sure no subclass tables have records for // this instance ClassMapping[] subs = base.getJoinablePCSubclassMappings(); SQLBuffer buf = null; Column[] pks; for (int i = 0; i < subs.length; i++) { pks = subs[i].getPrimaryKeyColumns(); if (pks.length == 0) continue; if (buf == null) { // make sure the base class is aliased first so that we don't // end up with our outer joins before the inner ones buf = new SQLBuffer(sel.getConfiguration(). getDBDictionaryInstance()); sel.getColumnAlias(base.getPrimaryKeyColumns()[0], joins); } else buf.append(" AND "); buf.append(sel.getColumnAlias(pks[0], joins)).append(" IS NULL"); } return buf; } }
public void load(OpenJPAStateManager sm, JDBCStore store, JDBCFetchConfiguration fetch) throws SQLException { Column col = field.getColumns()[0]; Select sel = store.getSQLFactory().newSelect(); sel.select(col); field.wherePrimaryKey(sel, sm, store); Result res = sel.execute(store, fetch); Object val = null; try { if (res.next()) val = load(col, res, null); } finally { res.close(); } sm.store(field.getIndex(), val); }
if (size == Long.MAX_VALUE || !sel.getAutoDistinct()) { if (!sel.isLRS()) return null;
evaluate(ctx, null, null, exps[i], states[i]); if (optHint != null) sel.setExpectedResultCount(optHint.intValue(), true); else if (this.ctx.isUnique()) sel.setExpectedResultCount(1, false); for (int j = 0; j < verts.length; j++) { selMappings.add(verts[j]); sels.add(sel); } else sels.add(sel.fullClone(1)); if (verts.length > 1 || sel.getFromSelect() != null) unionable = false;
public boolean checkVersion(OpenJPAStateManager sm, JDBCStore store, boolean updateVersion) throws SQLException { Column[] cols = vers.getColumns(); Select sel = store.getSQLFactory().newSelect(); sel.select(cols); sel.wherePrimaryKey(sm.getObjectId(), vers.getClassMapping(), store); // No need to lock version field (i.e. optimistic), except when version update is required (e.g. refresh) JDBCFetchConfiguration fetch = store.getFetchConfiguration(); if (!updateVersion && fetch.getReadLockLevel() >= MixedLockLevels.LOCK_PESSIMISTIC_READ) { fetch = (JDBCFetchConfiguration) fetch.clone(); fetch.setReadLockLevel(MixedLockLevels.LOCK_NONE); } Result res = sel.execute(store, fetch); try { if (!res.next()) return false; Object memVersion = sm.getVersion(); Object dbVersion = populateFromResult(res, null); boolean refresh = compare(memVersion, dbVersion) < 0; if (updateVersion) sm.setVersion(dbVersion); return !refresh; } finally { res.close(); } }
public void appendIndex(SQLBuffer sql, Select sel, Joins joins) { sql.append(sel.getColumnAlias(field.getOrderColumn(), field.getName())); }
public void appendIsNull(SQLBuffer sql, Select sel, Joins joins) { joins = join(joins, false); for (int i = 0; i < _cols.length; i++) { if (i > 0) { sql.append(" AND "); } // Some databases do not allow IS NULL for every column type - let the DBDictionary decide. DBDictionary dict = sel.getDictionary(); sql.append(dict.getIsNullSQL(sel.getColumnAlias(_cols[i], joins), _cols[i].getType())); } }
public void appendTo(Select sel, ExpState state, SQLBuffer sql, Column col) { if (sel != null) sel.setSchemaAlias(_schemaAlias); // if select is null, it means we are not aliasing columns // (e.g., during a bulk update) if (sel == null) sql.append(col.getIdentifier()); else if (_type == XPATH) // if this is an xpath, append xpath string sql.append(getXPath()); else sql.append(sel.getColumnAlias(col, state.joins)); }
sel.addJoinClassConditions(); && allowsAliasInBulkClause) { SQLBuffer from; if (sel.getFromSelect() != null) from = getFromSelect(sel, false); else SQLBuffer where = sel.getWhere(); if (where != null && !where.isEmpty()) { sql.append(" WHERE "); if (sel.getWhere() == null || sel.getWhere().isEmpty()) { sql.append(tableName); appendUpdates(sel, store, sql, params, updateParams, false); sel.clearSelects(); sel.setDistinct(true); sel.select(pks[0]); sql.append(tableName); appendUpdates(sel, store, sql, params, updateParams, false); sql.append(" WHERE "). append(pks[0]).append(" IN ("). append(sel.toSelect(false, null)).append(")"); } else { sel.clearSelects(); sel.setDistinct(false);