Package org.teiid.language

Class LanguageFactory

java.lang.Object

org.teiid.language.LanguageFactory

public class LanguageFactory
extends Object

Factory for the construction of language objects that implement the language interfaces. This factory is provided by the connector environment and can be used in modifying the language interfaces if needed.

Field Summary

Fields

Modifier and Type	Field	Description
static LanguageFactory	INSTANCE	Public instance, holds no state so can be shared by everyone.

Constructor Summary

Constructors

Constructor	Description
LanguageFactory()

Method Summary

Modifier and Type	Method	Description
AggregateFunction	createAggregate(String name, boolean isDistinct, Expression expression, Class<?> type)
AndOr	createAndOr(AndOr.Operator operator, Condition left, Condition right)
Argument	createArgument(Argument.Direction direction, Expression value, Class<?> type, ProcedureParameter metadataReference)
Call	createCall(String name, List<Argument> parameters, Procedure metadataReference)
ColumnReference	createColumnReference(String name, NamedTable group, Column metadataReference, Class<?> type)
Comparison	createCompareCriteria(Comparison.Operator operator, Expression leftExpression, Expression rightExpression)
Delete	createDelete(NamedTable group, Condition where)
Exists	createExists(Select query)
Function	createFunction(String functionName, List<? extends Expression> args, Class<?> type)
Function	createFunction(String functionName, Expression[] args, Class<?> type)
GroupBy	createGroupBy(List<Expression> items)
In	createIn(Expression leftExpression, List<Expression> rightExpressions, boolean isNegated)
DerivedTable	createInlineView(QueryExpression query, String name)
Insert	createInsert(NamedTable group, List<ColumnReference> columns, InsertValueSource valueSource)
ExpressionValueSource	createInsertExpressionValueSource(List<Expression> values)
IsNull	createIsNullCriteria(Expression expression, boolean isNegated)
Join	createJoin(Join.JoinType joinType, TableReference leftItem, TableReference rightItem, Condition condition)
Like	createLikeCriteria(Expression leftExpression, Expression rightExpression, Character escapeCharacter, boolean isNegated)
Literal	createLiteral(Object value, Class<?> type)
NamedTable	createNamedTable(String name, String correlationName, Table metadataReference)
Not	createNot(Condition criteria)
OrderBy	createOrderBy(List<SortSpecification> items)
SortSpecification	createOrderByItem(ColumnReference element, SortSpecification.Ordering direction)
Select	createQuery(List<DerivedColumn> select, boolean isDistinct, List<TableReference> from, Condition where, GroupBy groupBy, Condition having, OrderBy orderBy)
ScalarSubquery	createScalarSubquery(Select query)
SearchedCase	createSearchedCaseExpression(List<SearchedWhenClause> cases, Expression elseExpression, Class<?> type)
SearchedWhenClause	createSearchedWhenCondition(Condition condition, Expression result)
DerivedColumn	createSelectSymbol(String name, Expression expression)
SetClause	createSetClause(ColumnReference symbol, Expression value)
SetQuery	createSetOp(SetQuery.Operation operation, boolean all, QueryExpression leftQuery, QueryExpression rightQuery, OrderBy orderBy, Limit limit)
SubqueryComparison	createSubqueryCompareCriteria(Expression leftExpression, Comparison.Operator operator, SubqueryComparison.Quantifier quantifier, Select subquery)
SubqueryIn	createSubqueryInCriteria(Expression expression, Select subquery, boolean isNegated)
Update	createUpdate(NamedTable group, List<SetClause> updates, Condition criteria)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

INSTANCE

public static final LanguageFactory INSTANCE

Public instance, holds no state so can be shared by everyone.

Constructor Detail

LanguageFactory

public LanguageFactory()

Method Detail

createAggregate

public AggregateFunction createAggregate(String name,
                                         boolean isDistinct,
                                         Expression expression,
                                         Class<?> type)

createCompareCriteria

