java.lang.Object
- org.teiid.translator.ExecutionFactory<F,C>
- - org.teiid.translator.BaseDelegatingExecutionFactory<F,C>

All Implemented Interfaces:: DelegatingExecutionFactory<F,C>

@Translator(name="delegator",
            description="Translator that delegates to another translator with capability override certain methods/capabilities")
public class BaseDelegatingExecutionFactory<F,C>
extends ExecutionFactory<F,C>
implements DelegatingExecutionFactory<F,C>

Base delegating translator. Will proxy all calls to another ExecutionFactory. You will create a custom translator as a subclass of this class containing overrides for any method you wish to intercept. Given that subclass is given a Translator name of 'custom-delegator', your 'vdb.xml' file will contain an XML fragment like the following to assign the delegate:

 
 <translator type="custom-delegator" name="my-translator" description="custom translator">
    <property value="delegateName" name="name of the delegate instance"/>
    <!-- any custom properties will also appear here -->
 </translator>

Nested Class Summary
- Nested classes/interfaces inherited from class org.teiid.translator.ExecutionFactory
  ExecutionFactory.Format, ExecutionFactory.NullOrder, ExecutionFactory.SupportedJoinCriteria, ExecutionFactory.TransactionSupport

Field Summary
- Fields inherited from class org.teiid.translator.ExecutionFactory
  DEFAULT_MAX_FROM_GROUPS, DEFAULT_MAX_IN_CRITERIA_SIZE, DEFAULT_MAX_PROJECTED_COLUMNS

Constructor Summary

Constructors
Constructor Description

