[teiid-commits] teiid SVN: r2373 - in trunk: connectors/translator-jdbc/src/test/java/org/teiid/translator/jdbc/sqlserver and 21 other directories.

[teiid-commits at lists.jboss.org]

Author: shawkins
Date: 2010-07-26 10:17:53 -0400 (Mon, 26 Jul 2010)
New Revision: 2373

Added:
   trunk/engine/src/main/java/org/teiid/query/metadata/CompositeMetadataStore.java
   trunk/engine/src/main/java/org/teiid/query/metadata/TransformationMetadata.java
   trunk/engine/src/test/java/org/teiid/query/metadata/
   trunk/metadata/src/main/java/org/teiid/metadata/VdbConstants.java
Removed:
   trunk/engine/src/main/java/org/teiid/metadata/
   trunk/engine/src/test/java/org/teiid/metadata/
Modified:
   trunk/connectors/translator-jdbc/src/test/java/org/teiid/translator/jdbc/oracle/TestOracleTranslator.java
   trunk/connectors/translator-jdbc/src/test/java/org/teiid/translator/jdbc/sqlserver/TestSqlServerConversionVisitor.java
   trunk/connectors/translator-ldap/src/test/java/org/teiid/translator/ldap/TestIQueryToLdapSearchParser.java
   trunk/connectors/translator-salesforce/src/test/java/org/teiid/translator/salesforce/execution/visitors/TestVisitors.java
   trunk/engine/src/main/java/org/teiid/dqp/internal/datamgr/RuntimeMetadataImpl.java
   trunk/engine/src/main/java/org/teiid/dqp/internal/process/DataTierManagerImpl.java
   trunk/engine/src/main/java/org/teiid/query/metadata/TempMetadataAdapter.java
   trunk/engine/src/main/java/org/teiid/query/metadata/TempMetadataID.java
   trunk/engine/src/main/java/org/teiid/query/optimizer/relational/PlanToProcessConverter.java
   trunk/engine/src/main/java/org/teiid/query/resolver/command/TempTableResolver.java
   trunk/engine/src/main/java/org/teiid/query/resolver/util/ResolverUtil.java
   trunk/engine/src/main/java/org/teiid/query/tempdata/TempTableStore.java
   trunk/engine/src/test/java/org/teiid/query/metadata/TestTransformationMetadata.java
   trunk/engine/src/test/java/org/teiid/query/optimizer/TestDependentJoins.java
   trunk/engine/src/test/java/org/teiid/query/processor/TestSQLXMLProcessing.java
   trunk/engine/src/test/java/org/teiid/query/processor/TestTempTables.java
   trunk/engine/src/test/java/org/teiid/query/processor/TestTextTable.java
   trunk/engine/src/test/java/org/teiid/query/unittest/FakeMetadataFactory.java
   trunk/engine/src/test/java/org/teiid/query/unittest/RealMetadataFactory.java
   trunk/metadata/src/main/java/org/teiid/metadata/index/IndexMetadataFactory.java
   trunk/metadata/src/test/java/org/teiid/metadata/index/TestMultipleModelIndexes.java
   trunk/metadata/src/test/java/org/teiid/metadata/index/VDBMetadataFactory.java
   trunk/runtime/src/main/java/org/teiid/deployers/CompositeVDB.java
   trunk/runtime/src/main/java/org/teiid/deployers/VDBDeployer.java
   trunk/runtime/src/main/java/org/teiid/deployers/VDBRepository.java
   trunk/test-integration/common/src/test/java/org/teiid/dqp/internal/process/BaseQueryTest.java
   trunk/test-integration/common/src/test/java/org/teiid/dqp/internal/process/TestXMLTypeTranslations.java
Log:
TEIID-1167 adding primary key metadata TEIID-1166 fixing assertion error

Modified: trunk/connectors/translator-jdbc/src/test/java/org/teiid/translator/jdbc/oracle/TestOracleTranslator.java
===================================================================
--- trunk/connectors/translator-jdbc/src/test/java/org/teiid/translator/jdbc/oracle/TestOracleTranslator.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/connectors/translator-jdbc/src/test/java/org/teiid/translator/jdbc/oracle/TestOracleTranslator.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -36,12 +36,12 @@
 import org.teiid.dqp.internal.datamgr.FakeExecutionContextImpl;
 import org.teiid.language.Command;
 import org.teiid.metadata.Column;
-import org.teiid.metadata.CompositeMetadataStore;
 import org.teiid.metadata.MetadataStore;
 import org.teiid.metadata.Schema;
 import org.teiid.metadata.Table;
-import org.teiid.metadata.TransformationMetadata;
+import org.teiid.query.metadata.CompositeMetadataStore;
 import org.teiid.query.metadata.QueryMetadataInterface;
+import org.teiid.query.metadata.TransformationMetadata;
 import org.teiid.query.unittest.FakeMetadataFactory;
 import org.teiid.query.unittest.RealMetadataFactory;
 import org.teiid.translator.TranslatorException;

Modified: trunk/connectors/translator-jdbc/src/test/java/org/teiid/translator/jdbc/sqlserver/TestSqlServerConversionVisitor.java
===================================================================
--- trunk/connectors/translator-jdbc/src/test/java/org/teiid/translator/jdbc/sqlserver/TestSqlServerConversionVisitor.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/connectors/translator-jdbc/src/test/java/org/teiid/translator/jdbc/sqlserver/TestSqlServerConversionVisitor.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -30,12 +30,12 @@
 import org.teiid.core.types.DataTypeManager;
 import org.teiid.language.Command;
 import org.teiid.metadata.Column;
-import org.teiid.metadata.CompositeMetadataStore;
 import org.teiid.metadata.MetadataStore;
 import org.teiid.metadata.Schema;
 import org.teiid.metadata.Table;
-import org.teiid.metadata.TransformationMetadata;
+import org.teiid.query.metadata.CompositeMetadataStore;
 import org.teiid.query.metadata.QueryMetadataInterface;
+import org.teiid.query.metadata.TransformationMetadata;
 import org.teiid.query.unittest.RealMetadataFactory;
 import org.teiid.translator.TranslatorException;
 import org.teiid.translator.jdbc.TranslationHelper;

Modified: trunk/connectors/translator-ldap/src/test/java/org/teiid/translator/ldap/TestIQueryToLdapSearchParser.java
===================================================================
--- trunk/connectors/translator-ldap/src/test/java/org/teiid/translator/ldap/TestIQueryToLdapSearchParser.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/connectors/translator-ldap/src/test/java/org/teiid/translator/ldap/TestIQueryToLdapSearchParser.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -39,14 +39,14 @@
 import org.teiid.language.Command;
 import org.teiid.language.Select;
 import org.teiid.metadata.Column;
-import org.teiid.metadata.CompositeMetadataStore;
 import org.teiid.metadata.MetadataStore;
 import org.teiid.metadata.RuntimeMetadata;
 import org.teiid.metadata.Schema;
 import org.teiid.metadata.Table;
-import org.teiid.metadata.TransformationMetadata;
 import org.teiid.metadata.Column.SearchType;
+import org.teiid.query.metadata.CompositeMetadataStore;
 import org.teiid.query.metadata.QueryMetadataInterface;
+import org.teiid.query.metadata.TransformationMetadata;
 import org.teiid.query.unittest.RealMetadataFactory;
 import org.teiid.translator.TranslatorException;
 import org.teiid.translator.ldap.IQueryToLdapSearchParser;

Modified: trunk/connectors/translator-salesforce/src/test/java/org/teiid/translator/salesforce/execution/visitors/TestVisitors.java
===================================================================
--- trunk/connectors/translator-salesforce/src/test/java/org/teiid/translator/salesforce/execution/visitors/TestVisitors.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/connectors/translator-salesforce/src/test/java/org/teiid/translator/salesforce/execution/visitors/TestVisitors.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -31,13 +31,13 @@
 import org.teiid.core.types.DataTypeManager;
 import org.teiid.language.Select;
 import org.teiid.metadata.Column;
-import org.teiid.metadata.CompositeMetadataStore;
 import org.teiid.metadata.MetadataStore;
 import org.teiid.metadata.Schema;
 import org.teiid.metadata.Table;
-import org.teiid.metadata.TransformationMetadata;
 import org.teiid.metadata.Column.SearchType;
+import org.teiid.query.metadata.CompositeMetadataStore;
 import org.teiid.query.metadata.QueryMetadataInterface;
+import org.teiid.query.metadata.TransformationMetadata;
 import org.teiid.query.unittest.RealMetadataFactory;
 import org.teiid.translator.salesforce.execution.visitors.JoinQueryVisitor;
 import org.teiid.translator.salesforce.execution.visitors.SelectVisitor;

Modified: trunk/engine/src/main/java/org/teiid/dqp/internal/datamgr/RuntimeMetadataImpl.java
===================================================================
--- trunk/engine/src/main/java/org/teiid/dqp/internal/datamgr/RuntimeMetadataImpl.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/engine/src/main/java/org/teiid/dqp/internal/datamgr/RuntimeMetadataImpl.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -27,9 +27,12 @@
 import org.teiid.api.exception.query.QueryMetadataException;
 import org.teiid.core.TeiidComponentException;
 import org.teiid.core.util.ArgCheck;
-import org.teiid.metadata.*;
-import org.teiid.query.metadata.QueryMetadataInterface;
-import org.teiid.query.metadata.StoredProcedureInfo;
+import org.teiid.metadata.Column;
+import org.teiid.metadata.Procedure;
+import org.teiid.metadata.ProcedureParameter;
+import org.teiid.metadata.RuntimeMetadata;
+import org.teiid.metadata.Table;
+import org.teiid.query.metadata.*;
 import org.teiid.query.sql.lang.SPParameter;
 import org.teiid.translator.TranslatorException;
 

Modified: trunk/engine/src/main/java/org/teiid/dqp/internal/process/DataTierManagerImpl.java
===================================================================
--- trunk/engine/src/main/java/org/teiid/dqp/internal/process/DataTierManagerImpl.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/engine/src/main/java/org/teiid/dqp/internal/process/DataTierManagerImpl.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -60,7 +60,6 @@
 import org.teiid.language.SQLConstants.Reserved;
 import org.teiid.metadata.AbstractMetadataRecord;
 import org.teiid.metadata.Column;
-import org.teiid.metadata.CompositeMetadataStore;
 import org.teiid.metadata.Datatype;
 import org.teiid.metadata.ForeignKey;
 import org.teiid.metadata.KeyRecord;
