diff --git a/jOOQ/src/main/java/org/jooq/RenamedTable.java b/jOOQ/src/main/java/org/jooq/RenamedTable.java
index 53b22bc72a..f066557b48 100644
--- a/jOOQ/src/main/java/org/jooq/RenamedTable.java
+++ b/jOOQ/src/main/java/org/jooq/RenamedTable.java
@@ -37,6 +37,8 @@
  */
 package org.jooq;
 
+import static org.jooq.impl.DSL.name;
+
 import org.jooq.impl.TableImpl;
 
 /**
@@ -52,9 +54,9 @@ class RenamedTable<R extends Record> extends TableImpl<R> {
     private static final long serialVersionUID = -309012919785933903L;
 
     RenamedTable(Schema schema, Table<R> delegate, String rename) {
-        super(rename, schema);
+        super(name(rename), schema);
 
         for (Field<?> field : delegate.fields())
-            createField(field.getName(), field.getDataType(), this);
+            createField(field.getUnqualifiedName(), field.getDataType(), this);
     }
 }
diff --git a/jOOQ/src/main/java/org/jooq/impl/InformationSchemaMetaImpl.java b/jOOQ/src/main/java/org/jooq/impl/InformationSchemaMetaImpl.java
index 908cf53107..a82a58751e 100644
--- a/jOOQ/src/main/java/org/jooq/impl/InformationSchemaMetaImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/InformationSchemaMetaImpl.java
@@ -294,7 +294,7 @@ final class InformationSchemaMetaImpl extends AbstractMeta {
             }
 
             AbstractTable.createField(
-                xc.getColumnName(),
+                name(xc.getColumnName()),
                 type(typeName, length, precision, scale, nullable),
                 table,
                 xc.getComment()
diff --git a/jOOQ/src/main/java/org/jooq/impl/MetaImpl.java b/jOOQ/src/main/java/org/jooq/impl/MetaImpl.java
index 0ad3da8d89..eed3949766 100644
--- a/jOOQ/src/main/java/org/jooq/impl/MetaImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/MetaImpl.java
@@ -534,7 +534,7 @@ final class MetaImpl extends AbstractMeta {
         private static final long serialVersionUID = 4843841667753000233L;
 
         MetaTable(String name, Schema schema, Result<Record> columns, TableType tableType) {
-            super(DSL.name(name), schema, null, null, null, null, null, TableOptions.of(tableType));
+            super(name(name), schema, null, null, null, null, null, TableOptions.of(tableType));
 
             // Possible scenarios for columns being null:
             // - The "table" is in fact a SYNONYM
@@ -705,7 +705,7 @@ final class MetaImpl extends AbstractMeta {
                     fkFields[i] = (TableField<Record, ?>)         field(record.get(7, String.class));
                 }
 
-                references.add(new ReferenceImpl<>(new MetaPrimaryKey(pkTable, pkName, pkFields), this, DSL.name(fkName), fkFields, true));
+                references.add(new ReferenceImpl<>(new MetaPrimaryKey(pkTable, pkName, pkFields), this, name(fkName), fkFields, true));
             }
 
             return references;
@@ -801,7 +801,7 @@ final class MetaImpl extends AbstractMeta {
                     previousIndexName = indexName;
                     sortFields.clear();
 
-                    name = DSL.name(
+                    name = name(
                         record.get(0, String.class), // TABLE_CAT
                         record.get(1, String.class), // TABLE_SCHEM
                         indexName
@@ -897,7 +897,7 @@ final class MetaImpl extends AbstractMeta {
                     type = SQLDataType.OTHER;
                 }
 
-                createField(columnName, type, this, remarks);
+                createField(name(columnName), type, this, remarks);
             }
         }
     }
@@ -910,7 +910,7 @@ final class MetaImpl extends AbstractMeta {
         private static final long             serialVersionUID = 6997258619475953490L;
 
         MetaPrimaryKey(Table<Record> table, String pkName, TableField<Record, ?>[] fields) {
-            super(table, pkName == null ? null : DSL.name(pkName), fields, true);
+            super(table, pkName == null ? null : name(pkName), fields, true);
         }
 
         @Override
@@ -974,7 +974,7 @@ final class MetaImpl extends AbstractMeta {
                 for (int i = 0; i < value.size(); i++)
                     fkFields[i] = (TableField<Record, ?>) fkTable.field(value.get(i).get(7, String.class));
 
-                references.add(new ReferenceImpl<>(this, fkTable, DSL.name(fkName), fkFields, true));
+                references.add(new ReferenceImpl<>(this, fkTable, name(fkName), fkFields, true));
             }
 
             return references;
diff --git a/jOOQ/src/main/java/org/jooq/impl/Snapshot.java b/jOOQ/src/main/java/org/jooq/impl/Snapshot.java
index 57772c216c..19d826fe17 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Snapshot.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Snapshot.java
@@ -84,7 +84,7 @@ final class Snapshot extends AbstractMeta {
 
     private final void resolveReferences() {
         for (Catalog catalog : getCatalogs())
-            ((DetachedCatalog) catalog).resolveReferences();
+            ((SnapshotCatalog) catalog).resolveReferences();
     }
 
     @Override
@@ -92,26 +92,26 @@ final class Snapshot extends AbstractMeta {
         List<Catalog> result = new ArrayList<>();
 
         for (Catalog catalog : delegate.getCatalogs())
-            result.add(new DetachedCatalog(catalog));
+            result.add(new SnapshotCatalog(catalog));
 
         return result;
     }
 
-    private class DetachedCatalog extends CatalogImpl {
+    private class SnapshotCatalog extends CatalogImpl {
         private static final long          serialVersionUID = 7979890261252183486L;
-        private final List<DetachedSchema> schemas;
+        private final List<SnapshotSchema> schemas;
 
-        DetachedCatalog(Catalog catalog) {
+        SnapshotCatalog(Catalog catalog) {
             super(catalog.getQualifiedName(), catalog.getCommentPart());
 
             schemas = new ArrayList<>();
 
             for (Schema schema : catalog.getSchemas())
-                schemas.add(new DetachedSchema(this, schema));
+                schemas.add(new SnapshotSchema(this, schema));
         }
 
         private final void resolveReferences() {
-            for (DetachedSchema schema : schemas)
+            for (SnapshotSchema schema : schemas)
                 schema.resolveReferences();
         }
 
@@ -121,15 +121,15 @@ final class Snapshot extends AbstractMeta {
         }
     }
 
-    private class DetachedSchema extends SchemaImpl {
+    private class SnapshotSchema extends SchemaImpl {
         private static final long               serialVersionUID = -95755926444275258L;
 
-        private final List<DetachedDomain<?>>   domains;
-        private final List<DetachedTable<?>>    tables;
-        private final List<DetachedSequence<?>> sequences;
-        private final List<DetachedUDT<?>>      udts;
+        private final List<SnapshotDomain<?>>   domains;
+        private final List<SnapshotTable<?>>    tables;
+        private final List<SnapshotSequence<?>> sequences;
+        private final List<SnapshotUDT<?>>      udts;
 
-        DetachedSchema(DetachedCatalog catalog, Schema schema) {
+        SnapshotSchema(SnapshotCatalog catalog, Schema schema) {
             super(schema.getQualifiedName(), catalog, schema.getCommentPart());
 
             domains = new ArrayList<>();
@@ -138,17 +138,17 @@ final class Snapshot extends AbstractMeta {
             udts = new ArrayList<>();
 
             for (Domain<?> domain : schema.getDomains())
-                domains.add(new DetachedDomain<>(this, domain));
+                domains.add(new SnapshotDomain<>(this, domain));
             for (Table<?> table : schema.getTables())
-                tables.add(new DetachedTable<>(this, table));
+                tables.add(new SnapshotTable<>(this, table));
             for (Sequence<?> sequence : schema.getSequences())
-                sequences.add(new DetachedSequence<>(this, sequence));
+                sequences.add(new SnapshotSequence<>(this, sequence));
             for (UDT<?> udt : schema.getUDTs())
-                udts.add(new DetachedUDT<>(this, udt));
+                udts.add(new SnapshotUDT<>(this, udt));
         }
 
         final void resolveReferences() {
-            for (DetachedTable<?> table : tables)
+            for (SnapshotTable<?> table : tables)
                 table.resolveReferences();
         }
 
@@ -173,15 +173,15 @@ final class Snapshot extends AbstractMeta {
         }
     }
 
-    private class DetachedDomain<T> extends DomainImpl<T> {
+    private class SnapshotDomain<T> extends DomainImpl<T> {
         private static final long serialVersionUID = -1607062195966296849L;
 
-        DetachedDomain(DetachedSchema schema, Domain<T> domain) {
+        SnapshotDomain(SnapshotSchema schema, Domain<T> domain) {
             super(schema, domain.getQualifiedName(), domain.getDataType(), domain.getChecks().toArray(EMPTY_CHECK));
         }
     }
 
-    private class DetachedTable<R extends Record> extends TableImpl<R> {
+    private class SnapshotTable<R extends Record> extends TableImpl<R> {
         private static final long serialVersionUID = -6070726881709997500L;
 
         private final List<Index>            indexes;
@@ -191,7 +191,7 @@ final class Snapshot extends AbstractMeta {
         private final List<Check<R>>         checks;
         private Identity<R, ?>               identity;
 
-        DetachedTable(DetachedSchema schema, Table<R> table) {
+        SnapshotTable(SnapshotSchema schema, Table<R> table) {
             super(table.getQualifiedName(), schema, null, null, table.getCommentPart(), table.getOptions());
 
             indexes = new ArrayList<>();
@@ -200,7 +200,7 @@ final class Snapshot extends AbstractMeta {
             checks = new ArrayList<>();
 
             for (Field<?> field : table.fields()) {
-                TableField<R, ?> f = DetachedTable.createField(field.getUnqualifiedName(), field.getDataType(), this, field.getComment());
+                TableField<R, ?> f = createField(field.getUnqualifiedName(), field.getDataType(), this, field.getComment());
 
                 if (field.getDataType().identity() && identity == null)
                     identity = Internal.createIdentity(this, f);
@@ -293,10 +293,10 @@ final class Snapshot extends AbstractMeta {
         }
     }
 
-    private class DetachedSequence<T extends Number> extends SequenceImpl<T> {
+    private class SnapshotSequence<T extends Number> extends SequenceImpl<T> {
         private static final long serialVersionUID = -1607062195966296849L;
 
-        DetachedSequence(DetachedSchema schema, Sequence<T> sequence) {
+        SnapshotSequence(SnapshotSchema schema, Sequence<T> sequence) {
             super(
                 sequence.getQualifiedName(),
                 schema,
@@ -312,10 +312,10 @@ final class Snapshot extends AbstractMeta {
         }
     }
 
-    private class DetachedUDT<R extends UDTRecord<R>> extends UDTImpl<R> {
+    private class SnapshotUDT<R extends UDTRecord<R>> extends UDTImpl<R> {
         private static final long serialVersionUID = -5732449514562314202L;
 
-        DetachedUDT(DetachedSchema schema, UDT<R> udt) {
+        SnapshotUDT(SnapshotSchema schema, UDT<R> udt) {
             super(udt.getName(), schema, udt.getPackage(), udt.isSynthetic());
         }
     }