AbstractSQLQueryBuilder (Oracle Fusion Middleware Java API Reference for Oracle Extension SDK)

java.lang.Object
- oracle.javatools.db.AbstractDBObjectBuilder<T>
- - oracle.javatools.db.property.DerivedPropertyBuilder<SQLQuery>
  - - oracle.javatools.db.sql.AbstractSQLQueryBuilder

All Implemented Interfaces:

DBObjectBuilder<SQLQuery>, SQLQueryBuilder
```
public abstract class AbstractSQLQueryBuilder
extends DerivedPropertyBuilder<SQLQuery>
implements SQLQueryBuilder
```
Abstract implementation of SQLQuery that performs functions generic to any builder.

Since:

10.1.3

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class AbstractSQLQueryBuilder.QueryColumnInfo
- Nested classes/interfaces inherited from class oracle.javatools.db.AbstractDBObjectBuilder
  AbstractDBObjectBuilder.PropertyBuilder
- Nested classes/interfaces inherited from interface oracle.javatools.db.sql.SQLQueryBuilder
  SQLQueryBuilder.SQLQueryObjectSet

Nested Classes
Modifier and Type	Class and Description
`static class`	`AbstractSQLQueryBuilder.QueryColumnInfo`

Field Summary

Fields
Modifier and Type Field and Description

protected static SQLFragment[] EMPTY_ARRAY
- Fields inherited from interface oracle.javatools.db.DBObjectBuilder
  BASE_COMPONENT_KEY

Fields
Modifier and Type	Field and Description
`protected static SQLFragment[]`	`EMPTY_ARRAY`

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractSQLQueryBuilder(DBObjectProvider pro, Schema defaultSchema)
Constructor

