diff --git a/pgadmin/db/pgConn.cpp b/pgadmin/db/pgConn.cpp
index 3bfb268..660b52c 100644
--- a/pgadmin/db/pgConn.cpp
+++ b/pgadmin/db/pgConn.cpp
@@ -41,6 +41,7 @@ typedef u_long in_addr_t;
 #include "db/pgConn.h"
 #include "utils/misc.h"
 #include "db/pgSet.h"
+#include "utils/pgTypeCache.h"
 
 double pgConn::libpqVersion = 8.0;
 
@@ -80,6 +81,8 @@ pgConn::pgConn(const wxString &server, const wxString &service, const wxString &
 	needColQuoting = false;
 	utfConnectString = false;
 
+	typeCache = new pgTypeCache(this);
+
 	// Check the hostname/ipaddress
 	conn = 0;
 	noticeArg = 0;
@@ -227,6 +230,7 @@ pgConn::pgConn(const wxString &server, const wxString &service, const wxString &
 pgConn::~pgConn()
 {
 	Close();
+	delete typeCache;
 }
 
 
@@ -352,9 +356,15 @@ bool pgConn::Reconnect()
 
 pgConn *pgConn::Duplicate()
 {
-	return new pgConn(wxString(save_server), wxString(save_service), wxString(save_hostaddr), wxString(save_database), wxString(save_username), wxString(save_password),
+	pgConn *copy = new pgConn(wxString(save_server), wxString(save_service), wxString(save_hostaddr), wxString(save_database), wxString(save_username), wxString(save_password),
 	                  save_port, save_rolename, save_sslmode, save_oid,
 	                  save_applicationname, save_sslcert, save_sslkey, save_sslrootcert, save_sslcrl, save_sslcompression);
+
+	if(typeCache != NULL && copy != NULL && copy->typeCache != NULL)
+	{
+		copy->typeCache->SetInitial(typeCache);
+	}
+	return copy;
 }
 
 
@@ -1129,3 +1139,9 @@ bool pgConn::TableHasColumn(wxString schemaname, wxString tblname, const wxStrin
 	return false;
 }
 
+pgTypeCache *pgConn::GetTypeCache()
+{
+	wxASSERT(typeCache != NULL);
+	typeCache->assertConnMatchLink(this);
+	return typeCache;
+}
diff --git a/pgadmin/db/pgSet.cpp b/pgadmin/db/pgSet.cpp
index 5673cf1..68a689b 100644
--- a/pgadmin/db/pgSet.cpp
+++ b/pgadmin/db/pgSet.cpp
@@ -23,6 +23,7 @@
 #include "db/pgQueryThread.h"
 #include "utils/sysLogger.h"
 #include "utils/pgDefs.h"
+#include "utils/pgTypeCache.h"
 
 pgSet::pgSet()
 	: conv(wxConvLibc)
@@ -52,13 +53,6 @@ pgSet::pgSet(PGresult *newRes, pgConn *newConn, wxMBConv &cnv, bool needColQt)
 	else
 	{
 		nCols = PQnfields(res);
-		for (int x = 0; x < nCols + 1; x++)
-		{
-			colTypes.Add(wxT(""));
-			colFullTypes.Add(wxT(""));
-			colClasses.Add(0);
-		}
-
 		nRows = PQntuples(res);
 		MoveFirst();
 	}
@@ -100,84 +94,20 @@ long pgSet::GetInsertedCount() const
 pgTypClass pgSet::ColTypClass(const int col) const
 {
 	wxASSERT(col < nCols && col >= 0);
-
-	if (colClasses[col] != 0)
-		return (pgTypClass)colClasses[col];
-
-	wxString typoid = ExecuteScalar(
-	                      wxT("SELECT CASE WHEN typbasetype=0 THEN oid else typbasetype END AS basetype\n")
-	                      wxT("  FROM pg_type WHERE oid=") + NumToStr(ColTypeOid(col)));
-
-	switch (StrToLong(typoid))
-	{
-		case PGOID_TYPE_BOOL:
-			colClasses[col] = PGTYPCLASS_BOOL;
-			break;
-		case PGOID_TYPE_INT8:
-		case PGOID_TYPE_INT2:
-		case PGOID_TYPE_INT4:
-		case PGOID_TYPE_OID:
-		case PGOID_TYPE_XID:
-		case PGOID_TYPE_TID:
-		case PGOID_TYPE_CID:
-		case PGOID_TYPE_FLOAT4:
-		case PGOID_TYPE_FLOAT8:
-		case PGOID_TYPE_MONEY:
-		case PGOID_TYPE_BIT:
-		case PGOID_TYPE_NUMERIC:
-			colClasses[col] = PGTYPCLASS_NUMERIC;
-			break;
-		case PGOID_TYPE_BYTEA:
-		case PGOID_TYPE_CHAR:
-		case PGOID_TYPE_NAME:
-		case PGOID_TYPE_TEXT:
-		case PGOID_TYPE_VARCHAR:
-			colClasses[col] = PGTYPCLASS_STRING;
-			break;
-		case PGOID_TYPE_TIMESTAMP:
-		case PGOID_TYPE_TIMESTAMPTZ:
-		case PGOID_TYPE_TIME:
-		case PGOID_TYPE_TIMETZ:
-		case PGOID_TYPE_INTERVAL:
-			colClasses[col] = PGTYPCLASS_DATE;
-			break;
-		default:
-			colClasses[col] = PGTYPCLASS_OTHER;
-			break;
-	}
-
-	return (pgTypClass)colClasses[col];
+	return conn->GetTypeCache()->GetTypeClass(ColTypeOid(col));
 }
 
 
 wxString pgSet::ColType(const int col) const
 {
 	wxASSERT(col < nCols && col >= 0);
-
-	if (!colTypes[col].IsEmpty())
-		return colTypes[col];
-
-	wxString szSQL, szResult;
-	szSQL.Printf(wxT("SELECT format_type(oid,NULL) as typname FROM pg_type WHERE oid = %d"), (int)ColTypeOid(col));
-	szResult = ExecuteScalar(szSQL);
-	colTypes[col] = szResult;
-
-	return szResult;
+	return conn->GetTypeCache()->GetTypeName(ColTypeOid(col));
 }
 
 wxString pgSet::ColFullType(const int col) const
 {
 	wxASSERT(col < nCols && col >= 0);
-
-	if (!colFullTypes[col].IsEmpty())
-		return colFullTypes[col];
-
-	wxString szSQL, szResult;
-	szSQL.Printf(wxT("SELECT format_type(oid,%d) as typname FROM pg_type WHERE oid = %d"), (int)ColTypeMod(col), (int)ColTypeOid(col));
-	szResult = ExecuteScalar(szSQL);
-	colFullTypes[col] = szResult;
-
-	return szResult;
+	return conn->GetTypeCache()->GetFullTypeName(ColTypeOid(col), ColTypeMod(col));
 }
 
 int pgSet::ColScale(const int col) const
@@ -387,12 +317,6 @@ OID pgSet::GetOid(const wxString &col) const
 }
 
 
-wxString pgSet::ExecuteScalar(const wxString &sql) const
-{
-	return conn->ExecuteScalar(sql);
-}
-
-
 //////////////////////////////////////////////////////////////////
 
 pgSetIterator::pgSetIterator(pgConn *conn, const wxString &qry)
diff --git a/pgadmin/include/db/pgConn.h b/pgadmin/include/db/pgConn.h
index 993a059..3e87164 100644
--- a/pgadmin/include/db/pgConn.h
+++ b/pgadmin/include/db/pgConn.h
@@ -21,6 +21,8 @@
 // App headers
 #include "pgSet.h"
 
+class pgTypeCache;
+
 // status enums
 enum
 {
@@ -247,6 +249,8 @@ public:
 	pgNotification *GetNotification();
 	int GetTxStatus();
 
+	pgTypeCache *GetTypeCache();
+
 	void Reset();
 
 	bool StartCopy(const wxString query);
@@ -278,6 +282,10 @@ protected:
 	friend class pgQueryThread;
 
 private:
+	// This class can not be copied.
+	pgConn(const pgConn &rhs);
+	const pgConn &operator=(const pgConn &rhs);
+
 	bool DoConnect();
 
 	wxString qtString(const wxString &value);
@@ -290,6 +298,8 @@ private:
 	wxString reservedNamespaces;
 	wxString connstr;
 
+	pgTypeCache *typeCache;
+
 	wxString save_server, save_service, save_hostaddr, save_database, save_username, save_password, save_rolename, save_applicationname;
 	wxString save_sslcert, save_sslkey, save_sslrootcert, save_sslcrl;
 	int save_port, save_sslmode;
diff --git a/pgadmin/include/db/pgSet.h b/pgadmin/include/db/pgSet.h
index 1eee62f..61b3b2c 100644
--- a/pgadmin/include/db/pgSet.h
+++ b/pgadmin/include/db/pgSet.h
@@ -21,15 +21,6 @@
 
 #include "utils/misc.h"
 
-typedef enum
-{
-    PGTYPCLASS_NUMERIC = 1,
-    PGTYPCLASS_BOOL,
-    PGTYPCLASS_STRING,
-    PGTYPCLASS_DATE,
-    PGTYPCLASS_OTHER
-} pgTypClass;
-
 class pgConn;
 
 // Class declarations
@@ -139,8 +130,6 @@ protected:
 	wxString ExecuteScalar(const wxString &sql) const;
 	wxMBConv &conv;
 	bool needColQuoting;
-	mutable wxArrayString colTypes, colFullTypes;
-	wxArrayInt colClasses;
 };
 
 
diff --git a/pgadmin/include/utils/misc.h b/pgadmin/include/utils/misc.h
index 69403f3..b15fd3f 100644
--- a/pgadmin/include/utils/misc.h
+++ b/pgadmin/include/utils/misc.h
@@ -16,7 +16,7 @@
 #include <wx/datetime.h>
 #include <wx/tokenzr.h>
 
-#include "utils/misc.h"
+// ?? #include "utils/misc.h"
 
 class wxImageList;
 extern wxImageList *imageList;
@@ -265,5 +265,13 @@ wxString commandLineCleanOption(const wxString &option, bool schemaObject = fals
 wxString qtIdent(const wxString &value);    // add " if necessary
 wxString qtTypeIdent(const wxString &value);    // add " if necessary
 
-#endif
+typedef enum
+{
+    PGTYPCLASS_NUMERIC = 1,
+    PGTYPCLASS_BOOL,
+    PGTYPCLASS_STRING,
+    PGTYPCLASS_DATE,
+    PGTYPCLASS_OTHER
+} pgTypClass;
 
+#endif
diff --git a/pgadmin/include/utils/module.mk b/pgadmin/include/utils/module.mk
index e05ddef..30a833e 100644
--- a/pgadmin/include/utils/module.mk
+++ b/pgadmin/include/utils/module.mk
@@ -22,7 +22,8 @@ pgadmin3_SOURCES += \
 	include/utils/sysProcess.h \
 	include/utils/sysSettings.h \
 	include/utils/utffile.h \
-	include/utils/macros.h
+	include/utils/macros.h \
+	include/utils/pgTypeCache.h
 
 EXTRA_DIST += \
         include/utils/module.mk
diff --git a/pgadmin/include/utils/pgTypeCache.h b/pgadmin/include/utils/pgTypeCache.h
new file mode 100644
index 0000000..a759d7a
--- /dev/null
+++ b/pgadmin/include/utils/pgTypeCache.h
@@ -0,0 +1,88 @@
+//////////////////////////////////////////////////////////////////////////
+//
+// pgAdmin III - PostgreSQL Tools
+//
+// Copyright (C) 2002 - 2012, The pgAdmin Development Team
+// This software is released under the PostgreSQL Licence
+//
+// pgTypeCache.h - cache for data type names and details.
+//
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef PGTYPECACHE_H
+#define PGTYPECACHE_H
+
+// wxWindows headers
+#include <wx/wx.h>
+#include <wx/hashmap.h>
+
+// PostgreSQL headers
+#include <libpq-fe.h>
+
+#include "utils/misc.h"
+
+class pgConn;
+
+WX_DECLARE_HASH_MAP(int, wxString, wxIntegerHash, wxIntegerEqual, typmodStringMap);
+
+class CachedTypeDetails
+{
+public:
+	CachedTypeDetails();
+
+	pgTypClass typeClass;   // type class eg. numeric, string etc.
+	wxString basicName;      // format_type(oid, NULL)
+	int typTypMod;           // pg_types.typtypmod
+	typmodStringMap fullNames;        // map of typMod -> format_type(oid, typMod)
+};
+
+WX_DECLARE_HASH_MAP(OID, CachedTypeDetails, wxIntegerHash, wxIntegerEqual, oidTypeMap);
+
+class pgTypeCache
+{
+public:
+	pgTypeCache(pgConn *cn) : conn(cn), previousLimit(0) {}
+
+	// Pre-fill the cache with some cached data from another connection's cache.
+	void SetInitial(const pgTypeCache *other);
+
+	// Get the short type name from 'format_type(oid, NULL)'
+	wxString GetTypeName(OID oid);
+	// Get the full type name from 'format_type(oid, typeMod)'
+	wxString GetFullTypeName(OID oid, int typeMod = -1);
+	// Get the type class eg. numeric, string etc.
+	pgTypClass GetTypeClass(OID oid);
+
+	// Get the full type name from 'format_type(oid, pg_types.typtypmod)'
+	// TODO: Check if this should still be used. My old patch used it in three places:
+	// edbPackageFunctionFactory::AppendFunctions - now uses 'format_type(oid, NULL)'
+	// pgAggregateFactory::CreateObjects - still uses typtypmod.
+	// pgFunctionFactory::AppendFunctions - now uses 'format_type(oid, NULL)'
+	wxString GetDefaultFullTypeName(OID oid);
+
+	// Pre-fill the cache with all types in the database, or with only 'limit' types if it is provided.
+	void PreCache(int limit = 0);
+
+	// Make sure the two-way link to pgConn is correct.
+	void assertConnMatchLink( pgConn *test )
+	{
+		wxASSERT(conn != NULL);
+		wxASSERT(conn == test);
+	}
+
+private:
+	// This class can not be copied.
+	pgTypeCache(const pgTypeCache &rhs);
+	const pgTypeCache &operator=(const pgTypeCache &rhs);
+
+	oidTypeMap::iterator iLoadTypeIfMissing(OID oid, int *typeMod = NULL);
+	pgTypClass iGetTypeClass(OID baseOid);
+	void iLoadTypes(int limit, OID oid, int *typeMod = NULL);
+	void iLoadModName(oidTypeMap::iterator existingType, int typeMod);
+
+	pgConn *conn;
+	oidTypeMap types;
+	int previousLimit;
+};
+
+#endif
diff --git a/pgadmin/utils/module.mk b/pgadmin/utils/module.mk
index c307647..187ccbe 100644
--- a/pgadmin/utils/module.mk
+++ b/pgadmin/utils/module.mk
@@ -21,7 +21,8 @@ pgadmin3_SOURCES += \
 	utils/sysSettings.cpp \
 	utils/tabcomplete.c \
 	utils/utffile.cpp \
-	utils/macros.cpp
+	utils/macros.cpp \
+	utils/pgTypeCache.cpp
 
 EXTRA_DIST += \
 	utils/module.mk \
diff --git a/pgadmin/utils/pgTypeCache.cpp b/pgadmin/utils/pgTypeCache.cpp
new file mode 100644
index 0000000..b72ad1d
--- /dev/null
+++ b/pgadmin/utils/pgTypeCache.cpp
@@ -0,0 +1,236 @@
+//////////////////////////////////////////////////////////////////////////
+//
+// pgAdmin III - PostgreSQL Tools
+// RCS-ID:      $Id$
+// Copyright (C) 2002 - 2008, The pgAdmin Development Team
+// This software is released under the Artistic Licence
+//
+// pgTypeCache.cpp - cache for data type names and details.
+//
+//////////////////////////////////////////////////////////////////////////
+
+#include "pgAdmin3.h"
+
+#include "utils/pgTypeCache.h"
+#include "db/pgConn.h"
+#include "utils/pgDefs.h"
+
+CachedTypeDetails::CachedTypeDetails()
+	: typeClass(PGTYPCLASS_OTHER),
+	typTypMod(0)
+{
+}
+
+void pgTypeCache::SetInitial(const pgTypeCache *other)
+{
+	wxASSERT(other != NULL);
+	wxLogDebug(wxString::Format(wxT("pgTypeCache: set initial: %d cached types"), other->types.size()));
+	types = other->types;
+	previousLimit = other->previousLimit;
+}
+
+wxString pgTypeCache::GetTypeName(OID oid)
+{
+	oidTypeMap::iterator it = iLoadTypeIfMissing(oid);
+	wxLogDebug(wxString::Format(wxT("pgTypeCache: got basic name for oid %d: %s"), oid, (*it).second.basicName.c_str()));
+	return (*it).second.basicName;
+}
+
+pgTypClass pgTypeCache::GetTypeClass(OID oid)
+{
+	oidTypeMap::iterator it = iLoadTypeIfMissing(oid);
+	wxLogDebug(wxString::Format(wxT("pgTypeCache: got type class for oid %d: %d"), oid, (*it).second.typeClass));
+	return (*it).second.typeClass;
+}
+
+wxString pgTypeCache::GetFullTypeName(OID oid, int typeMod)
+{
+	oidTypeMap::iterator it = iLoadTypeIfMissing(oid, &typeMod);
+	wxLogDebug(wxString::Format(wxT("pgTypeCache: got full name for oid %d, typeMod %d: %s"), oid, typeMod, (*it).second.fullNames[typeMod].c_str()));
+	return (*it).second.fullNames[typeMod];
+}
+
+wxString pgTypeCache::GetDefaultFullTypeName(OID oid)
+{
+	oidTypeMap::iterator it = iLoadTypeIfMissing(oid);
+	wxLogDebug(wxString::Format(wxT("pgTypeCache: got default full name for oid %d: %s"), oid, (*it).second.fullNames[(*it).second.typTypMod].c_str()));
+	return (*it).second.fullNames[(*it).second.typTypMod];
+}
+
+void pgTypeCache::PreCache(int limit /*= 0*/)
+{
+	if (previousLimit == 0 || limit > previousLimit)
+	{
+		iLoadTypes(limit, 0, NULL);
+		previousLimit = limit;
+		if (previousLimit == 0)
+			previousLimit = types.size();
+	}
+}
+
+pgTypClass pgTypeCache::iGetTypeClass(OID baseOid)
+{
+	switch (baseOid)
+	{
+		case PGOID_TYPE_BOOL:
+			return PGTYPCLASS_BOOL;
+
+		case PGOID_TYPE_INT8:
+		case PGOID_TYPE_INT2:
+		case PGOID_TYPE_INT4:
+		case PGOID_TYPE_OID:
+		case PGOID_TYPE_XID:
+		case PGOID_TYPE_TID:
+		case PGOID_TYPE_CID:
+		case PGOID_TYPE_FLOAT4:
+		case PGOID_TYPE_FLOAT8:
+		case PGOID_TYPE_MONEY:
+		case PGOID_TYPE_BIT:
+		case PGOID_TYPE_NUMERIC:
+			return PGTYPCLASS_NUMERIC;
+
+		case PGOID_TYPE_BYTEA:
+		case PGOID_TYPE_CHAR:
+		case PGOID_TYPE_NAME:
+		case PGOID_TYPE_TEXT:
+		case PGOID_TYPE_VARCHAR:
+			return PGTYPCLASS_STRING;
+
+		case PGOID_TYPE_TIMESTAMP:
+		case PGOID_TYPE_TIMESTAMPTZ:
+		case PGOID_TYPE_TIME:
+		case PGOID_TYPE_TIMETZ:
+		case PGOID_TYPE_INTERVAL:
+			return PGTYPCLASS_DATE;
+
+		default:
+			return PGTYPCLASS_OTHER;
+	}
+}
+
+// Make sure that the requested OID and typmod combination is cached,
+// and return an iterator to the OID record.
+oidTypeMap::iterator pgTypeCache::iLoadTypeIfMissing(OID oid, int *typeMod /*= NULL*/)
+{
+	oidTypeMap::iterator it = types.find(oid);
+	bool typeMissing = it == types.end();
+	bool modMissing = !typeMissing && typeMod != NULL &&
+		(*it).second.fullNames.find(*typeMod) == (*it).second.fullNames.end();
+	if (typeMissing)
+	{
+		wxLogDebug(wxString::Format(wxT("pgTypeCache: cache miss for oid %d"), oid));
+		iLoadTypes(0, oid, typeMod);
+		it = types.find(oid);
+	}
+	else if (modMissing)
+	{
+		wxLogDebug(wxString::Format(wxT("pgTypeCache: partial cache hit for oid %d, typeMod %d"), oid, *typeMod));
+		iLoadModName(it, *typeMod);
+	}
+	else
+		wxLogDebug(wxString::Format(wxT("pgTypeCache: full cache hit for oid %d"), oid));
+
+	// Wait, what happens if we try to load an invalid OID? Bad things!
+	// It shouldn't happen, but maybe if a type was deleted after we got a field of that type in our resultset?
+	if (it == types.end())
+	{
+		wxLogWarning(wxString::Format(wxT("pgTypeCache: unable to load oid %d, returning dummy type info"), oid));
+		// Make up something that will at least avoid crashes.
+		CachedTypeDetails &currType = types[oid];
+
+		currType.typTypMod = -1;
+		currType.basicName = wxT("(unknown)");
+		currType.fullNames[currType.typTypMod] = wxT("(unknown)");
+		if (typeMod != NULL)
+		{
+			currType.fullNames[*typeMod] = wxT("(unknown)");
+		}
+		currType.typeClass = iGetTypeClass(oid);
+		it = types.find(oid);
+	}
+
+	wxASSERT(it != types.end());
+	return it;
+}
+
+// Load one or many type records, depending on whether oid is valid.
+// If one record is loaded, typeMod can point to a custom typmod value.
+// If many are loaded, the result row count can be limited by limit.
+void pgTypeCache::iLoadTypes(int limit, OID oid, int *typeMod)
+{
+	bool useLimit = limit > 0;
+	bool useOid = oid > 0;
+	bool useMod = useOid && typeMod != NULL;
+
+	const wxChar *sqlCommonFields = wxT("typtypmod,typbasetype,")
+			wxT("format_type(oid,NULL) as basic,")
+			wxT("format_type(oid,typtypmod) as def");
+	const wxChar *sqlFrom = wxT(" FROM pg_type");
+
+	wxString sql, tmp;
+	if (useOid)		// load a single type record
+	{
+		sql = wxT("SELECT ");
+		sql += sqlCommonFields;
+		if (useMod)
+		{
+			tmp.Printf(wxT(",format_type(oid,%d) as bymod"), *typeMod);
+			sql += tmp;
+			wxLogDebug(wxString::Format(wxT("pgTypeCache: loading oid %d with typeMod %d"), oid, *typeMod));
+		}
+		else
+			wxLogDebug(wxString::Format(wxT("pgTypeCache: loading oid %d"), oid));
+
+		sql += sqlFrom;
+		tmp.Printf(wxT(" WHERE oid=%d"), oid);
+		sql += tmp;
+	}
+	else
+	{
+		sql = wxT("SELECT oid,");
+		sql += sqlCommonFields;
+		sql += sqlFrom;
+		if (useLimit)
+		{
+			tmp.Printf(wxT(" LIMIT %d"), limit);
+			sql += tmp;
+			wxLogDebug(wxString::Format(wxT("pgTypeCache: loading %d types in a batch"), limit));
+		}
+		else
+			wxLogDebug(wxString::Format(wxT("pgTypeCache: loading entire pg_types table in a batch")));
+	}
+
+	pgSet *result = conn->ExecuteSet(sql);
+	if (result)
+	{
+		while (!result->Eof())
+		{
+			OID currOid = useOid? oid : result->GetOid(wxT("oid"));
+			CachedTypeDetails &currType = types[currOid];
+
+			currType.typTypMod = result->GetLong(wxT("typtypmod"));
+			currType.basicName = result->GetVal(wxT("basic"));
+			currType.fullNames[currType.typTypMod] = result->GetVal(wxT("def"));
+			if (useMod)
+			{
+				currType.fullNames[*typeMod] = result->GetVal(wxT("bymod"));
+			}
+			OID baseType = result->GetOid(wxT("typbasetype"));
+			currType.typeClass = iGetTypeClass(baseType == 0? currOid : baseType);
+
+			result->MoveNext();
+		}
+		delete result;
+	}
+	else
+		wxLogError(wxString::Format(wxT("pgTypeCache: failed to load type details")));
+}
+
+// Load a typmod-modified name for a type that is already cached.
+void pgTypeCache::iLoadModName(oidTypeMap::iterator existingType, int typeMod)
+{
+	wxASSERT(existingType != types.end());
+	wxString szSQL;
+	szSQL.Printf(wxT("SELECT format_type(%d,%d)"), (*existingType).first, typeMod);
+	(*existingType).second.fullNames[typeMod] = conn->ExecuteScalar(szSQL);
+}