@@ -68,7 +67,8 @@
 import org.teiid.metadata.ProcedureParameter;
 import org.teiid.metadata.Schema;
 import org.teiid.metadata.Table;
-import org.teiid.metadata.TransformationMetadata;
+import org.teiid.query.metadata.CompositeMetadataStore;
+import org.teiid.query.metadata.TransformationMetadata;
 import org.teiid.query.processor.CollectionTupleSource;
 import org.teiid.query.processor.ProcessorDataManager;
 import org.teiid.query.processor.QueryProcessor;

Copied: trunk/engine/src/main/java/org/teiid/query/metadata/CompositeMetadataStore.java (from rev 2371, trunk/engine/src/main/java/org/teiid/metadata/CompositeMetadataStore.java)
===================================================================
--- trunk/engine/src/main/java/org/teiid/query/metadata/CompositeMetadataStore.java	                        (rev 0)
+++ trunk/engine/src/main/java/org/teiid/query/metadata/CompositeMetadataStore.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -0,0 +1,145 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership.  Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301 USA.
+ */
+
+package org.teiid.query.metadata;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.teiid.api.exception.query.QueryMetadataException;
+import org.teiid.core.TeiidComponentException;
+import org.teiid.metadata.MetadataStore;
+import org.teiid.metadata.Procedure;
+import org.teiid.metadata.Schema;
+import org.teiid.metadata.Table;
+import org.teiid.metadata.Table.Type;
+
+
+/**
+ * Aggregates the metadata from multiple stores.  
+ * IMPORTANT: All strings queries should be in lower case.
+ */
+public class CompositeMetadataStore extends MetadataStore {
+
+	
+	public CompositeMetadataStore(MetadataStore metadataStore) {
+		addMetadataStore(metadataStore);
+	}
+	
+	public CompositeMetadataStore(List<MetadataStore> metadataStores) {
+		for (MetadataStore metadataStore : metadataStores) {
+			addMetadataStore(metadataStore);
+		}
+	}
+	
+	public void addMetadataStore(MetadataStore metadataStore) {
+		this.schemas.putAll(metadataStore.getSchemas());
+		this.datatypes.addAll(metadataStore.getDatatypes());
+	}
+	
+	public Schema getSchema(String fullName)
+			throws QueryMetadataException {
+		Schema result = getSchemas().get(fullName);
+		if (result == null) {
+	        throw new QueryMetadataException(fullName+TransformationMetadata.NOT_EXISTS_MESSAGE);
+		}
+		return result;
+	}
+	
+	public Table findGroup(String fullName)
+			throws QueryMetadataException {
+		int index = fullName.indexOf(TransformationMetadata.DELIMITER_STRING);
+		if (index == -1) {
+		    throw new QueryMetadataException(fullName+TransformationMetadata.NOT_EXISTS_MESSAGE);
+		}			
+		String schema = fullName.substring(0, index);
+		Table result = getSchema(schema).getTables().get(fullName.substring(index + 1));
+		if (result == null) {
+	        throw new QueryMetadataException(fullName+TransformationMetadata.NOT_EXISTS_MESSAGE);
+		}
+		return result;
+	}
+	
+	/**
+	 * TODO: this resolving mode allows partial matches of a full group name containing .
+	 * @param partialGroupName
+	 * @return
+	 */
+	public Collection<Table> getGroupsForPartialName(String partialGroupName) {
+		List<Table> result = new LinkedList<Table>();
+		for (Schema schema : getSchemas().values()) {
+			for (Table t : schema.getTables().values()) {
+				String fullName = t.getFullName();
+				if (fullName.regionMatches(true, fullName.length() - partialGroupName.length(), partialGroupName, 0, partialGroupName.length())) {
+					result.add(t);	
+				}
+			}
+		}
+		return result;
+	}
+	
+	public Collection<Procedure> getStoredProcedure(String name)
+			throws TeiidComponentException, QueryMetadataException {
+		List<Procedure> result = new LinkedList<Procedure>();
+		int index = name.indexOf(TransformationMetadata.DELIMITER_STRING);
+		if (index > -1) {
+			String schema = name.substring(0, index);
+			Procedure proc = getSchema(schema).getProcedures().get(name.substring(index + 1));
+			if (proc != null) {
+				result.add(proc);
+		        return result;
+			}	
+		}
+		//assume it's a partial name
+		name = TransformationMetadata.DELIMITER_STRING + name;
+		for (Schema schema : getSchemas().values()) {
+			for (Procedure p : schema.getProcedures().values()) {
+				String fullName = p.getFullName();
+				if (fullName.regionMatches(true, fullName.length() - name.length(), name, 0, name.length())) {
+					result.add(p);	
+				}
+			}
+		}
+		if (result.isEmpty()) {
+	        throw new QueryMetadataException(name.substring(1)+TransformationMetadata.NOT_EXISTS_MESSAGE);
+		}
+		return result;
+	}
+
+	/*
+	 * The next method is a hold over from XML/UUID resolving and will perform poorly
+	 */
+
+	public Collection<Table> getXMLTempGroups(Table tableRecord) {
+		ArrayList<Table> results = new ArrayList<Table>();
+		String namePrefix = tableRecord.getFullName() + TransformationMetadata.DELIMITER_STRING;
+		for (Table table : tableRecord.getParent().getTables().values()) {
+			if (table.getTableType() == Type.XmlStagingTable && table.getName().startsWith(namePrefix)) {
+				results.add(table);
+			}
+		}
+		return results;
+	}
+	
+}


Property changes on: trunk/engine/src/main/java/org/teiid/query/metadata/CompositeMetadataStore.java
___________________________________________________________________
Name: svn:mime-type
   + text/plain

Modified: trunk/engine/src/main/java/org/teiid/query/metadata/TempMetadataAdapter.java
===================================================================
--- trunk/engine/src/main/java/org/teiid/query/metadata/TempMetadataAdapter.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/engine/src/main/java/org/teiid/query/metadata/TempMetadataAdapter.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -23,6 +23,7 @@
 package org.teiid.query.metadata;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -371,7 +372,11 @@
         throws TeiidComponentException, QueryMetadataException {
         
         if(groupID instanceof TempMetadataID) {
-            return Collections.EMPTY_LIST;
+        	TempMetadataID id = (TempMetadataID)groupID;
+        	if (id.getPrimaryKey() == null) {
+        		return Collections.emptyList();
+        	}
+            return Arrays.asList(groupID);
         }
         return this.actualMetadata.getUniqueKeysInGroup(groupID);   
     }
@@ -396,6 +401,10 @@
     public List getElementIDsInKey(Object keyID) 
         throws TeiidComponentException, QueryMetadataException {
         
+    	if (keyID instanceof TempMetadataID) {
+    		return ((TempMetadataID)keyID).getPrimaryKey();
+    	}
+    	
         return this.actualMetadata.getElementIDsInKey(keyID);   
     }    
 

Modified: trunk/engine/src/main/java/org/teiid/query/metadata/TempMetadataID.java
===================================================================
--- trunk/engine/src/main/java/org/teiid/query/metadata/TempMetadataID.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/engine/src/main/java/org/teiid/query/metadata/TempMetadataID.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -51,6 +51,7 @@
     private int cardinality = QueryMetadataInterface.UNKNOWN_CARDINALITY;
     private LRUCache localCache;
     private boolean scalarGroup;