Constructors
Modifier	Constructor and Description
`protected`	`AbstractSQLQueryBuilder(DBObjectProvider pro, Schema defaultSchema)` Constructor

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addClauseException(SQLQueryClauseException sce)` Caches a clause exception so that it can be re-thrown after the build has finished.
`protected void`	`addExtraObject(SystemObject obj)`
`void`	`addFromObject(FromObject from)` Adds the given FromObject to the query.
`protected void`	`addFromObjects(FromObject[] froms)`
`void`	`addGroupByColumn(int index, SQLFragment colu)` Adds the given FromObjectUsage to the specified index of the GROUP BY clause.
`void`	`addGroupByColumn(SQLFragment colu)` Adds the given FromObjectUsage to the end of the GROUP BY clause.
`protected void`	`addJoinObject(FromObject from)`
`void`	`addOrderByObject(int index, OrderByObject ob)` Adds the given order by object to the given index in the clause.
`void`	`addOrderByObject(OrderByObject ob)` Adds the given order by object to the end of the order by clause.
`void`	`addSelectObject(int index, SelectObject select)` Inserts the given SelectObject to the query at the given index.
`void`	`addSelectObject(SelectObject select)` Adds the given SelectObject to the query.
`protected void`	`addSelectObjects(SelectObject[] selects)`
`void`	`buildDeclarativeProperties(SQLQuery query)` DerivedPropertyBuilder mechanism that directly builds the derived properties on the given SQLQuery.
`void`	`buildQuery(SQLQuery query)` Builds the query based on the given SQLQuery.
`void`	`buildQuery(java.lang.String sql)` Builds a query object from the given sql expression.
`void`	`buildQuery(java.lang.String sql, SQLQueryOwner parent)` Builds a query from the given sql expression.
`protected abstract void`	`buildQueryImpl(java.lang.String sql, SQLQuery query, SQLQueryOwner parent)` Builds the declarative components of the given SQLQuery based on the given select statement.
`boolean`	`canMergeRelationUsages(RelationUsage baseUsage, RelationUsage mergingUsage)` Determines whether the two RelationUsages are based on the same table.
`boolean`	`canSetGroupBy()` Returns true if this query can accept a group by clause.
`void`	`checkUsageQualifications()` Checks that every FromObjectUsage which isn't qualified is a unique name within the query.
`java.util.Collection<java.lang.String>`	`clearDerivedProperties(SQLQuery obj, java.lang.String property, DBObjectChange change)` Clears the properties that are derived from the given property and that need resetting given the new value for the source property.
`SQLQueryBuilder.SQLQueryObjectSet`	`constructFKJoin(FKConstraint fk, FromObject left, FromObject right)` Creates a JOIN in the query's FROM clause to represent the given FKConstraint.
`SQLQueryBuilder.SQLQueryObjectSet`	`constructFKJoins(FKConstraint[] fks, FromObject[] usagesToUse)` Creates a set of nested JOINs in the query's FROM clause to represent each given FKConstraint.
`SQLQueryBuilder.SQLQueryObjectSet`	`constructFromObject(SchemaObject relation, boolean createSelectObjects, boolean createJoins, FromObject[] includeInJoins)` Creates a FromObject for the query.
`FromObject`	`constructFromObject(java.lang.String expression, java.lang.String alias)` Creates a FromObject using the given alias and expression, parsing the expression into an appropriate set of SQLFragments.
`SQLQueryBuilder.SQLQueryObjectSet`	`constructFromObjects(Relation[] baseRelations, boolean createSelectObjects, boolean createJoins, FromObject[] includeInJoins)` Creates one or more FromObjects for the query.
`SQLQueryBuilder.SQLQueryObjectSet`	`constructSelectObject(Column col, FromObject usageToUse)` Creates a SelectObject for the query based on the column passed in.
`SelectObject`	`constructSelectObject(java.lang.String expression, java.lang.String alias)` Creates a SelectObject using the given alias and expression, parsing the expression into an appropriate set of SQLFragments.
`SQLQueryBuilder.SQLQueryObjectSet`	`constructSelectObjects(Column[] baseCols, FromObject[] usagesToUse)` Creates a set of SelectObjects for the query based on the columns passed in.
`protected abstract boolean`	`containsAsterisk()`
`protected FKUsage`	`createFKUsage(DBObjectID fkID, FromObject left, FromObject right)`
`SQLFragment`	`createFromFactory(SQLFragment parent, java.lang.String clause, java.lang.Integer offset)`
`protected FromObject`	`createFromObject(SchemaObject rel, java.util.List<java.lang.String> extraNames)`
`protected JoinCondition`	`createJoinCondition(FKConstraint fk, JoinObject join)` Constructs a condition to represent the given FK for the given join.
`FromObject`	`createJoinObject(FKConstraint fk, FromObject left, FromObject right)` Creates a FromObject that joins using a JoinCondition matching the given FK and joins the two from objects.
`protected SelectObject`	`createSelectObject(DBObjectID colId, FromObject from, java.lang.String alias)`
`java.lang.String`	`createUniqueFromAlias(java.lang.String base)` Takes the given base for an alias and returns an alias that will be unique within this builder's query.
`protected java.lang.String`	`createUniqueFromAlias(java.lang.String base, java.util.List<java.lang.String> extraNames)`
`java.lang.String`	`createUniqueSelectAlias(java.lang.String base)` Takes the given base for an alias and returns an alias that will be unique within this builder's query.
`protected java.lang.String`	`createUniqueSelectAlias(java.lang.String base, java.util.List<java.lang.String> extraNames)`
`protected FKUsage`	`doConstructFKUsage(FKConstraint fk, java.util.Map relsIDsToUse, java.util.List<FromObject> newFroms)`
`protected FromObject`	`doConstructFromObject(SchemaObject relation, java.util.List<DBObjectID> baseRelIDs, java.util.List<java.lang.String> relNames, java.util.Map<DBObjectID,FromObject> newRels, java.util.List<Column> cols, java.util.List<FKConstraint> fks)`
`protected FromObject`	`doConstructJoin(FKConstraint fk, java.util.Map<DBObjectID,FromObject> relsIDsToUse, java.util.List<FromObject> newFroms, FromObject left, FromObject right)`
`protected SelectObject`	`doConstructSelectObject(Column col, java.util.Map<DBObjectID,FromObject> relsToUse, java.util.Map<DBObjectID,FromObject> newRels, java.util.List<java.lang.String> relNames, java.util.List<java.lang.String> colNames)`
`DBObjectID`	`ensureID(DBObject frag)` Only call on an object that has been added to the hierarchy - e.g.
`protected void`	`ensureIDs(SQLFragment... frags)`
`protected FromObjectUsage`	`findColumnInColumnUsage(java.lang.String colName, boolean external, ColumnUsage colu, FromObject from)` Finds a column in the given ColumnUsage.
`FromObjectUsage`	`findColumnInFromExpression(java.lang.String colName, boolean external, SQLFragment exp, boolean allowDuplicates, FromObject from, SQLFragment creating)` Finds a Column of given name in the given FromObject's expression.
`protected FromObjectUsage`	`findColumnInFromObjects(java.lang.String colName, boolean external, FromObject[] froms, boolean allowDuplicates, boolean enforceInAll, SQLFragment creating)` Finds a Column of given name amongst the given FromObjects.
`FromObjectUsage`	`findColumnInFromObjects(java.lang.String colName, boolean external, SQLFragment creating, FromObject... extraFroms)` Finds a Column of given name amongst the RelationUsages in the query.
`protected FromObjectUsage`	`findColumnInJoin(java.lang.String colName, boolean external, JoinObject join, boolean allowDuplicates, SQLFragment creating)` Finds a column in the child FromObjects of a given JoinObject.
`FromObjectUsage`	`findColumnInRelation(java.lang.String colName, boolean external, Relation rel)` Finds a Column with the given name in a Relation and returns a FromObjectUsage that references that column.
`FromObjectUsage`	`findColumnInRelation(java.lang.String colName, boolean external, RelationUsage relU)` Finds a Column with the given name in the Relation referred to by the given RelationUsage, and returns a FromObjectUsage that references that column.
`ColumnUsage`	`findColumnInStarSubQuery(java.lang.String colName, boolean external, FromObject from)` The from object is of the form (SELECT * FROM <rel>) <alias>
`SelectObjectUsage`	`findColumnInSubQuery(java.lang.String colName, boolean external, SQLQuery query)`
`java.lang.String`	`getColumnName(SelectObject sel)`
`Column[]`	`getColumns()` Retrieves Column objects mapped to the columns in the SQL query that has been built, thereby giving the name and type of each column the query has.
`ColumnUsage[]`	`getColumnUsages()` Deprecated.
`protected Schema`	`getDefaultSchema()`
`SQLFragment[]`	`getDependentObjects(FromObject from)` Gets the objects in the query that are dependent on the given from object.
`SQLFragment[]`	`getDependentObjects(SelectObject select)` Gets the objects in the query that are dependent on the given select object.
`protected abstract DerivedPropertyBuilder`	`getDTUBuilder(int columnIndex)` Sublass implementations to provide a DerivedPropertyBuilder capable of building the DataTypeUsage property for Views/MatViews.
`protected java.lang.String`	`getExternalName(java.lang.String name)`
`FromObject`	`getFromObject(java.lang.String usableAlias)` Returns the from object that can be referenced by this alias.
`FromObject`	`getFromObject(java.lang.String usableAlias, FromObject extrafrom)` Gets a FromObject with the given alias.
`protected java.util.List<DBObjectID>`	`getIDs(DBObject[] objs)`
`protected java.lang.String`	`getInternalName(java.lang.String name)`
`protected java.util.logging.Logger`	`getLogger()`
`protected SchemaObject`	`getObject(DBObjectCriteria crit)`
`protected SchemaObject`	`getObject(java.lang.String type, Schema sch, java.lang.String relation)`
`protected SQLQuery`	`getQuery()`
`abstract java.util.List<AbstractSQLQueryBuilder.QueryColumnInfo>`	`getQueryColumnInfos()` Obtains information about the select list items for use in building view and materialized view columns without building the query unless absolutely necessary.
`RelationUsage[]`	`getRelationUsages()` Returns the RelationUsages found in the FROM clause of the SQLQuery.
`protected java.util.Map<DBObjectID,FromObject>`	`getRelIDs(FromObject[] usagesToUse)`
`SelectObject`	`getSelectObject(java.lang.String usableAlias)` Returns the select object that can be referenced by this alias.
`SQLQuery`	`getSQLQuery()` Returns the query that this builder is working on.
`boolean`	`isUniqueFromAlias(java.lang.String alias)` Returns true if this alias is unique within the builder's query.
`protected boolean`	`isUniqueFromAlias(java.lang.String alias, java.util.List<java.lang.String> extraNames)`
`boolean`	`isUniqueSelectAlias(java.lang.String alias)` Returns true if this alias is unique within the builder's query.
`protected boolean`	`isUniqueSelectAlias(java.lang.String alias, java.util.List<java.lang.String> extraNames)`
`protected boolean`	`isValidName(java.lang.String type, java.lang.String name)`
`FromObject[]`	`listAllFromObjects()` Returns all FromObjects in the FROM clause including those nested in JOIN conditions.
`FromObject[]`	`listAllFromObjects(boolean includeJoins)` Returns all FromObjects in the FROM clause including those nested in JOIN conditions.
`FKUsage[]`	`listAvailableFKs()` Returns all the FKs that could join the relations used in the view wrapped up in an FKUsage so as to include the appropriate FromObjects.
`protected void`	`loadObject(DBObject frag)` Load the given object (i.e.
`protected void`	`loadObjects(DBObject[] frags)`
`void`	`mergeRelationUsages(RelationUsage baseUsage, RelationUsage mergingUsage)` Merges two RelationUsages into one.
`SQLFragment`	`parseFromExpression(java.lang.String expression)` Parses an expression to see if it is a valid expression for a From object.
`protected SQLFragment`	`parseFromExpression(java.lang.String expression, FromObject creating)`
`SQLFragment`	`parseHavingExpression(java.lang.String expression)` By default this calls parseWhereExpression().
`SQLFragment`	`parseOrderByExpression(java.lang.String expression)` Parses an expression to see if it is a valid expression for a Order By object.
`protected SQLFragment`	`parseOrderByExpression(java.lang.String expression, OrderByObject obo)`
`SQLFragment`	`parseSelectExpression(java.lang.String expression)` Parses an expression to see if it is a valid expression for a Select object.
`protected SQLFragment`	`parseSelectExpression(java.lang.String expression, SelectObject creating)`
`SQLFragment`	`parseWhereExpression(java.lang.String expression)` Parses an expression to see if it is a valid expression for a Where object.
`SQLFragment`	`parseWhereExpression(java.lang.String expression, WhereObject creating)`
`protected void`	`registerAllSQLFragmentFactories(AbstractSQLQueryBuilder builder)`
`void`	`registerSQLFragmentFactory(SQLFragmentFactory fac)` Register plugin SQLFragmentFactory to create SQLFragments from the given String if not recognized by the base implementation.
`boolean`	`removeFromObject(FromObject obj)` Removes the given FromObject from the SQLQuery.
`boolean`	`removeGroupByColumn(SQLFragment colu)` Removes the given FromObjectUsage from the GROUP BY clause.
`boolean`	`removeJoinObject(FromObject obj)` If the expression for the given obj is a JoinObject the join is removed and the two FromObjects that were joined are added to the top level of the query.
`boolean`	`removeOrderByObject(OrderByObject ob)` Removes the given order by object from the orderby clause.
`boolean`	`removeSelectObject(SelectObject obj)` Removes the given SelectObject from the SQLQuery.
`protected boolean`	`removeWhereObject(SQLFragment obj)` Removes a top level WhereObject from the WHERE clause.
`void`	`replaceFromObject(FromObject oldFrom, FromObject newFrom)` Replaces the existing from object with a new one.
`void`	`replaceOrderByObject(OrderByObject oldOb, OrderByObject newOb)` Replaces the existing from object with a new one.
`void`	`replaceSelectObject(SelectObject oldSelect, SelectObject newSelect)` Replaces the existing select object with a new one.
`protected void`	`replaceWithAliases(FromObject[] froms)` replace any From Objects in the list that are aliases for a subquery_factoring_clause
`void`	`setExtraObjects(java.util.Collection<? extends SystemObject> objs)`
`void`	`setGroupByObject(GroupByObject obj)` Sets the group by object.
`void`	`setHavingObject(WhereObject having)` Sets the HAVING clause of the query.
`void`	`setHierarchicalQueryObject(HierarchicalQueryObject obj)` Sets the CONNECT BY clause of the query.
`protected void`	`setNewFromObject(DBObject frag, FromObject oldFrom, FromObject newFrom)`
`void`	`setOrderByObjects(OrderByObject[] orderbys)` Sets the order by objects for the query.
`void`	`setSingleRelation(Relation singleRelation)`
`protected void`	`setSQLQuery(SQLQuery query)` Sets the query we are building.
`protected void`	`setViewColDataType(Column col, SelectObject so)`
`void`	`setWhereObject(WhereObject obj)` Sets the WhereObject on the query (whilst caching any appropriate dependencies).
`void`	`syncViewColumns()` Deprecated. - no longer required
`<T extends SQLQueryException> void`	`throwException(T sqe)` Method that takes a SQLQueryException and rethrows it unless it is a SQLQueryClauseException and we are in the middle of a build.
`protected void`	`unloadObject(DBObject frag)`
`protected void`	`validateAlias(AliasFragment frag, java.lang.String type, java.lang.String alias)`
`void`	`validateQuery()` Validates a query object to check that its internal structure is correct.

Methods inherited from class oracle.javatools.db.property.DerivedPropertyBuilder
canBuildComponents, createObject, registerObject

Methods inherited from class oracle.javatools.db.AbstractDBObjectBuilder
buildObject, buildObjectComponent, canBuildEditableObject, ensureComponent, fillInObject, fillInObjectComponent, findObjectInProviderCache, findObjectInProviderCache, getBuiltProperties, getDerivedProperties, getObjectType, getProvider, getSchema, isBuildableProperty, markAsBuilt, markAsBuilt, needsBuilding, needsBuilding, newObject, newObject, updateTimestamp, updateTimestamp

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface oracle.javatools.db.sql.SQLQueryBuilder
addSetOperatorObject, ensureQueryNonDeclarative, getBuiltInFunctions, matchesProvider, parseOnExpression, supportsConnectBy, supportsGroupBy, supportsOrderBy

- Field Detail
  - EMPTY_ARRAY
```
protected static final SQLFragment[] EMPTY_ARRAY
```
- Constructor Detail
  - AbstractSQLQueryBuilder
```
protected AbstractSQLQueryBuilder(DBObjectProvider pro,
                       Schema defaultSchema)