BaseDelegatingExecutionFactory()

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`boolean`	`areLobsUsableAfterClose()`	Indicates if LOBs are usable after the execution is closed.
`void`	`closeConnection(C connection, F factory)`	Closes a connection object from the given connection factory.
`ProcedureExecution`	`createDirectExecution(List<Argument> arguments, Command command, ExecutionContext executionContext, RuntimeMetadata metadata, C connection)`
`ProcedureExecution`	`createProcedureExecution(Call command, ExecutionContext executionContext, RuntimeMetadata metadata, C connection)`
`ResultSetExecution`	`createResultSetExecution(QueryExpression command, ExecutionContext executionContext, RuntimeMetadata metadata, C connection)`
`UpdateExecution`	`createUpdateExecution(Command command, ExecutionContext executionContext, RuntimeMetadata metadata, C connection)`
`boolean`	`equals(Object obj)`
`String`	`getAddSupportedFunctions()`
`CacheDirective`	`getCacheDirective(Command command, ExecutionContext executionContext, RuntimeMetadata metadata)`	Get the `CacheDirective` to control command caching.
`String`	`getCachePattern()`
`Long`	`getCacheTtl()`
`String`	`getCollationLocale()`	Indicates the collation used for sorting
`C`	`getConnection(F factory, ExecutionContext executionContext)`	Return a connection object from the given connection factory.
`ExecutionFactory.NullOrder`	`getDefaultNullOrder()`	Returns the default null ordering
`protected ExecutionFactory<F,C>`	`getDelegate()`	For testing only
`String`	`getDelegateName()`
`String`	`getDirectQueryProcedureName()`	Defines the name of the direct processing procedure.
`String`	`getExcludedCommonTableExpressionName()`
`LanguageFactory`	`getLanguageFactory()`	Obtain a reference to the default LanguageFactory that can be used to construct new language interface objects.
`int`	`getMaxDependentInPredicates()`	Get the integer value representing the max number of dependent IN predicates.
`int`	`getMaxFromGroups()`	The number of groups supported in the from clause.
`int`	`getMaxInCriteriaSize()`	Get the integer value representing the number of values allowed in an IN criteria in the WHERE clause of a query
`int`	`getMaxProjectedColumns()`	The number of columns supported in projected select clause.
`void`	`getMetadata(MetadataFactory metadataFactory, C conn)`	Implement to provide metadata to the metadata for use by the engine.
`List<FunctionMethod>`	`getPushDownFunctions()`	Get a list of `FunctionMethod`s that will be contributed to the SYS schema.
`String`	`getRemoveSupportedFunctions()`
`Character`	`getRequiredLikeEscape()`	The required escape character or null if all are supported.
`List<String>`	`getSupportedFunctions()`	Get list of all supported function names.
`ExecutionFactory.SupportedJoinCriteria`	`getSupportedJoinCriteria()`	Get the supported join criteria.
`ExecutionFactory.TransactionSupport`	`getTransactionSupport()`
`TypeFacility`	`getTypeFacility()`	Obtain a reference to the type facility, which can be used to perform many type conversions supplied by the Connector API.
`int`	`hashCode()`
`void`	`initCapabilities(C connection)`	Will be called by `ExecutionFactory.start()` with a null connection if a source connection is not `ExecutionFactory.isSourceRequiredForCapabilities()`
`boolean`	`isCopyLobs()`
`boolean`	`isForkable()`	When forkable the engine may use a separate thread to interact with returned `Execution`.
`boolean`	`isImmutable()`	Defines if the Connector is read-only connector
`boolean`	`isSourceRequired()`	Flag that indicates if a underlying source connection required for this execution factory to work
`boolean`	`isSourceRequiredForCapabilities()`	If true, the `ExecutionFactory.initCapabilities(Object)` method will be consulted prior to determining the capabilities
`boolean`	`isSourceRequiredForMetadata()`	Flag that indicates if a underlying source connection required for this execution factory to return metadata
`boolean`	`isThreadBound()`
`boolean`	`requiresCriteria()`	Whether the source supports queries without criteria.
`boolean`	`returnsSingleUpdateCount()`	True if only a single value is returned for the update count.
`void`	`setAddSupportedFunctions(String functionNames)`
`void`	`setCachePattern(String cachePattern)`
`void`	`setCacheTtl(Long ttl)`
`void`	`setCollationLocale(String value)`
`void`	`setCopyLobs(boolean value)`
`void`	`setDefaultNullOrder(ExecutionFactory.NullOrder nullOrder)`
`void`	`setDelegate(ExecutionFactory<F,C> delegate)`	Sets the delegate, will be called by Teiid after `start()`
`void`	`setDelegateName(String delegateName)`
`void`	`setDirectQueryProcedureName(String name)`
`void`	`setExcludedCommonTableExpressionName(String value)`
`void`	`setForkable(boolean value)`
`void`	`setImmutable(boolean value)`
`void`	`setMaxDependentInPredicates(int maxDependentInPredicates)`
`void`	`setMaxFromGroups(int value)`
`void`	`setMaxInCriteriaSize(int max)`
`void`	`setMaxProjectedColumns(int value)`
`void`	`setRemoveSupportedFunctions(String functionNames)`
`void`	`setRequiredLikeEscape(Character c)`
`void`	`setRequiresCriteria(boolean value)`
`void`	`setSourceRequired(boolean value)`
`void`	`setSourceRequiredForCapabilities(boolean value)`
`void`	`setSourceRequiredForMetadata(boolean value)`
`void`	`setSupportedJoinCriteria(ExecutionFactory.SupportedJoinCriteria value)`
`void`	`setSupportsAdvancedOlapOperations(boolean value)`
`void`	`setSupportsAggregatesAvg(boolean value)`
`void`	`setSupportsAggregatesCount(boolean value)`
`void`	`setSupportsAggregatesCountBig(boolean supportsAggregatesCountBig)`
`void`	`setSupportsAggregatesCountStar(boolean value)`
`void`	`setSupportsAggregatesDistinct(boolean value)`
`void`	`setSupportsAggregatesEnhancedNumeric(boolean value)`
`void`	`setSupportsAggregatesMax(boolean value)`
`void`	`setSupportsAggregatesMin(boolean value)`
`void`	`setSupportsAggregatesSum(boolean value)`
`void`	`setSupportsAliasedTable(boolean value)`
`void`	`setSupportsArrayAgg(boolean value)`
`void`	`setSupportsArrayType(boolean value)`
`void`	`setSupportsBatchedUpdates(boolean value)`
`void`	`setSupportsBulkUpdate(boolean value)`
`void`	`setSupportsCommonTableExpressions(boolean value)`
`void`	`setSupportsCompareCriteriaEquals(boolean value)`
`void`	`setSupportsCompareCriteriaOrdered(boolean value)`
`void`	`setSupportsCompareCriteriaOrderedExclusive(boolean value)`
`void`	`setSupportsCorrelatedSubqueries(boolean value)`
`void`	`setSupportsCorrelatedSubqueryLimit(boolean value)`
`void`	`setSupportsDependentJoins(boolean value)`
`void`	`setSupportsDirectQueryProcedure(boolean value)`
`void`	`setSupportsElementaryOlapOperations(boolean value)`
`void`	`setSupportsExcept(boolean value)`
`void`	`setSupportsExistsCriteria(boolean value)`
`void`	`setSupportsFullDependentJoins(boolean value)`
`void`	`setSupportsFullOuterJoins(boolean supportsFullOuterJoins)`
`void`	`setSupportsFunctionsInGroupBy(boolean value)`
`void`	`setSupportsGeographyType(boolean supportsGeographyType)`
`void`	`setSupportsGroupBy(boolean value)`
`void`	`setSupportsGroupByMultipleDistinctAggregates(boolean value)`
`void`	`setSupportsGroupByRollup(boolean value)`
`void`	`setSupportsHaving(boolean value)`
`void`	`setSupportsInCriteria(boolean value)`
`void`	`setSupportsInCriteriaSubquery(boolean value)`
`void`	`setSupportsInlineViews(boolean value)`
`void`	`setSupportsInnerJoins(boolean supportsInnerJoins)`
`void`	`setSupportsInsertWithQueryExpression(boolean value)`
`void`	`setSupportsIntersect(boolean value)`
`void`	`setSupportsIsDistinctCriteria(boolean value)`
`void`	`setSupportsIsNullCriteria(boolean value)`
`void`	`setSupportsLateralJoin(boolean value)`
`void`	`setSupportsLateralJoinCondition(boolean value)`
`void`	`setSupportsLikeCriteria(boolean value)`
`void`	`setSupportsLikeCriteriaEscapeCharacter(boolean value)`
`void`	`setSupportsLikeRegex(boolean value)`
`void`	`setSupportsListAgg(boolean value)`
`void`	`setSupportsMultipleOpenStatements(boolean supportsMultipleOpenStatements)`
`void`	`setSupportsNotCriteria(boolean value)`
`void`	`setSupportsOnlyCorrelatedSubqueries(boolean value)`
`void`	`setSupportsOnlyFormatLiterals(boolean value)`
`void`	`setSupportsOnlyLateralJoinProcedure(boolean supportsOnlyLateralJoinProcedure)`
`void`	`setSupportsOnlyLiteralComparison(boolean value)`
`void`	`setSupportsOnlySingleTableGroupBy(boolean value)`
`void`	`setSupportsOnlyTimestampAddLiteral(boolean supportsOnlyTimestampAddLiteral)`
`void`	`setSupportsOrCriteria(boolean value)`
`void`	`setSupportsOrderBy(boolean supportsOrderBy)`
`void`	`setSupportsOrderByNullOrdering(boolean value)`
`void`	`setSupportsOrderByUnrelated(boolean value)`
`void`	`setSupportsOrderByWithExtendedGrouping(boolean value)`
`void`	`setSupportsOuterJoins(boolean supportsOuterJoins)`
`void`	`setSupportsPartialFiltering(boolean value)`
`void`	`setSupportsProcedureParameterExpression(Boolean supportsProcedureParameterExpression)`
`void`	`setSupportsProcedureTable(boolean value)`
`void`	`setSupportsQuantifiedCompareCriteriaAll(boolean value)`
`void`	`setSupportsQuantifiedCompareCriteriaSome(boolean value)`
`void`	`setSupportsRecursiveCommonTableExpressions(boolean value)`
`void`	`setSupportsRowLimit(boolean value)`
`void`	`setSupportsRowOffset(boolean value)`
`void`	`setSupportsScalarSubqueries(boolean value)`
`void`	`setSupportsScalarSubqueryProjection(boolean value)`
`void`	`setSupportsSearchedCaseExpressions(boolean value)`
`void`	`setSupportsSelectDistinct(boolean supportsSelectDistinct)`
`void`	`setSupportsSelectExpression(boolean value)`
`void`	`setSupportsSelectExpressionArrayType(boolean value)`
`void`	`setSupportsSelectWithoutFrom(boolean value)`
`void`	`setSupportsSelfJoins(boolean value)`
`void`	`setSupportsSetQueryLimitOffset(boolean value)`
`void`	`setSupportsSetQueryOrderBy(boolean value)`
`void`	`setSupportsSimilarTo(boolean value)`
`void`	`setSupportsStringAgg(boolean value)`
`void`	`setSupportsSubqueryCommonTableExpressions(boolean value)`
`void`	`setSupportsSubqueryInOn(boolean value)`
`void`	`setSupportsUnions(boolean value)`
`void`	`setSupportsUpsert(boolean value)`
`void`	`setSupportsWindowDistinctAggregates(boolean value)`
`void`	`setSupportsWindowFrameClause(boolean value)`
`void`	`setSupportsWindowFunctionCumeDist(boolean supportsCumeDist)`
`void`	`setSupportsWindowFunctionNthValue(boolean supportsNthValue)`
`void`	`setSupportsWindowFunctionNtile(boolean supportsNtile)`
`void`	`setSupportsWindowFunctionPercentRank(boolean supportsPercentRank)`
`void`	`setSupportsWindowOrderByWithAggregates(boolean value)`
`void`	`setThreadBound(boolean value)`
`void`	`setTransactionSupport(ExecutionFactory.TransactionSupport transactionSupport)`
`void`	`setUseAnsiJoin(boolean value)`
`void`	`setUseBindingsForDependentJoin(boolean value)`
`void`	`start()`	Initialize the connector with supplied configuration
`boolean`	`supportsAdvancedOlapOperations()`
`boolean`	`supportsAggregatesAvg()`	Support indicates connector can accept the AVG aggregate function
`boolean`	`supportsAggregatesCount()`	Support indicates connector can accept the COUNT aggregate function
`boolean`	`supportsAggregatesCountBig()`
`boolean`	`supportsAggregatesCountStar()`	Support indicates connector can accept the COUNT(*) aggregate function
`boolean`	`supportsAggregatesDistinct()`	Support indicates connector can accept DISTINCT within aggregate functions
`boolean`	`supportsAggregatesEnhancedNumeric()`	Support indicates connector can accept STDDEV_POP, STDDEV_VAR, VAR_POP, VAR_SAMP
`boolean`	`supportsAggregatesMax()`	Support indicates connector can accept the MAX aggregate function
`boolean`	`supportsAggregatesMin()`	Support indicates connector can accept the MIN aggregate function
`boolean`	`supportsAggregatesSum()`	Support indicates connector can accept the SUM aggregate function
`boolean`	`supportsAliasedTable()`	Support indicates connector can accept groups with aliases
`boolean`	`supportsArrayAgg()`
`boolean`	`supportsArrayType()`	The engine uses array types for dependent joins and for array expression.
`boolean`	`supportsBatchedUpdates()`	Whether the source supports `BatchedUpdates`
`boolean`	`supportsBulkUpdate()`	Whether the source supports updates with multiple value sets
`boolean`	`supportsCommonTableExpressions()`
`boolean`	`supportsCompareCriteriaEquals()`	Support indicates connector accepts criteria of form (element = constant)
`boolean`	`supportsCompareCriteriaOrdered()`	Support indicates connector accepts criteria of form (element <=\|>= constant) The query engine will may pushdown queries containing < or > if NOT is also supported.
`boolean`	`supportsCompareCriteriaOrderedExclusive()`	Support indicates connector accepts criteria of form (element <\|> constant)
`void`	`supportsCompareCriteriaOrderedExclusive(boolean value)`	Deprecated.
`boolean`	`supportsConvert(int fromType, int toType)`	Used for fine grained control of convert/cast pushdown.
`boolean`	`supportsCorrelatedSubqueries()`	Support indicates connector can accept correlated subqueries wherever subqueries are accepted
`boolean`	`supportsCorrelatedSubqueryLimit()`
`boolean`	`supportsDependentJoins()`	NOTE: The pushed independent tuples will not have been converted to a unique set and may contain duplicates.
`boolean`	`supportsDirectQueryProcedure()`	True, if this translator supports execution of source specific commands unaltered through a direct procedure.
`boolean`	`supportsElementaryOlapOperations()`
`boolean`	`supportsExcept()`	Support indicates that the connector supports the EXCEPT of two queries.
`boolean`	`supportsExistsCriteria()`	Support indicates connector accepts the EXISTS criteria
`boolean`	`supportsFormatLiteral(String literal, ExecutionFactory.Format format)`
`boolean`	`supportsFullDependentJoins()`
`boolean`	`supportsFullOuterJoins()`	Support indicates connector can accept full outer joins
`boolean`	`supportsFunctionsInGroupBy()`	Support indicates that the connector supports non-column expressions in GROUP BY, such as: `SELECT dayofmonth(theDate), COUNT(*) FROM table GROUP BY dayofmonth(theDate)`
`boolean`	`supportsGeographyType()`	If the geography type is supported by the standard ST_ geospatial functions
`boolean`	`supportsGroupBy()`	Whether the source supports an explicit GROUP BY clause
`boolean`	`supportsGroupByMultipleDistinctAggregates()`	Whether the source supports grouping with multiple distinct aggregates
`boolean`	`supportsGroupByRollup()`
`boolean`	`supportsHaving()`	Whether the source supports the HAVING clause
`boolean`	`supportsInCriteria()`	Support indicates connector accepts criteria of form (element IN set)
`boolean`	`supportsInCriteriaSubquery()`	Support indicates connector accepts IN criteria with a subquery on the right side
`boolean`	`supportsInlineViews()`	Support indicates connector can accept inline views (subqueries in the FROM clause).
`boolean`	`supportsInnerJoins()`	Support indicates connector can accept inner or cross joins
`boolean`	`supportsInsertWithQueryExpression()`	Support indicates that the connector can accept INSERTs with values specified by a `SetQuery` or `Select`
`boolean`	`supportsIntersect()`	Support indicates that the connector supports the INTERSECT of two queries.
`boolean`	`supportsIsDistinctCriteria()`	Support indicates connector accepts criteria of form (exp1 IS DISTINCT exp2)
`boolean`	`supportsIsNullCriteria()`	Support indicates connector accepts criteria of form (element IS NULL)
`boolean`	`supportsLateralJoin()`
`boolean`	`supportsLateralJoinCondition()`
`boolean`	`supportsLikeCriteria()`	Support indicates connector accepts criteria of form (element LIKE constant)
`boolean`	`supportsLikeCriteriaEscapeCharacter()`	Support indicates connector accepts criteria of form (element LIKE constant ESCAPE char)
`boolean`	`supportsLikeRegex()`
`boolean`	`supportsListAgg()`
`boolean`	`supportsMultipleOpenExecutions()`
`boolean`	`supportsNotCriteria()`	Support indicates connector accepts logical criteria NOT
`boolean`	`supportsOnlyCorrelatedSubqueries()`
`boolean`	`supportsOnlyFormatLiterals()`	See also `ExecutionFactory.supportsFormatLiteral(String, Format)`
`boolean`	`supportsOnlyLateralJoinProcedure()`
`boolean`	`supportsOnlyLiteralComparison()`
`boolean`	`supportsOnlySingleTableGroupBy()`	Whether the source supports grouping only over a single table
`boolean`	`supportsOnlyTimestampAddLiteral()`
`boolean`	`supportsOrCriteria()`	Support indicates connector accepts logical criteria connected by OR
`boolean`	`supportsOrderBy()`	Support indicates connector accepts ORDER BY clause, including multiple elements and ascending and descending sorts.
`boolean`	`supportsOrderByNullOrdering()`	Returns whether the database supports explicit null ordering.
`boolean`	`supportsOrderByUnrelated()`	Support indicates connector accepts ORDER BY clause with columns not from the select
`boolean`	`supportsOrderByWithExtendedGrouping()`
`boolean`	`supportsOuterJoins()`	Support indicates connector can accept left outer joins
`boolean`	`supportsPartialFiltering()`	Return true if the source has columns marked with the teiid_rel:partial that can return more rows than specified by a filter if the column is also projected.
`boolean`	`supportsProcedureParameterExpression()`	Return true if the translator supports expressions as procedure paramters.
`boolean`	`supportsProcedureTable()`
`boolean`	`supportsQuantifiedCompareCriteriaAll()`	Support indicates connector accepts the quantified comparison criteria that use ALL
`boolean`	`supportsQuantifiedCompareCriteriaSome()`	Support indicates connector accepts the quantified comparison criteria that use SOME
`boolean`	`supportsRecursiveCommonTableExpressions()`
`boolean`	`supportsRowLimit()`	Gets whether the connector can limit the number of rows returned by a query.
`boolean`	`supportsRowOffset()`	Gets whether the connector supports a SQL clause (similar to the LIMIT with an offset) that can return result sets that start in the middle of the resulting rows returned by a query
`boolean`	`supportsScalarSubqueries()`	Support indicates connector can accept scalar subqueries in the SELECT, WHERE, and HAVING clauses
`boolean`	`supportsScalarSubqueryProjection()`	If a scalar subquery can be projected.
`boolean`	`supportsSearchedCaseExpressions()`	Support indicates connector can accept queries with searched CASE WHEN criteria ...
`boolean`	`supportsSelectDistinct()`	Support indicates connector can accept queries with SELECT DISTINCT
`boolean`	`supportsSelectExpression()`	Support indicates connector can accept expressions other than element symbols in the SELECT clause.
`boolean`	`supportsSelectExpressionArrayType()`
`boolean`	`supportsSelectWithoutFrom()`
`boolean`	`supportsSelfJoins()`	Support indicates connector can accept self-joins where a group is joined to itself with aliases.
`boolean`	`supportsSetQueryLimitOffset()`	Support indicates that the connector supports an LIMIT/OFFSET on a SetQuery.
`boolean`	`supportsSetQueryOrderBy()`	Support indicates that the connector supports an ORDER BY on a SetQuery.
`boolean`	`supportsSimilarTo()`
`boolean`	`supportsStringAgg()`
`boolean`	`supportsSubqueryCommonTableExpressions()`
`boolean`	`supportsSubqueryInOn()`	Refines subquery support.
`boolean`	`supportsUnions()`	Support indicates that the connector supports the UNION of two queries.
`boolean`	`supportsUpsert()`
`boolean`	`supportsWindowDistinctAggregates()`
`boolean`	`supportsWindowFrameClause()`
`boolean`	`supportsWindowFunctionCumeDist()`
`boolean`	`supportsWindowFunctionNthValue()`
`boolean`	`supportsWindowFunctionNtile()`
`boolean`	`supportsWindowFunctionPercentRank()`
`boolean`	`supportsWindowOrderByWithAggregates()`
`String`	`toString()`
`boolean`	`useAnsiJoin()`	Whether the source prefers to use ANSI style joins.
`boolean`	`useBindingsForDependentJoin()`	If dependent join predicates should use literals that are marked as bind eligible.