+    private List<TempMetadataID> primaryKey;
     
     /**
      * Constructor for group form of metadata ID.
@@ -58,8 +59,7 @@
      * @param elements List of TempMetadataID representing elements
      */
     public TempMetadataID(String ID, List<TempMetadataID> elements) {
-        this.ID = ID;
-        this.elements = elements;
+        this(ID, elements, true, false);
     }
     
     /**
@@ -246,5 +246,13 @@
 	public void setScalarGroup(boolean scalarGroup) {
 		this.scalarGroup = scalarGroup;
 	}
+
+	public List<TempMetadataID> getPrimaryKey() {
+		return primaryKey;
+	}
+	
+	public void setPrimaryKey(List<TempMetadataID> primaryKey) {
+		this.primaryKey = primaryKey;
+	}
 		
 }

Copied: trunk/engine/src/main/java/org/teiid/query/metadata/TransformationMetadata.java (from rev 2371, trunk/engine/src/main/java/org/teiid/metadata/TransformationMetadata.java)
===================================================================
--- trunk/engine/src/main/java/org/teiid/query/metadata/TransformationMetadata.java	                        (rev 0)
+++ trunk/engine/src/main/java/org/teiid/query/metadata/TransformationMetadata.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -0,0 +1,1070 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership.  Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301 USA.
+ */
+
+package org.teiid.query.metadata;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+
+import org.jboss.virtual.VirtualFile;
+import org.teiid.adminapi.impl.VDBMetaData;
+import org.teiid.api.exception.query.QueryMetadataException;
+import org.teiid.core.TeiidComponentException;
+import org.teiid.core.types.BlobImpl;
+import org.teiid.core.types.ClobImpl;
+import org.teiid.core.types.DataTypeManager;
+import org.teiid.core.types.InputStreamFactory;
+import org.teiid.core.types.SQLXMLImpl;
+import org.teiid.core.util.ArgCheck;
+import org.teiid.core.util.LRUCache;
+import org.teiid.core.util.ObjectConverterUtil;
+import org.teiid.core.util.StringUtil;
+import org.teiid.dqp.DQPPlugin;
+import org.teiid.metadata.AbstractMetadataRecord;
+import org.teiid.metadata.Column;
+import org.teiid.metadata.ColumnSet;
+import org.teiid.metadata.Datatype;
+import org.teiid.metadata.ForeignKey;
+import org.teiid.metadata.KeyRecord;
+import org.teiid.metadata.Procedure;
+import org.teiid.metadata.ProcedureParameter;
+import org.teiid.metadata.Schema;
+import org.teiid.metadata.Table;
+import org.teiid.metadata.BaseColumn.NullType;
+import org.teiid.metadata.Column.SearchType;
+import org.teiid.metadata.ProcedureParameter.Type;
+import org.teiid.query.QueryPlugin;
+import org.teiid.query.function.FunctionLibrary;
+import org.teiid.query.function.FunctionTree;
+import org.teiid.query.function.SystemFunctionManager;
+import org.teiid.query.function.UDFSource;
+import org.teiid.query.function.metadata.FunctionMethod;
+import org.teiid.query.mapping.relational.QueryNode;
+import org.teiid.query.mapping.xml.MappingDocument;
+import org.teiid.query.mapping.xml.MappingLoader;
+import org.teiid.query.mapping.xml.MappingNode;
+import org.teiid.query.sql.lang.SPParameter;
+
+
+/**
+ * Teiid's implementation of the QueryMetadataInterface that reads columns, groups, models etc.
+ * from the metadata object model.
+ */
+public class TransformationMetadata extends BasicQueryMetadata implements Serializable {
+	
+	private final class VirtualFileInputStreamFactory extends
+			InputStreamFactory {
+		private final VirtualFile f;
+
+		private VirtualFileInputStreamFactory(VirtualFile f) {
+			this.f = f;
+		}
+
+		@Override
+		public InputStream getInputStream() throws IOException {
+			return f.openStream();
+		}
+		
+		@Override
+		public long getLength() {
+			try {
+				return f.getSize();
+			} catch (IOException e) {
+			}
+			return super.getLength();
+		}
+		
+		@Override
+		public void free() throws IOException {
+			f.close();
+		}
+	}
+
+	public static class Resource {
+		public Resource(VirtualFile file, boolean visible) {
+			this.file = file;
+			this.visible = visible;
+		}
+		VirtualFile file;
+		boolean visible;
+	}
+	
+	private static final long serialVersionUID = 1058627332954475287L;
+	
+	/** Delimiter character used when specifying fully qualified entity names */
+    public static final char DELIMITER_CHAR = StringUtil.Constants.DOT_CHAR;
+    public static final String DELIMITER_STRING = String.valueOf(DELIMITER_CHAR);
+    
+    // error message cached to avoid i18n lookup each time
+    public static String NOT_EXISTS_MESSAGE = StringUtil.Constants.SPACE+DQPPlugin.Util.getString("TransformationMetadata.does_not_exist._1"); //$NON-NLS-1$
+
+    private static Properties EMPTY_PROPS = new Properties();
+    
+    private final CompositeMetadataStore store;
+    private Map<String, Resource> vdbEntries;
+    private FunctionLibrary functionLibrary;
+    private VDBMetaData vdbMetaData;
+    
+    /*
+     * TODO: move caching to jboss cache structure
+     */
+    private final Map<String, Object> metadataCache = Collections.synchronizedMap(new LRUCache<String, Object>(250));
+    private final Map<String, Object> groupInfoCache = Collections.synchronizedMap(new LRUCache<String, Object>(250));
+    private final Map<String, Collection<Table>> partialNameToFullNameCache = Collections.synchronizedMap(new LRUCache<String, Collection<Table>>(1000));
+    private final Map<String, Collection<StoredProcedureInfo>> procedureCache = Collections.synchronizedMap(new LRUCache<String, Collection<StoredProcedureInfo>>(200));
+    /**
+     * TransformationMetadata constructor
+     * @param context Object containing the info needed to lookup metadta.
+     */
+    public TransformationMetadata(VDBMetaData vdbMetadata, final CompositeMetadataStore store, Map<String, Resource> vdbEntries, Collection <FunctionMethod> udfMethods) {
+    	ArgCheck.isNotNull(store);
+    	this.vdbMetaData = vdbMetadata;
+        this.store = store;
+        if (vdbEntries == null) {
+        	this.vdbEntries = Collections.emptyMap();
+        } else {
+        	this.vdbEntries = vdbEntries;
+        }
+        if (udfMethods == null) {
+        	udfMethods = Collections.emptyList();
+        }
+        this.functionLibrary = new FunctionLibrary(SystemFunctionManager.getSystemFunctions(), new FunctionTree(new UDFSource(udfMethods)));
+    }
+    
+    //==================================================================================
+    //                     I N T E R F A C E   M E T H O D S
+    //==================================================================================
+
+    public Object getElementID(final String elementName) throws TeiidComponentException, QueryMetadataException {
+    	int columnIndex = elementName.lastIndexOf(TransformationMetadata.DELIMITER_STRING);
+		if (columnIndex == -1) {
+			throw new QueryMetadataException(elementName+TransformationMetadata.NOT_EXISTS_MESSAGE);
+		}
+		Table table = this.store.findGroup(elementName.substring(0, columnIndex));
+		String shortElementName = elementName.substring(columnIndex + 1);
+		for (Column column : (List<Column>)getElementIDsInGroupID(table)) {
+			if (column.getName().equalsIgnoreCase(shortElementName)) {
+				return column;
+			}
+        }
+        throw new QueryMetadataException(elementName+TransformationMetadata.NOT_EXISTS_MESSAGE);
+    }
+
+    public Object getGroupID(final String groupName) throws TeiidComponentException, QueryMetadataException {
+        return getMetadataStore().findGroup(groupName.toLowerCase());
+    }
+    
+    public Collection getGroupsForPartialName(final String partialGroupName)
+        throws TeiidComponentException, QueryMetadataException {
+		ArgCheck.isNotEmpty(partialGroupName);
+
+		Collection<Table> matches = this.partialNameToFullNameCache.get(partialGroupName);
+		
+		if (matches == null) {
+			String partialName = DELIMITER_CHAR + partialGroupName.toLowerCase(); 
+	
+	        matches = getMetadataStore().getGroupsForPartialName(partialName);
+	        
+        	this.partialNameToFullNameCache.put(partialGroupName, matches);
+		}
+		
+		if (matches.isEmpty()) {
+			return Collections.emptyList();
+		}
+		
+		Collection<String> filteredResult = new ArrayList<String>(matches.size());
+		for (Table table : matches) {
+			if (vdbMetaData == null || vdbMetaData.getModel(table.getParent().getName()).isVisible()) {
+	        	filteredResult.add(table.getFullName());
+	        }
+		}
+		return filteredResult;
+    }
+
+    public Object getModelID(final Object groupOrElementID) throws TeiidComponentException, QueryMetadataException {
+    	ArgCheck.isInstanceOf(AbstractMetadataRecord.class, groupOrElementID);
+        AbstractMetadataRecord metadataRecord = (AbstractMetadataRecord) groupOrElementID;
+        AbstractMetadataRecord parent = metadataRecord.getParent();
+        if (parent instanceof Schema) {
+        	return parent;
+        }
+        if (parent == null) {
+        	throw createInvalidRecordTypeException(groupOrElementID);
+        }
+        parent = metadataRecord.getParent();
+        if (parent instanceof Schema) {
+        	return parent;
+        }
+    	throw createInvalidRecordTypeException(groupOrElementID);
+    }
+
+    public String getFullName(final Object metadataID) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(AbstractMetadataRecord.class, metadataID);
+        AbstractMetadataRecord metadataRecord = (AbstractMetadataRecord) metadataID;
+        return metadataRecord.getFullName();
+    }
+
+    public String getFullElementName(final String fullGroupName, final String shortElementName)     
+        throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isNotEmpty(fullGroupName);
+        ArgCheck.isNotEmpty(shortElementName);
+
+        return fullGroupName + DELIMITER_CHAR + shortElementName;
+    }
+
+    public String getShortElementName(final String fullElementName) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isNotEmpty(fullElementName);
+        int index = fullElementName.lastIndexOf(DELIMITER_CHAR);
+        if(index >= 0) { 
+            return fullElementName.substring(index+1);
+        }
+        return fullElementName;
+    }
+
+    /**
+     * Return the text portion of the fullElementName representing a group.
+     * That means that this should only return text that is part of the 
+     * fullElementName and not look up new IDs or do much of anything fancy.
+     * This method is used by the resolver to decide which portion of a fully-
+     * qualified element name is the group name.  It will compare whatever comes
+     * back with the actual group names and aliases in the query, which is 
+     * why it is important not to introduce new metadata here.  Also, returning
+     * null indicates that no portion of the fullElementName is a
+     * group name - that is ok as it will be resolved as an ambiguous element.
+     * @see org.teiid.query.metadata.QueryMetadataInterface#getGroupName(java.lang.String)
+     */
+    public String getGroupName(final String fullElementName) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isNotEmpty(fullElementName);  
+
+        int index = fullElementName.lastIndexOf(DELIMITER_CHAR);
+        if(index >= 0) { 
+            return fullElementName.substring(0, index);
+        }
+        return null;
+    }
+
+    public List getElementIDsInGroupID(final Object groupID) throws TeiidComponentException, QueryMetadataException {
+    	ArgCheck.isInstanceOf(Table.class, groupID);
+    	return ((Table)groupID).getColumns();
+    }
+
+    public Object getGroupIDForElementID(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        if(elementID instanceof Column) {
+            Column columnRecord = (Column) elementID;
+            return this.getGroupID(getGroupName(columnRecord.getFullName()));
+        } else if(elementID instanceof ProcedureParameter){
+            ProcedureParameter columnRecord = (ProcedureParameter) elementID;
+            return this.getGroupID(getGroupName(columnRecord.getFullName()));
+        } else {
+            throw createInvalidRecordTypeException(elementID);
+        }
+    }
+
+    public StoredProcedureInfo getStoredProcedureInfoForProcedure(final String fullyQualifiedProcedureName)
+        throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isNotEmpty(fullyQualifiedProcedureName);
+        String lowerGroupName = fullyQualifiedProcedureName.toLowerCase();
+        Collection<StoredProcedureInfo> results = this.procedureCache.get(lowerGroupName);
+        
+        if (results == null) {
+        	Collection<Procedure> procRecords = getMetadataStore().getStoredProcedure(lowerGroupName); 
+        	results = new ArrayList<StoredProcedureInfo>(procRecords.size());
+        	for (Procedure procRecord : procRecords) {
+                String procedureFullName = procRecord.getFullName();
+
+                // create the storedProcedure info object that would hold procedure's metadata
+                StoredProcedureInfo procInfo = new StoredProcedureInfo();
+                procInfo.setProcedureCallableName(procedureFullName);
+                procInfo.setProcedureID(procRecord);
+
+                // modelID for the procedure
+                procInfo.setModelID(procRecord.getParent());
+
+                // get the parameter metadata info
+                for (ProcedureParameter paramRecord : procRecord.getParameters()) {
+                    String runtimeType = paramRecord.getRuntimeType();
+                    int direction = this.convertParamRecordTypeToStoredProcedureType(paramRecord.getType());
+                    // create a parameter and add it to the procedure object
+                    SPParameter spParam = new SPParameter(paramRecord.getPosition(), direction, paramRecord.getFullName());
+                    spParam.setMetadataID(paramRecord);
+                    spParam.setClassType(DataTypeManager.getDataTypeClass(runtimeType));
+                    procInfo.addParameter(spParam);
+                }
+
+                // if the procedure returns a resultSet, obtain resultSet metadata
+                if(procRecord.getResultSet() != null) {
+                    ColumnSet<Procedure> resultRecord = procRecord.getResultSet();
+                    // resultSet is the last parameter in the procedure
+                    int lastParamIndex = procInfo.getParameters().size() + 1;
+                    SPParameter param = new SPParameter(lastParamIndex, SPParameter.RESULT_SET, resultRecord.getFullName());
+                    param.setClassType(java.sql.ResultSet.class);           
+                    param.setMetadataID(resultRecord);
+
+                    for (Column columnRecord : resultRecord.getColumns()) {
+                        String colType = columnRecord.getRuntimeType();
+                        param.addResultSetColumn(columnRecord.getFullName(), DataTypeManager.getDataTypeClass(colType), columnRecord);
+                    }
+
+                    procInfo.addParameter(param);            
+                }
+
+                // if this is a virtual procedure get the procedure plan
+                if(procRecord.isVirtual()) {
+                    QueryNode queryNode = new QueryNode(procedureFullName, procRecord.getQueryPlan()); 
+                    procInfo.setQueryPlan(queryNode);
+                }
+                
+                //subtract 1, to match up with the server
+                procInfo.setUpdateCount(procRecord.getUpdateCount() -1);
+				results.add(procInfo);
+			}
+        	this.procedureCache.put(lowerGroupName, results);        	
+        }
+        
+        StoredProcedureInfo result = null;
+        
+        for (StoredProcedureInfo storedProcedureInfo : results) {
+        	Schema schema = (Schema)storedProcedureInfo.getModelID();
+	        if(vdbMetaData == null || vdbMetaData.getModel(schema.getName()).isVisible()){
+	        	if (result != null) {
+	    			throw new QueryMetadataException(QueryPlugin.Util.getString("ambiguous_procedure", fullyQualifiedProcedureName)); //$NON-NLS-1$
+	    		}
+	        	result = storedProcedureInfo;
+	        }
+		}
+        
+		if (result == null) {
+			throw new QueryMetadataException(fullyQualifiedProcedureName+NOT_EXISTS_MESSAGE);
+		}
+    	
+        return result;
+    }
+    
+    /**
+     * Method to convert the parameter type returned from a ProcedureParameterRecord
+     * to the parameter type expected by StoredProcedureInfo
+     * @param parameterType
+     * @return
+     */
+    private int convertParamRecordTypeToStoredProcedureType(final ProcedureParameter.Type parameterType) {
+        switch (parameterType) {
+            case In : return SPParameter.IN;
+            case Out : return SPParameter.OUT;
+            case InOut : return SPParameter.INOUT;
+            case ReturnValue : return SPParameter.RETURN_VALUE;
+            default : 
+                return -1;
+        }
+    }
+
+    public String getElementType(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        if(elementID instanceof Column) {
+            return ((Column) elementID).getRuntimeType();            
+        } else if(elementID instanceof ProcedureParameter){
+            return ((ProcedureParameter) elementID).getRuntimeType();
+        } else {
+            throw createInvalidRecordTypeException(elementID);
+        }
+    }
+
+    public Object getDefaultValue(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        if(elementID instanceof Column) {
+            return ((Column) elementID).getDefaultValue();            
+        } else if(elementID instanceof ProcedureParameter){
+            return ((ProcedureParameter) elementID).getDefaultValue();
+        } else {
+            throw createInvalidRecordTypeException(elementID);
+        }
+    }
+
+    public Object getMinimumValue(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        if(elementID instanceof Column) {
+            return ((Column) elementID).getMinimumValue();            
+        } else if(elementID instanceof ProcedureParameter){
+            return null;
+        } else {
+            throw createInvalidRecordTypeException(elementID);
+        }
+    }
+
+    public Object getMaximumValue(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        if(elementID instanceof Column) {
+            return ((Column) elementID).getMaximumValue();            
+        } else if(elementID instanceof ProcedureParameter){
+            return null;
+        } else {
+            throw createInvalidRecordTypeException(elementID);
+        }
+    }
+
+    public boolean isVirtualGroup(final Object groupID) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(Table.class, groupID);
+        return ((Table) groupID).isVirtual();
+    }
+
+    /** 
+     * @see org.teiid.query.metadata.QueryMetadataInterface#isProcedureInputElement(java.lang.Object)
+     * @since 4.2
+     */
+    public boolean isProcedure(final Object groupID) throws TeiidComponentException, QueryMetadataException {
+    	if(groupID instanceof Procedure) {
+            return true;            
+        } 
+    	if(groupID instanceof Table){
+            return false;
+        } 
+    	throw createInvalidRecordTypeException(groupID);
+    }
+
+    public boolean isVirtualModel(final Object modelID) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(Schema.class, modelID);
+        Schema modelRecord = (Schema) modelID;
+        return !modelRecord.isPhysical();
+    }
+
+    public QueryNode getVirtualPlan(final Object groupID) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(Table.class, groupID);
+
+        Table tableRecord = (Table) groupID;
+        if (!tableRecord.isVirtual()) {
+            throw new QueryMetadataException(DQPPlugin.Util.getString("TransformationMetadata.QueryPlan_could_not_be_found_for_physical_group__6")+tableRecord.getFullName()); //$NON-NLS-1$
+        }
+        String transQuery = tableRecord.getSelectTransformation();
+        QueryNode queryNode = new QueryNode(tableRecord.getFullName(), transQuery);
+
+        // get any bindings and add them onto the query node
+        List bindings = tableRecord.getBindings();
+        if(bindings != null) {
+            for(Iterator bindIter = bindings.iterator();bindIter.hasNext();) {
+                queryNode.addBinding((String)bindIter.next());
+            }
+        }
+
+        return queryNode;
+    }
+
+    public String getInsertPlan(final Object groupID) throws TeiidComponentException, QueryMetadataException {
+    	ArgCheck.isInstanceOf(Table.class, groupID);
+        Table tableRecordImpl = (Table)groupID;
+        if (!tableRecordImpl.isVirtual()) {
+            throw new QueryMetadataException(DQPPlugin.Util.getString("TransformationMetadata.InsertPlan_could_not_be_found_for_physical_group__8")+tableRecordImpl.getFullName()); //$NON-NLS-1$
+        }
+        return ((Table)groupID).getInsertPlan();
+    }
+
+    public String getUpdatePlan(final Object groupID) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(Table.class, groupID);
+        Table tableRecordImpl = (Table)groupID;
+        if (!tableRecordImpl.isVirtual()) {
+        	throw new QueryMetadataException(DQPPlugin.Util.getString("TransformationMetadata.InsertPlan_could_not_be_found_for_physical_group__10")+tableRecordImpl.getFullName());         //$NON-NLS-1$
+        }
+        return ((Table)groupID).getUpdatePlan();
+    }
+
+    public String getDeletePlan(final Object groupID) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(Table.class, groupID);
+        Table tableRecordImpl = (Table)groupID;
+        if (!tableRecordImpl.isVirtual()) {
+            throw new QueryMetadataException(DQPPlugin.Util.getString("TransformationMetadata.DeletePlan_could_not_be_found_for_physical_group__12")+tableRecordImpl.getFullName()); //$NON-NLS-1$
+        }
+        return ((Table)groupID).getDeletePlan();
+    }
+
+    public boolean modelSupports(final Object modelID, final int modelConstant)
+        throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(Schema.class, modelID);
+
+        switch(modelConstant) {
+            default:
+                throw new UnsupportedOperationException(DQPPlugin.Util.getString("TransformationMetadata.Unknown_support_constant___12") + modelConstant); //$NON-NLS-1$
+        }        
+    }
+
+    public boolean groupSupports(final Object groupID, final int groupConstant)
+        throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(Table.class, groupID);
+        Table tableRecord = (Table) groupID;
+
+        switch(groupConstant) {
+            case SupportConstants.Group.UPDATE:
+                return tableRecord.supportsUpdate();
+            default:
+                throw new UnsupportedOperationException(DQPPlugin.Util.getString("TransformationMetadata.Unknown_support_constant___12") + groupConstant); //$NON-NLS-1$
+        }
+    }
+
+    public boolean elementSupports(final Object elementID, final int elementConstant)
+        throws TeiidComponentException, QueryMetadataException {
+        
+        if(elementID instanceof Column) {
+            Column columnRecord = (Column) elementID;            
+            switch(elementConstant) {
+                case SupportConstants.Element.NULL:
+                    return columnRecord.getNullType() == NullType.Nullable;
+                case SupportConstants.Element.NULL_UNKNOWN:
+                    return columnRecord.getNullType() == NullType.Unknown;
+                case SupportConstants.Element.SEARCHABLE_COMPARE:
+                    return (columnRecord.getSearchType() == SearchType.Searchable || columnRecord.getSearchType() == SearchType.All_Except_Like);
+                case SupportConstants.Element.SEARCHABLE_LIKE:
+                	return (columnRecord.getSearchType() == SearchType.Searchable || columnRecord.getSearchType() == SearchType.Like_Only);
+                case SupportConstants.Element.SELECT:
+                    return columnRecord.isSelectable();
+                case SupportConstants.Element.UPDATE:
+                    return columnRecord.isUpdatable();
+                case SupportConstants.Element.DEFAULT_VALUE:
+                    Object defaultValue = columnRecord.getDefaultValue();
+                    if(defaultValue == null) {
+                        return false;
+                    }
+                    return true;
+                case SupportConstants.Element.AUTO_INCREMENT:
+                    return columnRecord.isAutoIncremented();
+                case SupportConstants.Element.CASE_SENSITIVE:
+                    return columnRecord.isCaseSensitive();
+                case SupportConstants.Element.SIGNED:
+                    return columnRecord.isSigned();
+                default:
+                    throw new UnsupportedOperationException(DQPPlugin.Util.getString("TransformationMetadata.Unknown_support_constant___12") + elementConstant); //$NON-NLS-1$
+            }
+        } else if(elementID instanceof ProcedureParameter) {
+            ProcedureParameter columnRecord = (ProcedureParameter) elementID;            
+            switch(elementConstant) {
+                case SupportConstants.Element.NULL:
+                	return columnRecord.getNullType() == NullType.Nullable;
+                case SupportConstants.Element.NULL_UNKNOWN:
+                	return columnRecord.getNullType() == NullType.Unknown;
+                case SupportConstants.Element.SEARCHABLE_COMPARE:
+                case SupportConstants.Element.SEARCHABLE_LIKE:
+                    return false;
+                case SupportConstants.Element.SELECT:
+                    return columnRecord.getType() != Type.In;
+                case SupportConstants.Element.UPDATE:
+                    return false;
+                case SupportConstants.Element.DEFAULT_VALUE:
+                    Object defaultValue = columnRecord.getDefaultValue();
+                    if(defaultValue == null) {
+                        return false;
+                    }
+                    return true;
+                case SupportConstants.Element.AUTO_INCREMENT:
+                    return false;
+                case SupportConstants.Element.CASE_SENSITIVE:
+                    return false;
+                case SupportConstants.Element.SIGNED:
+                    return true;
+                default:
+                    throw new UnsupportedOperationException(DQPPlugin.Util.getString("TransformationMetadata.Unknown_support_constant___12") + elementConstant); //$NON-NLS-1$
+            }
+            
+        } else {            
+            throw createInvalidRecordTypeException(elementID);
+        }
+    }
+    
+    private IllegalArgumentException createInvalidRecordTypeException(Object elementID) {
+        return new IllegalArgumentException(DQPPlugin.Util.getString("TransformationMetadata.Invalid_type", elementID.getClass().getName()));         //$NON-NLS-1$
+    }
+
+    public int getMaxSetSize(final Object modelID) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(Schema.class, modelID);
+        return 0;
+    }
+
+    public Collection getIndexesInGroup(final Object groupID) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(Table.class, groupID);
+        return ((Table)groupID).getIndexes();
+    }
+
+    public Collection getUniqueKeysInGroup(final Object groupID)
+        throws TeiidComponentException, QueryMetadataException {
+    	ArgCheck.isInstanceOf(Table.class, groupID);
+    	Table tableRecordImpl = (Table)groupID;
+    	ArrayList<ColumnSet> result = new ArrayList<ColumnSet>(tableRecordImpl.getUniqueKeys());
+    	if (tableRecordImpl.getPrimaryKey() != null) {
+	    	result.add(tableRecordImpl.getPrimaryKey());
+    	}
+    	for (KeyRecord key : tableRecordImpl.getIndexes()) {
+			if (key.getType() == KeyRecord.Type.Index) {
+				result.add(key);
+			}
+		}
+    	return result;
+    }
+
+    public Collection getForeignKeysInGroup(final Object groupID)
+        throws TeiidComponentException, QueryMetadataException {
+    	ArgCheck.isInstanceOf(Table.class, groupID);
+    	return ((Table)groupID).getForeignKeys();
+    }
+
+    public Object getPrimaryKeyIDForForeignKeyID(final Object foreignKeyID)
+        throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(ForeignKey.class, foreignKeyID);
+        ForeignKey fkRecord = (ForeignKey) foreignKeyID;
+        return fkRecord.getPrimaryKey();
+    }
+
+    public Collection getAccessPatternsInGroup(final Object groupID)
+        throws TeiidComponentException, QueryMetadataException {
+    	ArgCheck.isInstanceOf(Table.class, groupID);
+    	return ((Table)groupID).getAccessPatterns();
+    }
+
+    public List getElementIDsInIndex(final Object index) throws TeiidComponentException, QueryMetadataException {
+    	ArgCheck.isInstanceOf(ColumnSet.class, index);
+    	return ((ColumnSet)index).getColumns();
+    }
+
+    public List getElementIDsInKey(final Object key) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(ColumnSet.class, key);
+        return ((ColumnSet)key).getColumns();
+    }
+
+    public List getElementIDsInAccessPattern(final Object accessPattern)
+        throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(ColumnSet.class, accessPattern);
+        return ((ColumnSet)accessPattern).getColumns();
+    }
+
+    public boolean isXMLGroup(final Object groupID) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(Table.class, groupID);
+
+        Table tableRecord = (Table) groupID;
+        return tableRecord.getTableType() == Table.Type.Document;
+    }
+
+    /** 
+     * @see org.teiid.query.metadata.QueryMetadataInterface#hasMaterialization(java.lang.Object)
+     * @since 4.2
+     */
+    public boolean hasMaterialization(final Object groupID) throws TeiidComponentException,
+                                                      QueryMetadataException {
+        ArgCheck.isInstanceOf(Table.class, groupID);
+        Table tableRecord = (Table) groupID;
+        return tableRecord.isMaterialized();
+    }
+
+    /** 
+     * @see org.teiid.query.metadata.QueryMetadataInterface#getMaterialization(java.lang.Object)
+     * @since 4.2
+     */
+    public Object getMaterialization(final Object groupID) throws TeiidComponentException,
+                                                    QueryMetadataException {
+        ArgCheck.isInstanceOf(Table.class, groupID);
+        Table tableRecord = (Table) groupID;
+        if(tableRecord.isMaterialized()) {
+	        return tableRecord.getMaterializedTable();
+        }
+        return null;
+    }
+
+    /** 
+     * @see org.teiid.query.metadata.QueryMetadataInterface#getMaterializationStage(java.lang.Object)
+     * @since 4.2
+     */
+    public Object getMaterializationStage(final Object groupID) throws TeiidComponentException,
+                                                         QueryMetadataException {
+        ArgCheck.isInstanceOf(Table.class, groupID);
+        Table tableRecord = (Table) groupID;
+        if(tableRecord.isMaterialized()) {
+	        return tableRecord.getMaterializedStageTable();
+        }
+        return null;
+    }
+
+    public MappingNode getMappingNode(final Object groupID) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(Table.class, groupID);
+
+        Table tableRecord = (Table) groupID;
+		final String groupName = tableRecord.getFullName();
+        if(tableRecord.isVirtual()) {
+            // get mappin transform
+            String document = tableRecord.getSelectTransformation();            
+            InputStream inputStream = new ByteArrayInputStream(document.getBytes());
+            MappingLoader reader = new MappingLoader();
+            MappingDocument mappingDoc = null;
+            try{
+                mappingDoc = reader.loadDocument(inputStream);
+                mappingDoc.setName(groupName);
+            } catch (Exception e){
+                throw new TeiidComponentException(e, DQPPlugin.Util.getString("TransformationMetadata.Error_trying_to_read_virtual_document_{0},_with_body__n{1}_1", groupName, mappingDoc)); //$NON-NLS-1$
+            } finally {
+            	try {
+					inputStream.close();
+            	} catch(Exception e) {}
+            }
+            return (MappingDocument)mappingDoc.clone();
+        }
+
+        return null;
+    }
+
+    /**
+     * @see org.teiid.query.metadata.QueryMetadataInterface#getVirtualDatabaseName()
+     */
+    public String getVirtualDatabaseName() throws TeiidComponentException, QueryMetadataException {
+    	if (vdbMetaData == null) {
+    		return null;
+    	}
+    	return vdbMetaData.getName();
+    }
+
+    public int getVirtualDatabaseVersion() {
+    	if (vdbMetaData == null) {
+    		return 0;
+    	}
+    	return vdbMetaData.getVersion();
+    }
+    
+    /**
+     * @see org.teiid.query.metadata.QueryMetadataInterface#getXMLTempGroups(java.lang.Object)
+     */
+    public Collection getXMLTempGroups(final Object groupID) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(Table.class, groupID);
+        Table tableRecord = (Table) groupID;
+
+        if(tableRecord.getTableType() == Table.Type.Document) {
+            return this.store.getXMLTempGroups(tableRecord);
+        }
+        return Collections.EMPTY_SET;
+    }
+
+    public int getCardinality(final Object groupID) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(Table.class, groupID);
+        return ((Table) groupID).getCardinality();
+    }
+
+    public List<SQLXMLImpl> getXMLSchemas(final Object groupID) throws TeiidComponentException, QueryMetadataException {
+
+        ArgCheck.isInstanceOf(Table.class, groupID);
+        Table tableRecord = (Table) groupID;
+
+        // lookup transformation record for the group
+        String groupName = tableRecord.getFullName();
+
+        // get the schema Paths
+        List<String> schemaPaths = tableRecord.getSchemaPaths();
+        
+        List<SQLXMLImpl> schemas = new LinkedList<SQLXMLImpl>();
+        if (schemaPaths == null) {
+        	return schemas;
+        }
+        File f = new File(tableRecord.getResourcePath());
+        String path = f.getParent();
+        if (File.separatorChar != '/') {
+        	path = path.replace(File.separatorChar, '/');
+        }
+        for (String string : schemaPaths) {
+        	SQLXMLImpl schema = getVDBResourceAsSQLXML(string);
+        	
+        	if (schema == null) {
+        		schema = getVDBResourceAsSQLXML(path + '/' + string);
+        	}
+        	
+        	if (schema == null) {
+        		throw new TeiidComponentException(DQPPlugin.Util.getString("TransformationMetadata.Error_trying_to_read_schemas_for_the_document/table____1")+groupName);             //$NON-NLS-1$		
+        	}
+        	schemas.add(schema);
+        }
+        
+        return schemas;
+    }
+
+    public String getNameInSource(final Object metadataID) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(AbstractMetadataRecord.class, metadataID);
+        return ((AbstractMetadataRecord) metadataID).getNameInSource();
+    }
+
+    public int getElementLength(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        if(elementID instanceof Column) {
+            return ((Column) elementID).getLength();            
+        } else if(elementID instanceof ProcedureParameter){
+            return ((ProcedureParameter) elementID).getLength();
+        } else {
+            throw createInvalidRecordTypeException(elementID);
+        }
+    }
+
+    public int getPosition(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        if(elementID instanceof Column) {
+            return ((Column) elementID).getPosition();
+        } else if(elementID instanceof ProcedureParameter) {
+            return ((ProcedureParameter) elementID).getPosition();            
+        } else {
+            throw createInvalidRecordTypeException(elementID);            
+        }
+    }
+    
+    public int getPrecision(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        if(elementID instanceof Column) {
+            return ((Column) elementID).getPrecision();
+        } else if(elementID instanceof ProcedureParameter) {
+            return ((ProcedureParameter) elementID).getPrecision();            
+        } else {
+            throw createInvalidRecordTypeException(elementID);            
+        }
+    }
+    
+    public int getRadix(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        if(elementID instanceof Column) {
+            return ((Column) elementID).getRadix();
+        } else if(elementID instanceof ProcedureParameter) {
+            return ((ProcedureParameter) elementID).getRadix();            
+        } else {
+            throw createInvalidRecordTypeException(elementID);            
+        }
+    }
+    
+	public String getFormat(Object elementID) throws TeiidComponentException, QueryMetadataException {
+        if(elementID instanceof Column) {
+            return ((Column) elementID).getFormat();
+        } 
+        throw createInvalidRecordTypeException(elementID);            
+	}       
+    
+    public int getScale(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        if(elementID instanceof Column) {
+            return ((Column) elementID).getScale();
+        } else if(elementID instanceof ProcedureParameter) {
+            return ((ProcedureParameter) elementID).getScale();            
+        } else {
+            throw createInvalidRecordTypeException(elementID);            
+        }
+    }
+
+    public int getDistinctValues(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        if(elementID instanceof Column) {
+            return ((Column) elementID).getDistinctValues();
+        } else if(elementID instanceof ProcedureParameter) {
+            return -1;            
+        } else {
+            throw createInvalidRecordTypeException(elementID);            
+        }
+    }
+
+    public int getNullValues(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        if(elementID instanceof Column) {
+            return ((Column) elementID).getNullValues();
+        } else if(elementID instanceof ProcedureParameter) {
+            return -1;            
+        } else {
+            throw createInvalidRecordTypeException(elementID);            
+        }
+    }
+
+    public String getNativeType(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        if(elementID instanceof Column) {
+            return ((Column) elementID).getNativeType();
+        } else if(elementID instanceof ProcedureParameter) {
+            return null;            
+        } else {
+            throw createInvalidRecordTypeException(elementID);            
+        }
+    }
+
+    public Properties getExtensionProperties(final Object metadataID) throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(AbstractMetadataRecord.class, metadataID);
+        AbstractMetadataRecord metadataRecord = (AbstractMetadataRecord) metadataID;
+        Map<String, String> result = metadataRecord.getProperties();
+        if (result == null) {
+        	return EMPTY_PROPS;
+        }
+        Properties p = new Properties();
+        p.putAll(result);
+        return p;
+    }
+
+    /** 
+     * @see org.teiid.query.metadata.BasicQueryMetadata#getBinaryVDBResource(java.lang.String)
+     * @since 4.3
+     */
+    public byte[] getBinaryVDBResource(String resourcePath) throws TeiidComponentException, QueryMetadataException {
+    	final VirtualFile f = getFile(resourcePath);
+    	if (f == null) {
+    		return null;
+    	}
+		try {
+			return ObjectConverterUtil.convertToByteArray(f.openStream());
+		} catch (IOException e) {
+			throw new TeiidComponentException(e);
+		}
+    }
+    
+    public ClobImpl getVDBResourceAsClob(String resourcePath) {
+    	final VirtualFile f = getFile(resourcePath);
+    	if (f == null) {
+    		return null;
+    	}
+		return new ClobImpl(new VirtualFileInputStreamFactory(f), -1);
+    }
+    
+    public SQLXMLImpl getVDBResourceAsSQLXML(String resourcePath) {
+    	final VirtualFile f = getFile(resourcePath);
+    	if (f == null) {
+    		return null;
+    	}
+		return new SQLXMLImpl(new VirtualFileInputStreamFactory(f));
+    }
+    
+    public BlobImpl getVDBResourceAsBlob(String resourcePath) {
+    	final VirtualFile f = getFile(resourcePath);
+    	if (f == null) {
+    		return null;
+    	}
+    	return new BlobImpl(new VirtualFileInputStreamFactory(f));
+    }
+    
+    private VirtualFile getFile(String resourcePath) {
+    	if (resourcePath == null) {
+    		return null;
+    	}
+    	Resource r = this.vdbEntries.get(resourcePath);
+    	if (r != null && r.visible) {
+    		return r.file;
+    	}
+    	return null;
+    }
+
+    /** 
+     * @see org.teiid.query.metadata.BasicQueryMetadata#getCharacterVDBResource(java.lang.String)
+     * @since 4.3
+     */
+    public String getCharacterVDBResource(String resourcePath) throws TeiidComponentException, QueryMetadataException {
+    	try {
+    		byte[] bytes = getBinaryVDBResource(resourcePath);
+    		if (bytes == null) {
+    			return null;
+    		}
+			return ObjectConverterUtil.convertToString(new ByteArrayInputStream(bytes));
+		} catch (IOException e) {
+			throw new TeiidComponentException(e);
+		}
+    }
+    
+    public CompositeMetadataStore getMetadataStore() {
+    	return this.store;
+    }
+
+    /** 
+     * @see org.teiid.query.metadata.BasicQueryMetadata#getVDBResourcePaths()
+     * @since 4.3
+     */
+    public String[] getVDBResourcePaths() throws TeiidComponentException, QueryMetadataException {
+    	LinkedList<String> paths = new LinkedList<String>();
+    	for (Map.Entry<String, Resource> entry : this.vdbEntries.entrySet()) {
+			if (entry.getValue().visible) {
+				paths.add(entry.getKey());
+			}
+		}
+    	return paths.toArray(new String[paths.size()]);
+    }
+    
+    /** 
+     * @see org.teiid.query.metadata.QueryMetadataInterface#getModeledType(java.lang.Object)
+     * @since 5.0
+     */
+    public String getModeledType(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        Datatype record = getDatatypeRecord(elementID);
+        if (record != null) {
+            return record.getDatatypeID();
+        }
+        return null;
+    }
+    
+    /** 
+     * @see org.teiid.query.metadata.QueryMetadataInterface#getModeledBaseType(java.lang.Object)
+     * @since 5.0
+     */
+    public String getModeledBaseType(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        Datatype record = getDatatypeRecord(elementID);
+        if (record != null) {
+            return record.getBasetypeID();
+        }
+        return null;
+    }
+
+    /** 
+     * @see org.teiid.query.metadata.QueryMetadataInterface#getModeledPrimitiveType(java.lang.Object)
+     * @since 5.0
+     */
+    public String getModeledPrimitiveType(final Object elementID) throws TeiidComponentException, QueryMetadataException {
+        Datatype record = getDatatypeRecord(elementID);
+        if (record != null) {
+            return record.getPrimitiveTypeID();
+        }
+        return null;
+    }
+
+    private Datatype getDatatypeRecord(final Object elementID) {
+        if (elementID instanceof Column) {
+            return ((Column)elementID).getDatatype();
+        } else if (elementID instanceof ProcedureParameter) {
+            return ((ProcedureParameter)elementID).getDatatype();
+        } else {
+            throw createInvalidRecordTypeException(elementID);            
+        }
+    }
+
+	@Override
+	public Object addToMetadataCache(Object metadataID, String key, Object value)
+			throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(AbstractMetadataRecord.class, metadataID);
+        boolean groupInfo = key.startsWith(GroupInfo.CACHE_PREFIX);
+        key = getCacheKey(key, (AbstractMetadataRecord)metadataID);
+        if (groupInfo) {
+        	return this.groupInfoCache.put(key, value); 
+        }
+    	return this.metadataCache.put(key, value); 
+	}
+
+	@Override
+	public Object getFromMetadataCache(Object metadataID, String key)
+			throws TeiidComponentException, QueryMetadataException {
+        ArgCheck.isInstanceOf(AbstractMetadataRecord.class, metadataID);
+        boolean groupInfo = key.startsWith(GroupInfo.CACHE_PREFIX);
+        key = getCacheKey(key, (AbstractMetadataRecord)metadataID);
+        if (groupInfo) {
+        	return this.groupInfoCache.get(key); 
+        }
+    	return this.metadataCache.get(key);
+	}
+
+	private String getCacheKey(String key, AbstractMetadataRecord record) {
+		return record.getUUID() + "/" + key; //$NON-NLS-1$
+	}
+
+	@Override
+	public FunctionLibrary getFunctionLibrary() {
+		return this.functionLibrary;
+	}
+}
\ No newline at end of file