public Comparison createCompareCriteria(Comparison.Operator operator,
                                        Expression leftExpression,
                                        Expression rightExpression)

createAndOr

public AndOr createAndOr(AndOr.Operator operator,
                         Condition left,
                         Condition right)

createDelete

public Delete createDelete(NamedTable group,
                           Condition where)

createColumnReference

public ColumnReference createColumnReference(String name,
                                             NamedTable group,
                                             Column metadataReference,
                                             Class<?> type)

createExists

public Exists createExists(Select query)

createFunction

public Function createFunction(String functionName,
                               Expression[] args,
                               Class<?> type)

createFunction

public Function createFunction(String functionName,
                               List<? extends Expression> args,
                               Class<?> type)

createNamedTable

public NamedTable createNamedTable(String name,
                                   String correlationName,
                                   Table metadataReference)

createGroupBy

public GroupBy createGroupBy(List<Expression> items)

createIn

public In createIn(Expression leftExpression,
                   List<Expression> rightExpressions,
                   boolean isNegated)

createInsert

public Insert createInsert(NamedTable group,
                           List<ColumnReference> columns,
                           InsertValueSource valueSource)

createInsertExpressionValueSource

public ExpressionValueSource createInsertExpressionValueSource(List<Expression> values)

createIsNullCriteria

public IsNull createIsNullCriteria(Expression expression,
                                   boolean isNegated)

createJoin

public Join createJoin(Join.JoinType joinType,
                       TableReference leftItem,
                       TableReference rightItem,
                       Condition condition)

createLikeCriteria

public Like createLikeCriteria(Expression leftExpression,
                               Expression rightExpression,
                               Character escapeCharacter,
                               boolean isNegated)

createLiteral

public Literal createLiteral(Object value,
                             Class<?> type)

createNot

public Not createNot(Condition criteria)

createOrderBy

public OrderBy createOrderBy(List<SortSpecification> items)

createOrderByItem

public SortSpecification createOrderByItem(ColumnReference element,
                                           SortSpecification.Ordering direction)

createArgument

public Argument createArgument(Argument.Direction direction,
                               Expression value,
                               Class<?> type,
                               ProcedureParameter metadataReference)

createCall

public Call createCall(String name,
                       List<Argument> parameters,
                       Procedure metadataReference)

createQuery

public Select createQuery(List<DerivedColumn> select,
                          boolean isDistinct,
                          List<TableReference> from,
                          Condition where,
                          GroupBy groupBy,
                          Condition having,
                          OrderBy orderBy)

createScalarSubquery

public ScalarSubquery createScalarSubquery(Select query)

createSearchedCaseExpression

public SearchedCase createSearchedCaseExpression(List<SearchedWhenClause> cases,
                                                 Expression elseExpression,
                                                 Class<?> type)

createSearchedWhenCondition

public SearchedWhenClause createSearchedWhenCondition(Condition condition,
                                                      Expression result)

createSelectSymbol

public DerivedColumn createSelectSymbol(String name,
                                        Expression expression)

createSubqueryCompareCriteria

public SubqueryComparison createSubqueryCompareCriteria(Expression leftExpression,
                                                        Comparison.Operator operator,
                                                        SubqueryComparison.Quantifier quantifier,
                                                        Select subquery)

createSubqueryInCriteria

public SubqueryIn createSubqueryInCriteria(Expression expression,
                                           Select subquery,
                                           boolean isNegated)

createUpdate

public Update createUpdate(NamedTable group,
                           List<SetClause> updates,
                           Condition criteria)

createInlineView

public DerivedTable createInlineView(QueryExpression query,
                                     String name)

createSetOp

public SetQuery createSetOp(SetQuery.Operation operation,
                            boolean all,
                            QueryExpression leftQuery,
                            QueryExpression rightQuery,
                            OrderBy orderBy,
                            Limit limit)

createSetClause

public SetClause createSetClause(ColumnReference symbol,
                                 Expression value)