Methods inherited from class org.teiid.translator.ExecutionFactory
addPushDownFunction, createExecution, getConnection, getInstance, getMetadataProcessor, getNativeQueryProcedureName, setNativeQueryProcedureName, setSupportsNativeQueries, supportsNativeQueries

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

- Constructor Detail
  - BaseDelegatingExecutionFactory
```
public BaseDelegatingExecutionFactory()
```
- Method Detail
  - getDelegate
```
protected ExecutionFactory<F,C> getDelegate()
```
    For testing only
  - setDelegate
```
public void setDelegate(ExecutionFactory<F,C> delegate)
```
    Sets the delegate, will be called by Teiid after start()
    
    Specified by:
    
    setDelegate in interface DelegatingExecutionFactory<F,C>
  - getDelegateName
```
@TranslatorProperty(display="Delegate name",
                    required=true)
public String getDelegateName()
```
    Specified by:
    
    getDelegateName in interface DelegatingExecutionFactory<F,C>
  - setDelegateName
```
public void setDelegateName(String delegateName)
```
  - areLobsUsableAfterClose
```
public boolean areLobsUsableAfterClose()
```
    Description copied from class: ExecutionFactory
    
    Indicates if LOBs are usable after the execution is closed.
    
    Overrides:
    
    areLobsUsableAfterClose in class ExecutionFactory<F,C>
    
    Returns:
    
    true if LOBs can be used after close
  - closeConnection
```
public void closeConnection(C connection,
                            F factory)
```
    Description copied from class: ExecutionFactory
    
    Closes a connection object from the given connection factory. The default implementation assumes a JCA Connection. Subclasses should override, if they use another type of connection.
    
    Overrides:
    
    closeConnection in class ExecutionFactory<F,C>
  - createProcedureExecution
```
public ProcedureExecution createProcedureExecution(Call command,
                                                   ExecutionContext executionContext,
                                                   RuntimeMetadata metadata,
                                                   C connection)
                                            throws TranslatorException
```
    Overrides:
    
    createProcedureExecution in class ExecutionFactory<F,C>
    
    Throws:
    
    TranslatorException
  - createResultSetExecution
```
public ResultSetExecution createResultSetExecution(QueryExpression command,
                                                   ExecutionContext executionContext,
                                                   RuntimeMetadata metadata,
                                                   C connection)
                                            throws TranslatorException
```
    Overrides:
    
    createResultSetExecution in class ExecutionFactory<F,C>
    
    Throws:
    
    TranslatorException
  - createUpdateExecution
```
public UpdateExecution createUpdateExecution(Command command,
                                             ExecutionContext executionContext,
                                             RuntimeMetadata metadata,
                                             C connection)
                                      throws TranslatorException
```
    Overrides:
    
    createUpdateExecution in class ExecutionFactory<F,C>
    
    Throws:
    
    TranslatorException
  - getConnection
```
public C getConnection(F factory,
                       ExecutionContext executionContext)
                throws TranslatorException
```
    Description copied from class: ExecutionFactory
    
    Return a connection object from the given connection factory. The default implementation assumes a JCA ConnectionFactory. Subclasses should override, if they use another type of connection factory or wish to use the ExecutionContext. By default calls ExecutionFactory.getConnection(Object)
    
    Overrides:
    
    getConnection in class ExecutionFactory<F,C>
    
    executionContext - null if this is a system request for a connection
    
    Returns:
    
    a connection
    
    Throws:
    
    TranslatorException
  - getDefaultNullOrder
```
@TranslatorProperty(display="Default Null Order",
                    advanced=true)
public ExecutionFactory.NullOrder getDefaultNullOrder()
```
    Description copied from class: ExecutionFactory
    
    Returns the default null ordering
    
    Overrides:
    
    getDefaultNullOrder in class ExecutionFactory<F,C>
    
    Returns:
    
    the ExecutionFactory.NullOrder
  - setDefaultNullOrder
```
public void setDefaultNullOrder(ExecutionFactory.NullOrder nullOrder)
```
  - getLanguageFactory
```
public LanguageFactory getLanguageFactory()
```
    Description copied from class: ExecutionFactory
    
    Obtain a reference to the default LanguageFactory that can be used to construct new language interface objects. This is typically needed when modifying the language objects passed to the connector or for testing when objects need to be created.
    
    Overrides:
    
    getLanguageFactory in class ExecutionFactory<F,C>
  - getMaxFromGroups
```
@TranslatorProperty(display="Max FROM Allowed",
                    description="The number of groups supported in the from clause",
                    advanced=true)
public int getMaxFromGroups()
```
    Description copied from class: ExecutionFactory
    
    The number of groups supported in the from clause. Added for a Sybase limitation.
    
    Overrides:
    
    getMaxFromGroups in class ExecutionFactory<F,C>
    
    Returns:
    
    the number of groups supported in the from clause, or -1 if there is no limit
  - setMaxFromGroups
```
public void setMaxFromGroups(int value)
```
  - getMaxProjectedColumns
```
@TranslatorProperty(display="Max projected columns allowed",
                    description="The number of columns supported in projected select clause",
                    advanced=true)
public int getMaxProjectedColumns()
```
    Description copied from class: ExecutionFactory
    
    The number of columns supported in projected select clause. Added for a postgresql limitation.
    
    Overrides:
    
    getMaxProjectedColumns in class ExecutionFactory<F,C>
    
    Returns:
    
    the maximum number of columns in the projected select clause or -1 if there is no limit
  - setMaxProjectedColumns
```
public void setMaxProjectedColumns(int value)
```
  - getMetadata
```
public void getMetadata(MetadataFactory metadataFactory,
                        C conn)
                 throws TranslatorException
```
    Description copied from class: ExecutionFactory
    
    Implement to provide metadata to the metadata for use by the engine. This is the primary method of creating metadata for dynamic VDBs.
    
    Overrides:
    
    getMetadata in class ExecutionFactory<F,C>
    
    conn - may be null if the source is not required
    
    Throws:
    
    TranslatorException - to indicate a recoverable error, otherwise a RuntimeException
    
    See Also:
    
    ExecutionFactory.isSourceRequiredForMetadata()
  - getPushDownFunctions
```
public List<FunctionMethod> getPushDownFunctions()
```
    Description copied from class: ExecutionFactory
    
    Get a list of FunctionMethods that will be contributed to the SYS schema. To avoid conflicts with system functions, the function name should contain a qualifier - typically <translator name>.<function name>
    
    Overrides:
    
    getPushDownFunctions in class ExecutionFactory<F,C>
    
    Returns:
    
    See Also:
    
    ExecutionFactory.addPushDownFunction(String, String, String, String...)
  - getSupportedFunctions
```
public List<String> getSupportedFunctions()
```
    Description copied from class: ExecutionFactory
    
    Get list of all supported function names. Arithmetic functions have names like "+".
    
    Overrides:
    
    getSupportedFunctions in class ExecutionFactory<F,C>
    
    See Also:
    
    for a listing of system pushdown functions. Note that not all system functions are listed as some functions will use a common name such as CONCAT vs. the || operator, and other functions will be rewritten and not pushed down, such as SPACE. Note: User defined functions should be specified fully qualified.
  - getAddSupportedFunctions
```
@TranslatorProperty(display="Add Supported Functions(CSV)",
                    description="Add comma seperated names to system functions",
                    advanced=true)
public String getAddSupportedFunctions()
```
  - setAddSupportedFunctions
```
public void setAddSupportedFunctions(String functionNames)
```
  - getRemoveSupportedFunctions
```
@TranslatorProperty(display="Remove Supported Functions(CSV)",
                    description="Remove comma seperated names from system functions",
                    advanced=true)
public String getRemoveSupportedFunctions()
```
  - setRemoveSupportedFunctions
```
public void setRemoveSupportedFunctions(String functionNames)
```
  - getTypeFacility
```
public TypeFacility getTypeFacility()
```
    Description copied from class: ExecutionFactory
    
    Obtain a reference to the type facility, which can be used to perform many type conversions supplied by the Connector API.
    
    Overrides:
    
    getTypeFacility in class ExecutionFactory<F,C>
  - isImmutable
```
public boolean isImmutable()
```
    Description copied from class: ExecutionFactory
    
    Defines if the Connector is read-only connector
    
    Overrides:
    
    isImmutable in class ExecutionFactory<F,C>
    
    Returns:
  - setImmutable
```
public void setImmutable(boolean value)
```
    Overrides:
    
    setImmutable in class ExecutionFactory<F,C>
  - isSourceRequired
```
@TranslatorProperty(display="Is Source Required",
                    advanced=true)
public boolean isSourceRequired()
```
    Description copied from class: ExecutionFactory
    
    Flag that indicates if a underlying source connection required for this execution factory to work
    
    Overrides:
    
    isSourceRequired in class ExecutionFactory<F,C>
    
    Returns:
  - setSourceRequired
```
public void setSourceRequired(boolean value)
```
    Overrides:
    
    setSourceRequired in class ExecutionFactory<F,C>
  - supportsAggregatesAvg
```
@TranslatorProperty(display="Supports AVG()",
                    advanced=true)
public boolean supportsAggregatesAvg()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept the AVG aggregate function
    
    Overrides:
    
    supportsAggregatesAvg in class ExecutionFactory<F,C>
  - setSupportsAggregatesAvg
```
public void setSupportsAggregatesAvg(boolean value)
```
  - supportsAggregatesCount
```
@TranslatorProperty(display="Supports COUNT()",
                    advanced=true)
public boolean supportsAggregatesCount()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept the COUNT aggregate function
    
    Overrides:
    
    supportsAggregatesCount in class ExecutionFactory<F,C>
  - setSupportsAggregatesCount
```
public void setSupportsAggregatesCount(boolean value)
```
  - supportsAggregatesCountStar