Property changes on: trunk/engine/src/main/java/org/teiid/query/metadata/TransformationMetadata.java
___________________________________________________________________
Name: svn:mime-type
   + text/plain

Modified: trunk/engine/src/main/java/org/teiid/query/optimizer/relational/PlanToProcessConverter.java
===================================================================
--- trunk/engine/src/main/java/org/teiid/query/optimizer/relational/PlanToProcessConverter.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/engine/src/main/java/org/teiid/query/optimizer/relational/PlanToProcessConverter.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -36,6 +36,7 @@
 import org.teiid.core.id.IntegerID;
 import org.teiid.core.id.IntegerIDFactory;
 import org.teiid.core.util.Assertion;
+import org.teiid.language.TableReference;
 import org.teiid.query.analysis.AnalysisRecord;
 import org.teiid.query.execution.QueryExecPlugin;
 import org.teiid.query.metadata.QueryMetadataInterface;
@@ -83,6 +84,7 @@
 import org.teiid.query.sql.lang.OrderBy;
 import org.teiid.query.sql.lang.Query;
 import org.teiid.query.sql.lang.StoredProcedure;
+import org.teiid.query.sql.lang.TableFunctionReference;
 import org.teiid.query.sql.lang.TextTable;
 import org.teiid.query.sql.lang.XMLTable;
 import org.teiid.query.sql.lang.SetQuery.Operation;
