@Test
public void testMultipleCommands2() throws Exception {
String ddl =
" CREATE VIRTUAL PROCEDURE getTweets(query varchar) RETURNS (created_on varchar(25), from_user varchar(25), to_user varchar(25), \n"
+ " profile_image_url varchar(25), source varchar(25), text varchar(140)) AS \n"
+ " select tweet.* from \n"
+ " (call twitter.invokeHTTP(action => 'GET', endpoint =>querystring('',query as \"q\"))) w, \n"
+ " XMLTABLE('results' passing JSONTOXML('myxml', w.result) columns \n"
+ " created_on string PATH 'created_at', \n"
+ " from_user string PATH 'from_user',\n"
+ " to_user string PATH 'to_user', \n"
+ " profile_image_url string PATH 'profile_image_url', \n"
+ " source string PATH 'source', \n"
+ " text string PATH 'text') tweet;"
+ " CREATE VIEW Tweet AS select * FROM twitterview.getTweets;";
Schema s = helpParse(ddl, "model").getSchema();
Map<String, Table> tableMap = s.getTables();
Table table = tableMap.get("Tweet");
assertNotNull(table);
Map<String, Procedure> procedureMap = s.getProcedures();
Procedure p = procedureMap.get("getTweets");
assertNotNull(p);
}
@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));
}
}
}
}
@Test
public void testOptionsKey() throws Exception {
String ddl =
"CREATE FOREIGN TABLE G1( e1 integer, e2 varchar, e3 date, UNIQUE (e1) OPTIONS (CUSTOM_PROP 'VALUE'))";
Schema s = helpParse(ddl, "model").getSchema();
Map<String, Table> tableMap = s.getTables();
assertTrue("Table not found", tableMap.containsKey("G1"));
Table table = tableMap.get("G1");
KeyRecord record = table.getAllKeys().iterator().next();
assertEquals("VALUE", record.getProperty("CUSTOM_PROP", false));
}
@Test
public void testMultiKeyPK() throws Exception {
String ddl = "CREATE FOREIGN TABLE G1( e1 integer, e2 varchar, e3 date, PRIMARY KEY (e1, e2))";
Schema s = helpParse(ddl, "model").getSchema();
Map<String, Table> tableMap = s.getTables();
assertTrue("Table not found", tableMap.containsKey("G1"));
Table table = tableMap.get("G1");
assertEquals(table.getColumns().subList(0, 2), table.getPrimaryKey().getColumns());
}
@Test
public void testFBI() throws Exception {
String ddl =
"CREATE FOREIGN TABLE G1(e1 integer, e2 varchar, CONSTRAINT fbi INDEX (UPPER(e2)))";
Schema s = helpParse(ddl, "model").getSchema();
Map<String, Table> tableMap = s.getTables();
Table table = tableMap.get("G1");
assertEquals(1, table.getFunctionBasedIndexes().size());
}
@Test
public void testView() throws Exception {
String ddl =
"CREATE View G1( e1 integer, e2 varchar) OPTIONS (CARDINALITY 12) AS select e1, e2 from foo.bar";
Schema s = helpParse(ddl, "model").getSchema();
Map<String, Table> tableMap = s.getTables();
Table table = tableMap.get("G1");
assertEquals("SELECT e1, e2 FROM foo.bar", table.getSelectTransformation());
assertEquals(12, table.getCardinality());
}
@Test
public void testAlterTableDropOptions() throws Exception {
String ddl =
"CREATE FOREIGN TABLE G1( e1 integer, e2 varchar, e3 date) OPTIONS(CARDINALITY 12, FOO 'BAR');"
+ "ALTER FOREIGN TABLE G1 OPTIONS(DROP CARDINALITY);"
+ "ALTER FOREIGN TABLE G1 OPTIONS(DROP FOO);";
Schema s = helpParse(ddl, "model").getSchema();
Map<String, Table> tableMap = s.getTables();
assertTrue("Table not found", tableMap.containsKey("G1"));
Table table = tableMap.get("G1");
assertEquals(-1, table.getCardinality());
assertNull(table.getProperty("FOO", false));
}
@Test
public void testUDT() throws Exception {
String ddl =
"CREATE FOREIGN TABLE G1( e1 integer, e2 varchar OPTIONS (UDT 'NMTOKENS(12,13,14)'))";
Schema s = helpParse(ddl, "model").getSchema();
Map<String, Table> tableMap = s.getTables();
assertTrue("Table not found", tableMap.containsKey("G1"));
Table table = tableMap.get("G1");
assertEquals("NMTOKENS", table.getColumns().get(1).getDatatype().getName());
assertEquals(12, table.getColumns().get(1).getLength());
assertEquals(13, table.getColumns().get(1).getPrecision());
assertEquals(14, table.getColumns().get(1).getScale());
}
@Test
public void testMultipleCommands() throws Exception {
String ddl =
"CREATE VIEW V1 AS SELECT * FROM PM1.G1 "
+ "CREATE PROCEDURE FOO(P1 integer) RETURNS (e1 integer, e2 varchar) AS SELECT * FROM PM1.G1;";
Schema s = helpParse(ddl, "model").getSchema();
Map<String, Table> tableMap = s.getTables();
Table table = tableMap.get("V1");
assertNotNull(table);
assertEquals("SELECT * FROM PM1.G1", table.getSelectTransformation());
Map<String, Procedure> procedureMap = s.getProcedures();
Procedure p = procedureMap.get("FOO");
assertNotNull(p);
assertEquals("SELECT * FROM PM1.G1;", p.getQueryPlan());
}
@Test
public void testConstraints2() throws Exception {
String ddl =
"CREATE FOREIGN TABLE G1( e1 integer, e2 varchar, e3 date, "
+ "ACCESSPATTERN(e1), UNIQUE(e1), ACCESSPATTERN(e2, e3))";
Schema s = helpParse(ddl, "model").getSchema();
Map<String, Table> tableMap = s.getTables();
assertTrue("Table not found", tableMap.containsKey("G1"));
Table table = tableMap.get("G1");
assertEquals(table.getColumns().subList(0, 1), table.getUniqueKeys().get(0).getColumns());
assertEquals(2, table.getAccessPatterns().size());
assertEquals(table.getColumns().subList(0, 1), table.getAccessPatterns().get(0).getColumns());
assertEquals(table.getColumns().subList(1, 3), table.getAccessPatterns().get(1).getColumns());
}
@Test
public void testInsteadOfTrigger() throws Exception {
String ddl =
"CREATE VIEW G1( e1 integer, e2 varchar) AS select * from foo;"
+ "CREATE TRIGGER ON G1 INSTEAD OF INSERT AS "
+ "FOR EACH ROW \n"
+ "BEGIN ATOMIC \n"
+ "insert into g1 (e1, e2) values (1, 'trig');\n"
+ "END;"
+ "CREATE View G2( e1 integer, e2 varchar) AS select * from foo;";
Schema s = helpParse(ddl, "model").getSchema();
Map<String, Table> tableMap = s.getTables();
assertTrue("Table not found", tableMap.containsKey("G1"));
assertTrue("Table not found", tableMap.containsKey("G2"));
assertEquals(
"FOR EACH ROW\nBEGIN ATOMIC\nINSERT INTO g1 (e1, e2) VALUES (1, 'trig');\nEND",
s.getTable("G1").getInsertPlan());
}
@Test
public void testAlterTableAddColumnOptions() throws Exception {
String ddl =
"CREATE FOREIGN TABLE G1( e1 integer, e2 varchar, e3 date);"
+ "ALTER FOREIGN TABLE G1 OPTIONS(ADD CARDINALITY 12);"
+ "ALTER FOREIGN TABLE G1 ALTER COLUMN e1 OPTIONS(ADD NULL_VALUE_COUNT 12);"
+ "ALTER FOREIGN TABLE G1 ALTER COLUMN e1 OPTIONS(ADD FOO 'BAR');";
Schema s = helpParse(ddl, "model").getSchema();
Map<String, Table> tableMap = s.getTables();
assertTrue("Table not found", tableMap.containsKey("G1"));
Table table = tableMap.get("G1");
assertEquals(12, table.getCardinality());
Column c = table.getColumnByName("e1");
assertNotNull(c);
assertEquals("BAR", c.getProperty("FOO", false));
assertEquals(12, c.getNullValues());
}
@Test
public void testAlterTableRemoveColumnOptions() throws Exception {
String ddl =
"CREATE FOREIGN TABLE G1( e1 integer OPTIONS (NULL_VALUE_COUNT 12, FOO 'BAR'), e2 varchar, e3 date);"
+ "ALTER FOREIGN TABLE G1 ALTER COLUMN e1 OPTIONS(DROP NULL_VALUE_COUNT);"
+ "ALTER FOREIGN TABLE G1 ALTER COLUMN e1 OPTIONS(DROP FOO);"
+ "ALTER FOREIGN TABLE G1 ALTER COLUMN e1 OPTIONS( ADD x 'y');";
Schema s = helpParse(ddl, "model").getSchema();
Map<String, Table> tableMap = s.getTables();
assertTrue("Table not found", tableMap.containsKey("G1"));
Table table = tableMap.get("G1");
Column c = table.getColumnByName("e1");
assertNotNull(c);
assertNull(c.getProperty("FOO", false));
assertEquals(-1, c.getNullValues());
assertEquals("y", c.getProperty("x", false));
}
@Test
public void testFK() throws Exception {
String ddl =
"CREATE FOREIGN TABLE G1(g1e1 integer, g1e2 varchar, PRIMARY KEY(g1e1, g1e2));\n"
+ "CREATE FOREIGN TABLE G2( g2e1 integer, g2e2 varchar, "
+ "FOREIGN KEY (g2e1, g2e2) REFERENCES G1 (g1e1, g1e2) options (\"teiid_rel:allow-join\" true))";
Schema s = helpParse(ddl, "model").getSchema();
Map<String, Table> tableMap = s.getTables();
assertEquals(2, tableMap.size());
assertTrue("Table not found", tableMap.containsKey("G1"));
assertTrue("Table not found", tableMap.containsKey("G2"));
Table table = tableMap.get("G2");
ForeignKey fk = table.getForeignKeys().get(0);
assertEquals(Boolean.TRUE.toString(), fk.getProperty(ForeignKey.ALLOW_JOIN, false));
assertEquals(fk.getColumns(), table.getColumns());
assertEquals("G1", fk.getReferenceTableName());
}
private void visit(Schema schema) {
boolean first = true;
if (this.includeTables) {
for (Table t : schema.getTables().values()) {
if (first) {
first = false;
} else {
append(NEWLINE);
append(NEWLINE);
}
visit(t);
}
}
if (this.includeProcedures) {
for (Procedure p : schema.getProcedures().values()) {
if (first) {
first = false;
} else {
append(NEWLINE);
append(NEWLINE);
}
visit(p);
}
}
if (this.includeFunctions) {
for (FunctionMethod f : schema.getFunctions().values()) {
if (first) {
first = false;
} else {
append(NEWLINE);
append(NEWLINE);
}
visit(f);
}
}
}
@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 static void buildAssosiationSets(MetadataStore metadataStore, List<Builder> edmSchemas) {
for (Schema schema : metadataStore.getSchemaList()) {
EdmSchema.Builder odataSchema = findSchema(edmSchemas, schema.getName());
EdmEntityContainer.Builder entityContainer =
findEntityContainer(edmSchemas, schema.getName());
List<EdmAssociationSet.Builder> assosiationSets = new ArrayList<EdmAssociationSet.Builder>();
List<EdmAssociation.Builder> assosiations = new ArrayList<EdmAssociation.Builder>();
for (Table table : schema.getTables().values()) {
// build Associations
for (ForeignKey fk : table.getForeignKeys()) {
EdmEntitySet.Builder entitySet =
findEntitySet(edmSchemas, schema.getName(), table.getName());
EdmEntitySet.Builder refEntitySet =
findEntitySet(edmSchemas, schema.getName(), fk.getReferenceTableName());
EdmEntityType.Builder entityType =
findEntityType(edmSchemas, schema.getName(), table.getName());
EdmEntityType.Builder refEntityType =
findEntityType(edmSchemas, schema.getName(), fk.getReferenceTableName());
// check to see if fk is part of this table's pk, then it is 1 to 1 relation
boolean onetoone = sameColumnSet(table.getPrimaryKey(), fk);
// Build Association Ends
EdmAssociationEnd.Builder endSelf =
EdmAssociationEnd.newBuilder()
.setRole(table.getName())
.setType(entityType)
.setMultiplicity(onetoone ? EdmMultiplicity.ZERO_TO_ONE : EdmMultiplicity.MANY);
EdmAssociationEnd.Builder endRef =
EdmAssociationEnd.newBuilder()
.setRole(fk.getReferenceTableName())
.setType(refEntityType)
.setMultiplicity(EdmMultiplicity.ZERO_TO_ONE);
// Build Association
EdmAssociation.Builder association = EdmAssociation.newBuilder();
association.setName(table.getName() + "_" + fk.getName());
association.setEnds(endSelf, endRef);
association.setNamespace(
refEntityType
.getFullyQualifiedTypeName()
.substring(0, refEntityType.getFullyQualifiedTypeName().indexOf('.')));
assosiations.add(association);
// Build ReferentialConstraint
if (fk.getReferenceColumns() != null) {
EdmReferentialConstraint.Builder erc = EdmReferentialConstraint.newBuilder();
erc.setPrincipalRole(fk.getReferenceTableName());
erc.addPrincipalReferences(fk.getReferenceColumns());
erc.setDependentRole(table.getName());
erc.addDependentReferences(getColumnNames(fk.getColumns()));
association.setRefConstraint(erc);
}
// Add EdmNavigationProperty to entity type
EdmNavigationProperty.Builder nav =
EdmNavigationProperty.newBuilder(fk.getReferenceTableName());
nav.setRelationshipName(fk.getName());
nav.setFromToName(table.getName(), fk.getReferenceTableName());
nav.setRelationship(association);
nav.setFromTo(endSelf, endRef);
entityType.addNavigationProperties(nav);
// Add EdmNavigationProperty to Reference entity type
EdmNavigationProperty.Builder refNav = EdmNavigationProperty.newBuilder(table.getName());
refNav.setRelationshipName(fk.getName());
refNav.setFromToName(fk.getReferenceTableName(), table.getName());
refNav.setRelationship(association);
refNav.setFromTo(endRef, endSelf);
refEntityType.addNavigationProperties(refNav);
// build AssosiationSet
EdmAssociationSet.Builder assosiationSet =
EdmAssociationSet.newBuilder()
.setName(table.getName() + "_" + fk.getName())
.setAssociationName(fk.getName());
// Build AssosiationSet Ends
EdmAssociationSetEnd.Builder endOne =
EdmAssociationSetEnd.newBuilder()
.setEntitySet(entitySet)
.setRoleName(table.getName())
.setRole(
EdmAssociationEnd.newBuilder()
.setType(entityType)
.setRole(entityType.getName()));
EdmAssociationSetEnd.Builder endTwo =
EdmAssociationSetEnd.newBuilder()
.setEntitySet(refEntitySet)
.setRoleName(fk.getReferenceTableName())
.setRole(
EdmAssociationEnd.newBuilder()
.setType(refEntityType)
.setRole(refEntityType.getName()));
assosiationSet.setEnds(endOne, endTwo);
assosiationSet.setAssociation(association);
assosiationSets.add(assosiationSet);
}
}
entityContainer.addAssociationSets(assosiationSets);
odataSchema.addAssociations(assosiations);
}
}
@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()));
}
}
}
}
private static void buildEntityTypes(
MetadataStore metadataStore, List<EdmSchema.Builder> edmSchemas) {
for (Schema schema : metadataStore.getSchemaList()) {
List<EdmEntitySet.Builder> entitySets = new ArrayList<EdmEntitySet.Builder>();
List<EdmEntityType.Builder> entityTypes = new ArrayList<EdmEntityType.Builder>();
for (Table table : schema.getTables().values()) {
KeyRecord primaryKey = table.getPrimaryKey();
List<KeyRecord> uniques = table.getUniqueKeys();
if (primaryKey == null && uniques.isEmpty()) {
LogManager.logDetail(
LogConstants.CTX_ODATA,
ODataPlugin.Util.gs(ODataPlugin.Event.TEIID16002, table.getFullName()));
continue;
}
EdmEntityType.Builder entityType =
EdmEntityType.newBuilder().setName(table.getName()).setNamespace(schema.getName());
// adding key
if (primaryKey != null) {
for (Column c : primaryKey.getColumns()) {
entityType.addKeys(c.getName());
}
} else {
for (Column c : uniques.get(0).getColumns()) {
entityType.addKeys(c.getName());
}
}
// adding properties
for (Column c : table.getColumns()) {
EdmProperty.Builder property =
EdmProperty.newBuilder(c.getName())
.setType(ODataTypeManager.odataType(c.getDatatype().getRuntimeTypeName()))
.setNullable(c.getNullType() == NullType.Nullable);
if (c.getDatatype()
.getRuntimeTypeName()
.equals(DataTypeManager.DefaultDataTypes.STRING)) {
property.setFixedLength(c.isFixedLength()).setMaxLength(c.getLength()).setUnicode(true);
}
entityType.addProperties(property);
}
// entity set one for one entity type
EdmEntitySet.Builder entitySet =
EdmEntitySet.newBuilder().setName(table.getName()).setEntityType(entityType);
entityType.setNamespace(schema.getName());
entitySets.add(entitySet);
// add enitity types for entity schema
entityTypes.add(entityType);
}
// entity container is holder entity sets, association sets, function imports
EdmEntityContainer.Builder entityContainer =
EdmEntityContainer.newBuilder()
.setName(schema.getName())
.setIsDefault(false)
.addEntitySets(entitySets);
// build entity schema
EdmSchema.Builder modelSchema =
EdmSchema.newBuilder()
.setNamespace(schema.getName())
.addEntityTypes(entityTypes)
.addEntityContainers(entityContainer);
edmSchemas.add(modelSchema);
}
}
@Test
public void testForeignTable() throws Exception {
String ddl =
"CREATE FOREIGN TABLE G1(\n"
+ "e1 integer primary key,\n"
+ "e2 varchar(10) unique,\n"
+ "e3 date not null unique,\n"
+ "e4 decimal(12,3) default 12.2 options (searchable 'unsearchable'),\n"
+ "e5 integer auto_increment INDEX OPTIONS (UUID 'uuid', NAMEINSOURCE 'nis', SELECTABLE 'NO'),\n"
+ "e6 varchar index default 'hello')\n"
+ "OPTIONS (CARDINALITY 12, UUID 'uuid2', UPDATABLE 'true', FOO 'BAR', ANNOTATION 'Test Table')";
Schema s = helpParse(ddl, "model").getSchema();
Map<String, Table> tableMap = s.getTables();
assertTrue("Table not found", tableMap.containsKey("G1"));
Table table = tableMap.get("G1");
assertTrue(table.isPhysical());
assertFalse(table.isVirtual());
assertFalse(table.isSystem());
assertFalse(table.isMaterialized());
assertFalse(table.isDeletePlanEnabled());
assertEquals("uuid2", table.getUUID());
assertEquals(12, table.getCardinality());
assertTrue(table.supportsUpdate());
assertEquals("BAR", table.getProperties().get("FOO"));
assertEquals("Test Table", table.getAnnotation());
assertEquals(6, table.getColumns().size());
List<Column> columns = table.getColumns();
Column e1 = columns.get(0);
Column e2 = columns.get(1);
Column e3 = columns.get(2);
Column e4 = columns.get(3);
Column e5 = columns.get(4);
Column e6 = columns.get(5);
assertEquals("e1", e1.getName());
assertEquals("int", e1.getDatatype().getName());
assertEquals("primary key not same", e1, table.getPrimaryKey().getColumns().get(0));
assertEquals("e2", e2.getName());
assertEquals("string", e2.getDatatype().getName());
assertEquals("unique", e2, table.getUniqueKeys().get(0).getColumns().get(0));
assertEquals(NullType.Nullable, e2.getNullType());
assertEquals(10, e2.getLength());
assertEquals(0, e2.getPrecision());
assertEquals("e3", e3.getName());
assertEquals("date", e3.getDatatype().getName());
assertEquals("unique", e3, table.getUniqueKeys().get(1).getColumns().get(0));
assertEquals(NullType.No_Nulls, e3.getNullType());
assertEquals("e4", e4.getName());
assertEquals("bigdecimal", e4.getDatatype().getName());
assertEquals(false, e4.isAutoIncremented());
assertEquals(12, e4.getPrecision());
assertEquals(3, e4.getScale());
assertEquals(SearchType.Unsearchable, e4.getSearchType());
assertEquals("12.2", e4.getDefaultValue());
assertEquals("e5", e5.getName());
assertEquals("int", e5.getDatatype().getName());
assertEquals(true, e5.isAutoIncremented());
assertEquals("uuid", e5.getUUID());
assertEquals("nis", e5.getNameInSource());
assertEquals(false, e5.isSelectable());
assertEquals("index", e5, table.getIndexes().get(0).getColumns().get(0));
assertEquals("e6", e6.getName());
assertEquals("string", e6.getDatatype().getName());
assertEquals("index", e6, table.getIndexes().get(1).getColumns().get(0));
assertEquals("hello", e6.getDefaultValue());
}