```
@TranslatorProperty(display="Supports Count(*)",
                    advanced=true)
public boolean supportsAggregatesCountStar()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept the COUNT(*) aggregate function
    
    Overrides:
    
    supportsAggregatesCountStar in class ExecutionFactory<F,C>
  - setSupportsAggregatesCountStar
```
public void setSupportsAggregatesCountStar(boolean value)
```
  - supportsAggregatesDistinct
```
@TranslatorProperty(display="Supports DISTINCT",
                    advanced=true)
public boolean supportsAggregatesDistinct()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept DISTINCT within aggregate functions
    
    Overrides:
    
    supportsAggregatesDistinct in class ExecutionFactory<F,C>
  - setSupportsAggregatesDistinct
```
public void setSupportsAggregatesDistinct(boolean value)
```
  - supportsAggregatesEnhancedNumeric
```
@TranslatorProperty(display="Supports Aggegate Enhanced Numeric",
                    advanced=true)
public boolean supportsAggregatesEnhancedNumeric()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept STDDEV_POP, STDDEV_VAR, VAR_POP, VAR_SAMP
    
    Overrides:
    
    supportsAggregatesEnhancedNumeric in class ExecutionFactory<F,C>
  - setSupportsAggregatesEnhancedNumeric
```
public void setSupportsAggregatesEnhancedNumeric(boolean value)
```
  - supportsAggregatesMax
```
@TranslatorProperty(display="Supports MAX",
                    advanced=true)
public boolean supportsAggregatesMax()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept the MAX aggregate function
    
    Overrides:
    
    supportsAggregatesMax in class ExecutionFactory<F,C>
  - setSupportsAggregatesMax
```
public void setSupportsAggregatesMax(boolean value)
```
  - supportsAggregatesMin
```
@TranslatorProperty(display="Supports MIN",
                    advanced=true)
public boolean supportsAggregatesMin()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept the MIN aggregate function
    
    Overrides:
    
    supportsAggregatesMin in class ExecutionFactory<F,C>
  - setSupportsAggregatesMin
```
public void setSupportsAggregatesMin(boolean value)
```
  - supportsAggregatesSum
```
@TranslatorProperty(display="Supports SUM",
                    advanced=true)
public boolean supportsAggregatesSum()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept the SUM aggregate function
    
    Overrides:
    
    supportsAggregatesSum in class ExecutionFactory<F,C>
  - setSupportsAggregatesSum
```
public void setSupportsAggregatesSum(boolean value)
```
  - supportsAliasedTable
```
@TranslatorProperty(display="Supports Alias (ex: as A)",
                    advanced=true)
public boolean supportsAliasedTable()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept groups with aliases
    
    Overrides:
    
    supportsAliasedTable in class ExecutionFactory<F,C>
  - setSupportsAliasedTable
```
public void setSupportsAliasedTable(boolean value)
```
  - supportsBatchedUpdates
```
@TranslatorProperty(display="Supports Batched Updates",
                    advanced=true)
public boolean supportsBatchedUpdates()
```
    Description copied from class: ExecutionFactory
    
    Whether the source supports BatchedUpdates
    
    Overrides:
    
    supportsBatchedUpdates in class ExecutionFactory<F,C>
  - setSupportsBatchedUpdates
```
public void setSupportsBatchedUpdates(boolean value)
```
  - supportsBulkUpdate
```
@TranslatorProperty(display="Supports Bulk Updates",
                    advanced=true)
public boolean supportsBulkUpdate()
```
    Description copied from class: ExecutionFactory
    
    Whether the source supports updates with multiple value sets
    
    Overrides:
    
    supportsBulkUpdate in class ExecutionFactory<F,C>
  - setSupportsBulkUpdate
```
public void setSupportsBulkUpdate(boolean value)
```
  - supportsCommonTableExpressions
```
@TranslatorProperty(display="Supports Common Table Expressions",
                    advanced=true)
public boolean supportsCommonTableExpressions()
```
    Overrides:
    
    supportsCommonTableExpressions in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the WITH clause is supported
  - setSupportsCommonTableExpressions
```
public void setSupportsCommonTableExpressions(boolean value)
```
  - supportsCompareCriteriaEquals
```
@TranslatorProperty(display="Supports Compare Criteria Equals",
                    advanced=true)
public boolean supportsCompareCriteriaEquals()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts criteria of form (element = constant)
    
    Overrides:
    
    supportsCompareCriteriaEquals in class ExecutionFactory<F,C>
  - setSupportsCompareCriteriaEquals
```
public void setSupportsCompareCriteriaEquals(boolean value)
```
  - supportsCompareCriteriaOrdered
```
@TranslatorProperty(display="Supports Compare Criteria Ordered",
                    advanced=true)
public boolean supportsCompareCriteriaOrdered()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts criteria of form (element <=|>= constant)
    The query engine will may pushdown queries containing < or > if NOT is also supported.
    
    Overrides:
    
    supportsCompareCriteriaOrdered in class ExecutionFactory<F,C>
  - setSupportsCompareCriteriaOrdered
```
public void setSupportsCompareCriteriaOrdered(boolean value)
```
  - supportsCorrelatedSubqueries
```
@TranslatorProperty(display="Supports Correlated Subqueries",
                    advanced=true)
public boolean supportsCorrelatedSubqueries()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept correlated subqueries wherever subqueries are accepted
    
    Overrides:
    
    supportsCorrelatedSubqueries in class ExecutionFactory<F,C>
  - setSupportsCorrelatedSubqueries
```
public void setSupportsCorrelatedSubqueries(boolean value)
```
  - supportsExcept
```
@TranslatorProperty(display="Supports EXCEPT",
                    advanced=true)
public boolean supportsExcept()
```
    Description copied from class: ExecutionFactory
    
    Support indicates that the connector supports the EXCEPT of two queries.
    
    Overrides:
    
    supportsExcept in class ExecutionFactory<F,C>
  - setSupportsExcept
```
public void setSupportsExcept(boolean value)
```
  - supportsExistsCriteria
```
@TranslatorProperty(display="Supports EXISTS",
                    advanced=true)
public boolean supportsExistsCriteria()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts the EXISTS criteria
    
    Overrides:
    
    supportsExistsCriteria in class ExecutionFactory<F,C>
  - setSupportsExistsCriteria
```
public void setSupportsExistsCriteria(boolean value)
```
  - supportsFunctionsInGroupBy
```
@TranslatorProperty(display="Supports Functions in GROUP BY",
                    advanced=true)
public boolean supportsFunctionsInGroupBy()
```
    Description copied from class: ExecutionFactory
    
    Support indicates that the connector supports non-column expressions in GROUP BY, such as: SELECT dayofmonth(theDate), COUNT(*) FROM table GROUP BY dayofmonth(theDate)
    
    Overrides:
    
    supportsFunctionsInGroupBy in class ExecutionFactory<F,C>
  - setSupportsFunctionsInGroupBy
```
public void setSupportsFunctionsInGroupBy(boolean value)
```
  - supportsGroupBy
```
@TranslatorProperty(display="Supports GROUP BY",
                    advanced=true)
public boolean supportsGroupBy()
```
    Description copied from class: ExecutionFactory
    
    Whether the source supports an explicit GROUP BY clause
    
    Overrides:
    
    supportsGroupBy in class ExecutionFactory<F,C>
  - setSupportsGroupBy
```
public void setSupportsGroupBy(boolean value)
```
  - supportsHaving
```
@TranslatorProperty(display="Supports HAVING",
                    advanced=true)
public boolean supportsHaving()
```
    Description copied from class: ExecutionFactory
    
    Whether the source supports the HAVING clause
    
    Overrides:
    
    supportsHaving in class ExecutionFactory<F,C>
  - setSupportsHaving
```
public void setSupportsHaving(boolean value)
```
  - supportsInCriteria
```
@TranslatorProperty(display="Supports IN",
                    advanced=true)
public boolean supportsInCriteria()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts criteria of form (element IN set)
    
    Overrides:
    
    supportsInCriteria in class ExecutionFactory<F,C>
  - setSupportsInCriteria
```
public void setSupportsInCriteria(boolean value)
```
  - supportsInCriteriaSubquery
```
@TranslatorProperty(display="Supports IN in Subquery",
                    advanced=true)
public boolean supportsInCriteriaSubquery()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts IN criteria with a subquery on the right side
    
    Overrides:
    
    supportsInCriteriaSubquery in class ExecutionFactory<F,C>
  - setSupportsInCriteriaSubquery
```
public void setSupportsInCriteriaSubquery(boolean value)
```
  - supportsInlineViews
```
@TranslatorProperty(display="Supports Inline Views",
                    advanced=true)
public boolean supportsInlineViews()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept inline views (subqueries in the FROM clause).
    
    Overrides:
    
    supportsInlineViews in class ExecutionFactory<F,C>
  - setSupportsInlineViews
```
public void setSupportsInlineViews(boolean value)
```
  - supportsInsertWithQueryExpression
```
@TranslatorProperty(display="Supports INSERT with Query Expression",
                    advanced=true)
public boolean supportsInsertWithQueryExpression()
```
    Description copied from class: ExecutionFactory
    
    Support indicates that the connector can accept INSERTs with values specified by a SetQuery or Select
    
    Overrides:
    
    supportsInsertWithQueryExpression in class ExecutionFactory<F,C>
  - setSupportsInsertWithQueryExpression
```
public void setSupportsInsertWithQueryExpression(boolean value)
```
  - supportsIntersect
```
@TranslatorProperty(display="Supports INTERSECT",
                    advanced=true)
public boolean supportsIntersect()
```
    Description copied from class: ExecutionFactory
    
    Support indicates that the connector supports the INTERSECT of two queries.
    
    Overrides:
    
    supportsIntersect in class ExecutionFactory<F,C>
  - setSupportsIntersect
```
public void setSupportsIntersect(boolean value)
```
  - supportsIsNullCriteria
```
@TranslatorProperty(display="Supports ISNULL",
                    advanced=true)
public boolean supportsIsNullCriteria()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts criteria of form (element IS NULL)
    
    Overrides:
    
    supportsIsNullCriteria in class ExecutionFactory<F,C>
  - setSupportsIsNullCriteria
```
public void setSupportsIsNullCriteria(boolean value)
```
  - supportsLikeCriteria
```
@TranslatorProperty(display="Supports LIKE",
                    advanced=true)
public boolean supportsLikeCriteria()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts criteria of form (element LIKE constant)
    
    Overrides:
    
    supportsLikeCriteria in class ExecutionFactory<F,C>
  - setSupportsLikeCriteria
```
public void setSupportsLikeCriteria(boolean value)
```
  - supportsLikeCriteriaEscapeCharacter
```
@TranslatorProperty(display="Supports Escape Char in LIKE",
                    advanced=true)
public boolean supportsLikeCriteriaEscapeCharacter()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts criteria of form (element LIKE constant ESCAPE char)
    
    Overrides:
    
    supportsLikeCriteriaEscapeCharacter in class ExecutionFactory<F,C>
  - setSupportsLikeCriteriaEscapeCharacter
```
public void setSupportsLikeCriteriaEscapeCharacter(boolean value)
```
  - supportsNotCriteria
```
@TranslatorProperty(display="Supports NOT",
                    advanced=true)