@@ -90,6 +92,7 @@
 import org.teiid.query.sql.symbol.ElementSymbol;
 import org.teiid.query.sql.symbol.Expression;
 import org.teiid.query.sql.symbol.GroupSymbol;
+import org.teiid.query.sql.symbol.SingleElementSymbol;
 import org.teiid.query.sql.util.SymbolMap;
 import org.teiid.query.sql.visitor.EvaluatableVisitor;
 import org.teiid.query.sql.visitor.GroupCollectorVisitor;
@@ -377,6 +380,7 @@
 					XMLTableNode xtn = new XMLTableNode(getID());
 					//we handle the projection filtering once here rather than repeating the
 					//path analysis on a per plan basis
+					updateGroupName(node, xt);
 					Map elementMap = RelationalNode.createLookupMap(xt.getProjectedSymbols());
 			        List cols = (List) node.getProperty(NodeConstants.Info.OUTPUT_COLS);
 					int[] projectionIndexes = RelationalNode.getProjectionIndexes(elementMap, cols);
@@ -392,7 +396,9 @@
 				}
 				if (source instanceof TextTable) {
 					TextTableNode ttn = new TextTableNode(getID());
-					ttn.setTable((TextTable)source);
+					TextTable tt = (TextTable)source;
+					updateGroupName(node, tt);
+					ttn.setTable(tt);
 					processNode = ttn;
 					break;
 				}
