@Override
public void visit(AggregateFunction obj) {
if (!obj.getParameters().isEmpty()) {
visitNodes(obj.getParameters());
}
if (obj.getName().equals(AggregateFunction.COUNT)) {
HashMap<String, String> options = new HashMap<String, String>();
options.put(CountStarIterator.ALIAS, this.currentAlias);
options.put(CountStarIterator.ENCODING, this.ef.getEncoding());
IteratorSetting it =
new IteratorSetting(this.iteratorPriority++, CountStarIterator.class, options);
// expression expects a column
Column c = new Column();
c.setName(this.currentAlias);
c.setDatatype(
SystemMetadata.getInstance()
.getSystemStore()
.getDatatypes()
.get("integer")); // $NON-NLS-1$
c.setProperty(AccumuloMetadataProcessor.CF, this.currentAlias);
this.scanIterators.add(it);
this.onGoingExpression.push(c);
} else if (obj.getName().equals(AggregateFunction.AVG)) {
} else if (obj.getName().equals(AggregateFunction.SUM)) {
} else if (obj.getName().equals(AggregateFunction.MIN)) {
} else if (obj.getName().equals(AggregateFunction.MAX)) {
} else {
}
}
/**
* method to execute the supplied query
*
* @param query the query object.
* @param maxBatchSize the max batch size.
*/
@Override
public void execute() throws TranslatorException {
String ctxName = this.searchDetails.getContextName();
String filter = this.searchDetails.getContextFilter();
if (ctxName == null || filter == null || this.ctrls == null) {
throw new TranslatorException(
"Search context, filter, or controls were null. Cannot execute search."); //$NON-NLS-1$
}
ArrayList<Column> attributeList = searchDetails.getElementList();
// determine if there is an array value to unwrap
for (int i = 0; i < attributeList.size(); i++) {
Column col = attributeList.get(i);
if (Boolean.valueOf(col.getProperty(LDAPExecutionFactory.UNWRAP, false))) {
if (unwrapPos > -1) {
throw new TranslatorException(
LDAPPlugin.Util.gs(LDAPPlugin.Event.TEIID12014, col, attributeList.get(unwrapPos)));
}
unwrapPos = i;
}
}
setRequestControls(null);
// Execute the search.
executeSearch();
}
static List<String> getColumnNames(List<Column> columns) {
ArrayList<String> names = new ArrayList<String>();
for (Column c : columns) {
names.add(c.getName());
}
return names;
}
@Test
public void testEnititySet() throws Exception {
ODataMetadataProcessor processor = new ODataMetadataProcessor();
MetadataFactory mf =
new MetadataFactory(
"vdb",
1,
"trippin",
SystemMetadata.getInstance().getRuntimeTypeMap(),
new Properties(),
null);
ArrayList<CsdlProperty> properties = new ArrayList<CsdlProperty>();
properties.add(
createProperty("name", EdmPrimitiveTypeKind.String).setMaxLength(25).setNullable(false));
properties.add(createProperty("dob", EdmPrimitiveTypeKind.DateTimeOffset).setNullable(true));
properties.add(createProperty("ssn", EdmPrimitiveTypeKind.Int64).setNullable(false));
CsdlEntityType entityType = new CsdlEntityType();
entityType.setName("Person");
entityType.setProperties(properties);
entityType.setKey(Arrays.asList(new CsdlPropertyRef().setName("ssn")));
CsdlEntitySet es = createES("Persons", "namespace.Person");
XMLMetadata metadata = buildXmlMetadata(es, entityType);
processor.getMetadata(mf, metadata);
assertNotNull(mf.getSchema().getTable("Persons"));
Table person = mf.getSchema().getTable("Persons");
assertEquals(3, person.getColumns().size());
assertNotNull(person.getColumnByName("name"));
assertNotNull(person.getColumnByName("dob"));
assertNotNull(person.getColumnByName("ssn"));
Column name = person.getColumnByName("name");
Column dob = person.getColumnByName("dob");
Column ssn = person.getColumnByName("ssn");
assertEquals("string", name.getDatatype().getRuntimeTypeName());
assertEquals("timestamp", dob.getDatatype().getRuntimeTypeName());
assertEquals("long", ssn.getDatatype().getRuntimeTypeName());
assertTrue(name.getNullType() == NullType.No_Nulls);
assertTrue(dob.getNullType() == NullType.Nullable);
assertTrue(ssn.getNullType() == NullType.No_Nulls);
assertEquals(25, name.getLength());
assertNotNull(person.getPrimaryKey());
assertEquals(1, person.getPrimaryKey().getColumns().size());
assertEquals("ssn", person.getPrimaryKey().getColumns().get(0).getName());
assertTrue(person.getForeignKeys().isEmpty());
}
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;
}
public boolean isPartOfPrimaryKey(Column column) {
KeyRecord pk = ((Table) column.getParent()).getPrimaryKey();
if (pk != null) {
for (Column col : pk.getColumns()) {
if (col.getName().equals(column.getName())) {
return true;
}
}
}
return false;
}
@Override
public void visit(In obj) {
visitNode(obj.getLeftExpression());
Column c = (Column) this.onGoingExpression.pop();
ArrayList<Object> values = new ArrayList<Object>();
for (Expression expr : obj.getRightExpressions()) {
visitNode(expr);
values.add(this.onGoingExpression.pop().toString());
}
this.filterValues.put(c.getName(), values);
}
@Override
public void visit(Comparison obj) {
if (obj.getOperator() == Operator.EQ) {
visitNode(obj.getLeftExpression());
Column c = (Column) this.onGoingExpression.pop();
visitNode(obj.getRightExpression());
ArrayList<Object> values = new ArrayList<Object>();
values.add(this.onGoingExpression.pop().toString());
this.filterValues.put(c.getName(), values);
} else {
this.exceptions.add(new TranslatorException("Only Equality supported"));
}
}
@SuppressWarnings("rawtypes")
public static List<Object> performSearch(
Condition where, OrderBy orderby, String cacheName, InfinispanConnection conn)
throws TranslatorException {
QueryBuilder qb = getQueryBuilder(cacheName, conn);
if (orderby != null) {
List<SortSpecification> sss = orderby.getSortSpecifications();
for (SortSpecification spec : sss) {
Expression exp = spec.getExpression();
Column mdIDElement = ((ColumnReference) exp).getMetadataObject();
SortOrder so = SortOrder.ASC;
if (spec.getOrdering().name().equalsIgnoreCase(SortOrder.DESC.name())) {
so = SortOrder.DESC;
}
qb = qb.orderBy(mdIDElement.getSourceName(), so);
}
}
FilterConditionContext fcc = buildQueryFromWhereClause(where, qb, null);
List<Object> results = null;
Query query = null;
if (fcc != null) {
query = fcc.toBuilder().build();
results = query.list();
if (results == null) {
return Collections.emptyList();
}
} else if (orderby != null) {
query = qb.build();
results = query.list();
if (results == null) {
return Collections.emptyList();
}
} else {
results = new ArrayList<Object>();
RemoteCache<?, Object> c = (RemoteCache<?, Object>) conn.getCache();
for (Object id : c.keySet()) {
results.add(c.get(id));
}
}
return results;
}
private boolean keyMatches(List<String> names, KeyRecord record) {
if (names.size() != record.getColumns().size()) {
return false;
}
Set<String> keyNames = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
for (Column c : record.getColumns()) {
keyNames.add(c.getName());
}
for (int i = 0; i < names.size(); i++) {
if (!keyNames.contains(names.get(i))) {
return false;
}
}
return true;
}
@Test
public void testForeignTemp() {
Create create = new Create();
create.setTable(new GroupSymbol("tempTable")); // $NON-NLS-1$
create.setOn("source");
Table t = new Table();
t.setName("tempTable");
t.setUUID("tid:0");
Column c = new Column();
c.setName("x");
c.setUUID("tid:0");
Datatype string = SystemMetadata.getInstance().getRuntimeTypeMap().get("string");
c.setDatatype(string, true);
t.addColumn(c);
c = new Column();
c.setName("y");
c.setUUID("tid:0");
Datatype decimal = SystemMetadata.getInstance().getRuntimeTypeMap().get("decimal");
c.setDatatype(decimal, true);
t.addColumn(c);
t.setCardinality(10000);
create.setTableMetadata(t);
helpTest(
"create foreign temporary table tempTable (x string, y decimal) options (cardinality 10000) on source",
"CREATE FOREIGN TEMPORARY TABLE tempTable (\n x string,\n y bigdecimal\n) OPTIONS (CARDINALITY 10000) ON 'source'",
create); //$NON-NLS-1$ //$NON-NLS-2$
}
private static HashMap<String, String> buildTableMetadata(
String tableName, List<Column> columns, String encoding) {
HashMap<String, String> options = new HashMap<String, String>();
options.put(EvaluatorIterator.COLUMNS_COUNT, String.valueOf(columns.size()));
options.put(EvaluatorIterator.TABLENAME, tableName);
options.put(EvaluatorIterator.ENCODING, encoding);
for (int i = 0; i < columns.size(); i++) {
Column column = columns.get(i);
options.put(EvaluatorIterator.createColumnName(EvaluatorIterator.NAME, i), column.getName());
if (!SQLStringVisitor.getRecordName(column).equals(AccumuloMetadataProcessor.ROWID)) {
options.put(
EvaluatorIterator.createColumnName(EvaluatorIterator.CF, i),
column.getProperty(AccumuloMetadataProcessor.CF, false));
if (column.getProperty(AccumuloMetadataProcessor.CQ, false) != null) {
options.put(
EvaluatorIterator.createColumnName(EvaluatorIterator.CQ, i),
column.getProperty(AccumuloMetadataProcessor.CQ, false));
}
if (column.getProperty(AccumuloMetadataProcessor.VALUE_IN, false) != null) {
options.put(
EvaluatorIterator.createColumnName(EvaluatorIterator.VALUE_IN, i),
column.getProperty(AccumuloMetadataProcessor.VALUE_IN, false));
}
}
options.put(
EvaluatorIterator.createColumnName(EvaluatorIterator.DATA_TYPE, i),
column.getDatatype().getJavaClassName());
}
return options;
}
@Override
public void visit(DerivedColumn obj) {
this.currentAlias = buildAlias(obj.getAlias());
visitNode(obj.getExpression());
Column column = (Column) this.onGoingExpression.pop();
String CF = column.getProperty(AccumuloMetadataProcessor.CF, false);
String CQ = column.getProperty(AccumuloMetadataProcessor.CQ, false);
if (CQ != null) {
this.keybasedColumnMap.put(CF + "/" + CQ, column); // $NON-NLS-1$
} else {
this.keybasedColumnMap.put(CF, column);
}
// no expressions in select are allowed.
this.selectColumns.add(column);
}
@SuppressWarnings({"rawtypes", "unchecked"})
public static FilterConditionContext visit(
In obj, QueryBuilder queryBuilder, FilterConditionBeginContext fcbc)
throws TranslatorException {
LogManager.logTrace(LogConstants.CTX_CONNECTOR, "Parsing IN criteria."); // $NON-NLS-1$
Expression lhs = obj.getLeftExpression();
List<Expression> rhsList = obj.getRightExpressions();
List v = new ArrayList(rhsList.size());
// = Arrays.asList(1
boolean createdQuery = false;
for (Expression expr : rhsList) {
if (expr instanceof Literal) {
Literal literal = (Literal) expr;
Object value = escapeReservedChars(literal.getValue());
v.add(value);
createdQuery = true;
} else {
throw new TranslatorException(
InfinispanPlugin.Util.gs(InfinispanPlugin.Event.TEIID25052, new Object[] {expr, "IN"}));
}
}
if (createdQuery) {
Column col = ((ColumnReference) lhs).getMetadataObject();
if (fcbc == null) {
if (obj.isNegated()) {
return queryBuilder.not().having(col.getSourceName()).in(v);
}
return queryBuilder.having(col.getSourceName()).in(v);
}
if (obj.isNegated()) {
return fcbc.not().having(col.getSourceName()).in(v);
}
return fcbc.having(col.getSourceName()).in(v);
}
return null;
}
@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));
}
@SuppressWarnings("rawtypes")
public static FilterConditionContext visit(
IsNull obj, QueryBuilder queryBuilder, FilterConditionBeginContext fcbc) {
LogManager.logTrace(LogConstants.CTX_CONNECTOR, "Parsing IsNull criteria."); // $NON-NLS-1$
Expression exp = obj.getExpression();
Column c = ((ColumnReference) exp).getMetadataObject();
if (fcbc == null) {
if (obj.isNegated()) {
return queryBuilder.not().having(c.getSourceName()).isNull();
}
return queryBuilder.having(c.getSourceName()).isNull();
}
if (obj.isNegated()) {
return fcbc.not().having(c.getSourceName()).isNull();
}
return fcbc.having(c.getSourceName()).isNull();
}
private void addColumns(List<Column> columns, boolean includeType) {
append(LPAREN);
boolean first = true;
for (Column c : columns) {
if (first) {
first = false;
} else {
append(COMMA).append(SPACE);
}
if (includeType) {
appendColumn(c, true, includeType);
appendColumnOptions(c);
} else if (c.getParent() instanceof KeyRecord) {
// function based column
append(c.getNameInSource());
} else {
append(SQLStringVisitor.escapeSinglePart(c.getName()));
}
}
append(RPAREN);
}
static boolean sameColumnSet(KeyRecord recordOne, KeyRecord recordTwo) {
if (recordOne == null || recordTwo == null) {
return false;
}
List<Column> setOne = recordOne.getColumns();
List<Column> setTwo = recordTwo.getColumns();
if (setOne.size() != setTwo.size()) {
return false;
}
for (int i = 0; i < setOne.size(); i++) {
Column one = setOne.get(i);
Column two = setTwo.get(i);
if (!one.getName().equals(two.getName())) {
return false;
}
}
return true;
}
@SuppressWarnings("rawtypes")
public static FilterConditionContext visit(
Like obj, QueryBuilder queryBuilder, FilterConditionBeginContext fcbc)
throws TranslatorException {
LogManager.logTrace(LogConstants.CTX_CONNECTOR, "Parsing LIKE criteria."); // $NON-NLS-1$
Expression lhs = obj.getLeftExpression();
Expression rhs = obj.getRightExpression();
Column c = null;
Expression literalExp = null;
if (lhs instanceof ColumnReference) {
c = ((ColumnReference) lhs).getMetadataObject();
literalExp = rhs;
} else {
c = ((ColumnReference) rhs).getMetadataObject();
literalExp = lhs;
}
String value = null;
if (literalExp instanceof Literal) {
value = (String) escapeReservedChars(((Literal) literalExp).getValue());
if (fcbc == null) {
if (obj.isNegated()) {
return queryBuilder.not().having(c.getSourceName()).like(value);
}
return queryBuilder.having(c.getSourceName()).like(value);
}
if (obj.isNegated()) {
return fcbc.not().having(c.getSourceName()).like(value);
}
return fcbc.having(c.getSourceName()).like(value);
}
throw new TranslatorException(
InfinispanPlugin.Util.gs(
InfinispanPlugin.Event.TEIID25052, new Object[] {literalExp.toString(), "LIKE"}));
}
private void visit(Table table, Column column) {
append(NEWLINE).append(TAB);
if (table.getTableType() == Table.Type.TemporaryTable
&& column.isAutoIncremented()
&& column.getNullType() == NullType.No_Nulls
&& column.getJavaType() == DataTypeManager.DefaultDataClasses.INTEGER) {
append(SQLStringVisitor.escapeSinglePart(column.getName()));
append(SPACE);
append(SERIAL);
} else {
appendColumn(column, true, true);
if (column.isAutoIncremented()) {
append(SPACE).append(AUTO_INCREMENT);
}
}
appendDefault(column);
// options
appendColumnOptions(column);
}
@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);
}
}
}
}
}
public void handleInsertSequences(Insert insert) throws TranslatorException {
/*
* If a missing auto_increment column is modeled with name in source indicating that an Oracle Sequence
* then pull the Sequence name out of the name in source of the column.
*/
if (!(insert.getValueSource() instanceof ExpressionValueSource)) {
return;
}
ExpressionValueSource values = (ExpressionValueSource) insert.getValueSource();
if (insert.getTable().getMetadataObject() == null) {
return;
}
List<Column> allElements = insert.getTable().getMetadataObject().getColumns();
if (allElements.size() == values.getValues().size()) {
return;
}
int index = 0;
List<ColumnReference> elements = insert.getColumns();
for (Column element : allElements) {
if (!element.isAutoIncremented()) {
continue;
}
String name = element.getNameInSource();
int seqIndex = name.indexOf(SEQUENCE);
if (seqIndex == -1) {
continue;
}
boolean found = false;
while (index < elements.size()) {
if (element.equals(elements.get(index).getMetadataObject())) {
found = true;
break;
}
index++;
}
if (found) {
continue;
}
String sequence = name.substring(seqIndex + SEQUENCE.length());
int delimiterIndex = sequence.indexOf(Tokens.DOT);
if (delimiterIndex == -1) {
throw new TranslatorException(
JDBCPlugin.Event.TEIID11017,
JDBCPlugin.Util.gs(JDBCPlugin.Event.TEIID11017, SEQUENCE, name));
}
String sequenceGroupName = sequence.substring(0, delimiterIndex);
String sequenceElementName = sequence.substring(delimiterIndex + 1);
NamedTable sequenceGroup =
this.getLanguageFactory().createNamedTable(sequenceGroupName, null, null);
ColumnReference sequenceElement =
this.getLanguageFactory()
.createColumnReference(
sequenceElementName, sequenceGroup, null, element.getJavaType());
insert
.getColumns()
.add(
index,
this.getLanguageFactory()
.createColumnReference(
element.getName(), insert.getTable(), element, element.getJavaType()));
values.getValues().add(index, sequenceElement);
}
}
private void buildColumnOptions(BaseColumn baseColumn, StringBuilder options) {
if (baseColumn instanceof Column) {
Column column = (Column) baseColumn;
if (!column.isSelectable()) {
addOption(options, SELECTABLE, column.isSelectable());
}
// if table is already updatable, then columns are implicitly updatable.
if (!column.isUpdatable()
&& column.getParent() instanceof Table
&& ((Table) column.getParent()).supportsUpdate()) {
addOption(options, UPDATABLE, column.isUpdatable());
}
if (column.isCurrency()) {
addOption(options, CURRENCY, column.isCurrency());
}
// only record if not default
if (!column.isCaseSensitive() && column.getDatatype().isCaseSensitive()) {
addOption(options, CASE_SENSITIVE, column.isCaseSensitive());
}
if (!column.isSigned() && column.getDatatype().isSigned()) {
addOption(options, SIGNED, column.isSigned());
}
if (column.isFixedLength()) {
addOption(options, FIXED_LENGTH, column.isFixedLength());
}
// length and octet length should be same. so this should be never be true.
// TODO - this is not quite valid since we are dealing with length representing chars in
// UTF-16, then there should be twice the bytes
if (column.getCharOctetLength() != 0 && column.getLength() != column.getCharOctetLength()) {
addOption(options, CHAR_OCTET_LENGTH, column.getCharOctetLength());
}
// by default the search type is default data type search, so avoid it.
if (column.getSearchType() != null
&& (!column.getSearchType().equals(column.getDatatype().getSearchType())
|| column.isSearchTypeSet())) {
addOption(options, SEARCHABLE, column.getSearchType().name());
}
if (column.getMinimumValue() != null) {
addOption(options, MIN_VALUE, column.getMinimumValue());
}
if (column.getMaximumValue() != null) {
addOption(options, MAX_VALUE, column.getMaximumValue());
}
if (column.getNullValues() != -1) {
addOption(options, NULL_VALUE_COUNT, column.getNullValues());
}
if (column.getDistinctValues() != -1) {
addOption(options, DISTINCT_VALUES, column.getDistinctValues());
}
}
if (baseColumn.getNativeType() != null) {
addOption(options, NATIVE_TYPE, baseColumn.getNativeType());
}
buildOptions(baseColumn, options);
}
@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());
}
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);
}
}
@SuppressWarnings("rawtypes")
public static FilterConditionContext visit(
Comparison obj, QueryBuilder queryBuilder, FilterConditionBeginContext fcbc)
throws TranslatorException {
LogManager.logTrace(LogConstants.CTX_CONNECTOR, "Parsing Comparison criteria."); // $NON-NLS-1$
Comparison.Operator op = obj.getOperator();
Expression lhs = obj.getLeftExpression();
Expression rhs = obj.getRightExpression();
// joins between the objects in the same cache is not usable
if ((lhs instanceof ColumnReference && rhs instanceof ColumnReference)
|| (lhs instanceof Literal && rhs instanceof Literal)) {
return null;
}
Object value = null;
Column mdIDElement = null;
Literal literal = null;
if (lhs instanceof ColumnReference) {
mdIDElement = ((ColumnReference) lhs).getMetadataObject();
literal = (Literal) rhs;
value = literal.getValue();
} else if (rhs instanceof ColumnReference) {
mdIDElement = ((ColumnReference) rhs).getMetadataObject();
literal = (Literal) lhs;
value = literal.getValue();
}
if (value == null) {
throw new TranslatorException(InfinispanPlugin.Util.gs(InfinispanPlugin.Event.TEIID25051));
}
value = escapeReservedChars(value);
switch (op) {
case NE:
if (fcbc == null) {
return queryBuilder.not().having(mdIDElement.getSourceName()).eq(value);
}
return fcbc.not().having(mdIDElement.getSourceName()).eq(value);
case EQ:
if (fcbc == null) {
return queryBuilder.having(mdIDElement.getSourceName()).eq(value);
}
return fcbc.having(mdIDElement.getSourceName()).eq(value);
case GT:
if (fcbc == null) {
return queryBuilder.having(mdIDElement.getSourceName()).gt(value);
}
return fcbc.having(mdIDElement.getSourceName()).gt(value);
case GE:
if (fcbc == null) {
return queryBuilder.having(mdIDElement.getSourceName()).gte(value);
}
return fcbc.having(mdIDElement.getSourceName()).gte(value);
case LT:
if (fcbc == null) {
return queryBuilder.having(mdIDElement.getSourceName()).lt(value);
}
return fcbc.having(mdIDElement.getSourceName()).lt(value);
case LE:
if (fcbc == null) {
return queryBuilder.having(mdIDElement.getSourceName()).lte(value);
}
return fcbc.having(mdIDElement.getSourceName()).lte(value);
default:
throw new TranslatorException(
InfinispanPlugin.Util.gs(
InfinispanPlugin.Event.TEIID25050, new Object[] {op, "NE, EQ, GT, GE, LT, LE"}));
}
}
private Object convertSingleValue(
Column modelElement, String modelAttrName, Class<?> modelAttrClass, Object objResult)
throws TranslatorException, InvalidNameException {
if (objResult == null) {
return null;
}
// GHH 20080326 - if attribute is not a string or empty, just
// return null.
if (!(objResult instanceof String)) {
return objResult;
}
String strResult = (String) objResult;
// MPW - 3.9.07 - Also return NULL when attribute is unset or empty string.
// There is no way to differentiate between being unset and being the empty string.
if (strResult.equals("")) { // $NON-NLS-1$
return null;
}
// MPW: 3-11-07: Added support for java.lang.Integer conversion.
if (TypeFacility.RUNTIME_TYPES.TIMESTAMP.equals(modelAttrClass)) {
String timestampFormat = modelElement.getFormat();
if (timestampFormat == null) {
timestampFormat = LDAPConnectorConstants.ldapTimestampFormat;
}
SimpleDateFormat dateFormat = new SimpleDateFormat(timestampFormat);
try {
Date dateResult = dateFormat.parse(strResult);
Timestamp tsResult = new Timestamp(dateResult.getTime());
return tsResult;
} catch (ParseException pe) {
throw new TranslatorException(
pe,
LDAPPlugin.Util.getString(
"LDAPSyncQueryExecution.timestampParseFailed", modelAttrName)); // $NON-NLS-1$
}
// TODO: Extend support for more types in the future.
// Specifically, add support for byte arrays, since that's actually supported
// in the underlying data source.
}
// extract rdn
String type = modelElement.getProperty(LDAPExecutionFactory.RDN_TYPE, false);
if (type != null) {
String prefix = modelElement.getProperty(LDAPExecutionFactory.DN_PREFIX, false);
LdapName name = new LdapName(strResult);
if (prefix != null) {
if (!name.getPrefix(name.size() - 1).toString().equals(prefix)) {
throw new InvalidNameException();
}
} else if (name.size() > 1) {
throw new InvalidNameException();
}
Rdn rdn = name.getRdn(name.size() - 1);
if (!rdn.getType().equals(type)) {
throw new InvalidNameException();
}
return rdn.getValue();
}
return strResult; // the Teiid type conversion logic will handle refine from here if necessary
}
// GHH 20080326 - added resultDistinguishedName to method signature. If
// there is an element in the model named "DN" and there is no attribute
// with this name in the search result, we return this new parameter
// value for that column in the result
// GHH 20080326 - added handling of ClassCastException when non-string
// attribute is returned
private Object getValue(
Column modelElement, SearchResult result, Attributes attrs, boolean unwrap)
throws TranslatorException, InvalidNameException {
String modelAttrName = modelElement.getSourceName();
Class<?> modelAttrClass = modelElement.getJavaType();
String multivalAttr = modelElement.getDefaultValue();
if (modelAttrName == null) {
final String msg =
LDAPPlugin.Util.getString("LDAPSyncQueryExecution.nullAttrError"); // $NON-NLS-1$
throw new TranslatorException(msg);
}
Attribute resultAttr = attrs.get(modelAttrName);
// If the attribute is not present, we return NULL.
if (resultAttr == null) {
// GHH 20080326 - return DN from input parameter
// if DN attribute is not present in search result
if (modelAttrName.equalsIgnoreCase("DN")) { // $NON-NLS-1$
return result.getNameInNamespace();
}
return null;
}
Object objResult = null;
try {
if (TypeFacility.RUNTIME_TYPES.STRING.equals(modelAttrClass)
&& MULTIVALUED_CONCAT.equalsIgnoreCase(multivalAttr)) {
// mpw 5/09
// Order the multi-valued attrs alphabetically before creating a single string,
// using the delimiter to separate each token
ArrayList<String> multivalList = new ArrayList<String>();
NamingEnumeration<?> attrNE = resultAttr.getAll();
int length = 0;
while (attrNE.hasMore()) {
String val = (String) attrNE.next();
multivalList.add(val);
length += ((val == null ? 0 : val.length()) + 1);
}
Collections.sort(multivalList);
StringBuilder multivalSB = new StringBuilder(length);
Iterator<String> itr = multivalList.iterator();
while (itr.hasNext()) {
multivalSB.append(itr.next());
if (itr.hasNext()) {
multivalSB.append(delimiter);
}
}
return multivalSB.toString();
}
if (modelAttrClass.isArray()) {
return getArray(modelAttrClass.getComponentType(), resultAttr, modelElement, modelAttrName);
}
if (unwrap && resultAttr.size() > 1) {
return getArray(modelAttrClass, resultAttr, modelElement, modelAttrName);
}
// just a single value
objResult = resultAttr.get();
} catch (NamingException ne) {
final String msg =
LDAPPlugin.Util.gs(LDAPPlugin.Event.TEIID12004, modelAttrName)
+ " : "
+ ne.getExplanation(); // $NON-NLS-1$m
LogManager.logWarning(LogConstants.CTX_CONNECTOR, msg);
throw new TranslatorException(ne, msg);
}
return convertSingleValue(modelElement, modelAttrName, modelAttrClass, objResult);
}
private static void buildFunctionImports(MetadataStore metadataStore, List<Builder> edmSchemas) {
for (Schema schema : metadataStore.getSchemaList()) {
EdmSchema.Builder odataSchema = findSchema(edmSchemas, schema.getName());
EdmEntityContainer.Builder entityContainer =
findEntityContainer(edmSchemas, schema.getName());
// procedures
for (Procedure proc : schema.getProcedures().values()) {
EdmFunctionImport.Builder edmProcedure = EdmFunctionImport.newBuilder();
edmProcedure.setName(proc.getName());
String httpMethod = "POST";
for (ProcedureParameter pp : proc.getParameters()) {
if (pp.getName().equals("return")) {
httpMethod = "GET";
edmProcedure.setReturnType(
ODataTypeManager.odataType(pp.getDatatype().getRuntimeTypeName()));
continue;
}
EdmFunctionParameter.Builder param = EdmFunctionParameter.newBuilder();
param.setName(pp.getName());
param.setType(ODataTypeManager.odataType(pp.getDatatype().getRuntimeTypeName()));
if (pp.getType() == ProcedureParameter.Type.In) {
param.setMode(Mode.In);
} else if (pp.getType() == ProcedureParameter.Type.InOut) {
param.setMode(Mode.InOut);
} else if (pp.getType() == ProcedureParameter.Type.Out) {
param.setMode(Mode.Out);
}
param.setNullable(pp.getNullType() == NullType.Nullable);
edmProcedure.addParameters(param);
}
// add a complex type for return resultset.
ColumnSet<Procedure> returnColumns = proc.getResultSet();
if (returnColumns != null) {
httpMethod = "GET";
EdmComplexType.Builder complexType = EdmComplexType.newBuilder();
complexType.setName(proc.getName() + "_" + returnColumns.getName());
complexType.setNamespace(schema.getName());
for (Column c : returnColumns.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);
}
complexType.addProperties(property);
}
odataSchema.addComplexTypes(complexType);
edmProcedure.setIsCollection(true);
edmProcedure.setReturnType(
EdmCollectionType.newBuilder()
.setCollectionType(complexType)
.setKind(CollectionKind.Collection));
}
edmProcedure.setHttpMethod(httpMethod);
entityContainer.addFunctionImports(edmProcedure);
}
}
}