public boolean supportsNotCriteria()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts logical criteria NOT
    
    Overrides:
    
    supportsNotCriteria in class ExecutionFactory<F,C>
  - setSupportsNotCriteria
```
public void setSupportsNotCriteria(boolean value)
```
  - supportsOrCriteria
```
@TranslatorProperty(display="Supports OR",
                    advanced=true)
public boolean supportsOrCriteria()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts logical criteria connected by OR
    
    Overrides:
    
    supportsOrCriteria in class ExecutionFactory<F,C>
  - setSupportsOrCriteria
```
public void setSupportsOrCriteria(boolean value)
```
  - supportsOrderByNullOrdering
```
@TranslatorProperty(display="Supports ORDER BY col NULLS [FIRST|LAST|HIGH|LOW]",
                    advanced=true)
public boolean supportsOrderByNullOrdering()
```
    Description copied from class: ExecutionFactory
    
    Returns whether the database supports explicit null ordering.
    
    Overrides:
    
    supportsOrderByNullOrdering in class ExecutionFactory<F,C>
    
    Returns:
    
    true if nulls first/last can be specified
  - setSupportsOrderByNullOrdering
```
public void setSupportsOrderByNullOrdering(boolean value)
```
  - supportsOrderByUnrelated
```
@TranslatorProperty(display="Supports ORDER BY Unrelated",
                    advanced=true)
public boolean supportsOrderByUnrelated()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts ORDER BY clause with columns not from the select
    
    Overrides:
    
    supportsOrderByUnrelated in class ExecutionFactory<F,C>
    
    Returns:
  - setSupportsOrderByUnrelated
```
public void setSupportsOrderByUnrelated(boolean value)
```
  - supportsQuantifiedCompareCriteriaAll
```
@TranslatorProperty(display="Supports ALL",
                    advanced=true)
public boolean supportsQuantifiedCompareCriteriaAll()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts the quantified comparison criteria that use ALL
    
    Overrides:
    
    supportsQuantifiedCompareCriteriaAll in class ExecutionFactory<F,C>
  - setSupportsQuantifiedCompareCriteriaAll
```
public void setSupportsQuantifiedCompareCriteriaAll(boolean value)
```
  - supportsQuantifiedCompareCriteriaSome
```
@TranslatorProperty(display="Supports SOME",
                    advanced=true)
public boolean supportsQuantifiedCompareCriteriaSome()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts the quantified comparison criteria that use SOME
    
    Overrides:
    
    supportsQuantifiedCompareCriteriaSome in class ExecutionFactory<F,C>
  - setSupportsQuantifiedCompareCriteriaSome
```
public void setSupportsQuantifiedCompareCriteriaSome(boolean value)
```
  - supportsRowLimit
```
@TranslatorProperty(display="Supports LIMIT",
                    advanced=true)
public boolean supportsRowLimit()
```
    Description copied from class: ExecutionFactory
    
    Gets whether the connector can limit the number of rows returned by a query.
    
    Overrides:
    
    supportsRowLimit in class ExecutionFactory<F,C>
  - setSupportsRowLimit
```
public void setSupportsRowLimit(boolean value)
```
  - supportsRowOffset
```
@TranslatorProperty(display="Supports LIMIT OFFSET",
                    advanced=true)
public boolean supportsRowOffset()
```
    Description copied from class: ExecutionFactory
    
    Gets whether the connector supports a SQL clause (similar to the LIMIT with an offset) that can return result sets that start in the middle of the resulting rows returned by a query
    
    Overrides:
    
    supportsRowOffset in class ExecutionFactory<F,C>
  - setSupportsRowOffset
```
public void setSupportsRowOffset(boolean value)
```
  - supportsScalarSubqueries
```
@TranslatorProperty(display="Supports Scalar Sub-Queries",
                    advanced=true)
public boolean supportsScalarSubqueries()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept scalar subqueries in the SELECT, WHERE, and HAVING clauses
    
    Overrides:
    
    supportsScalarSubqueries in class ExecutionFactory<F,C>
  - setSupportsScalarSubqueries
```
public void setSupportsScalarSubqueries(boolean value)
```
  - supportsSearchedCaseExpressions
```
@TranslatorProperty(display="Supports CASE Expression",
                    advanced=true)
public boolean supportsSearchedCaseExpressions()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept queries with searched CASE WHEN criteria ... END
    
    Overrides:
    
    supportsSearchedCaseExpressions in class ExecutionFactory<F,C>
  - setSupportsSearchedCaseExpressions
```
public void setSupportsSearchedCaseExpressions(boolean value)
```
  - supportsSelectExpression
```
@TranslatorProperty(display="Supports SELECT expressions",
                    advanced=true)
public boolean supportsSelectExpression()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept expressions other than element symbols in the SELECT clause. Specific supports for the expression type are still checked.
    
    Overrides:
    
    supportsSelectExpression in class ExecutionFactory<F,C>
  - setSupportsSelectExpression
```
public void setSupportsSelectExpression(boolean value)
```
  - supportsSelfJoins
```
@TranslatorProperty(display="Supports Self JOINS",
                    advanced=true)
public boolean supportsSelfJoins()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept self-joins where a group is joined to itself with aliases. Connector must also support ExecutionFactory.supportsAliasedTable().
    
    Overrides:
    
    supportsSelfJoins in class ExecutionFactory<F,C>
  - setSupportsSelfJoins
```
public void setSupportsSelfJoins(boolean value)
```
  - supportsSetQueryOrderBy
```
@TranslatorProperty(display="Supports Set Query Orderby",
                    advanced=true)
public boolean supportsSetQueryOrderBy()
```
    Description copied from class: ExecutionFactory
    
    Support indicates that the connector supports an ORDER BY on a SetQuery.
    
    Overrides:
    
    supportsSetQueryOrderBy in class ExecutionFactory<F,C>
  - setSupportsSetQueryOrderBy
```
public void setSupportsSetQueryOrderBy(boolean value)
```
  - supportsUnions
```
@TranslatorProperty(display="Supports UNION",
                    advanced=true)
public boolean supportsUnions()
```
    Description copied from class: ExecutionFactory
    
    Support indicates that the connector supports the UNION of two queries.
    
    Overrides:
    
    supportsUnions in class ExecutionFactory<F,C>
  - setSupportsUnions
```
public void setSupportsUnions(boolean value)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - useAnsiJoin
```
@TranslatorProperty(display="Supports ANSI Joins",
                    advanced=true)
public boolean useAnsiJoin()
```
    Description copied from class: ExecutionFactory
    
    Whether the source prefers to use ANSI style joins.
    
    Overrides:
    
    useAnsiJoin in class ExecutionFactory<F,C>
  - setUseAnsiJoin
```
public void setUseAnsiJoin(boolean value)
```
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - isCopyLobs
```
@TranslatorProperty(display="Supports Copy LOBS",
                    advanced=true)
public boolean isCopyLobs()
```
    Overrides:
    
    isCopyLobs in class ExecutionFactory<F,C>
  - setCopyLobs
```
public void setCopyLobs(boolean value)
```
    Overrides:
    
    setCopyLobs in class ExecutionFactory<F,C>
  - supportsArrayAgg
```
@TranslatorProperty(display="Supports Array Aggregation",
                    advanced=true)
public boolean supportsArrayAgg()
```
    Overrides:
    
    supportsArrayAgg in class ExecutionFactory<F,C>
    
    Returns:
    
    true if array_agg is supported
  - setSupportsArrayAgg
```
public void setSupportsArrayAgg(boolean value)
```
  - supportsElementaryOlapOperations
```
@TranslatorProperty(display="Supports OLAP Operations",
                    advanced=true)
public boolean supportsElementaryOlapOperations()
```
    Overrides:
    
    supportsElementaryOlapOperations in class ExecutionFactory<F,C>
    
    Returns:
    
    true if Elementary OLAP operations are supported including window functions and inline window specifications that include simple expressions in partitioning and ordering
  - setSupportsElementaryOlapOperations
```
public void setSupportsElementaryOlapOperations(boolean value)
```
  - supportsWindowFrameClause
```
@TranslatorProperty(display="Supports Window Frame Clause on a Window Function",
                    advanced=true)
public boolean supportsWindowFrameClause()
```
    Overrides:
    
    supportsWindowFrameClause in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the window frame clause is supported
  - setSupportsWindowFrameClause
```
public void setSupportsWindowFrameClause(boolean value)
```
  - supportsFormatLiteral
```
public boolean supportsFormatLiteral(String literal,
                                     ExecutionFactory.Format format)
```
    Overrides:
    
    supportsFormatLiteral in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the given Java format string is supported
  - supportsLikeRegex
```
@TranslatorProperty(display="Supports REGEX in LIKE",
                    advanced=true)
public boolean supportsLikeRegex()
```
    Overrides:
    
    supportsLikeRegex in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the LIKE_REGEX predicate is supported
  - setSupportsLikeRegex
```
public void setSupportsLikeRegex(boolean value)
```
  - supportsOnlyFormatLiterals
```
@TranslatorProperty(display="Supports only Format Literals",
                    advanced=true)
public boolean supportsOnlyFormatLiterals()
```
    Description copied from class: ExecutionFactory
    
    See also ExecutionFactory.supportsFormatLiteral(String, Format)
    
    Overrides:
    
    supportsOnlyFormatLiterals in class ExecutionFactory<F,C>
    
    Returns:
    
    true if only literal formats are supports.
  - setSupportsOnlyFormatLiterals
```
public void setSupportsOnlyFormatLiterals(boolean value)
```
  - supportsOnlySingleTableGroupBy
```
@TranslatorProperty(display="Supports Single Table GROUP BY",
                    advanced=true)
public boolean supportsOnlySingleTableGroupBy()
```
    Description copied from class: ExecutionFactory
    
    Whether the source supports grouping only over a single table
    
    Overrides:
    
    supportsOnlySingleTableGroupBy in class ExecutionFactory<F,C>
    
    Returns:
  - setSupportsOnlySingleTableGroupBy
```
public void setSupportsOnlySingleTableGroupBy(boolean value)
```
  - supportsSimilarTo
```
@TranslatorProperty(display="Supports SIMILAR TO",
                    advanced=true)
public boolean supportsSimilarTo()
```
    Overrides:
    
    supportsSimilarTo in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the SIMILAR TO predicate is supported
  - setSupportsSimilarTo
```
public void setSupportsSimilarTo(boolean value)
```
  - supportsWindowDistinctAggregates
```
@TranslatorProperty(display="Supports Windowed Aggregates",
                    advanced=true)
public boolean supportsWindowDistinctAggregates()
```
    Overrides:
    
    supportsWindowDistinctAggregates in class ExecutionFactory<F,C>
    
    Returns:
    
    true if distinct aggregates can be windowed function.
  - setSupportsWindowDistinctAggregates
```
public void setSupportsWindowDistinctAggregates(boolean value)
```
  - supportsWindowOrderByWithAggregates
```
@TranslatorProperty(display="Supports Order by With Windowed Aggregates",
                    advanced=true)