@@ -447,6 +453,14 @@
 		return processNode;
 	}
 
+	private void updateGroupName(PlanNode node, TableFunctionReference tt) {
+		String groupName = node.getGroups().iterator().next().getName();
+		tt.getGroupSymbol().setName(groupName);
+		for (ElementSymbol symbol : tt.getProjectedSymbols()) {
+			symbol.setName(groupName + SingleElementSymbol.SEPARATOR + symbol.getShortName());
+		}
+	}
+
     private RelationalNode correctProjectionInternalTables(PlanNode node,
                                                                 AccessNode aNode, Query query) throws QueryMetadataException,
                                                                                                        TeiidComponentException {

Modified: trunk/engine/src/main/java/org/teiid/query/resolver/command/TempTableResolver.java
===================================================================
--- trunk/engine/src/main/java/org/teiid/query/resolver/command/TempTableResolver.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/engine/src/main/java/org/teiid/query/resolver/command/TempTableResolver.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -22,6 +22,7 @@
 
 package org.teiid.query.resolver.command;
 
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
@@ -77,15 +78,25 @@
             //if we get here then either the group does not exist or has already been defined as a temp table
             //if it has been defined as a temp table, that's ok we'll use this as the new definition and throw an
             //exception at runtime if the user has not dropped the previous table yet
-            ResolverUtil.addTempTable(metadata, group, create.getColumns());
-            
-            ResolverUtil.resolveGroup(((Create)command).getTable(), metadata);
+            TempMetadataID tempTable = ResolverUtil.addTempTable(metadata, group, create.getColumns());
+            ResolverUtil.resolveGroup(create.getTable(), metadata);
             Set<GroupSymbol> groups = new HashSet<GroupSymbol>();
-            groups.add(((Create)command).getTable());
+            groups.add(create.getTable());
             ResolverVisitor.resolveLanguageObject(command, groups, metadata);
+            addPrimaryKey(create, tempTable);
         } else if(command.getType() == Command.TYPE_DROP) {
             ResolverUtil.resolveGroup(((Drop)command).getTable(), metadata);
         }
     }
 
