/**
* This method transforms a value of the source type into a value of the target type.
*
* @param value Incoming value of source type
* @return Outgoing value of target type
* @throws Exception if value is an incorrect input type or the transformation fails
*/
public Object transformDirect(Object value) throws Exception {
try {
return Byte.valueOf(((String) value).trim());
} catch (NumberFormatException e) {
throw new TeiidClientException(Messages.gs(Messages.TEIID.TEIID10074, value));
}
}
@Override
public void execute(
VDBMetaData vdb,
MetadataStore store,
ValidatorReport report,
MetadataValidator metadataValidator) {
for (Schema schema : store.getSchemaList()) {
if (vdb.getImportedModels().contains(schema.getName())) {
continue;
}
ModelMetaData model = vdb.getModel(schema.getName());
if (schema.getTables().isEmpty()
&& schema.getProcedures().isEmpty()
&& schema.getFunctions().isEmpty()) {
metadataValidator.log(
report, model, Messages.gs(Messages.TEIID.TEIID31070, model.getName()));
}
for (Table t : schema.getTables().values()) {
if (t.getColumns() == null || t.getColumns().size() == 0) {
metadataValidator.log(
report, model, Messages.gs(Messages.TEIID.TEIID31071, t.getFullName()));
}
Set<String> names = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
validateConstraintNames(metadataValidator, report, model, t.getAllKeys(), names);
validateConstraintNames(
metadataValidator, report, model, t.getFunctionBasedIndexes(), names);
}
// procedure validation is handled in parsing routines.
if (!schema.getFunctions().isEmpty()) {
ActivityReport<ReportItem> funcReport =
new ActivityReport<ReportItem>(
"Translator metadata load " + model.getName()); // $NON-NLS-1$
FunctionMetadataValidator.validateFunctionMethods(
teiidVersion, schema.getFunctions().values(), report);
if (report.hasItems()) {
metadataValidator.log(
report, model, Messages.gs(Messages.TEIID.TEIID31073, funcReport));
}
}
}
}
/**
* @see org.teiid.query.resolver.CommandResolver#resolveCommand(org.teiid.query.sql.lang.Command,
* TempMetadataAdapter, boolean)
*/
@Override
public void resolveCommand(
Command command, TempMetadataAdapter metadata, boolean resolveNullLiterals) throws Exception {
DynamicCommand dynamicCmd = (DynamicCommand) command;
Iterator columns = dynamicCmd.getAsColumns().iterator();
Set<GroupSymbol> groups = new HashSet<GroupSymbol>();
// if there is no into group, just create temp metadata ids
if (dynamicCmd.getIntoGroup() == null) {
while (columns.hasNext()) {
ElementSymbol column = (ElementSymbol) columns.next();
column.setMetadataID(new TempMetadataID(column.getShortName(), column.getType()));
}
} else if (dynamicCmd.getIntoGroup().isTempGroupSymbol()) {
while (columns.hasNext()) {
ElementSymbol column = (ElementSymbol) columns.next();
GroupSymbol gs = getTeiidParser().createASTNode(ASTNodes.GROUP_SYMBOL);
gs.setName(dynamicCmd.getIntoGroup().getName());
column.setGroupSymbol(gs);
}
}
ResolverVisitor visitor = new ResolverVisitor(getTeiidParser().getVersion());
visitor.resolveLanguageObject(
dynamicCmd, groups, dynamicCmd.getExternalGroupContexts(), metadata);
String sqlType = getDataTypeManager().getDataTypeName(dynamicCmd.getSql().getType());
String targetType = DataTypeManagerService.DefaultDataTypes.STRING.getId();
if (!targetType.equals(sqlType)
&& !getDataTypeManager().isImplicitConversion(sqlType, targetType)) {
throw new QueryResolverException(Messages.gs(Messages.TEIID.TEIID30100, sqlType));
}
if (dynamicCmd.getUsing() != null && !dynamicCmd.getUsing().isEmpty()) {
for (SetClause clause : dynamicCmd.getUsing().getClauses()) {
ElementSymbol id = clause.getSymbol();
GroupSymbol gs = getTeiidParser().createASTNode(ASTNodes.GROUP_SYMBOL);
gs.setName(ProcedureReservedWords.DVARS);
id.setGroupSymbol(gs);
id.setType(clause.getValue().getType());
id.setMetadataID(new TempMetadataID(id.getName(), id.getType()));
}
}
GroupSymbol intoSymbol = dynamicCmd.getIntoGroup();
if (intoSymbol != null) {
if (!intoSymbol.isImplicitTempGroupSymbol()) {
ResolverUtil.resolveGroup(intoSymbol, metadata);
} else {
List symbols = dynamicCmd.getAsColumns();
ResolverUtil.resolveImplicitTempGroup(metadata, intoSymbol, symbols);
}
}
}
private MappingBaseNode getRecursiveRootNode(MappingRecursiveElement elem) {
if (hasSource(elem.getMappingClass())) {
return this;
}
MappingBaseNode parent = this.getParentNode();
if (parent != null) {
return parent.getRecursiveRootNode(elem);
}
throw new RuntimeException(Messages.gs(Messages.TEIID.TEIID30457, elem));
}
private Column addColumn(String name, Class<?> type, Table table, MetadataFactory mf)
throws Exception {
if (type == null) {
throw new Exception(Messages.gs(Messages.TEIID.TEIID31086, name, table.getFullName()));
}
Column column =
mf.addColumn(
name, DataTypeManagerService.getInstance(teiidVersion).getDataTypeName(type), table);
column.setUpdatable(table.supportsUpdate());
return column;
}
@Override
public void addChildNode(MappingNode childNode) {
if (childNode instanceof MappingAllNode) addAllNode((MappingAllNode) childNode);
else if (childNode instanceof MappingChoiceNode) addChoiceNode((MappingChoiceNode) childNode);
else if (childNode instanceof MappingCriteriaNode)
addCriteriaNode((MappingCriteriaNode) childNode);
else if (childNode instanceof MappingElement) addChildElement((MappingElement) childNode);
else if (childNode instanceof MappingSequenceNode)
addSequenceNode((MappingSequenceNode) childNode);
else if (childNode instanceof MappingSourceNode) addSourceNode((MappingSourceNode) childNode);
else throw new RuntimeException(Messages.gs(Messages.TEIID.TEIID30457, childNode));
}
private void validateConstraintNames(
MetadataValidator metadataValidator,
ValidatorReport report,
ModelMetaData model,
Collection<KeyRecord> keys,
Set<String> names) {
for (KeyRecord record : keys) {
if (record.getName() == null) {
continue;
}
if (!names.add(record.getName())) {
metadataValidator.log(
report, model, Messages.gs(Messages.TEIID.TEIID31152, record.getFullName()));
}
}
}
@Override
public void writeBatch(
ObjectOutput out, String[] types, List<? extends List<?>> batch, byte version)
throws IOException {
if (batch == null) {
out.writeInt(-1);
} else {
if (version > 0 && batch.size() > 0) {
out.writeInt(-batch.size() - 1);
out.writeByte(version);
} else {
out.writeInt(batch.size());
}
if (batch.size() > 0) {
int columns = types.length;
out.writeInt(columns);
for (int i = 0; i < columns; i++) {
ColumnSerializer serializer = getSerializer(types[i], version);
try {
serializer.writeColumn(out, i, batch);
} catch (ClassCastException e) {
Object obj = null;
String objectClass = null;
objectSearch:
for (int row = 0; row < batch.size(); row++) {
obj = batch.get(row).get(i);
if (obj != null) {
objectClass = obj.getClass().getName();
break objectSearch;
}
}
throw new RuntimeException(
Messages.gs(
Messages.TEIID.TEIID20001,
new Object[] {types[i], new Integer(i), objectClass}),
e);
}
}
}
}
}
protected static Geometry transformGeometry(CoordinateTransform ct, Geometry geom)
throws Exception {
if (geom instanceof Polygon) {
return transformPolygon(ct, (Polygon) geom);
} else if (geom instanceof Point) {
return transformPoint(ct, (Point) geom);
} else if (geom instanceof LinearRing) {
return transformLinearRing(ct, (LinearRing) geom);
} else if (geom instanceof LineString) {
return transformLineString(ct, (LineString) geom);
} else if (geom instanceof MultiPolygon) {
return transformMultiPolygon(ct, (MultiPolygon) geom);
} else if (geom instanceof MultiPoint) {
return transformMultiPoint(ct, (MultiPoint) geom);
} else if (geom instanceof MultiLineString) {
return transformMultiLineString(ct, (MultiLineString) geom);
} else if (geom instanceof GeometryCollection) {
return transformGeometryCollection(ct, (GeometryCollection) geom);
} else {
throw new Exception(Messages.gs(Messages.TEIID.TEIID31164, geom.getGeometryType()));
}
}
public void addSequenceNode(MappingSequenceNodeImpl elem) {
throw new RuntimeException(Messages.gs(Messages.TEIID.TEIID30452));
}
@Override
public void execute(
VDBMetaData vdb,
MetadataStore store,
ValidatorReport report,
MetadataValidator metadataValidator) {
for (Schema schema : store.getSchemaList()) {
if (vdb.getImportedModels().contains(schema.getName())) {
continue;
}
ModelMetaData model = vdb.getModel(schema.getName());
for (Table t : schema.getTables().values()) {
if (t.isVirtual()) {
if (t.isMaterialized() && t.getMaterializedTable() != null) {
String matTableName = t.getMaterializedTable().getFullName();
int index = matTableName.indexOf(Table.NAME_DELIM_CHAR);
if (index == -1) {
metadataValidator.log(
report,
model,
Messages.gs(Messages.TEIID.TEIID31088, matTableName, t.getFullName()));
} else {
String schemaName = matTableName.substring(0, index);
Schema matSchema = store.getSchema(schemaName);
if (matSchema == null) {
metadataValidator.log(
report,
model,
Messages.gs(
Messages.TEIID.TEIID31089, schemaName, matTableName, t.getFullName()));
} else {
Table matTable = matSchema.getTable(matTableName.substring(index + 1));
if (matTable == null) {
metadataValidator.log(
report,
model,
Messages.gs(
Messages.TEIID.TEIID31090,
matTableName.substring(index + 1),
schemaName,
t.getFullName()));
} else {
t.setMaterializedTable(matTable);
}
}
}
}
}
for (KeyRecord record : t.getAllKeys()) {
if (record.getColumns() == null || record.getColumns().isEmpty()) {
metadataValidator.log(
report,
model,
Messages.gs(Messages.TEIID.TEIID31149, t.getFullName(), record.getName()));
}
}
List<ForeignKey> fks = t.getForeignKeys();
if (fks == null || fks.isEmpty()) {
continue;
}
for (ForeignKey fk : fks) {
// Only applicable to older teiid releases than 8.9
if (fk.getReferenceKey() != null
&& !metadataValidator.isTeiidOrGreater(Version.TEIID_8_9)) {
// ensure derived fields are set
fk.setReferenceKey(fk.getReferenceKey());
continue;
}
String referenceTableName = fk.getReferenceTableName();
Table referenceTable = null;
if (fk.getReferenceKey() == null) {
if (referenceTableName == null) {
metadataValidator.log(
report, model, Messages.gs(Messages.TEIID.TEIID31091, t.getFullName()));
continue;
}
// TODO there is an ambiguity here because we don't properly track the name parts
// so we have to first check for a table name that may contain .
referenceTable = schema.getTable(referenceTableName);
} else {
referenceTableName = fk.getReferenceKey().getParent().getFullName();
}
String referenceSchemaName = schema.getName();
int index = referenceTableName.indexOf(Table.NAME_DELIM_CHAR);
if (referenceTable == null) {
if (index != -1) {
referenceSchemaName = referenceTableName.substring(0, index);
Schema referenceSchema = store.getSchema(referenceSchemaName);
if (referenceSchema == null) {
metadataValidator.log(
report,
model,
Messages.gs(Messages.TEIID.TEIID31093, referenceSchemaName, t.getFullName()));
continue;
}
referenceTable = referenceSchema.getTable(referenceTableName.substring(index + 1));
}
if (referenceTable == null) {
metadataValidator.log(
report,
model,
Messages.gs(
Messages.TEIID.TEIID31092,
t.getFullName(),
referenceTableName.substring(index + 1),
referenceSchemaName));
continue;
}
}
KeyRecord uniqueKey = null;
List<String> referenceColumns = fk.getReferenceColumns();
if (fk.getReferenceKey() != null) {
// index metadata logic sets the key prior to having the column names
List<Column> cols = fk.getReferenceKey().getColumns();
referenceColumns = new ArrayList<String>();
for (Column col : cols) {
referenceColumns.add(col.getName());
}
}
if (referenceColumns == null || referenceColumns.isEmpty()) {
if (referenceTable.getPrimaryKey() == null) {
metadataValidator.log(
report,
model,
Messages.gs(
Messages.TEIID.TEIID31094,
t.getFullName(),
referenceTableName.substring(index + 1),
referenceSchemaName));
} else {
uniqueKey = referenceTable.getPrimaryKey();
}
} else {
for (KeyRecord record : referenceTable.getUniqueKeys()) {
if (keyMatches(fk.getReferenceColumns(), record)) {
uniqueKey = record;
break;
}
}
if (uniqueKey == null
&& referenceTable.getPrimaryKey() != null
&& keyMatches(fk.getReferenceColumns(), referenceTable.getPrimaryKey())) {
uniqueKey = referenceTable.getPrimaryKey();
}
}
if (uniqueKey == null) {
metadataValidator.log(
report,
model,
Messages.gs(
Messages.TEIID.TEIID31095,
t.getFullName(),
referenceTableName.substring(index + 1),
referenceSchemaName,
fk.getReferenceColumns()));
} else {
fk.setReferenceKey(uniqueKey);
}
}
}
}
}
private void validate(
VDBMetaData vdb,
ModelMetaData model,
AbstractMetadataRecord record,
ValidatorReport report,
IQueryMetadataInterface metadata,
MetadataFactory mf) {
ValidatorReport resolverReport = null;
try {
if (record instanceof Procedure) {
Procedure p = (Procedure) record;
Command command = queryParser.parseProcedure(p.getQueryPlan(), false);
GroupSymbol gs = createASTNode(ASTNodes.GROUP_SYMBOL);
gs.setName(p.getFullName());
QueryResolver resolver = new QueryResolver(queryParser);
resolver.resolveCommand(command, gs, ICommand.TYPE_STORED_PROCEDURE, metadata, false);
Validator validator = new Validator();
resolverReport = validator.validate(command, metadata);
determineDependencies(p, command);
} else if (record instanceof Table) {
Table t = (Table) record;
GroupSymbol symbol = createASTNode(ASTNodes.GROUP_SYMBOL);
symbol.setName(t.getFullName());
ResolverUtil.resolveGroup(symbol, metadata);
String selectTransformation = t.getSelectTransformation();
boolean columnsIsEmpty = t.getColumns() == null || t.getColumns().isEmpty();
// Consider columns if teid 8.11 or lower
boolean considerColumns_811 =
isTeiidOrGreater(Version.TEIID_8_12_4) ? true : columnsIsEmpty;
// Consider columns if teiid 8.12.4+
boolean considerColumns_8124 =
isTeiidOrGreater(Version.TEIID_8_12_4) ? columnsIsEmpty : true;
if (t.isVirtual() && considerColumns_811) {
QueryCommand command = (QueryCommand) queryParser.parseCommand(selectTransformation);
QueryResolver resolver = new QueryResolver(queryParser);
resolver.resolveCommand(command, metadata);
Validator validator = new Validator();
resolverReport = validator.validate(command, metadata);
if (!resolverReport.hasItems() && considerColumns_8124) {
List<Expression> symbols = command.getProjectedSymbols();
for (Expression column : symbols) {
try {
addColumn(Symbol.getShortName(column), column.getType(), t, mf);
} catch (Exception e) {
log(report, model, e.getMessage());
}
}
}
if (considerColumns_8124) {
determineDependencies(t, command);
if (t.getInsertPlan() != null && t.isInsertPlanEnabled()) {
validateUpdatePlan(
model, report, metadata, t, t.getInsertPlan(), Command.TYPE_INSERT);
}
if (t.getUpdatePlan() != null && t.isUpdatePlanEnabled()) {
validateUpdatePlan(
model, report, metadata, t, t.getUpdatePlan(), Command.TYPE_UPDATE);
}
if (t.getDeletePlan() != null && t.isDeletePlanEnabled()) {
validateUpdatePlan(
model, report, metadata, t, t.getDeletePlan(), Command.TYPE_DELETE);
}
}
}
boolean addCacheHint = false;
if (t.isMaterialized() && t.getMaterializedTable() == null) {
List<KeyRecord> fbis = t.getFunctionBasedIndexes();
List<GroupSymbol> groups = Arrays.asList(symbol);
if (fbis != null && !fbis.isEmpty()) {
for (KeyRecord fbi : fbis) {
for (int j = 0; j < fbi.getColumns().size(); j++) {
Column c = fbi.getColumns().get(j);
if (c.getParent() != fbi) {
continue;
}
String exprString = c.getNameInSource();
try {
Expression ex = queryParser.parseExpression(exprString);
ResolverVisitor resolverVisitor = new ResolverVisitor(teiidVersion);
resolverVisitor.resolveLanguageObject(ex, groups, metadata);
if (!ValueIteratorProviderCollectorVisitor.getValueIteratorProviders(ex)
.isEmpty()) {
log(
report,
model,
Messages.gs(Messages.TEIID.TEIID31114, exprString, fbi.getFullName()));
}
EvaluatableVisitor ev = new EvaluatableVisitor(teiidVersion);
PreOrPostOrderNavigator.doVisit(ex, ev, PostOrderNavigator.PRE_ORDER);
if (ev.getDeterminismLevel().compareTo(Determinism.VDB_DETERMINISTIC) < 0) {
log(
report,
model,
Messages.gs(Messages.TEIID.TEIID31115, exprString, fbi.getFullName()));
}
} catch (QueryResolverException e) {
log(
report,
model,
Messages.gs(
Messages.TEIID.TEIID31116,
exprString,
fbi.getFullName(),
e.getMessage()));
}
}
}
}
} else {
addCacheHint = true;
}
// this seems to parse, resolve and validate.
QueryResolver resolver = new QueryResolver(queryParser);
QueryNode node =
resolver.resolveView(
symbol,
new QueryNode(t.getSelectTransformation()),
SQLConstants.Reserved.SELECT,
metadata);
CacheHint cacheHint = node.getCommand().getCacheHint();
Long ttl = -1L;
if (cacheHint != null
&& cacheHint.getTtl() != null
&& addCacheHint
&& t.getProperty(MATVIEW_TTL, false) == null) {
ttl = cacheHint.getTtl();
t.setProperty(MATVIEW_TTL, String.valueOf(ttl));
}
}
if (resolverReport != null && resolverReport.hasItems()) {
for (ValidatorFailure v : resolverReport.getItems()) {
log(
report,
model,
v.getStatus() == IValidatorFailure.VFStatus.ERROR ? Severity.ERROR : Severity.WARNING,
v.getMessage());
}
}
processReport(model, record, report, resolverReport);
} catch (Exception e) {
log(
report,
model,
Messages.gs(Messages.TEIID.TEIID31080, record.getFullName(), e.getMessage()));
}
}
@Override
public void execute(
VDBMetaData vdb,
MetadataStore store,
ValidatorReport report,
MetadataValidator metadataValidator) {
IQueryMetadataInterface metadata = vdb.getAttachment(IQueryMetadataInterface.class);
metadata = new TempMetadataAdapter(metadata, new TempMetadataStore());
for (Schema schema : store.getSchemaList()) {
if (vdb.getImportedModels().contains(schema.getName())) {
continue;
}
ModelMetaData model = vdb.getModel(schema.getName());
MetadataFactory mf =
new MetadataFactory(
teiidVersion, vdb.getName(), vdb.getVersion(), metadataValidator.typeMap, model) {
@Override
protected void setUUID(AbstractMetadataRecord record) {
if (count >= 0) {
count = Integer.MIN_VALUE;
}
super.setUUID(record);
}
};
mf.setBuiltinDataTypes(store.getDatatypes());
for (AbstractMetadataRecord record : schema.getResolvingOrder()) {
if (record instanceof Table) {
Table t = (Table) record;
// no need to verify the transformation of the xml mapping document,
// as this is very specific and designer already validates it.
if (t.getTableType() == Table.Type.Document
|| t.getTableType() == Table.Type.XmlMappingClass
|| t.getTableType() == Table.Type.XmlStagingTable) {
continue;
}
if (t.isVirtual() && t.getTableType() != Table.Type.TemporaryTable) {
if (t.getSelectTransformation() == null) {
metadataValidator.log(
report,
model,
Messages.gs(Messages.TEIID.TEIID31079, t.getFullName(), model.getName()));
} else {
metadataValidator.validate(vdb, model, t, report, metadata, mf);
}
}
} else if (record instanceof Procedure) {
Procedure p = (Procedure) record;
boolean test = p.isVirtual();
if (teiidVersion.isLessThan(Version.TEIID_8_11)) test = test && !p.isFunction();
if (test) {
if (p.getQueryPlan() == null) {
metadataValidator.log(
report,
model,
Messages.gs(Messages.TEIID.TEIID31081, p.getFullName(), model.getName()));
} else {
metadataValidator.validate(vdb, model, p, report, metadata, mf);
}
}
}
}
}
}
@Override
public void execute(
VDBMetaData vdb,
MetadataStore store,
ValidatorReport report,
MetadataValidator metadataValidator) {
for (Schema schema : store.getSchemaList()) {
if (vdb.getImportedModels().contains(schema.getName())) {
continue;
}
ModelMetaData model = vdb.getModel(schema.getName());
for (Table t : schema.getTables().values()) {
if (t.isPhysical() && !model.isSource()) {
metadataValidator.log(
report,
model,
Messages.gs(Messages.TEIID.TEIID31075, t.getFullName(), model.getName()));
}
}
Set<String> names = new HashSet<String>();
for (Procedure p : schema.getProcedures().values()) {
boolean hasReturn = false;
names.clear();
for (int i = 0; i < p.getParameters().size(); i++) {
ProcedureParameter param = p.getParameters().get(i);
if (param.isVarArg() && param != p.getParameters().get(p.getParameters().size() - 1)) {
// check that the rest of the parameters are optional
// this accommodates variadic multi-source procedures
// effective this and the resolving logic ensure that you can used named parameters
// for everything,
// or call the vararg procedure as normal
if (isTeiidOrGreater(Version.TEIID_8_10)) {
for (int j = i + 1; j < p.getParameters().size(); j++) {
ProcedureParameter param1 = p.getParameters().get(j);
if ((param1.getType() == Type.In || param1.getType() == Type.InOut)
&& (param1.isVarArg()
|| (param1.getNullType() != NullType.Nullable
&& param1.getDefaultValue() == null))) {
metadataValidator.log(
report, model, Messages.gs(Messages.TEIID.TEIID31112, p.getFullName()));
}
}
} else {
metadataValidator.log(
report, model, Messages.gs(Messages.TEIID.TEIID31112, p.getFullName()));
}
}
if (param.getType() == ProcedureParameter.Type.ReturnValue) {
if (hasReturn) {
metadataValidator.log(
report, model, Messages.gs(Messages.TEIID.TEIID31107, p.getFullName()));
}
hasReturn = true;
} else if (p.isFunction()
&& param.getType() != ProcedureParameter.Type.In
&& teiidVersion.isGreaterThanOrEqualTo(Version.TEIID_8_11)) {
metadataValidator.log(
report,
model,
Messages.gs(Messages.TEIID.TEIID31165, p.getFullName(), param.getFullName()));
}
if (!names.add(param.getName())) {
metadataValidator.log(
report,
model,
Messages.gs(Messages.TEIID.TEIID31106, p.getFullName(), param.getFullName()));
}
}
if (!p.isVirtual() && !model.isSource()) {
metadataValidator.log(
report,
model,
Messages.gs(Messages.TEIID.TEIID31077, p.getFullName(), model.getName()));
}
if (p.isFunction() && teiidVersion.isGreaterThanOrEqualTo(Version.TEIID_8_11)) {
if (!hasReturn) {
metadataValidator.log(
report, model, Messages.gs(Messages.TEIID.TEIID31166, p.getFullName()));
}
if (p.isVirtual() && p.getQueryPlan() == null) {
metadataValidator.log(
report, model, Messages.gs(Messages.TEIID.TEIID31167, p.getFullName()));
}
}
}
for (FunctionMethod func : schema.getFunctions().values()) {
for (FunctionParameter param : func.getInputParameters()) {
if (param.isVarArg()
&& param != func.getInputParameters().get(func.getInputParameterCount() - 1)) {
metadataValidator.log(
report, model, Messages.gs(Messages.TEIID.TEIID31112, func.getFullName()));
}
}
if (func.getPushdown().equals(FunctionMethod.PushDown.MUST_PUSHDOWN)
&& !model.isSource()) {
metadataValidator.log(
report,
model,
Messages.gs(Messages.TEIID.TEIID31078, func.getFullName(), model.getName()));
}
}
}
}
public void addChoiceNode(MappingChoiceNode elem) {
throw new RuntimeException(Messages.gs(Messages.TEIID.TEIID30452));
}