public boolean supportsWindowOrderByWithAggregates()
```
    Overrides:
    
    supportsWindowOrderByWithAggregates in class ExecutionFactory<F,C>
    
    Returns:
    
    true if all aggregates can have window function order by clauses.
  - setSupportsWindowOrderByWithAggregates
```
public void setSupportsWindowOrderByWithAggregates(boolean value)
```
  - getMaxInCriteriaSize
```
public int getMaxInCriteriaSize()
```
    Description copied from class: ExecutionFactory
    
    Get the integer value representing the number of values allowed in an IN criteria in the WHERE clause of a query
    
    Overrides:
    
    getMaxInCriteriaSize in class ExecutionFactory<F,C>
  - setMaxInCriteriaSize
```
public void setMaxInCriteriaSize(int max)
```
    Overrides:
    
    setMaxInCriteriaSize in class ExecutionFactory<F,C>
  - getSupportedJoinCriteria
```
public ExecutionFactory.SupportedJoinCriteria getSupportedJoinCriteria()
```
    Description copied from class: ExecutionFactory
    
    Get the supported join criteria. A null return value will be treated as ExecutionFactory.SupportedJoinCriteria.ANY
    
    Overrides:
    
    getSupportedJoinCriteria in class ExecutionFactory<F,C>
  - setSupportedJoinCriteria
```
public void setSupportedJoinCriteria(ExecutionFactory.SupportedJoinCriteria value)
```
    Overrides:
    
    setSupportedJoinCriteria in class ExecutionFactory<F,C>
  - requiresCriteria
```
public boolean requiresCriteria()
```
    Description copied from class: ExecutionFactory
    
    Whether the source supports queries without criteria.
    
    Overrides:
    
    requiresCriteria in class ExecutionFactory<F,C>
  - setRequiresCriteria
```
public void setRequiresCriteria(boolean value)
```
    Overrides:
    
    setRequiresCriteria in class ExecutionFactory<F,C>
  - supportsFullOuterJoins
```
public boolean supportsFullOuterJoins()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept full outer joins
    
    Overrides:
    
    supportsFullOuterJoins in class ExecutionFactory<F,C>
  - setSupportsFullOuterJoins
```
public void setSupportsFullOuterJoins(boolean supportsFullOuterJoins)
```
    Overrides:
    
    setSupportsFullOuterJoins in class ExecutionFactory<F,C>
  - supportsInnerJoins
```
public boolean supportsInnerJoins()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept inner or cross joins
    
    Overrides:
    
    supportsInnerJoins in class ExecutionFactory<F,C>
  - setSupportsInnerJoins
```
public void setSupportsInnerJoins(boolean supportsInnerJoins)
```
    Overrides:
    
    setSupportsInnerJoins in class ExecutionFactory<F,C>
  - supportsOrderBy
```
public boolean supportsOrderBy()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts ORDER BY clause, including multiple elements and ascending and descending sorts.
    
    Overrides:
    
    supportsOrderBy in class ExecutionFactory<F,C>
  - setSupportsOrderBy
```
public void setSupportsOrderBy(boolean supportsOrderBy)
```
    Overrides:
    
    setSupportsOrderBy in class ExecutionFactory<F,C>
  - supportsOuterJoins
```
public boolean supportsOuterJoins()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept left outer joins
    
    Overrides:
    
    supportsOuterJoins in class ExecutionFactory<F,C>
  - setSupportsOuterJoins
```
public void setSupportsOuterJoins(boolean supportsOuterJoins)
```
    Overrides:
    
    setSupportsOuterJoins in class ExecutionFactory<F,C>
  - supportsSelectDistinct
```
public boolean supportsSelectDistinct()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector can accept queries with SELECT DISTINCT
    
    Overrides:
    
    supportsSelectDistinct in class ExecutionFactory<F,C>
  - setSupportsSelectDistinct
```
public void setSupportsSelectDistinct(boolean supportsSelectDistinct)
```
    Overrides:
    
    setSupportsSelectDistinct in class ExecutionFactory<F,C>
  - getMaxDependentInPredicates
```
public int getMaxDependentInPredicates()
```
    Description copied from class: ExecutionFactory
    
    Get the integer value representing the max number of dependent IN predicates. This may be used to split a single dependent value via OR, or multiple dependent values via AND.
    
    Overrides:
    
    getMaxDependentInPredicates in class ExecutionFactory<F,C>
  - setMaxDependentInPredicates
```
public void setMaxDependentInPredicates(int maxDependentInPredicates)
```
    Overrides:
    
    setMaxDependentInPredicates in class ExecutionFactory<F,C>
  - supportsAdvancedOlapOperations
```
@TranslatorProperty(display="Supports Advanced OLAP Operations",
                    advanced=true)
public boolean supportsAdvancedOlapOperations()
```
    Overrides:
    
    supportsAdvancedOlapOperations in class ExecutionFactory<F,C>
    
    Returns:
    
    true if Advanced OLAP operations are supported including the aggregate function filter clause.
  - setSupportsAdvancedOlapOperations
```
public void setSupportsAdvancedOlapOperations(boolean value)
```
  - supportsSubqueryInOn
```
@TranslatorProperty(display="Supports Subquery In ON",
                    advanced=true)
public boolean supportsSubqueryInOn()
```
    Description copied from class: ExecutionFactory
    
    Refines subquery support.
    
    Overrides:
    
    supportsSubqueryInOn in class ExecutionFactory<F,C>
    
    Returns:
    
    true if subqueries are supported in the on clause.
  - setSupportsSubqueryInOn
```
public void setSupportsSubqueryInOn(boolean value)
```
  - supportsConvert
```
public boolean supportsConvert(int fromType,
                               int toType)
```
    Description copied from class: ExecutionFactory
    
    Used for fine grained control of convert/cast pushdown. The ExecutionFactory.getSupportedFunctions() should contain SourceSystemFunctions.CONVERT. This method can then return false to indicate a lack of specific support. The engine will does not care about an unnecessary conversion where fromType == toType. By default lob conversion is disabled.
    
    Overrides:
    
    supportsConvert in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the given conversion is supported.
    
    See Also:
    
    TypeFacility.RUNTIME_CODES, TypeFacility.RUNTIME_CODES
  - supportsDependentJoins
```
@TranslatorProperty(display="Supports Dependent Joins",
                    advanced=true)
public boolean supportsDependentJoins()
```
    Description copied from class: ExecutionFactory
    
    NOTE: The pushed independent tuples will not have been converted to a unique set and may contain duplicates.
    
    Overrides:
    
    supportsDependentJoins in class ExecutionFactory<F,C>
    
    Returns:
    
    true if dependent join key pushdown is supported
  - setSupportsDependentJoins
```
public void setSupportsDependentJoins(boolean value)
```
  - supportsOnlyLiteralComparison
```
@TranslatorProperty(display="Supports Only Literal Comparision",
                    advanced=true)
public boolean supportsOnlyLiteralComparison()
```
    Overrides:
    
    supportsOnlyLiteralComparison in class ExecutionFactory<F,C>
    
    Returns:
    
    true if only Literal comparisons (equality, ordered, like, etc.) are supported for non-join conditions.
  - setSupportsOnlyLiteralComparison
```
public void setSupportsOnlyLiteralComparison(boolean value)
```
  - getCacheDirective
```
public CacheDirective getCacheDirective(Command command,
                                        ExecutionContext executionContext,
                                        RuntimeMetadata metadata)
                                 throws TranslatorException
```
    Description copied from class: ExecutionFactory
    
    Get the CacheDirective to control command caching.
    Use CacheDirective.Scope.NONE to indicate to the engine that no caching should be performed by the engine.
    If cache parameters on the CacheDirective will be changed by the Execution, then a new instance of a CacheDirective should be set each time.
    
    Overrides:
    
    getCacheDirective in class ExecutionFactory<F,C>
    
    Throws:
    
    TranslatorException
  - isSourceRequiredForMetadata
```
@TranslatorProperty(display="Is Source Required For Metadata",
                    advanced=true)
public boolean isSourceRequiredForMetadata()
```
    Description copied from class: ExecutionFactory
    
    Flag that indicates if a underlying source connection required for this execution factory to return metadata
    
    Overrides:
    
    isSourceRequiredForMetadata in class ExecutionFactory<F,C>
    
    Returns:
    
    true if required
  - setSourceRequiredForMetadata
```
public void setSourceRequiredForMetadata(boolean value)
```
    Overrides:
    
    setSourceRequiredForMetadata in class ExecutionFactory<F,C>
  - isForkable
```
@TranslatorProperty(display="Is Forkable",
                    description="When forkable the engine may use a separate thread to interact with returned Exection",
                    advanced=true)
public boolean isForkable()
```
    Description copied from class: ExecutionFactory
    
    When forkable the engine may use a separate thread to interact with returned Execution.
    
    Overrides:
    
    isForkable in class ExecutionFactory<F,C>
    
    Returns:
    
    true if Executions can be called in separate threads from the processing thread
  - setForkable
```
public void setForkable(boolean value)
```
  - supportsArrayType
```
@TranslatorProperty(display="Supports Array Type",
                    advanced=true)
public boolean supportsArrayType()
```
    Description copied from class: ExecutionFactory
    
    The engine uses array types for dependent joins and for array expression.
    
    Overrides:
    
    supportsArrayType in class ExecutionFactory<F,C>
    
    Returns:
    
    true if an array type is supported.
  - setSupportsArrayType
```
public void setSupportsArrayType(boolean value)
```
  - getDirectQueryProcedureName
```
@TranslatorProperty(display="Direct Query Procedure Name",
                    advanced=true)
public String getDirectQueryProcedureName()
```
    Description copied from class: ExecutionFactory
    
    Defines the name of the direct processing procedure. This metadata or signature of the procedure is defined automatically.
    
    Overrides:
    
    getDirectQueryProcedureName in class ExecutionFactory<F,C>
    
    Returns:
  - setDirectQueryProcedureName
```
public void setDirectQueryProcedureName(String name)
```
    Overrides:
    
    setDirectQueryProcedureName in class ExecutionFactory<F,C>
  - supportsDirectQueryProcedure
```
public boolean supportsDirectQueryProcedure()
```
    Description copied from class: ExecutionFactory
    
    True, if this translator supports execution of source specific commands unaltered through a direct procedure.
    
    Overrides:
    
    supportsDirectQueryProcedure in class ExecutionFactory<F,C>
    
    Returns:
  - setSupportsDirectQueryProcedure
```
public void setSupportsDirectQueryProcedure(boolean value)
```
    Overrides:
    
    setSupportsDirectQueryProcedure in class ExecutionFactory<F,C>
  - createDirectExecution
```
public ProcedureExecution createDirectExecution(List<Argument> arguments,
                                                Command command,
                                                ExecutionContext executionContext,
                                                RuntimeMetadata metadata,
                                                C connection)
                                         throws TranslatorException
```
    Overrides:
    
    createDirectExecution in class ExecutionFactory<F,C>
    
    Throws:
    
    TranslatorException
  - supportsOnlyCorrelatedSubqueries