```
    Constructor
- Method Detail
  - getLogger
```
protected final java.util.logging.Logger getLogger()
```
    Overrides:
    
    getLogger in class AbstractDBObjectBuilder<SQLQuery>
  - getDefaultSchema
```
protected final Schema getDefaultSchema()
```
  - getQuery
```
protected final SQLQuery getQuery()
```
  - buildQuery
```
public final void buildQuery(java.lang.String sql)
                      throws SQLQueryException
```
    Builds a query object from the given sql expression.
    
    Specified by:
    
    buildQuery in interface SQLQueryBuilder
    
    Throws:
    
    SQLQueryException - if the query cannot be built.
  - buildQuery
```
public final void buildQuery(java.lang.String sql,
              SQLQueryOwner parent)
                      throws SQLQueryException
```
    Builds a query from the given sql expression. The parent is the parent of the query.
    
    Specified by:
    
    buildQuery in interface SQLQueryBuilder
    
    Throws:
    
    SQLQueryException - if the query cannot be built.
  - setSQLQuery
```
protected final void setSQLQuery(SQLQuery query)
```
    Sets the query we are building. This cannot be used to change the current query.
  - buildQueryImpl
```
protected abstract void buildQueryImpl(java.lang.String sql,
                  SQLQuery query,
                  SQLQueryOwner parent)
                                throws SQLQueryException
```
    Builds the declarative components of the given SQLQuery based on the given select statement.
    
    Parameters:
    
    sql - the query string to build
    
    query - the SQLQuery object to build the declarative representation in to
    
    parent - the query's owner (if one exists)
    
    Throws:
    
    SQLQueryException - if the query cannot be built.
  - clearDerivedProperties
```
public java.util.Collection<java.lang.String> clearDerivedProperties(SQLQuery obj,
                                                            java.lang.String property,
                                                            DBObjectChange change)
```
    Description copied from class: DerivedPropertyBuilder
    
    Clears the properties that are derived from the given property and that need resetting given the new value for the source property.
    
    Overrides:
    
    clearDerivedProperties in class DerivedPropertyBuilder<SQLQuery>
    
    Parameters:
    
    obj - the object the property is being changed on
    
    property - the property being changed
    
    change - the overall change that is occuring
    
    Returns:
    
    the properties that are derived from the given property, and were cleared.
  - buildQuery
```
public final void buildQuery(SQLQuery query)
                      throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Builds the query based on the given SQLQuery. If the query is non declarative an attempt will be made to make it declarative.
    
    Specified by:
    
    buildQuery in interface SQLQueryBuilder
    
    Throws:
    
    SQLQueryException - if the query cannot be built.
  - buildDeclarativeProperties
```
public final void buildDeclarativeProperties(SQLQuery query)
                                      throws SQLQueryException
```
    DerivedPropertyBuilder mechanism that directly builds the derived properties on the given SQLQuery.
    
    Parameters:
    
    query - the query to build (cannot be null)
    
    Throws:
    
    SQLQueryException
  - throwException