+	public static void addPrimaryKey(Create create, TempMetadataID tempTable) {
+		if (!create.getPrimaryKey().isEmpty()) {
+			ArrayList<TempMetadataID> primaryKey = new ArrayList<TempMetadataID>(create.getPrimaryKey().size());
+			for (ElementSymbol symbol : create.getPrimaryKey()) {
+				primaryKey.add((TempMetadataID) symbol.getMetadataID());
+			}
+			tempTable.setPrimaryKey(primaryKey);
+		}
+	}
+
 }

Modified: trunk/engine/src/main/java/org/teiid/query/resolver/util/ResolverUtil.java
===================================================================
--- trunk/engine/src/main/java/org/teiid/query/resolver/util/ResolverUtil.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/engine/src/main/java/org/teiid/query/resolver/util/ResolverUtil.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -631,10 +631,10 @@
         return store.addTempGroup(symbol.getName(), symbols, !tempTable, tempTable);
     }
     
-    public static void addTempTable(TempMetadataAdapter metadata,
+    public static TempMetadataID addTempTable(TempMetadataAdapter metadata,
                                      GroupSymbol symbol,
                                      List symbols) throws QueryResolverException {
-        addTempGroup(metadata, symbol, symbols, true);
+        return addTempGroup(metadata, symbol, symbols, true);
     }
 
     /** 

Modified: trunk/engine/src/main/java/org/teiid/query/tempdata/TempTableStore.java
===================================================================
--- trunk/engine/src/main/java/org/teiid/query/tempdata/TempTableStore.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/engine/src/main/java/org/teiid/query/tempdata/TempTableStore.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -38,8 +38,10 @@
 import org.teiid.core.TeiidProcessingException;
 import org.teiid.query.eval.Evaluator;
 import org.teiid.query.execution.QueryExecPlugin;
+import org.teiid.query.metadata.TempMetadataID;
 import org.teiid.query.metadata.TempMetadataStore;
 import org.teiid.query.processor.CollectionTupleSource;
+import org.teiid.query.resolver.command.TempTableResolver;
 import org.teiid.query.sql.lang.Command;
 import org.teiid.query.sql.lang.Create;
 import org.teiid.query.sql.lang.Criteria;
@@ -91,7 +93,8 @@
     		columns.addAll(0, primaryKey);
     	} 
         //add metadata
-        tempMetadataStore.addTempGroup(tempTableName, columns, false, true);
+        TempMetadataID id = tempMetadataStore.addTempGroup(tempTableName, columns, false, true);
+        TempTableResolver.addPrimaryKey(create, id);
         TempTable tempTable = new TempTable(buffer, columns, create.getPrimaryKey().size(), sessionID);
         groupToTupleSourceID.put(tempTableName, tempTable);
     }

Copied: trunk/engine/src/test/java/org/teiid/query/metadata (from rev 2371, trunk/engine/src/test/java/org/teiid/metadata)

Modified: trunk/engine/src/test/java/org/teiid/query/metadata/TestTransformationMetadata.java
===================================================================
--- trunk/engine/src/test/java/org/teiid/metadata/TestTransformationMetadata.java	2010-07-23 21:44:19 UTC (rev 2371)
+++ trunk/engine/src/test/java/org/teiid/query/metadata/TestTransformationMetadata.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -20,7 +20,7 @@
  * 02110-1301 USA.
  */
 
-package org.teiid.metadata;
+package org.teiid.query.metadata;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
@@ -39,6 +39,8 @@
 import org.teiid.core.types.DataTypeManager;
 import org.teiid.metadata.Datatype;
 import org.teiid.metadata.MetadataFactory;
+import org.teiid.query.metadata.CompositeMetadataStore;
+import org.teiid.query.metadata.TransformationMetadata;
 import org.teiid.query.unittest.FakeMetadataFactory;
 
 

Modified: trunk/engine/src/test/java/org/teiid/query/optimizer/TestDependentJoins.java
===================================================================
--- trunk/engine/src/test/java/org/teiid/query/optimizer/TestDependentJoins.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/engine/src/test/java/org/teiid/query/optimizer/TestDependentJoins.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -29,8 +29,8 @@
 
 import junit.framework.TestCase;
 
-import org.teiid.metadata.TransformationMetadata;
 import org.teiid.query.metadata.QueryMetadataInterface;
+import org.teiid.query.metadata.TransformationMetadata;
 import org.teiid.query.optimizer.TestOptimizer.ComparisonMode;
 import org.teiid.query.optimizer.capabilities.BasicSourceCapabilities;
 import org.teiid.query.optimizer.capabilities.FakeCapabilitiesFinder;

Modified: trunk/engine/src/test/java/org/teiid/query/processor/TestSQLXMLProcessing.java
===================================================================
--- trunk/engine/src/test/java/org/teiid/query/processor/TestSQLXMLProcessing.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/engine/src/test/java/org/teiid/query/processor/TestSQLXMLProcessing.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -358,7 +358,17 @@
     
         process(sql, expected);
     }
+    
+	@Test public void testXmlTableSubquery() throws Exception {
+		String sql = "select * from xmltable('/a/b' passing convert('<a><b>first</b><b x=\"attr\">c</b></a>', xml) columns x string path '@x', val string path '/.') as x where val = (select max(e1) from pm1.g1 as x)";
+    	
+        List[] expected = new List[] {
+        		Arrays.asList("attr", "c"),
+        };    
 
+        process(sql, expected);
+    }
+
     private static FakeDataManager dataManager = new FakeDataManager();
     
     @BeforeClass public static void oneTimeSetUp() {

Modified: trunk/engine/src/test/java/org/teiid/query/processor/TestTempTables.java
===================================================================
--- trunk/engine/src/test/java/org/teiid/query/processor/TestTempTables.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/engine/src/test/java/org/teiid/query/processor/TestTempTables.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -22,7 +22,10 @@
 
 package org.teiid.query.processor;
 
+import static org.junit.Assert.*;
+
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 
 import org.junit.Before;
@@ -33,15 +36,19 @@
 import org.teiid.query.tempdata.TempTableStore;
 import org.teiid.query.unittest.FakeMetadataFactory;
 
-
+ at SuppressWarnings("nls")
 public class TestTempTables {
 	
 	private TempMetadataAdapter metadata;
 	private TempTableDataManager dataManager;
 
 	private void execute(String sql, List[] expectedResults) throws Exception {
-		TestProcessor.doProcess(TestProcessor.helpGetPlan(sql, metadata), dataManager, expectedResults, TestProcessor.createCommandContext());
+		execute(expectedResults, TestProcessor.helpGetPlan(sql, metadata));
 	}
+	
+	private void execute(List[] expectedResults, ProcessorPlan processorPlan) throws Exception {
+		TestProcessor.doProcess(processorPlan, dataManager, expectedResults, TestProcessor.createCommandContext());
+	}
 
 	@Before public void setUp() {
 		TempTableStore tempStore = new TempTableStore(BufferManagerFactory.getStandaloneBufferManager(), "1", null); //$NON-NLS-1$
@@ -122,4 +129,11 @@
 		execute("select count(*) from x", new List[] {Arrays.asList(2)}); //$NON-NLS-1$
 	}
 	
+	@Test public void testPrimaryKeyMetadata() throws Exception {
+		execute("create local temporary table x (e1 string, e2 integer, primary key (e2))", new List[] {Arrays.asList(0)}); //$NON-NLS-1$
+		Collection c = metadata.getUniqueKeysInGroup(metadata.getGroupID("x"));
+		assertEquals(1, c.size());
+		assertEquals(1, (metadata.getElementIDsInKey(c.iterator().next()).size()));
+	}
+	
 }

Modified: trunk/engine/src/test/java/org/teiid/query/processor/TestTextTable.java
===================================================================
--- trunk/engine/src/test/java/org/teiid/query/processor/TestTextTable.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/engine/src/test/java/org/teiid/query/processor/TestTextTable.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -185,7 +185,19 @@
 
         process(sql, expected);
     }