```
@TranslatorProperty(display="Supports Correlated Sub Queries",
                    advanced=true)
public boolean supportsOnlyCorrelatedSubqueries()
```
    Overrides:
    
    supportsOnlyCorrelatedSubqueries in class ExecutionFactory<F,C>
    
    Returns:
    
    true if only correlated subqueries are supported.
  - setSupportsOnlyCorrelatedSubqueries
```
public void setSupportsOnlyCorrelatedSubqueries(boolean value)
```
  - isSourceRequiredForCapabilities
```
@TranslatorProperty(display="Source required for Capabilities",
                    advanced=true)
public boolean isSourceRequiredForCapabilities()
```
    Description copied from class: ExecutionFactory
    
    If true, the ExecutionFactory.initCapabilities(Object) method will be consulted prior to determining the capabilities
    
    Overrides:
    
    isSourceRequiredForCapabilities in class ExecutionFactory<F,C>
    
    Returns:
  - setSourceRequiredForCapabilities
```
public void setSourceRequiredForCapabilities(boolean value)
```
  - initCapabilities
```
public void initCapabilities(C connection)
                      throws TranslatorException
```
    Description copied from class: ExecutionFactory
    
    Will be called by ExecutionFactory.start() with a null connection if a source connection is not ExecutionFactory.isSourceRequiredForCapabilities()
    
    Overrides:
    
    initCapabilities in class ExecutionFactory<F,C>
    
    Throws:
    
    TranslatorException
  - supportsStringAgg
```
@TranslatorProperty(display="Supports STRING_AGG",
                    advanced=true)
public boolean supportsStringAgg()
```
    Overrides:
    
    supportsStringAgg in class ExecutionFactory<F,C>
    
    Returns:
    
    true if string_agg is supported
  - setSupportsStringAgg
```
public void setSupportsStringAgg(boolean value)
```
  - supportsListAgg
```
@TranslatorProperty(display="Supports LISTAGG",
                    advanced=true)
public boolean supportsListAgg()
```
    Overrides:
    
    supportsListAgg in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the translator supports a simplified string_agg - listagg
  - setSupportsListAgg
```
public void setSupportsListAgg(boolean value)
```
  - supportsFullDependentJoins
```
@TranslatorProperty(display="Supports Full Dependent Joins",
                    advanced=true)
public boolean supportsFullDependentJoins()
```
    Overrides:
    
    supportsFullDependentJoins in class ExecutionFactory<F,C>
    
    Returns:
    
    true if full dependent join pushdown is supported
  - setSupportsFullDependentJoins
```
public void setSupportsFullDependentJoins(boolean value)
```
  - supportsSelectWithoutFrom
```
@TranslatorProperty(display="Supports SELECT w/o FROM",
                    advanced=true)
public boolean supportsSelectWithoutFrom()
```
    Overrides:
    
    supportsSelectWithoutFrom in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the translator support SELECT without a FROM clause
  - setSupportsSelectWithoutFrom
```
public void setSupportsSelectWithoutFrom(boolean value)
```
  - supportsGroupByRollup
```
@TranslatorProperty(display="Supports GROUP BY ROLLUP",
                    advanced=true)
public boolean supportsGroupByRollup()
```
    Overrides:
    
    supportsGroupByRollup in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the translator support GROUP BY ROLLUP
  - setSupportsGroupByRollup
```
public void setSupportsGroupByRollup(boolean value)
```
  - supportsOrderByWithExtendedGrouping
```
@TranslatorProperty(display="Supports Orderby w/extended grouping",
                    advanced=true)
public boolean supportsOrderByWithExtendedGrouping()
```
    Overrides:
    
    supportsOrderByWithExtendedGrouping in class ExecutionFactory<F,C>
    
    Returns:
    
    true if order by is supported over a grouping with a rollup, cube, etc.
  - setSupportsOrderByWithExtendedGrouping
```
public void setSupportsOrderByWithExtendedGrouping(boolean value)
```
  - isThreadBound
```
public boolean isThreadBound()
```
    Overrides:
    
    isThreadBound in class ExecutionFactory<F,C>
    
    Returns:
    
    True, if this translator's executions must complete in a single thread.
  - setThreadBound
```
public void setThreadBound(boolean value)
```
    Overrides:
    
    setThreadBound in class ExecutionFactory<F,C>
  - getCollationLocale
```
public String getCollationLocale()
```
    Description copied from class: ExecutionFactory
    
    Indicates the collation used for sorting
    
    Overrides:
    
    getCollationLocale in class ExecutionFactory<F,C>
  - setCollationLocale
```
public void setCollationLocale(String value)
```
    Overrides:
    
    setCollationLocale in class ExecutionFactory<F,C>
  - supportsRecursiveCommonTableExpressions
```
@TranslatorProperty(display="Supports Recursive Common Table Expresions",
                    advanced=true)
public boolean supportsRecursiveCommonTableExpressions()
```
    Overrides:
    
    supportsRecursiveCommonTableExpressions in class ExecutionFactory<F,C>
    
    Returns:
    
    true if a recursive WITH clause item is supported
  - setSupportsRecursiveCommonTableExpressions
```
public void setSupportsRecursiveCommonTableExpressions(boolean value)
```
  - supportsCompareCriteriaOrderedExclusive
```
@TranslatorProperty(display="Supports Criteria Ordered Exclusive",
                    advanced=true)
public boolean supportsCompareCriteriaOrderedExclusive()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts criteria of form (element <|> constant)
    
    Overrides:
    
    supportsCompareCriteriaOrderedExclusive in class ExecutionFactory<F,C>
  - supportsCompareCriteriaOrderedExclusive
```
@Deprecated
public void supportsCompareCriteriaOrderedExclusive(boolean value)
```
    Deprecated.
  - setSupportsCompareCriteriaOrderedExclusive
```
public void setSupportsCompareCriteriaOrderedExclusive(boolean value)
```
  - returnsSingleUpdateCount
```
public boolean returnsSingleUpdateCount()
```
    Description copied from class: ExecutionFactory
    
    True if only a single value is returned for the update count. This overrides the default expectation of an update count array for bulk/batch commands. It is expected that every command is successful.
    
    Overrides:
    
    returnsSingleUpdateCount in class ExecutionFactory<F,C>
    
    Returns:
  - supportsPartialFiltering
```
@TranslatorProperty(display="Supports Partial Filtering",
                    advanced=true)
public boolean supportsPartialFiltering()
```
    Description copied from class: ExecutionFactory
    Return true if the source has columns marked with the teiid_rel:partial that can return more rows than specified by a filter if the column is also projected. This most closely matches the semantics of ldap queries with multi-valued attributes marked as partial.
    When true, the following supports cannot also be true:
    
    supportsOuterJoins()
    supportsFullOuterJoins()
    supportsInlineViews()
    supportsIntersect()
    supportsExcept()
    supportsSelectExpression()
    supportsUnions()
    supportsSelectDistinct()
    supportsGroupBy()
    Overrides:
    
    supportsPartialFiltering in class ExecutionFactory<F,C>
    
    Returns:
  - setSupportsPartialFiltering
```
public void setSupportsPartialFiltering(boolean value)
```
  - useBindingsForDependentJoin
```
@TranslatorProperty(display="Use Bindings for Dependent Joins",
                    advanced=true)
public boolean useBindingsForDependentJoin()
```
    Description copied from class: ExecutionFactory
    
    If dependent join predicates should use literals that are marked as bind eligible.
    
    Overrides:
    
    useBindingsForDependentJoin in class ExecutionFactory<F,C>
  - setUseBindingsForDependentJoin
```
public void setUseBindingsForDependentJoin(boolean value)
```
  - supportsSubqueryCommonTableExpressions
```
@TranslatorProperty(display="Supports Subquery Common Table Expressions",
                    advanced=true)
public boolean supportsSubqueryCommonTableExpressions()
```
    Overrides:
    
    supportsSubqueryCommonTableExpressions in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the WITH clause can appear in subqueries
  - setSupportsSubqueryCommonTableExpressions
```
public void setSupportsSubqueryCommonTableExpressions(boolean value)
```
  - supportsCorrelatedSubqueryLimit
```
@TranslatorProperty(display="Supports Correlated Subquery Limit",
                    advanced=true)
public boolean supportsCorrelatedSubqueryLimit()
```
    Overrides:
    
    supportsCorrelatedSubqueryLimit in class ExecutionFactory<F,C>
    
    Returns:
    
    true if a correlated subquery can support a limit clause
  - setSupportsCorrelatedSubqueryLimit
```
public void setSupportsCorrelatedSubqueryLimit(boolean value)
```
  - getRequiredLikeEscape
```
@TranslatorProperty(display="Escape char for LIKE",
                    advanced=true)
public Character getRequiredLikeEscape()
```
    Description copied from class: ExecutionFactory
    
    The required escape character or null if all are supported.
    
    Overrides:
    
    getRequiredLikeEscape in class ExecutionFactory<F,C>
    
    Returns:
  - setRequiredLikeEscape
```
public void setRequiredLikeEscape(Character c)
```
  - supportsScalarSubqueryProjection
```
@TranslatorProperty(display="Supports Scalar SubQuery in SELECT",
                    advanced=true)
public boolean supportsScalarSubqueryProjection()
```
    Description copied from class: ExecutionFactory
    
    If a scalar subquery can be projected.
    
    Overrides:
    
    supportsScalarSubqueryProjection in class ExecutionFactory<F,C>
    
    Returns:
  - setSupportsScalarSubqueryProjection
```
public void setSupportsScalarSubqueryProjection(boolean value)
```
  - getTransactionSupport
```
public ExecutionFactory.TransactionSupport getTransactionSupport()
```
    Overrides:
    
    getTransactionSupport in class ExecutionFactory<F,C>
  - setTransactionSupport
```
public void setTransactionSupport(ExecutionFactory.TransactionSupport transactionSupport)
```
    Overrides:
    
    setTransactionSupport in class ExecutionFactory<F,C>
  - getExcludedCommonTableExpressionName
```
@TranslatorProperty(display="Excluded Common Table Expression Name",
                    advanced=true)
public String getExcludedCommonTableExpressionName()
```
    Overrides:
    
    getExcludedCommonTableExpressionName in class ExecutionFactory<F,C>
  - setExcludedCommonTableExpressionName
```
public void setExcludedCommonTableExpressionName(String value)
```
    Overrides:
    
    setExcludedCommonTableExpressionName in class ExecutionFactory<F,C>
  - supportsLateralJoin
```
@TranslatorProperty(display="Supports Lateral Join",
                    advanced=true)
public boolean supportsLateralJoin()
```
    Overrides:
    
    supportsLateralJoin in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the source supports lateral join
  - setSupportsLateralJoin
```
public void setSupportsLateralJoin(boolean value)
```
  - supportsLateralJoinCondition
```
@TranslatorProperty(display="Supports Lateral Join Condition",
                    advanced=true)