```
public <T extends SQLQueryException> void throwException(T sqe)
                    throws T extends SQLQueryException
```
    Method that takes a SQLQueryException and rethrows it unless it is a SQLQueryClauseException and we are in the middle of a build. SQLQueryClauseExceptions do not prevent a build from continuing so they are cached to allow the build to finish and then re-thrown at the end.
    
    Type Parameters:
    
    T - SQLQueryException implementation
    
    Parameters:
    
    sqe - exception to cache or rethrow
    
    Throws:
    
    T - if sqe is not a clause exception (or we're not building)
    
    T extends SQLQueryException
  - addClauseException
```
public void addClauseException(SQLQueryClauseException sce)
```
    Caches a clause exception so that it can be re-thrown after the build has finished.
    
    Parameters:
    
    sce - the problem with a clause in the query we're building.
    
    Throws:
    
    java.lang.IllegalStateException - if this method is called and we're not building a query.
  - validateQuery
```
public void validateQuery()
                   throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Validates a query object to check that its internal structure is correct. This is only structural (first level) validation.
    
    Specified by:
    
    validateQuery in interface SQLQueryBuilder
    
    Throws:
    
    SQLQueryException - if the query fails to validate.
  - ensureIDs
```
protected void ensureIDs(SQLFragment... frags)
```
    See Also:
    
    ensureID(DBObject)
  - ensureID
```
public DBObjectID ensureID(DBObject frag)
```
    Only call on an object that has been added to the hierarchy - e.g. add a FROM object to the query first, then call ensureID.
  - loadObjects
```
protected void loadObjects(DBObject[] frags)
```
  - loadObject
```
protected void loadObject(DBObject frag)
```
    Load the given object (i.e. scan for dependencies).
  - unloadObject
```
protected void unloadObject(DBObject frag)
```
  - getIDs
```
protected java.util.List<DBObjectID> getIDs(DBObject[] objs)
                                     throws SQLQueryException
```
    Throws:
    
    SQLQueryException
  - getRelIDs
```
protected java.util.Map<DBObjectID,FromObject> getRelIDs(FromObject[] usagesToUse)
```
  - setNewFromObject
```
protected void setNewFromObject(DBObject frag,
                    FromObject oldFrom,
                    FromObject newFrom)
```
  - getInternalName
```
protected java.lang.String getInternalName(java.lang.String name)
```
  - getExternalName
```
protected java.lang.String getExternalName(java.lang.String name)
```
  - isValidName
```
protected boolean isValidName(java.lang.String type,
                  java.lang.String name)
```
  - validateAlias
```
protected void validateAlias(AliasFragment frag,
                 java.lang.String type,
                 java.lang.String alias)
                      throws InvalidAliasException
```
    Throws:
    
    InvalidAliasException
  - getSQLQuery
```
public SQLQuery getSQLQuery()
```
    Description copied from interface: SQLQueryBuilder
    
    Returns the query that this builder is working on.
    
    Specified by:
    
    getSQLQuery in interface SQLQueryBuilder
  - addSelectObject
```
public void addSelectObject(SelectObject select)
                     throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Adds the given SelectObject to the query.
    
    Specified by:
    
    addSelectObject in interface SQLQueryBuilder
    
    Throws:
    
    SQLQueryException
  - addSelectObject
```
public void addSelectObject(int index,
                   SelectObject select)
                     throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Inserts the given SelectObject to the query at the given index.
    
    Specified by:
    
    addSelectObject in interface SQLQueryBuilder
    
    Throws:
    
    SQLQueryException
  - isUniqueSelectAlias
```
public boolean isUniqueSelectAlias(java.lang.String alias)
```
    Description copied from interface: SQLQueryBuilder
    
    Returns true if this alias is unique within the builder's query.
    
    Specified by:
    
    isUniqueSelectAlias in interface SQLQueryBuilder
  - isUniqueSelectAlias
```
protected boolean isUniqueSelectAlias(java.lang.String alias,
                          java.util.List<java.lang.String> extraNames)
```
  - createUniqueSelectAlias
```
public java.lang.String createUniqueSelectAlias(java.lang.String base)
```
    Description copied from interface: SQLQueryBuilder
    
    Takes the given base for an alias and returns an alias that will be unique within this builder's query.
    
    Specified by:
    
    createUniqueSelectAlias in interface SQLQueryBuilder
  - createUniqueSelectAlias
```
protected java.lang.String createUniqueSelectAlias(java.lang.String base,
                                       java.util.List<java.lang.String> extraNames)
```
  - getSelectObject
```
public SelectObject getSelectObject(java.lang.String usableAlias)
```
    Description copied from interface: SQLQueryBuilder
    
    Returns the select object that can be referenced by this alias. It can be the alias of the object, or if the object doesn't have an alias the expression.
    
    Specified by:
    
    getSelectObject in interface SQLQueryBuilder
  - constructSelectObject
```
public SelectObject constructSelectObject(java.lang.String expression,
                                 java.lang.String alias)
                                   throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Creates a SelectObject using the given alias and expression, parsing the expression into an appropriate set of SQLFragments. The SelectObject created is added to the builder's query, and returned from the method.
    
    Specified by:
    
    constructSelectObject in interface SQLQueryBuilder
    
    Parameters:
    
    expression - the sql for the SelectObject
    
    alias - the alias for the SelectObject
    
    Returns:
    
    the SelectObject that's been added to the query as a result of the operation
    
    Throws:
    
    SQLQueryException
  - constructSelectObject
```
public SQLQueryBuilder.SQLQueryObjectSet constructSelectObject(Column col,
                                                      FromObject usageToUse)
                                                        throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Creates a SelectObject for the query based on the column passed in. A relevant RelationUsage can be provided in the FromObject passed in. If no relevant RelationUsage exists for a the column, a default RelationUsage is created. RelationUsages that already exist in the view are not reused - unless they are in the candidate array. The objects are automatically added to the query.
    
    Specified by:
    
    constructSelectObject in interface SQLQueryBuilder
    
    Parameters:
    
    col - the column to use as the base of the new SelectObject.
    
    usageToUse - A FromObjects in the query that may be used while creating the SelectObject. If null, then a relation usage will be created by default.
    
    Throws:
    
    SQLQueryException - if the select object cannot be built.
  - constructSelectObjects
```
public SQLQueryBuilder.SQLQueryObjectSet constructSelectObjects(Column[] baseCols,
                                                       FromObject[] usagesToUse)
                                                         throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Creates a set of SelectObjects for the query based on the columns passed in. Relevant RelationUsages are taken from the array of candidate usages passed into this method. If no relevant RelationUsage exists for a given column, a default RelationUsage is created. RelationUsages that already exist in the view are not reused - unless they are in the candidate array. The objects are automatically added to the query.
    
    Specified by:
    
    constructSelectObjects in interface SQLQueryBuilder
    
    Parameters:
    
    baseCols - An array of columns to be the base columns of the new SelectObjects.
    
    usagesToUse - An array of FromObjects in the query that may be used while creating the SelectObjects. If null, then relation usages will be created by default.
    
    Throws:
    
    SQLQueryException - if the select objects cannot be built.
  - doConstructSelectObject
```
protected SelectObject doConstructSelectObject(Column col,
                                   java.util.Map<DBObjectID,FromObject> relsToUse,
                                   java.util.Map<DBObjectID,FromObject> newRels,
                                   java.util.List<java.lang.String> relNames,
                                   java.util.List<java.lang.String> colNames)
                                        throws SQLQueryException
```
    Throws:
    
    SQLQueryException
  - createSelectObject
```
protected SelectObject createSelectObject(DBObjectID colId,
                              FromObject from,
                              java.lang.String alias)
```
  - addSelectObjects
```
protected void addSelectObjects(SelectObject[] selects)
```
  - removeSelectObject
```
public boolean removeSelectObject(SelectObject obj)
```
    Description copied from interface: SQLQueryBuilder
    
    Removes the given SelectObject from the SQLQuery. This will cascade to remove all dependent WhereObject fragments.
    
    Specified by:
    
    removeSelectObject in interface SQLQueryBuilder
    
    Parameters:
    
    obj - the SelectObject to remove.
    
    Returns:
    
    true if the remove operation was successful.
  - replaceSelectObject
```
public void replaceSelectObject(SelectObject oldSelect,
                       SelectObject newSelect)
                         throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Replaces the existing select object with a new one. Will remove any dependent parts of the WHERE clauses accordingly.
    
    Specified by:
    
    replaceSelectObject in interface SQLQueryBuilder
    
    Throws:
    
    SQLQueryException
  - isUniqueFromAlias
```
public boolean isUniqueFromAlias(java.lang.String alias)
```
    Description copied from interface: SQLQueryBuilder
    
    Returns true if this alias is unique within the builder's query.
    
    Specified by:
    
    isUniqueFromAlias in interface SQLQueryBuilder
  - isUniqueFromAlias
```
protected boolean isUniqueFromAlias(java.lang.String alias,
                        java.util.List<java.lang.String> extraNames)
```
  - createUniqueFromAlias
```
public java.lang.String createUniqueFromAlias(java.lang.String base)
```
    Description copied from interface: SQLQueryBuilder
    
    Takes the given base for an alias and returns an alias that will be unique within this builder's query.
    
    Specified by:
    
    createUniqueFromAlias in interface SQLQueryBuilder
  - createUniqueFromAlias
```
protected java.lang.String createUniqueFromAlias(java.lang.String base,
                                     java.util.List<java.lang.String> extraNames)
```
  - listAllFromObjects
```
public FromObject[] listAllFromObjects()
```
    Description copied from interface: SQLQueryBuilder
    
    Returns all FromObjects in the FROM clause including those nested in JOIN conditions. This will not return the FromObjects for the JOINS themselves, just those that contain RelationUsages, SQLQuery objects etc.
    
    Specified by:
    
    listAllFromObjects in interface SQLQueryBuilder
    
    Returns:
  - listAllFromObjects
```
public FromObject[] listAllFromObjects(boolean includeJoins)
```
    Description copied from interface: SQLQueryBuilder
    
    Returns all FromObjects in the FROM clause including those nested in JOIN conditions. Unless the includeJoins parameter is set to true, this will not return the FromObjects for the JOINS themselves, just those that contain RelationUsages, SQLQuery objects etc.
    
    Specified by:
    
    listAllFromObjects in interface SQLQueryBuilder
    
    Parameters:
    
    includeJoins - if set to true, FromObjects for JOINs will be included in the returned array
    
    Returns:
  - getFromObject
```
public FromObject getFromObject(java.lang.String usableAlias)
```
    Description copied from interface: SQLQueryBuilder
    
    Returns the from object that can be referenced by this alias. It can be the alias of the object, or if the object doesn't have an alias the expression.
    
    Specified by:
    
    getFromObject in interface SQLQueryBuilder
  - getFromObject
```
public FromObject getFromObject(java.lang.String usableAlias,
                       FromObject extrafrom)
```
    Gets a FromObject with the given alias. First looks in the given FromObject which can contain froms in the process of being created.
  - constructFromObject
```
public FromObject constructFromObject(java.lang.String expression,
                             java.lang.String alias)
                               throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Creates a FromObject using the given alias and expression, parsing the expression into an appropriate set of SQLFragments. The FromObject created is added to the builder's query, and returned from the method.
    
    Specified by:
    
    constructFromObject in interface SQLQueryBuilder
    
    Parameters:
    
    expression - the sql for the FromObject
    
    alias - the alias for the FromObject
    
    Returns:
    
    the FromObject that's been added to the query as a result of the operation
    
    Throws:
    
    SQLQueryException
  - createFromObject
```
protected FromObject createFromObject(SchemaObject rel,
                          java.util.List<java.lang.String> extraNames)
                               throws SQLQueryException
```
    Throws:
    
    SQLQueryException
  - constructFromObject
```
public SQLQueryBuilder.SQLQueryObjectSet constructFromObject(SchemaObject relation,
                                                    boolean createSelectObjects,
                                                    boolean createJoins,
                                                    FromObject[] includeInJoins)
                                                      throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Creates a FromObject for the query. Optionally also creates SelectObjects based on the columns of the relation passed in. Optionally creates WHERE clause joins between the new relation usage based on any foreign keys found between tables in the array. The objects are automatically added to the query.
    
    Specified by:
    
    constructFromObject in interface SQLQueryBuilder
    
    Parameters:
    
    relation - a table, view or synonym from which to create the new RelationUsage.
    
    createSelectObjects - If true, a SelectObject is created for each column in the base relation.
    
    createJoins - If true, a WhereObject is created for each foreign key between tables in the array of relations.
    
    includeInJoins - Whether or not the createJoins parameter is set to true, any foreign key between the base relation of these FromObjects and a relation in the baseRelations parameter causes the relevant WhereObject to be created. This parameter can be null.
    
    Throws:
    
    SQLQueryException - if the from objects cannot be built.
  - doConstructFromObject
```
protected FromObject doConstructFromObject(SchemaObject relation,
                               java.util.List<DBObjectID> baseRelIDs,
                               java.util.List<java.lang.String> relNames,
                               java.util.Map<DBObjectID,FromObject> newRels,
                               java.util.List<Column> cols,
                               java.util.List<FKConstraint> fks)
                                    throws SQLQueryException
```
    Throws:
    
    SQLQueryException
  - constructFromObjects
```
public SQLQueryBuilder.SQLQueryObjectSet constructFromObjects(Relation[] baseRelations,
                                                     boolean createSelectObjects,
                                                     boolean createJoins,
                                                     FromObject[] includeInJoins)
                                                       throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Creates one or more FromObjects for the query. Optionally also creates SelectObjects based on the columns of the relations passed in. Optionally creates WHERE clause joins between the new relation usages based on any foreign keys found between tables in the array. The objects are automatically added to the query.
    
    Specified by:
    
    constructFromObjects in interface SQLQueryBuilder
    
    Parameters:
    
    baseRelations - An array of tables and views from which to create the new RelationUsages.
    
    createSelectObjects - If true, a SelectObject is created for each column in the base relation.
    
    createJoins - If true, a WhereObject is created for each foreign key between tables in the array of relations.
    
    includeInJoins - Whether or not the createJoins parameter is set to true, any foreign key between the base relation of these FromObjects and a relation in the baseRelations parameter causes the relevant WhereObject to be created. This parameter can be null.
    
    Throws:
    
    SQLQueryException - if the from objects cannot be built.
  - addFromObject
```
public void addFromObject(FromObject from)
                   throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Adds the given FromObject to the query.
    
    Specified by:
    
    addFromObject in interface SQLQueryBuilder
    
    Throws:
    
    SQLQueryException
  - addFromObjects
```
protected void addFromObjects(FromObject[] froms)
```
  - addJoinObject
```
protected void addJoinObject(FromObject from)
```
  - replaceFromObject
```
public void replaceFromObject(FromObject oldFrom,
                     FromObject newFrom)
                       throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Replaces the existing from object with a new one. Will remove any dependent parts of the SELECT and WHERE clauses accordingly.
    
    Specified by:
    
    replaceFromObject in interface SQLQueryBuilder
    
    Throws:
    
    SQLQueryException
  - removeJoinObject
```
public boolean removeJoinObject(FromObject obj)
```
    Description copied from interface: SQLQueryBuilder
    
    If the expression for the given obj is a JoinObject the join is removed and the two FromObjects that were joined are added to the top level of the query.
    
    Specified by:
    
    removeJoinObject in interface SQLQueryBuilder
  - removeFromObject
```
public boolean removeFromObject(FromObject obj)
```
    Description copied from interface: SQLQueryBuilder
    
    Removes the given FromObject from the SQLQuery. This will cascade to remove all SelectObject and WhereObject fragments that were dependent on this FromObject.
    
    Specified by:
    
    removeFromObject in interface SQLQueryBuilder
    
    Parameters:
    
    obj - the FromObject to remove.
    
    Returns:
    
    true if the remove operation was successful.
  - constructFKJoin
```
public SQLQueryBuilder.SQLQueryObjectSet constructFKJoin(FKConstraint fk,
                                                FromObject left,
                                                FromObject right)
                                                  throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Creates a JOIN in the query's FROM clause to represent the given FKConstraint. By default this is an INNER join with an ON clause. If the left or right expressions are provided they will be used without being checked. Be sure to supply them if and only if you know they are the right expressions to be reused. They will be removed from their current parent when joined.
    
    Specified by:
    
    constructFKJoin in interface SQLQueryBuilder
    
    Parameters:
    
    fk - the foreign key constraint to creat a join for
    
    left - the left hand expression for the join to be created.
    
    right - the right hand expression for the join to be created.
    
    Throws:
    
    SQLQueryException
  - constructFKJoins
```
public SQLQueryBuilder.SQLQueryObjectSet constructFKJoins(FKConstraint[] fks,
                                                 FromObject[] usagesToUse)
                                                   throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Creates a set of nested JOINs in the query's FROM clause to represent each given FKConstraint. By default these are an INNER joins. The order of the keys in the array matters - it must reflect the required JOIN heircachy.
    
    Specified by:
    
    constructFKJoins in interface SQLQueryBuilder
    
    Parameters:
    
    fks - the foreign key constraints to creat joins for, in order.
    
    usagesToUse - an array of FromObjects to use for the JOIN. If the relations in question aren't in the array new FromObjects will be created as necessary
    
    Throws:
    
    SQLQueryException
  - doConstructJoin
```
protected FromObject doConstructJoin(FKConstraint fk,
                         java.util.Map<DBObjectID,FromObject> relsIDsToUse,
                         java.util.List<FromObject> newFroms,
                         FromObject left,
                         FromObject right)
                              throws SQLQueryException
```
    Throws:
    
    SQLQueryException
  - createJoinObject
```
public FromObject createJoinObject(FKConstraint fk,
                          FromObject left,
                          FromObject right)
                            throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Creates a FromObject that joins using a JoinCondition matching the given FK and joins the two from objects.
    
    Specified by:
    
    createJoinObject in interface SQLQueryBuilder
    
    Parameters:
    
    fk - the FKConstraint to use to create the join condition
    
    left - the from for the LHS of the join
    
    right - the from for the RHS of the join
    
    Returns:
    
    a FromObject containing the two joined FromObjects
    
    Throws:
    
    SQLQueryException
  - createJoinCondition
```
protected JoinCondition createJoinCondition(FKConstraint fk,
                                JoinObject join)
```
    Constructs a condition to represent the given FK for the given join. If possible a USING condition is created, otherwise ON is used.
  - doConstructFKUsage
```
protected FKUsage doConstructFKUsage(FKConstraint fk,
                         java.util.Map relsIDsToUse,
                         java.util.List<FromObject> newFroms)
                              throws SQLQueryException
```
    Throws:
    
    SQLQueryException
  - createFKUsage
```
protected FKUsage createFKUsage(DBObjectID fkID,
                    FromObject left,
                    FromObject right)
```
  - setWhereObject
```
public void setWhereObject(WhereObject obj)
```
    Description copied from interface: SQLQueryBuilder
    
    Sets the WhereObject on the query (whilst caching any appropriate dependencies).
    
    Specified by:
    
    setWhereObject in interface SQLQueryBuilder
    
    Parameters:
    
    obj - the query's new WhereObject
  - removeWhereObject
```
protected boolean removeWhereObject(SQLFragment obj)
```
    Removes a top level WhereObject from the WHERE clause. The obj must either be the clauses WhereObject, or a direct child of that WhereObject.
  - getRelationUsages
```
public RelationUsage[] getRelationUsages()
```
    Description copied from interface: SQLQueryBuilder
    Returns the RelationUsages found in the FROM clause of the SQLQuery. As this is restricted to the FROM clause, this doesn't return RelationUsages from within subqueries of the SELECT or WHERE clauses. For all RelationUsages use the generic DBUtil.findChildren method - i.e.
```
   DBUtil.findChildren( builder.getSQLQuery(), RelationUsage.class )
 
```
    Specified by:
    
    getRelationUsages in interface SQLQueryBuilder
    
    Returns:
    
    the RelationUsages found in the FROM clause.
    
    See Also:
    
    DBUtil.findChildren(oracle.javatools.db.DBObject, java.lang.Class<T>)
  - getDependentObjects
```
public SQLFragment[] getDependentObjects(FromObject from)
```
    Gets the objects in the query that are dependent on the given from object. Does not recurse (i.e. the list could contain more FromObject objects from inside JOINs).
    
    Specified by:
    
    getDependentObjects in interface SQLQueryBuilder
    
    Parameters:
    
    from - the FromObject to get the dependencies for
    
    Returns:
    
    an array of dependent fragments (SelectObject or WhereObject)
  - getDependentObjects
```
public SQLFragment[] getDependentObjects(SelectObject select)
```
    Gets the objects in the query that are dependent on the given select object.
    
    Specified by:
    
    getDependentObjects in interface SQLQueryBuilder
    
    Parameters:
    
    select - the object to get the dependencies for
    
    Returns:
    
    an array of dependent fragments.
  - canMergeRelationUsages
```
public boolean canMergeRelationUsages(RelationUsage baseUsage,
                             RelationUsage mergingUsage)
```
    Description copied from interface: SQLQueryBuilder
    
    Determines whether the two RelationUsages are based on the same table. A true result indcates that mergeRelationUsages will be valid.
    
    Specified by:
    
    canMergeRelationUsages in interface SQLQueryBuilder
    
    Parameters:
    
    baseUsage - The RelationUsage that will remain and form the basis of the new usage after the merge
    
    mergingUsage - The RelationUsage which will be removed as part of the merge. Any relevant WhereObjects and SelectObjects will be made to reference the new merged usage.
    
    Returns:
    
    true if the relation usages can be merged
  - mergeRelationUsages
```
public void mergeRelationUsages(RelationUsage baseUsage,
                       RelationUsage mergingUsage)
                         throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Merges two RelationUsages into one. The relevant SelectObjects and WhereObjects are updated to use the new alias of the merged RelationUsage. The two usages for the merge must reference the same base relation and be in the same view. The merged RelationUsage is returned and is also added to the query automatically.
    
    Specified by:
    
    mergeRelationUsages in interface SQLQueryBuilder
    
    Parameters:
    
    baseUsage - The RelationUsage that will remain and form the basis of the new usage after the merge
    
    mergingUsage - The RelationUsage which will be removed as part of the merge. Any relevant WhereObjects and SelectObjects will be made to reference the new merged usage.
    
    Throws:
    
    SQLQueryException - if an error occurs merging the relations.
  - listAvailableFKs
```
public FKUsage[] listAvailableFKs()
```
    Description copied from interface: SQLQueryBuilder
    
    Returns all the FKs that could join the relations used in the view wrapped up in an FKUsage so as to include the appropriate FromObjects.
    
    Specified by:
    
    listAvailableFKs in interface SQLQueryBuilder
  - getColumnUsages
```
@Deprecated
public ColumnUsage[] getColumnUsages()
```
    Deprecated.
    
    Specified by:
    
    getColumnUsages in interface SQLQueryBuilder
    
    See Also:
    
    DBUtil.findChildren(oracle.javatools.db.DBObject, java.lang.Class<T>)
  - findColumnInFromObjects
```
public FromObjectUsage findColumnInFromObjects(java.lang.String colName,
                                      boolean external,
                                      SQLFragment creating,
                                      FromObject... extraFroms)
                                        throws SQLQueryException
```
    Finds a Column of given name amongst the RelationUsages in the query. Will throw a SQLQueryException if the column name appears in more than one Relation referred to in the query. Returns an appropriate expression for that Column to use within the query.
    
    Parameters:
    
    colName - the column name to find
    
    external - whether colName is an external (true) or internal (false) name.
    
    creating - the fragment we are in the context of creating
    
    extraFroms - extra FromObjects to search within for the column (the query's own FromObjects are searched automatically).
    
    Throws:
    
    SQLQueryException
  - replaceWithAliases
```
protected void replaceWithAliases(FromObject[] froms)
```
    replace any From Objects in the list that are aliases for a subquery_factoring_clause
  - findColumnInFromObjects
```
protected FromObjectUsage findColumnInFromObjects(java.lang.String colName,
                                      boolean external,
                                      FromObject[] froms,
                                      boolean allowDuplicates,
                                      boolean enforceInAll,
                                      SQLFragment creating)
                                           throws SQLQueryException
```
    Finds a Column of given name amongst the given FromObjects.
    
    Parameters:
    
    colName - the name of the column to find
    
    external - whether colName is an external (true) or internal (false) name.
    
    froms - the FromObjects to search in
    
    allowDuplicates - whether to allow duplicate columns to exist ( if false a found duplicate will throw a SQLQueryException)
    
    enforceInAll - whether to enforce that the column must exist in all FromObjects (e.g. when creating a join), if true and the column isn't present in all FROMs a SQLQueryException will be thrown.
    
    creating - the fragment we are in the context of creating
    
    Returns:
    
    a FromObjectUsage referencing the found column
    
    Throws:
    
    SQLQueryException
  - findColumnInFromExpression
```
public FromObjectUsage findColumnInFromExpression(java.lang.String colName,
                                         boolean external,
                                         SQLFragment exp,
                                         boolean allowDuplicates,
                                         FromObject from,
                                         SQLFragment creating)
                                           throws SQLQueryException
```
    Finds a Column of given name in the given FromObject's expression.
    
    Parameters:
    
    colName - the name of the column to find
    
    external - whether colName is an external (true) or internal (false) name.
    
    exp - the expression to search under (e.g. if this is a RelationUsage we look for a Column on the referenced Relation).
    
    allowDuplicates - whether to allow duplicate columns to exist ( if false a found duplicate will throw a SQLQueryException)
    
    from - the parent of exp
    
    creating - the fragment we are in the context of creating
    
    Returns:
    
    a FromObjectUsage referencing the found column, or null if no column is found.
    
    Throws:
    
    SQLQueryException
  - findColumnInColumnUsage
```
protected FromObjectUsage findColumnInColumnUsage(java.lang.String colName,
                                      boolean external,
                                      ColumnUsage colu,
                                      FromObject from)
```
    Finds a column in the given ColumnUsage. A "column" can exist underneath a column usage when the ColumnUsage is referencing a Type column, the sub-column is then an attribute or method on that Type.
    
    Parameters:
    
    colName - the name of the column to find
    
    external - whether colName is an external (true) or internal (false) name.
    
    colu - the ColumnUsage to search under
    
    from - the parent of colu
    
    Returns:
    
    a FromObjectUsage referencing the found column, or null if no column is found.
  - findColumnInJoin
```
protected FromObjectUsage findColumnInJoin(java.lang.String colName,
                               boolean external,
                               JoinObject join,
                               boolean allowDuplicates,
                               SQLFragment creating)
                                    throws SQLQueryException
```
    Finds a column in the child FromObjects of a given JoinObject.
    
    Parameters:
    
    colName - the name of the column to find
    
    external - whether colName is an external (true) or internal (false) name.
    
    join - the JoinObject to search underneath
    
    allowDuplicates - whether to allow duplicate columns to exist ( if false a found duplicate will throw a SQLQueryException)
    
    creating - the fragment we are in the context of creating
    
    Returns:
    
    a FromObjectUsage referencing the found column
    
    Throws:
    
    SQLQueryException
  - findColumnInRelation
```
public FromObjectUsage findColumnInRelation(java.lang.String colName,
                                   boolean external,
                                   RelationUsage relU)
                                     throws SQLQueryException
```
    Finds a Column with the given name in the Relation referred to by the given RelationUsage, and returns a FromObjectUsage that references that column.
    
    Parameters:
    
    colName - the name of the column to find
    
    external - whether colName is an external (true) or internal (false) name.
    
    relU - the relation usage that references the relation to search.
    
    Returns:
    
    a FromObjectUsage for the found column, or null.
    
    Throws:
    
    SQLQueryException
  - findColumnInRelation
```
public FromObjectUsage findColumnInRelation(java.lang.String colName,
                                   boolean external,
                                   Relation rel)
                                     throws SQLQueryException
```
    Finds a Column with the given name in a Relation and returns a FromObjectUsage that references that column.
    Warning: The returned ColumnUsage won't have a FromObject set.
    
    Parameters:
    
    colName - the name of the column to find
    
    external - whether colName is an external (true) or internal (false) name.
    
    rel - the relation to search in
    
    Returns:
    
    a FromObjectUsage for the found column, or null.
    
    Throws:
    
    SQLQueryException
  - findColumnInSubQuery
```
public SelectObjectUsage findColumnInSubQuery(java.lang.String colName,
                                     boolean external,
                                     SQLQuery query)
                                       throws SQLQueryException
```
    Throws:
    
    SQLQueryException
  - findColumnInStarSubQuery
```
public ColumnUsage findColumnInStarSubQuery(java.lang.String colName,
                                   boolean external,
                                   FromObject from)
                                     throws SQLQueryException
```
    The from object is of the form (SELECT * FROM <rel>) <alias>
    
    Throws:
    
    SQLQueryException
  - setHierarchicalQueryObject
```
public void setHierarchicalQueryObject(HierarchicalQueryObject obj)
```
    Description copied from interface: SQLQueryBuilder
    
    Sets the CONNECT BY clause of the query.
    
    Specified by:
    
    setHierarchicalQueryObject in interface SQLQueryBuilder
  - setGroupByObject
```
public void setGroupByObject(GroupByObject obj)
```
    Description copied from interface: SQLQueryBuilder
    
    Sets the group by object. This caches any dependent objects against their FromObjects appropriately.
    
    Specified by:
    
    setGroupByObject in interface SQLQueryBuilder
  - canSetGroupBy
```
public boolean canSetGroupBy()
```
    Description copied from interface: SQLQueryBuilder
    
    Returns true if this query can accept a group by clause. To have a group by clause there must be a grouping function in the SELECT clause.
    
    Specified by:
    
    canSetGroupBy in interface SQLQueryBuilder
  - addGroupByColumn
```
public void addGroupByColumn(SQLFragment colu)
```
    Description copied from interface: SQLQueryBuilder
    
    Adds the given FromObjectUsage to the end of the GROUP BY clause. Will create a GroupByObject if necessary.
    
    Specified by:
    
    addGroupByColumn in interface SQLQueryBuilder
  - addGroupByColumn
```
public void addGroupByColumn(int index,
                    SQLFragment colu)
```
    Description copied from interface: SQLQueryBuilder
    
    Adds the given FromObjectUsage to the specified index of the GROUP BY clause.
    
    Specified by:
    
    addGroupByColumn in interface SQLQueryBuilder
  - removeGroupByColumn
```
public boolean removeGroupByColumn(SQLFragment colu)
```
    Description copied from interface: SQLQueryBuilder
    
    Removes the given FromObjectUsage from the GROUP BY clause. Will remove the GROUP BY clause if there are no column usages left.
    
    Specified by:
    
    removeGroupByColumn in interface SQLQueryBuilder
  - parseHavingExpression
```
public SQLFragment parseHavingExpression(java.lang.String expression)
                                  throws SQLQueryException
```
    By default this calls parseWhereExpression().
    
    Specified by:
    
    parseHavingExpression in interface SQLQueryBuilder
    
    Parameters:
    
    expression - the sql to parse as a HAVING fragment.
    
    Returns:
    
    SQLFragment for the expression.
    
    Throws:
    
    SQLQueryException
  - parseOrderByExpression
```
public final SQLFragment parseOrderByExpression(java.lang.String expression)
                                         throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Parses an expression to see if it is a valid expression for a Order By object. If the parse is successful a SQLFragment will be returned for the expression. If the parse isn't successful an appropriate Exception will be thrown.
    
    Specified by:
    
    parseOrderByExpression in interface SQLQueryBuilder
    
    Parameters:
    
    expression - the sql to parse as a ORDER BY fragment.
    
    Returns:
    
    SQLFragment for the expression.
    
    Throws:
    
    SQLQueryException
  - parseOrderByExpression
```
protected SQLFragment parseOrderByExpression(java.lang.String expression,
                                 OrderByObject obo)
                                      throws SQLQueryException
```
    Throws:
    
    SQLQueryException
  - setHavingObject
```
public void setHavingObject(WhereObject having)
```
    Description copied from interface: SQLQueryBuilder
    
    Sets the HAVING clause of the query. This is for convinience only as the HAVING object is a child of the GroupByObject. This method assumes that a GroupByObject exists on the SQLQuery. This means a NPE will be thrown if you try and set the HAVING clause and no GroupBy has been set.
    
    Specified by:
    
    setHavingObject in interface SQLQueryBuilder
  - addOrderByObject
```
public void addOrderByObject(OrderByObject ob)
```
    Description copied from interface: SQLQueryBuilder
    
    Adds the given order by object to the end of the order by clause.
    
    Specified by:
    
    addOrderByObject in interface SQLQueryBuilder
  - addOrderByObject
```
public void addOrderByObject(int index,
                    OrderByObject ob)
```
    Description copied from interface: SQLQueryBuilder
    
    Adds the given order by object to the given index in the clause. If the index is out of bounds the object is added to the end of the clause.
    
    Specified by:
    
    addOrderByObject in interface SQLQueryBuilder
  - removeOrderByObject
```
public boolean removeOrderByObject(OrderByObject ob)
```
    Description copied from interface: SQLQueryBuilder
    
    Removes the given order by object from the orderby clause.
    
    Specified by:
    
    removeOrderByObject in interface SQLQueryBuilder
  - replaceOrderByObject
```
public void replaceOrderByObject(OrderByObject oldOb,
                        OrderByObject newOb)
```
    Description copied from interface: SQLQueryBuilder
    
    Replaces the existing from object with a new one. Will recache any dependencies on the FROM clause.
    
    Specified by:
    
    replaceOrderByObject in interface SQLQueryBuilder
  - setOrderByObjects
```
public void setOrderByObjects(OrderByObject[] orderbys)
```
    Description copied from interface: SQLQueryBuilder
    
    Sets the order by objects for the query. If there are existing objects they are replaced. Passing null will remove all order by objects.
    
    Specified by:
    
    setOrderByObjects in interface SQLQueryBuilder
  - syncViewColumns
```
@Deprecated
public void syncViewColumns()
                     throws AliasInUseException
```
    Deprecated. - no longer required
    
    Specified by:
    
    syncViewColumns in interface SQLQueryBuilder
    
    Throws:
    
    AliasInUseException
  - getColumnName
```
public java.lang.String getColumnName(SelectObject sel)
```
  - checkUsageQualifications
```
public void checkUsageQualifications()
```
    Checks that every FromObjectUsage which isn't qualified is a unique name within the query. If it isn't then the column is explicitly qualified.
  - parseFromExpression
```
public final SQLFragment parseFromExpression(java.lang.String expression)
                                      throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Parses an expression to see if it is a valid expression for a From object. If the parse is successful a SQLFragment will be returned for the expression. If the parse isn't successful an appropriate Exception will be thrown.
    
    Specified by:
    
    parseFromExpression in interface SQLQueryBuilder
    
    Parameters:
    
    expression - the sql to parse as a FROM fragment.
    
    Returns:
    
    SQLFragment for the expression.
    
    Throws:
    
    SQLQueryException
  - parseFromExpression
```
protected SQLFragment parseFromExpression(java.lang.String expression,
                              FromObject creating)
                                   throws SQLQueryException
```
    Throws:
    
    SQLQueryException
  - parseSelectExpression
```
public final SQLFragment parseSelectExpression(java.lang.String expression)
                                        throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Parses an expression to see if it is a valid expression for a Select object. If the parse is successful a SQLFragment will be returned for the expression. If the parse isn't successful an appropriate Exception will be thrown.
    
    Specified by:
    
    parseSelectExpression in interface SQLQueryBuilder
    
    Parameters:
    
    expression - the sql to parse as a SELECT fragment.
    
    Returns:
    
    SQLFragment for the expression.
    
    Throws:
    
    SQLQueryException
  - parseSelectExpression
```
protected SQLFragment parseSelectExpression(java.lang.String expression,
                                SelectObject creating)
                                     throws SQLQueryException
```
    Throws:
    
    SQLQueryException
  - parseWhereExpression
```
public final SQLFragment parseWhereExpression(java.lang.String expression)
                                       throws SQLQueryException
```
    Description copied from interface: SQLQueryBuilder
    
    Parses an expression to see if it is a valid expression for a Where object. If the parse is successful a SQLFragment will be returned for the expression. If the parse isn't successful an appropriate Exception will be thrown.
    
    Specified by:
    
    parseWhereExpression in interface SQLQueryBuilder
    
    Parameters:
    
    expression - the sql to parse as a WHERE fragment.
    
    Returns:
    
    SQLFragment for the expression.
    
    Throws:
    
    SQLQueryException
  - parseWhereExpression
```
public SQLFragment parseWhereExpression(java.lang.String expression,
                               WhereObject creating)
                                 throws SQLQueryException
```
    Throws:
    
    SQLQueryException
  - getColumns
```
public Column[] getColumns()
                    throws DBException
```
    Description copied from interface: SQLQueryBuilder
    
    Retrieves Column objects mapped to the columns in the SQL query that has been built, thereby giving the name and type of each column the query has. A * column will be expanded.
    
    Specified by:
    
    getColumns in interface SQLQueryBuilder
    
    Throws:
    
    DBException - if the query cannot be processed
  - getDTUBuilder
```
protected abstract DerivedPropertyBuilder getDTUBuilder(int columnIndex)
```
    Sublass implementations to provide a DerivedPropertyBuilder capable of building the DataTypeUsage property for Views/MatViews.
  - containsAsterisk
```
protected abstract boolean containsAsterisk()
                                     throws SQLQueryException
```
    Returns:
    
    true if one or more Select list items are an asterisk.
    
    Throws:
    
    SQLQueryException
  - getQueryColumnInfos
```
public abstract java.util.List<AbstractSQLQueryBuilder.QueryColumnInfo> getQueryColumnInfos()
                                                                                     throws SQLQueryException
```
    Obtains information about the select list items for use in building view and materialized view columns without building the query unless absolutely necessary.
    
    Returns:
    
    Throws:
    
    SQLQueryException
  - setViewColDataType
```
protected void setViewColDataType(Column col,
                      SelectObject so)
```
  - setSingleRelation
```
public void setSingleRelation(Relation singleRelation)
```
  - setExtraObjects
```
public void setExtraObjects(java.util.Collection<? extends SystemObject> objs)
```
  - addExtraObject
```
protected void addExtraObject(SystemObject obj)
```
  - getObject
```
protected SchemaObject getObject(java.lang.String type,
                     Schema sch,
                     java.lang.String relation)
                          throws DBException
```
    Throws:
    
    DBException
  - getObject
```
protected SchemaObject getObject(DBObjectCriteria crit)
                          throws DBException
```
    Throws:
    
    DBException
  - registerSQLFragmentFactory
```
public void registerSQLFragmentFactory(SQLFragmentFactory fac)
```
    Description copied from interface: SQLQueryBuilder
    
    Register plugin SQLFragmentFactory to create SQLFragments from the given String if not recognized by the base implementation.
    
    Specified by:
    
    registerSQLFragmentFactory in interface SQLQueryBuilder
  - registerAllSQLFragmentFactories
```
protected void registerAllSQLFragmentFactories(AbstractSQLQueryBuilder builder)
```
  - createFromFactory
```
public final SQLFragment createFromFactory(SQLFragment parent,
                            java.lang.String clause,
                            java.lang.Integer offset)
```

Class AbstractSQLQueryBuilder

Nested Class Summary

Nested classes/interfaces inherited from class oracle.javatools.db.AbstractDBObjectBuilder

Nested classes/interfaces inherited from interface oracle.javatools.db.sql.SQLQueryBuilder

Field Summary

Fields inherited from interface oracle.javatools.db.DBObjectBuilder

Constructor Summary

Method Summary

Methods inherited from class oracle.javatools.db.property.DerivedPropertyBuilder

Methods inherited from class oracle.javatools.db.AbstractDBObjectBuilder

Methods inherited from class java.lang.Object

Methods inherited from interface oracle.javatools.db.sql.SQLQueryBuilder

Field Detail

EMPTY_ARRAY

Constructor Detail

AbstractSQLQueryBuilder

Method Detail

getLogger

getDefaultSchema

getQuery

buildQuery

buildQuery

setSQLQuery

buildQueryImpl

clearDerivedProperties

buildQuery

buildDeclarativeProperties

throwException

addClauseException

validateQuery

ensureIDs

ensureID

loadObjects

loadObject

unloadObject

getIDs

getRelIDs

setNewFromObject

getInternalName

getExternalName

isValidName

validateAlias

getSQLQuery

addSelectObject

addSelectObject

isUniqueSelectAlias

isUniqueSelectAlias

createUniqueSelectAlias

createUniqueSelectAlias

getSelectObject

constructSelectObject

constructSelectObject

constructSelectObjects

doConstructSelectObject

createSelectObject

addSelectObjects

removeSelectObject

replaceSelectObject

isUniqueFromAlias

isUniqueFromAlias

createUniqueFromAlias

createUniqueFromAlias

listAllFromObjects

listAllFromObjects

getFromObject

getFromObject

constructFromObject

createFromObject

constructFromObject

doConstructFromObject

constructFromObjects

addFromObject

addFromObjects

addJoinObject

replaceFromObject

removeJoinObject

removeFromObject

constructFKJoin

constructFKJoins

doConstructJoin