+	
+	@Test public void testTextTableSubquery() throws Exception {
+		String sql = "select x.* from pm1.g1, texttable(e1 || ',' || e2 COLUMNS x string, y integer) x where y < (select avg(e2) from pm1.g1 as x)";
+    	
+        List[] expected = new List[] {
+        		Arrays.asList("a", 0),
+        		Arrays.asList("c", 1),
+        		Arrays.asList("a", 0),
+        };    
 
+        process(sql, expected);
+    }
+
     public static void process(String sql, List[] expectedResults) throws Exception {    
     	FakeDataManager dataManager = new FakeDataManager();
         sampleData1(dataManager);

Modified: trunk/engine/src/test/java/org/teiid/query/unittest/FakeMetadataFactory.java
===================================================================
--- trunk/engine/src/test/java/org/teiid/query/unittest/FakeMetadataFactory.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/engine/src/test/java/org/teiid/query/unittest/FakeMetadataFactory.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -39,16 +39,16 @@
 import org.teiid.core.types.DataTypeManager;
 import org.teiid.dqp.internal.process.DQPWorkContext;
 import org.teiid.metadata.Table;
-import org.teiid.metadata.TransformationMetadata;
 import org.teiid.query.mapping.relational.QueryNode;
 import org.teiid.query.mapping.xml.MappingAttribute;
 import org.teiid.query.mapping.xml.MappingDocument;
 import org.teiid.query.mapping.xml.MappingElement;
 import org.teiid.query.mapping.xml.MappingSequenceNode;
 import org.teiid.query.metadata.QueryMetadataInterface;
+import org.teiid.query.metadata.TransformationMetadata;
 import org.teiid.query.sql.symbol.ElementSymbol;
 
-
+ at SuppressWarnings("nls")
 public class FakeMetadataFactory {
 
     private static FakeMetadataFacade CACHED_EXAMPLE1 = example1();

Modified: trunk/engine/src/test/java/org/teiid/query/unittest/RealMetadataFactory.java
===================================================================
--- trunk/engine/src/test/java/org/teiid/query/unittest/RealMetadataFactory.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/engine/src/test/java/org/teiid/query/unittest/RealMetadataFactory.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -32,17 +32,17 @@
 import org.teiid.core.types.DataTypeManager;
 import org.teiid.metadata.Column;
 import org.teiid.metadata.ColumnSet;
-import org.teiid.metadata.CompositeMetadataStore;
 import org.teiid.metadata.MetadataStore;
 import org.teiid.metadata.Procedure;
 import org.teiid.metadata.ProcedureParameter;
 import org.teiid.metadata.Schema;
 import org.teiid.metadata.Table;
-import org.teiid.metadata.TransformationMetadata;
 import org.teiid.metadata.BaseColumn.NullType;
 import org.teiid.metadata.Column.SearchType;
 import org.teiid.metadata.ProcedureParameter.Type;
 import org.teiid.query.mapping.relational.QueryNode;
+import org.teiid.query.metadata.CompositeMetadataStore;
+import org.teiid.query.metadata.TransformationMetadata;
 import org.teiid.query.sql.lang.SPParameter;
 
 

Copied: trunk/metadata/src/main/java/org/teiid/metadata/VdbConstants.java (from rev 2371, trunk/engine/src/main/java/org/teiid/metadata/VdbConstants.java)
===================================================================
--- trunk/metadata/src/main/java/org/teiid/metadata/VdbConstants.java	                        (rev 0)
+++ trunk/metadata/src/main/java/org/teiid/metadata/VdbConstants.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -0,0 +1,37 @@
+/*
+ * JBoss, Home of Professional Open Source.
+ * See the COPYRIGHT.txt file distributed with this work for information
+ * regarding copyright ownership.  Some portions may be licensed
+ * to Red Hat, Inc. under one or more contributor license agreements.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301 USA.
+ */
+
+package org.teiid.metadata;
+
+
+
+/**
+ * Constants used for VDB processing.
+ */
+public interface VdbConstants {
+
+    public static final String DEPLOYMENT_FILE = "vdb.xml"; // !!! DO NOT CHANGE VALUE as this would cause problems with existing VDBs having DEF files !!! //$NON-NLS-1$
+    public static final String VDB_ARCHIVE_EXTENSION = ".vdb"; //$NON-NLS-1$
+    public final static String INDEX_EXT        = ".INDEX";     //$NON-NLS-1$
+    public final static String SEARCH_INDEX_EXT = ".SEARCH_INDEX";     //$NON-NLS-1$
+    public final static String MODEL_EXT = ".xmi";     //$NON-NLS-1$
+}

Modified: trunk/metadata/src/main/java/org/teiid/metadata/index/IndexMetadataFactory.java
===================================================================
--- trunk/metadata/src/main/java/org/teiid/metadata/index/IndexMetadataFactory.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/metadata/src/main/java/org/teiid/metadata/index/IndexMetadataFactory.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -62,9 +62,9 @@
 import org.teiid.metadata.ProcedureParameter;
 import org.teiid.metadata.Schema;
 import org.teiid.metadata.Table;
-import org.teiid.metadata.TransformationMetadata;
 import org.teiid.metadata.VdbConstants;
-import org.teiid.metadata.TransformationMetadata.Resource;
+import org.teiid.query.metadata.TransformationMetadata;
+import org.teiid.query.metadata.TransformationMetadata.Resource;
 
 
 /**

Modified: trunk/metadata/src/test/java/org/teiid/metadata/index/TestMultipleModelIndexes.java
===================================================================
--- trunk/metadata/src/test/java/org/teiid/metadata/index/TestMultipleModelIndexes.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/metadata/src/test/java/org/teiid/metadata/index/TestMultipleModelIndexes.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -29,7 +29,7 @@
 import org.junit.Test;
 import org.teiid.core.util.UnitTestUtil;
 import org.teiid.metadata.Table;
-import org.teiid.metadata.TransformationMetadata;
+import org.teiid.query.metadata.TransformationMetadata;
 
 @SuppressWarnings("nls")
 public class TestMultipleModelIndexes {

Modified: trunk/metadata/src/test/java/org/teiid/metadata/index/VDBMetadataFactory.java
===================================================================
--- trunk/metadata/src/test/java/org/teiid/metadata/index/VDBMetadataFactory.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/metadata/src/test/java/org/teiid/metadata/index/VDBMetadataFactory.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -38,11 +38,11 @@
 import org.teiid.core.util.FileUtils;
 import org.teiid.core.util.LRUCache;
 import org.teiid.core.util.UnitTestUtil;
-import org.teiid.metadata.CompositeMetadataStore;
 import org.teiid.metadata.MetadataStore;
-import org.teiid.metadata.TransformationMetadata;
 import org.teiid.query.function.metadata.FunctionMetadataReader;
 import org.teiid.query.function.metadata.FunctionMethod;
+import org.teiid.query.metadata.CompositeMetadataStore;
+import org.teiid.query.metadata.TransformationMetadata;
 
 
 @SuppressWarnings("nls")

Modified: trunk/runtime/src/main/java/org/teiid/deployers/CompositeVDB.java
===================================================================
--- trunk/runtime/src/main/java/org/teiid/deployers/CompositeVDB.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/runtime/src/main/java/org/teiid/deployers/CompositeVDB.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -29,12 +29,12 @@
 import org.teiid.adminapi.impl.DataPolicyMetadata;
 import org.teiid.adminapi.impl.ModelMetaData;
 import org.teiid.adminapi.impl.VDBMetaData;
-import org.teiid.metadata.CompositeMetadataStore;
 import org.teiid.metadata.MetadataStore;
-import org.teiid.metadata.TransformationMetadata;
-import org.teiid.metadata.TransformationMetadata.Resource;
 import org.teiid.query.function.metadata.FunctionMethod;
+import org.teiid.query.metadata.CompositeMetadataStore;
 import org.teiid.query.metadata.QueryMetadataInterface;
+import org.teiid.query.metadata.TransformationMetadata;
+import org.teiid.query.metadata.TransformationMetadata.Resource;
 import org.teiid.vdb.runtime.VDBKey;
 
 

Modified: trunk/runtime/src/main/java/org/teiid/deployers/VDBDeployer.java
===================================================================
--- trunk/runtime/src/main/java/org/teiid/deployers/VDBDeployer.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/runtime/src/main/java/org/teiid/deployers/VDBDeployer.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -47,8 +47,8 @@
 import org.teiid.logging.LogConstants;
 import org.teiid.logging.LogManager;
 import org.teiid.metadata.MetadataStore;
-import org.teiid.metadata.TransformationMetadata.Resource;
 import org.teiid.metadata.index.IndexMetadataFactory;
+import org.teiid.query.metadata.TransformationMetadata.Resource;
 import org.teiid.runtime.RuntimePlugin;
 import org.teiid.translator.ExecutionFactory;
 import org.teiid.translator.TranslatorException;

Modified: trunk/runtime/src/main/java/org/teiid/deployers/VDBRepository.java
===================================================================
--- trunk/runtime/src/main/java/org/teiid/deployers/VDBRepository.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/runtime/src/main/java/org/teiid/deployers/VDBRepository.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -45,7 +45,7 @@
 import org.teiid.metadata.Datatype;
 import org.teiid.metadata.MetadataFactory;
 import org.teiid.metadata.MetadataStore;
-import org.teiid.metadata.TransformationMetadata.Resource;
+import org.teiid.query.metadata.TransformationMetadata.Resource;
 import org.teiid.runtime.RuntimePlugin;
 import org.teiid.translator.TranslatorException;
 import org.teiid.vdb.runtime.VDBKey;

Modified: trunk/test-integration/common/src/test/java/org/teiid/dqp/internal/process/BaseQueryTest.java
===================================================================
--- trunk/test-integration/common/src/test/java/org/teiid/dqp/internal/process/BaseQueryTest.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/test-integration/common/src/test/java/org/teiid/dqp/internal/process/BaseQueryTest.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -26,10 +26,10 @@
 import junit.framework.TestCase;
 
 import org.teiid.dqp.message.RequestID;
-import org.teiid.metadata.TransformationMetadata;
 import org.teiid.metadata.index.VDBMetadataFactory;
 import org.teiid.query.analysis.AnalysisRecord;
 import org.teiid.query.metadata.QueryMetadataInterface;
+import org.teiid.query.metadata.TransformationMetadata;
 import org.teiid.query.optimizer.QueryOptimizer;
 import org.teiid.query.optimizer.TestOptimizer;
 import org.teiid.query.optimizer.capabilities.CapabilitiesFinder;

Modified: trunk/test-integration/common/src/test/java/org/teiid/dqp/internal/process/TestXMLTypeTranslations.java
===================================================================
--- trunk/test-integration/common/src/test/java/org/teiid/dqp/internal/process/TestXMLTypeTranslations.java	2010-07-24 03:25:41 UTC (rev 2372)
+++ trunk/test-integration/common/src/test/java/org/teiid/dqp/internal/process/TestXMLTypeTranslations.java	2010-07-26 14:17:53 UTC (rev 2373)
@@ -35,8 +35,8 @@
 import org.teiid.core.util.ObjectConverterUtil;
 import org.teiid.core.util.UnitTestUtil;
 import org.teiid.dqp.message.RequestID;
-import org.teiid.metadata.TransformationMetadata;
 import org.teiid.query.metadata.QueryMetadataInterface;
+import org.teiid.query.metadata.TransformationMetadata;
 import org.teiid.query.optimizer.capabilities.BasicSourceCapabilities;
 import org.teiid.query.optimizer.capabilities.FakeCapabilitiesFinder;
 import org.teiid.query.optimizer.capabilities.SourceCapabilities.Capability;