public boolean supportsLateralJoinCondition()
```
    Overrides:
    
    supportsLateralJoinCondition in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the source supports lateral join conditions
  - setSupportsLateralJoinCondition
```
public void setSupportsLateralJoinCondition(boolean value)
```
  - supportsProcedureTable
```
@TranslatorProperty(display="Supports Procedure Table",
                    advanced=true)
public boolean supportsProcedureTable()
```
    Overrides:
    
    supportsProcedureTable in class ExecutionFactory<F,C>
    
    Returns:
  - setSupportsProcedureTable
```
public void setSupportsProcedureTable(boolean value)
```
  - supportsGroupByMultipleDistinctAggregates
```
@TranslatorProperty(display="Supports GROUP By with Multiple DISTINCTS",
                    advanced=true)
public boolean supportsGroupByMultipleDistinctAggregates()
```
    Description copied from class: ExecutionFactory
    
    Whether the source supports grouping with multiple distinct aggregates
    
    Overrides:
    
    supportsGroupByMultipleDistinctAggregates in class ExecutionFactory<F,C>
    
    Returns:
  - setSupportsGroupByMultipleDistinctAggregates
```
public void setSupportsGroupByMultipleDistinctAggregates(boolean value)
```
  - start
```
public void start()
           throws TranslatorException
```
    Description copied from class: ExecutionFactory
    
    Initialize the connector with supplied configuration
    
    Overrides:
    
    start in class ExecutionFactory<F,C>
    
    Throws:
    
    TranslatorException
  - supportsUpsert
```
@TranslatorProperty(display="Supports Upsert",
                    advanced=true)
public boolean supportsUpsert()
```
    Overrides:
    
    supportsUpsert in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the source supports upsert
  - setSupportsUpsert
```
public void setSupportsUpsert(boolean value)
```
  - supportsSelectExpressionArrayType
```
@TranslatorProperty(display="Supports SELECT array type expressions",
                    advanced=true)
public boolean supportsSelectExpressionArrayType()
```
    Overrides:
    
    supportsSelectExpressionArrayType in class ExecutionFactory<F,C>
    
    Returns:
    
    true if array type expressions can be projected
  - setSupportsSelectExpressionArrayType
```
public void setSupportsSelectExpressionArrayType(boolean value)
```
  - supportsSetQueryLimitOffset
```
@TranslatorProperty(display="Supports SET Query OFFSET/LIMIT",
                    advanced=true)
public boolean supportsSetQueryLimitOffset()
```
    Description copied from class: ExecutionFactory
    
    Support indicates that the connector supports an LIMIT/OFFSET on a SetQuery.
    
    Overrides:
    
    supportsSetQueryLimitOffset in class ExecutionFactory<F,C>
  - setSupportsSetQueryLimitOffset
```
public void setSupportsSetQueryLimitOffset(boolean value)
```
  - supportsIsDistinctCriteria
```
@TranslatorProperty(display="Supports IS DISTINCT",
                    advanced=true)
public boolean supportsIsDistinctCriteria()
```
    Description copied from class: ExecutionFactory
    
    Support indicates connector accepts criteria of form (exp1 IS DISTINCT exp2)
    
    Overrides:
    
    supportsIsDistinctCriteria in class ExecutionFactory<F,C>
  - setSupportsIsDistinctCriteria
```
public void setSupportsIsDistinctCriteria(boolean value)
```
  - supportsOnlyLateralJoinProcedure
```
@TranslatorProperty(display="Supports Only Lateral Join Procedure",
                    advanced=true)
public boolean supportsOnlyLateralJoinProcedure()
```
    Overrides:
    
    supportsOnlyLateralJoinProcedure in class ExecutionFactory<F,C>
    
    Returns:
    
    true if lateral joins are restricted to only procedures / table valued functions
  - setSupportsOnlyLateralJoinProcedure
```
public void setSupportsOnlyLateralJoinProcedure(boolean supportsOnlyLateralJoinProcedure)
```
  - supportsOnlyTimestampAddLiteral
```
@TranslatorProperty(display="Supports Only TimestampAdd literal",
                    advanced=true)
public boolean supportsOnlyTimestampAddLiteral()
```
    Overrides:
    
    supportsOnlyTimestampAddLiteral in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the source supports only timestamp add literals
  - setSupportsOnlyTimestampAddLiteral
```
public void setSupportsOnlyTimestampAddLiteral(boolean supportsOnlyTimestampAddLiteral)
```
  - getCachePattern
```
@TranslatorProperty(display="Cache Pattern",
                    advanced=true)
public String getCachePattern()
```
  - setCachePattern
```
public void setCachePattern(String cachePattern)
```
  - getCacheTtl
```
@TranslatorProperty(display="Cache TTL",
                    advanced=true)
public Long getCacheTtl()
```
  - setCacheTtl
```
public void setCacheTtl(Long ttl)
```
  - supportsWindowFunctionNtile
```
@TranslatorProperty(display="Supports NTILE",
                    advanced=true)
public boolean supportsWindowFunctionNtile()
```
    Overrides:
    
    supportsWindowFunctionNtile in class ExecutionFactory<F,C>
    
    Returns:
    
    true if ntile is supported. defaults to ExecutionFactory.supportsElementaryOlapOperations()
  - setSupportsWindowFunctionNtile
```
public void setSupportsWindowFunctionNtile(boolean supportsNtile)
```
  - supportsWindowFunctionPercentRank
```
@TranslatorProperty(display="Supports PERCENT_RANK",
                    advanced=true)
public boolean supportsWindowFunctionPercentRank()
```
    Overrides:
    
    supportsWindowFunctionPercentRank in class ExecutionFactory<F,C>
    
    Returns:
    
    true if percent_rank is supported. defaults to ExecutionFactory.supportsElementaryOlapOperations()
  - setSupportsWindowFunctionPercentRank
```
public void setSupportsWindowFunctionPercentRank(boolean supportsPercentRank)
```
  - supportsWindowFunctionCumeDist
```
@TranslatorProperty(display="Supports CUME_DIST",
                    advanced=true)
public boolean supportsWindowFunctionCumeDist()
```
    Overrides:
    
    supportsWindowFunctionCumeDist in class ExecutionFactory<F,C>
    
    Returns:
    
    true if cume_dist is supported. defaults to ExecutionFactory.supportsElementaryOlapOperations()
  - setSupportsWindowFunctionCumeDist
```
public void setSupportsWindowFunctionCumeDist(boolean supportsCumeDist)
```
  - supportsWindowFunctionNthValue
```
@TranslatorProperty(display="Supports NTH_VALUE",
                    advanced=true)
public boolean supportsWindowFunctionNthValue()
```
    Overrides:
    
    supportsWindowFunctionNthValue in class ExecutionFactory<F,C>
    
    Returns:
    
    true if nth_value is supported. defaults to ExecutionFactory.supportsElementaryOlapOperations()
  - setSupportsWindowFunctionNthValue
```
public void setSupportsWindowFunctionNthValue(boolean supportsNthValue)
```
  - supportsMultipleOpenExecutions
```
public boolean supportsMultipleOpenExecutions()
```
    Overrides:
    
    supportsMultipleOpenExecutions in class ExecutionFactory<F,C>
    
    Returns:
    
    true if multiple executions may be open against a single connection at a time
  - setSupportsMultipleOpenStatements
```
public void setSupportsMultipleOpenStatements(boolean supportsMultipleOpenStatements)
```
  - supportsAggregatesCountBig
```
public boolean supportsAggregatesCountBig()
```
    Overrides:
    
    supportsAggregatesCountBig in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the translator supports a specific count aggregate returning a long value ExecutionFactory.supportsAggregatesCount() will be consulted by the engine, this capability only affects the name of the pushed count function if a long value is expected
  - setSupportsAggregatesCountBig
```
public void setSupportsAggregatesCountBig(boolean supportsAggregatesCountBig)
```
  - supportsGeographyType
```
public boolean supportsGeographyType()
```
    Description copied from class: ExecutionFactory
    
    If the geography type is supported by the standard ST_ geospatial functions
    
    Overrides:
    
    supportsGeographyType in class ExecutionFactory<F,C>
    
    Returns:
    
    true if the translator supports the geography type
  - setSupportsGeographyType
```
public void setSupportsGeographyType(boolean supportsGeographyType)
```
  - supportsProcedureParameterExpression
```
public boolean supportsProcedureParameterExpression()
```
    Description copied from class: ExecutionFactory
    
    Return true if the translator supports expressions as procedure paramters.
    
    Overrides:
    
    supportsProcedureParameterExpression in class ExecutionFactory<F,C>
    
    Returns:
  - setSupportsProcedureParameterExpression
```
public void setSupportsProcedureParameterExpression(Boolean supportsProcedureParameterExpression)
```

Class BaseDelegatingExecutionFactory<F,​C>

Nested Class Summary

Nested classes/interfaces inherited from class org.teiid.translator.ExecutionFactory

Field Summary

Fields inherited from class org.teiid.translator.ExecutionFactory

Constructor Summary

Method Summary

Methods inherited from class org.teiid.translator.ExecutionFactory

Methods inherited from class java.lang.Object

Constructor Detail

BaseDelegatingExecutionFactory

Method Detail

getDelegate

setDelegate

getDelegateName

setDelegateName

areLobsUsableAfterClose

closeConnection

createProcedureExecution

createResultSetExecution

createUpdateExecution

getConnection

getDefaultNullOrder

setDefaultNullOrder

getLanguageFactory

getMaxFromGroups

setMaxFromGroups

getMaxProjectedColumns

setMaxProjectedColumns

getMetadata

getPushDownFunctions

getSupportedFunctions

getAddSupportedFunctions

setAddSupportedFunctions

getRemoveSupportedFunctions

setRemoveSupportedFunctions

getTypeFacility

isImmutable

setImmutable

isSourceRequired

setSourceRequired

supportsAggregatesAvg

setSupportsAggregatesAvg

supportsAggregatesCount

setSupportsAggregatesCount

supportsAggregatesCountStar

setSupportsAggregatesCountStar

supportsAggregatesDistinct

setSupportsAggregatesDistinct

supportsAggregatesEnhancedNumeric

setSupportsAggregatesEnhancedNumeric

supportsAggregatesMax

setSupportsAggregatesMax

supportsAggregatesMin

setSupportsAggregatesMin

supportsAggregatesSum

setSupportsAggregatesSum

supportsAliasedTable

setSupportsAliasedTable

supportsBatchedUpdates

setSupportsBatchedUpdates

supportsBulkUpdate

setSupportsBulkUpdate

supportsCommonTableExpressions

setSupportsCommonTableExpressions

supportsCompareCriteriaEquals

setSupportsCompareCriteriaEquals

supportsCompareCriteriaOrdered

setSupportsCompareCriteriaOrdered

supportsCorrelatedSubqueries

setSupportsCorrelatedSubqueries

supportsExcept

setSupportsExcept

supportsExistsCriteria

setSupportsExistsCriteria

supportsFunctionsInGroupBy

setSupportsFunctionsInGroupBy

supportsGroupBy

setSupportsGroupBy

supportsHaving

Class BaseDelegatingExecutionFactory<F,C>