diff --git a/jOOQ-codegen/src/main/java/org/jooq/util/JavaGenerator.java b/jOOQ-codegen/src/main/java/org/jooq/util/JavaGenerator.java
index 08e93c0d5e..49aac49f06 100644
--- a/jOOQ-codegen/src/main/java/org/jooq/util/JavaGenerator.java
+++ b/jOOQ-codegen/src/main/java/org/jooq/util/JavaGenerator.java
@@ -3342,7 +3342,7 @@ public class JavaGenerator extends AbstractGenerator {
         if (scala) {
             out.tab(1).javadoc("Create a <code>%s</code> table reference", table.getQualifiedOutputName());
             out.tab(1).println("def this() = {");
-            out.tab(2).println("this(\"%s\", null, null)", table.getOutputName());
+            out.tab(2).println("this(%s.name(\"%s\"), null, null)", DSL.class, table.getOutputName());
             out.tab(1).println("}");
         }
         else {
@@ -3357,7 +3357,7 @@ public class JavaGenerator extends AbstractGenerator {
                 out.tab(1).println("private %s() {", className);
             }
 
-            out.tab(2).println("this(\"%s\", null);", table.getOutputName());
+            out.tab(2).println("this(%s.name(\"%s\"), null);", DSL.class, table.getOutputName());
             out.tab(1).println("}");
         }
 
@@ -3365,6 +3365,11 @@ public class JavaGenerator extends AbstractGenerator {
         if (scala) {
             out.tab(1).javadoc("Create an aliased <code>%s</code> table reference", table.getQualifiedOutputName());
             out.tab(1).println("def this(alias : %s) = {", String.class);
+            out.tab(2).println("this(%s.name(alias), %s, null)", DSL.class, tableId);
+            out.tab(1).println("}");
+
+            out.tab(1).javadoc("Create an aliased <code>%s</code> table reference", table.getQualifiedOutputName());
+            out.tab(1).println("def this(alias : %s) = {", Name.class);
             out.tab(2).println("this(alias, %s, null)", tableId);
             out.tab(1).println("}");
         }
@@ -3376,6 +3381,11 @@ public class JavaGenerator extends AbstractGenerator {
         else if (generateInstanceFields()) {
             out.tab(1).javadoc("Create an aliased <code>%s</code> table reference", table.getQualifiedOutputName());
             out.tab(1).println("public %s(%s alias) {", className, String.class);
+            out.tab(2).println("this(%s.name(alias), %s);", DSL.class, tableId);
+            out.tab(1).println("}");
+
+            out.tab(1).javadoc("Create an aliased <code>%s</code> table reference", table.getQualifiedOutputName());
+            out.tab(1).println("public %s(%s alias) {", className, Name.class);
             out.tab(2).println("this(alias, %s);", tableId);
             out.tab(1).println("}");
         }
@@ -3383,7 +3393,7 @@ public class JavaGenerator extends AbstractGenerator {
         out.println();
 
         if (scala) {
-            out.tab(1).println("private def this(alias : %s, aliased : %s[%s]) = {", String.class, Table.class, recordType);
+            out.tab(1).println("private def this(alias : %s, aliased : %s[%s]) = {", Name.class, Table.class, recordType);
             if (table.isTableValuedFunction())
                 out.tab(2).println("this(alias, aliased, new %s[ %s[_] ](%s))", out.ref("scala.Array"), Field.class, table.getParameters().size());
             else
@@ -3392,7 +3402,7 @@ public class JavaGenerator extends AbstractGenerator {
             out.tab(1).println("}");
         }
         else {
-            out.tab(1).println("private %s(%s alias, %s<%s> aliased) {", className, String.class, Table.class, recordType);
+            out.tab(1).println("private %s(%s alias, %s<%s> aliased) {", className, Name.class, Table.class, recordType);
             if (table.isTableValuedFunction())
                 out.tab(2).println("this(alias, aliased, new %s[%s]);", Field.class, table.getParameters().size());
             else
@@ -3401,7 +3411,7 @@ public class JavaGenerator extends AbstractGenerator {
             out.tab(1).println("}");
 
             out.println();
-            out.tab(1).println("private %s(%s alias, %s<%s> aliased, %s<?>[] parameters) {", className, String.class, Table.class, recordType, Field.class);
+            out.tab(1).println("private %s(%s alias, %s<%s> aliased, %s<?>[] parameters) {", className, Name.class, Table.class, recordType, Field.class);
             out.tab(2).println("super(alias, null, aliased, parameters, \"%s\");", escapeString(comment));
             out.tab(1).println("}");
         }
@@ -3563,6 +3573,17 @@ public class JavaGenerator extends AbstractGenerator {
             out.println();
             out.tab(1).println("override def as(alias : %s) : %s = {", String.class, className);
 
+            if (table.isTableValuedFunction())
+                out.tab(2).println("new %s(%s.name(alias), this, parameters)", className, DSL.class);
+            else
+                out.tab(2).println("new %s(%s.name(alias), this)", className, DSL.class);
+
+            out.tab(1).println("}");
+
+
+            out.println();
+            out.tab(1).println("override def as(alias : %s) : %s = {", Name.class, className);
+
             if (table.isTableValuedFunction())
                 out.tab(2).println("new %s(alias, this, parameters)", className);
             else
@@ -3577,6 +3598,17 @@ public class JavaGenerator extends AbstractGenerator {
             out.tab(1).overrideInherit();
             out.tab(1).println("public %s as(%s alias) {", className, String.class);
 
+            if (table.isTableValuedFunction())
+                out.tab(2).println("return new %s(%s.name(alias), this, parameters);", className, DSL.class);
+            else
+                out.tab(2).println("return new %s(%s.name(alias), this);", className, DSL.class);
+
+            out.tab(1).println("}");
+
+
+            out.tab(1).overrideInherit();
+            out.tab(1).println("public %s as(%s alias) {", className, Name.class);
+
             if (table.isTableValuedFunction())
                 out.tab(2).println("return new %s(alias, this, parameters);", className);
             else
@@ -3590,9 +3622,9 @@ public class JavaGenerator extends AbstractGenerator {
             out.tab(1).println("override def rename(name : %s) : %s = {", String.class, className);
 
             if (table.isTableValuedFunction())
-                out.tab(2).println("new %s(name, null, parameters)", className);
+                out.tab(2).println("new %s(%s.name(name), null, parameters)", className, DSL.class);
             else
-                out.tab(2).println("new %s(name, null)", className);
+                out.tab(2).println("new %s(%s.name(name), null)", className, DSL.class);
 
             out.tab(1).println("}");
         }
@@ -3604,9 +3636,9 @@ public class JavaGenerator extends AbstractGenerator {
             out.tab(1).println("public %s rename(%s name) {", className, String.class);
 
             if (table.isTableValuedFunction())
-                out.tab(2).println("return new %s(name, null, parameters);", className);
+                out.tab(2).println("return new %s(%s.name(name), null, parameters);", className, DSL.class);
             else
-                out.tab(2).println("return new %s(name, null);", className);
+                out.tab(2).println("return new %s(%s.name(name), null);", className, DSL.class);
 
             out.tab(1).println("}");
         }
diff --git a/jOOQ/src/main/java/org/jooq/Field.java b/jOOQ/src/main/java/org/jooq/Field.java
index bd2ac65a54..ae9dbb01c7 100644
--- a/jOOQ/src/main/java/org/jooq/Field.java
+++ b/jOOQ/src/main/java/org/jooq/Field.java
@@ -154,6 +154,23 @@ public interface Field<T> extends SelectField<T>, GroupField, FieldOrRow {
     @Support
     Field<T> as(String alias);
 
+    /**
+     * Create an alias for this field.
+     * <p>
+     * Note that the case-sensitivity of the returned field depends on
+     * {@link Settings#getRenderNameStyle()} and the {@link Name}. By default,
+     * field aliases are quoted, and thus case-sensitive - use
+     * {@link DSL#unquotedName(String...)} for case-insensitive aliases.
+     * <p>
+     * If the argument {@link Name#getName()} is qualified, then the
+     * {@link Name#last()} part will be used.
+     *
+     * @param alias The alias name
+     * @return The field alias
+     */
+    @Support
+    Field<T> as(Name alias);
+
     /**
      * Create an alias for this field based on another field's name.
      * <p>
diff --git a/jOOQ/src/main/java/org/jooq/Table.java b/jOOQ/src/main/java/org/jooq/Table.java
index 44b872d5a9..2e216b5fc1 100644
--- a/jOOQ/src/main/java/org/jooq/Table.java
+++ b/jOOQ/src/main/java/org/jooq/Table.java
@@ -379,6 +379,119 @@ public interface Table<R extends Record> extends TableLike<R> {
     Table<R> as(String alias, BiFunction<? super Field<?>, ? super Integer, ? extends String> aliasFunction);
 
 
+    /**
+     * Create an alias for this table.
+     * <p>
+     * Note that the case-sensitivity of the returned table depends on
+     * {@link Settings#getRenderNameStyle()} and the {@link Name}. By default,
+     * table aliases are quoted, and thus case-sensitive - use
+     * {@link DSL#unquotedName(String...)} for case-insensitive aliases.
+     * <p>
+     * If the argument {@link Name#getName()} is qualified, then the
+     * {@link Name#last()} part will be used.
+     *
+     * @param alias The alias name
+     * @return The table alias
+     */
+    @Support
+    Table<R> as(Name alias);
+
+    /**
+     * Create an alias for this table and its fields.
+     * <p>
+     * Note that the case-sensitivity of the returned table depends on
+     * {@link Settings#getRenderNameStyle()} and the {@link Name}. By default,
+     * table aliases are quoted, and thus case-sensitive - use
+     * {@link DSL#unquotedName(String...)} for case-insensitive aliases.
+     * <p>
+     * If the argument {@link Name#getName()} is qualified, then the
+     * {@link Name#last()} part will be used.
+     * <p>
+     * <h5>Derived column lists for table references</h5>
+     * <p>
+     * Note, not all databases support derived column lists for their table
+     * aliases. On the other hand, some databases do support derived column
+     * lists, but only for derived tables. jOOQ will try to turn table
+     * references into derived tables to make this syntax work. In other words,
+     * the following statements are equivalent: <code><pre>
+     * -- Using derived column lists to rename columns (e.g. Postgres)
+     * SELECT t.a, t.b
+     * FROM my_table t(a, b)
+     *
+     * -- Nesting table references within derived tables (e.g. SQL Server)
+     * SELECT t.a, t.b
+     * FROM (
+     *   SELECT * FROM my_table
+     * ) t(a, b)
+     * </pre></code>
+     * <p>
+     * <h5>Derived column lists for derived tables</h5>
+     * <p>
+     * Other databases may not support derived column lists at all, but they do
+     * support common table expressions. The following statements are
+     * equivalent: <code><pre>
+     * -- Using derived column lists to rename columns (e.g. Postgres)
+     * SELECT t.a, t.b
+     * FROM (
+     *   SELECT 1, 2
+     * ) AS t(a, b)
+     *
+     * -- Using UNION ALL to produce column names (e.g. MySQL)
+     * SELECT t.a, t.b
+     * FROM (
+     *   SELECT null a, null b FROM DUAL WHERE 1 = 0
+     *   UNION ALL
+     *   SELECT 1, 2 FROM DUAL
+     * ) t
+     * </pre></code>
+     *
+     * @param alias The alias name
+     * @param fieldAliases The field aliases. Excess aliases are ignored,
+     *            missing aliases will be substituted by this table's field
+     *            names.
+     * @return The table alias
+     */
+    @Support
+    Table<R> as(Name alias, Name... fieldAliases);
+
+
+    /**
+     * Create an alias for this table and its fields.
+     * <p>
+     * This works like {@link #as(Name, Name...)}, except that field aliases
+     * are provided by a function. This is useful, for instance, to prefix all
+     * columns with a common prefix:
+     * <p>
+     * <code><pre>
+     * MY_TABLE.as("t1", f -> "prefix_" + f.getName());
+     * </pre></code>
+     *
+     * @param alias The alias name
+     * @param aliasFunction The function providing field aliases.
+     * @return The table alias
+     */
+    @Support
+    Table<R> as(Name alias, Function<? super Field<?>, ? extends Name> aliasFunction);
+
+    /**
+     * Create an alias for this table and its fields.
+     * <p>
+     * This works like {@link #as(Name, Name...)}, except that field aliases
+     * are provided by a function. This is useful, for instance, to prefix all
+     * columns with a common prefix:
+     * <p>
+     * <code><pre>
+     * MY_TABLE.as("t1", (f, i) -> "column" + i);
+     * </pre></code>
+     *
+     * @param alias The alias name
+     * @param aliasFunction The function providing field aliases.
+     * @return The table alias
+     */
+    @Support
+    Table<R> as(Name alias, BiFunction<? super Field<?>, ? super Integer, ? extends Name> aliasFunction);
+
+
     /**
      * Create an alias for this table based on another table's name.
      * <p>
@@ -411,7 +524,7 @@ public interface Table<R extends Record> extends TableLike<R> {
     /**
      * Create an alias for this table and its fields.
      * <p>
-     * This works like {@link #as(String, String...)}, except that field aliases
+     * This works like {@link #as(Table, Field...)}, except that field aliases
      * are provided by a function. This is useful, for instance, to prefix all
      * columns with a common prefix:
      * <p>
@@ -429,7 +542,7 @@ public interface Table<R extends Record> extends TableLike<R> {
     /**
      * Create an alias for this table and its fields.
      * <p>
-     * This works like {@link #as(String, String...)}, except that field aliases
+     * This works like {@link #as(Table, Field...)}, except that field aliases
      * are provided by a function. This is useful, for instance, to prefix all
      * columns with a common prefix:
      * <p>
diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractField.java b/jOOQ/src/main/java/org/jooq/impl/AbstractField.java
index 833ccdc094..05b23e4334 100644
--- a/jOOQ/src/main/java/org/jooq/impl/AbstractField.java
+++ b/jOOQ/src/main/java/org/jooq/impl/AbstractField.java
@@ -87,6 +87,7 @@ import org.jooq.DataType;
 import org.jooq.DatePart;
 import org.jooq.Field;
 import org.jooq.LikeEscapeStep;
+import org.jooq.Name;
 import org.jooq.QuantifiedSelect;
 import org.jooq.Record;
 import org.jooq.Record1;
@@ -109,16 +110,16 @@ abstract class AbstractField<T> extends AbstractQueryPart implements Field<T> {
     private static final long     serialVersionUID = 2884811923648354905L;
     private static final Clause[] CLAUSES          = { FIELD };
 
-    private final String          name;
+    private final Name            name;
     private final String          comment;
     private final DataType<T>     dataType;
 
-    AbstractField(String name, DataType<T> type) {
+    AbstractField(Name name, DataType<T> type) {
         this(name, type, null, type.getBinding());
     }
 
     @SuppressWarnings("unchecked")
-    AbstractField(String name, DataType<T> type, String comment, Binding<?, T> binding) {
+    AbstractField(Name name, DataType<T> type, String comment, Binding<?, T> binding) {
         super();
 
         this.name = name;
@@ -182,12 +183,18 @@ abstract class AbstractField<T> extends AbstractQueryPart implements Field<T> {
     // ------------------------------------------------------------------------
 
     @Override
-    public Field<T> as(String alias) {
+    public final Field<T> as(String alias) {
+        return as(DSL.name(alias));
+    }
+
+    @Override
+    public Field<T> as(Name alias) {
         return new FieldAlias<T>(this, alias);
     }
 
     @Override
     public final Field<T> as(Field<?> otherField) {
+        // [#5997] TODO Change this
         return as(otherField.getName());
     }
 
@@ -202,7 +209,7 @@ abstract class AbstractField<T> extends AbstractQueryPart implements Field<T> {
 
     @Override
     public final String getName() {
-        return name;
+        return StringUtils.defaultIfNull(name.last(), "");
     }
 
     @Override
@@ -2032,21 +2039,18 @@ abstract class AbstractField<T> extends AbstractQueryPart implements Field<T> {
 
     @Override
     public boolean equals(Object that) {
-        if (this == that) {
+        if (this == that)
             return true;
-        }
 
         // [#2144] Non-equality can be decided early, without executing the
         // rather expensive implementation of AbstractQueryPart.equals()
-        if (that instanceof AbstractField) {
-            if (StringUtils.equals(name, (((AbstractField<?>) that).name))) {
+        if (that instanceof AbstractField)
+            if (StringUtils.equals(name.last(), (((AbstractField<?>) that).name.last())))
                 return super.equals(that);
-            }
-
+            else
+                return false;
+        else
             return false;
-        }
-
-        return false;
     }
 
     @Override
@@ -2054,6 +2058,6 @@ abstract class AbstractField<T> extends AbstractQueryPart implements Field<T> {
 
         // [#1938] This is a much more efficient hashCode() implementation
         // compared to that of standard QueryParts
-        return name.hashCode();
+        return name.last().hashCode();
     }
 }
diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractFunction.java b/jOOQ/src/main/java/org/jooq/impl/AbstractFunction.java
index 93de299da0..1a3c313823 100644
--- a/jOOQ/src/main/java/org/jooq/impl/AbstractFunction.java
+++ b/jOOQ/src/main/java/org/jooq/impl/AbstractFunction.java
@@ -55,7 +55,7 @@ abstract class AbstractFunction<T> extends AbstractField<T> {
     private final Field<?>[]   arguments;
 
     AbstractFunction(String name, DataType<T> type, Field<?>... arguments) {
-        super(name, type);
+        super(DSL.name(name), type);
 
         this.arguments = arguments;
     }
diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractParam.java b/jOOQ/src/main/java/org/jooq/impl/AbstractParam.java
index ee68d33cb6..8ae7292fd5 100644
--- a/jOOQ/src/main/java/org/jooq/impl/AbstractParam.java
+++ b/jOOQ/src/main/java/org/jooq/impl/AbstractParam.java
@@ -45,6 +45,7 @@ import static org.jooq.conf.ParamType.NAMED_OR_INLINED;
 import org.jooq.Clause;
 import org.jooq.Context;
 import org.jooq.DataType;
+import org.jooq.Name;
 import org.jooq.Param;
 import org.jooq.ParamMode;
 import org.jooq.UDTRecord;
@@ -87,8 +88,9 @@ abstract class AbstractParam<T> extends AbstractField<T> implements Param<T> {
      * <li>Otherwise, take the string value of <code>value</code></li>
      * </ul>
      */
-    private static String name(Object value, String paramName) {
-        return paramName != null
+    private static Name name(Object value, String paramName) {
+        return DSL.name(
+               paramName != null
              ? paramName
 
              // [#3707] Protect value.toString call for certain jOOQ types.
@@ -99,7 +101,8 @@ abstract class AbstractParam<T> extends AbstractField<T> implements Param<T> {
 
 
 
-             : String.valueOf(value);
+             : String.valueOf(value)
+        );
     }
 
     // ------------------------------------------------------------------------
diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractRoutine.java b/jOOQ/src/main/java/org/jooq/impl/AbstractRoutine.java
index 441d807ccd..19d69f2032 100644
--- a/jOOQ/src/main/java/org/jooq/impl/AbstractRoutine.java
+++ b/jOOQ/src/main/java/org/jooq/impl/AbstractRoutine.java
@@ -1513,7 +1513,9 @@ public abstract class AbstractRoutine<T> extends AbstractQueryPart implements Ro
 
         @SuppressWarnings("unchecked")
         RoutineField() {
-            super(AbstractRoutine.this.getName(),
+
+            // [#5997] TODO Retain quotation flag
+            super(DSL.name(AbstractRoutine.this.getName()),
                   AbstractRoutine.this.type == null
 
                   // [#4254] PostgreSQL may have stored functions that don't
diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractTable.java b/jOOQ/src/main/java/org/jooq/impl/AbstractTable.java
index a36a854217..b39dead8f3 100644
--- a/jOOQ/src/main/java/org/jooq/impl/AbstractTable.java
+++ b/jOOQ/src/main/java/org/jooq/impl/AbstractTable.java
@@ -290,6 +290,16 @@ abstract class AbstractTable<R extends Record> extends AbstractQueryPart impleme
         return as(alias, aliasFunction);
     }
 
+    @Override
+    public /* non-final for covariant overriding */ Table<R> as(String alias) {
+        return as(DSL.name(alias));
+    }
+
+    @Override
+    public /* non-final for covariant overriding */ Table<R> as(String alias, String... fieldAliases) {
+        return as(DSL.name(alias), Tools.names(fieldAliases));
+    }
+
     @Override
     public final Table<R> as(String alias, Function<? super Field<?>, ? extends String> aliasFunction) {
         return as(alias, Stream.of(fields()).map(aliasFunction).toArray(String[]::new));
@@ -305,6 +315,32 @@ abstract class AbstractTable<R extends Record> extends AbstractQueryPart impleme
     }
 
 
+    @Override
+    public /* non-final for covariant overriding */ Table<R> as(Name alias) {
+        throw new UnsupportedOperationException("Subtypes should override this method. If using the jOOQ code generator, please re-generate your code");
+    }
+
+    @Override
+    public /* non-final for covariant overriding */ Table<R> as(Name alias, Name... fieldAliases) {
+        throw new UnsupportedOperationException("Subtypes should override this method. If using the jOOQ code generator, please re-generate your code");
+    }
+
+
+    @Override
+    public final Table<R> as(Name alias, Function<? super Field<?>, ? extends Name> aliasFunction) {
+        return as(alias, Stream.of(fields()).map(aliasFunction).toArray(Name[]::new));
+    }
+
+    @Override
+    public final Table<R> as(Name alias, BiFunction<? super Field<?>, ? super Integer, ? extends Name> aliasFunction) {
+        Field<?>[] fields = fields();
+        Name[] names = new Name[fields.length];
+        for (int i = 0; i < fields.length; i++)
+            names[i] = aliasFunction.apply(fields[i], i);
+        return as(alias, names);
+    }
+
+
     // ------------------------------------------------------------------------
     // XXX: Table API
     // ------------------------------------------------------------------------
@@ -492,7 +528,8 @@ abstract class AbstractTable<R extends Record> extends AbstractQueryPart impleme
           ? (DataType<U>) type
           : type.asConvertedDataType(actualBinding);
 
-        final TableFieldImpl<R, U> tableField = new TableFieldImpl<R, U>(name, actualType, table, comment, actualBinding);
+        // [#5999] TODO: Allow for user-defined Names
+        final TableFieldImpl<R, U> tableField = new TableFieldImpl<R, U>(DSL.name(name), actualType, table, comment, actualBinding);
 
         // [#1199] The public API of Table returns immutable field lists
         if (table instanceof TableImpl) {
@@ -651,22 +688,26 @@ abstract class AbstractTable<R extends Record> extends AbstractQueryPart impleme
 
     @Override
     public final Table<R> as(Table<?> otherTable) {
+        // [#5997] TODO Change this
         return as(otherTable.getName());
     }
 
     @Override
     public final Table<R> as(Table<?> otherTable, Field<?>... otherFields) {
+        // [#5997] TODO Change this
         return as(otherTable.getName(), Tools.fieldNames(otherFields));
     }
 
 
     @Override
     public final Table<R> as(Table<?> otherTable, Function<? super Field<?>, ? extends Field<?>> aliasFunction) {
+        // [#5997] TODO Change this
         return as(otherTable.getName(), f -> aliasFunction.apply(f).getName());
     }
 
     @Override
     public final Table<R> as(Table<?> otherTable, BiFunction<? super Field<?>, ? super Integer, ? extends Field<?>> aliasFunction) {
+        // [#5997] TODO Change this
         return as(otherTable.getName(), (f, i) -> aliasFunction.apply(f, i).getName());
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/Alias.java b/jOOQ/src/main/java/org/jooq/impl/Alias.java
index 347e05ded8..abda943be4 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Alias.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Alias.java
@@ -68,6 +68,7 @@ import static org.jooq.impl.Tools.DataKey.DATA_UNALIAS_ALIASES_IN_ORDER_BY;
 import org.jooq.Clause;
 import org.jooq.Context;
 import org.jooq.Field;
+import org.jooq.Name;
 import org.jooq.QueryPart;
 import org.jooq.Record;
 import org.jooq.SQLDialect;
@@ -86,23 +87,23 @@ final class Alias<Q extends QueryPart> extends AbstractQueryPart {
     private static final Clause[] CLAUSES_FIELD_ALIAS     = { FIELD, FIELD_ALIAS };
 
     private final Q               wrapped;
-    private final String          alias;
-    private final String[]        fieldAliases;
+    private final Name            alias;
+    private final Name[]          fieldAliases;
     private final boolean         wrapInParentheses;
 
-    Alias(Q wrapped, String alias) {
+    Alias(Q wrapped, Name alias) {
         this(wrapped, alias, null, false);
     }
 
-    Alias(Q wrapped, String alias, boolean wrapInParentheses) {
+    Alias(Q wrapped, Name alias, boolean wrapInParentheses) {
         this(wrapped, alias, null, wrapInParentheses);
     }
 
-    Alias(Q wrapped, String alias, String[] fieldAliases) {
+    Alias(Q wrapped, Name alias, Name[] fieldAliases) {
         this(wrapped, alias, fieldAliases, false);
     }
 
-    Alias(Q wrapped, String alias, String[] fieldAliases, boolean wrapInParentheses) {
+    Alias(Q wrapped, Name alias, Name[] fieldAliases, boolean wrapInParentheses) {
         this.wrapped = wrapped;
         this.alias = alias;
         this.fieldAliases = fieldAliases;
@@ -115,6 +116,8 @@ final class Alias<Q extends QueryPart> extends AbstractQueryPart {
 
     @Override
     public final void accept(Context<?> context) {
+        boolean qualify = context.qualify();
+
         if (context.declareAliases() && (context.declareFields() || context.declareTables())) {
             context.declareAliases(false);
 
@@ -143,8 +146,7 @@ final class Alias<Q extends QueryPart> extends AbstractQueryPart {
                 emulatedDerivedColumnList = true;
 
                 SelectFieldList fields = new SelectFieldList();
-                for (String fieldAlias : fieldAliases) {
-
+                for (Name fieldAlias : fieldAliases) {
                     switch (family) {
 
 
@@ -189,8 +191,10 @@ final class Alias<Q extends QueryPart> extends AbstractQueryPart {
             // [#291] some aliases cause trouble, if they are not explicitly marked using "as"
             toSQLAs(context);
 
-            context.sql(' ');
-            context.literal(alias);
+            context.sql(' ')
+                   .qualify(false)
+                   .visit(alias)
+                   .qualify(qualify);
 
             // [#1801] Add field aliases to the table alias, if applicable
             if (fieldAliases != null && !emulatedDerivedColumnList) {
@@ -234,7 +238,9 @@ final class Alias<Q extends QueryPart> extends AbstractQueryPart {
 
 
         else {
-            context.literal(alias);
+            context.qualify(false)
+                   .visit(alias)
+                   .qualify(qualify);
         }
     }
 
@@ -257,7 +263,7 @@ final class Alias<Q extends QueryPart> extends AbstractQueryPart {
 
         for (int i = 0; i < fieldAliases.length; i++) {
             context.sql(separator);
-            context.literal(fieldAliases[i]);
+            context.visit(fieldAliases[i]);
 
             separator = ", ";
         }
diff --git a/jOOQ/src/main/java/org/jooq/impl/Array.java b/jOOQ/src/main/java/org/jooq/impl/Array.java
index a4f52c5e00..885647813e 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Array.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Array.java
@@ -56,7 +56,7 @@ final class Array<T> extends AbstractField<T[]> {
     private final Fields<Record> fields;
 
     Array(Collection<? extends Field<T>> fields) {
-        super("array", type(fields));
+        super(DSL.name("array"), type(fields));
 
         this.fields = new Fields<Record>(fields);
     }
diff --git a/jOOQ/src/main/java/org/jooq/impl/ArrayTable.java b/jOOQ/src/main/java/org/jooq/impl/ArrayTable.java
index 4ca4b9ef56..ce18208050 100644
--- a/jOOQ/src/main/java/org/jooq/impl/ArrayTable.java
+++ b/jOOQ/src/main/java/org/jooq/impl/ArrayTable.java
@@ -43,6 +43,7 @@ import java.util.List;
 import org.jooq.Configuration;
 import org.jooq.Context;
 import org.jooq.Field;
+import org.jooq.Name;
 import org.jooq.Param;
 import org.jooq.Record;
 import org.jooq.Table;
@@ -64,20 +65,20 @@ final class ArrayTable extends AbstractTable<Record> {
 
     private final Field<?>       array;
     private final Fields<Record> field;
-    private final String         alias;
-    private final String[]       fieldAliases;
+    private final Name           alias;
+    private final Name[]         fieldAliases;
 
     ArrayTable(Field<?> array) {
-        this(array, "array_table");
+        this(array, DSL.name("array_table"));
     }
 
-    ArrayTable(Field<?> array, String alias) {
-        this(array, alias, new String[] { "COLUMN_VALUE" });
+    ArrayTable(Field<?> array, Name alias) {
+        this(array, alias, new Name[] { DSL.name("COLUMN_VALUE") });
     }
 
     @SuppressWarnings({ "unchecked" })
-    ArrayTable(Field<?> array, String alias, String[] fieldAliases) {
-        super(alias);
+    ArrayTable(Field<?> array, Name alias, Name[] fieldAliases) {
+        super(alias.last());
 
         Class<?> arrayType;
 
@@ -112,7 +113,7 @@ final class ArrayTable extends AbstractTable<Record> {
         this.field = init(arrayType, alias, fieldAliases);
     }
 
-    private static final Fields<Record> init(Class<?> arrayType, String alias, String[] fieldAliases) {
+    private static final Fields<Record> init(Class<?> arrayType, Name alias, Name[] fields) {
         List<Field<?>> result = new ArrayList<Field<?>>();
 
         // [#1114] VARRAY/TABLE of OBJECT have more than one field
@@ -120,7 +121,7 @@ final class ArrayTable extends AbstractTable<Record> {
             try {
                 UDTRecord<?> record = (UDTRecord<?>) arrayType.newInstance();
                 for (Field<?> f : record.fields()) {
-                    result.add(DSL.field(name(alias, f.getName()), f.getDataType()));
+                    result.add(DSL.field(name(alias.last(), f.getName()), f.getDataType()));
                 }
             }
             catch (Exception e) {
@@ -130,7 +131,7 @@ final class ArrayTable extends AbstractTable<Record> {
 
         // Simple array types have a synthetic field called "COLUMN_VALUE"
         else {
-            result.add(DSL.field(name(alias, "COLUMN_VALUE"), DSL.getDataType(arrayType)));
+            result.add(DSL.field(name(alias.last(), "COLUMN_VALUE"), DSL.getDataType(arrayType)));
         }
 
         return new Fields<Record>(result);
@@ -142,13 +143,13 @@ final class ArrayTable extends AbstractTable<Record> {
     }
 
     @Override
-    public final Table<Record> as(String as) {
+    public final Table<Record> as(Name as) {
         return new ArrayTable(array, as);
     }
 
     @Override
-    public final Table<Record> as(String as, String... fieldAliases) {
-        return new ArrayTable(array, as, fieldAliases);
+    public final Table<Record> as(Name as, Name... fields) {
+        return new ArrayTable(array, as, fields);
     }
 
     @Override
@@ -223,7 +224,7 @@ final class ArrayTable extends AbstractTable<Record> {
         public final void accept(Context<?> ctx) {
             ctx.keyword("table")
                .sql('(')
-               .visit(name(fieldAliases == null || fieldAliases.length == 0 ? "COLUMN_VALUE" : fieldAliases[0]))
+               .visit(fieldAliases == null || fieldAliases.length == 0 ? DSL.name("COLUMN_VALUE") : fieldAliases[0])
                .sql(' ');
 
             // If the array type is unknown (e.g. because it's returned from
@@ -260,7 +261,7 @@ final class ArrayTable extends AbstractTable<Record> {
         private static final long serialVersionUID = 2662639259338694177L;
 
         DialectArrayTable() {
-            super(alias);
+            super(alias.last());
         }
 
         @Override
@@ -269,13 +270,13 @@ final class ArrayTable extends AbstractTable<Record> {
         }
 
         @Override
-        public final Table<Record> as(String as) {
+        public final Table<Record> as(Name as) {
             return new TableAlias<Record>(this, as);
         }
 
         @Override
-        public final Table<Record> as(String as, String... fieldAliases) {
-            return new TableAlias<Record>(this, as, fieldAliases);
+        public final Table<Record> as(Name as, Name... fields) {
+            return new TableAlias<Record>(this, as, fields);
         }
 
         @Override
diff --git a/jOOQ/src/main/java/org/jooq/impl/ArrayTableEmulation.java b/jOOQ/src/main/java/org/jooq/impl/ArrayTableEmulation.java
index 8c3cafd972..849c02a6be 100644
--- a/jOOQ/src/main/java/org/jooq/impl/ArrayTableEmulation.java
+++ b/jOOQ/src/main/java/org/jooq/impl/ArrayTableEmulation.java
@@ -42,6 +42,7 @@ import static org.jooq.impl.DSL.using;
 import org.jooq.Configuration;
 import org.jooq.Context;
 import org.jooq.Field;
+import org.jooq.Name;
 import org.jooq.Record;
 import org.jooq.Select;
 import org.jooq.Table;
@@ -61,26 +62,26 @@ final class ArrayTableEmulation extends AbstractTable<Record> {
 
     private final Object[]          array;
     private final Fields<Record>    field;
-    private final String            alias;
-    private final String            fieldAlias;
+    private final Name              alias;
+    private final Name              fieldAlias;
 
     private transient Table<Record> table;
 
     ArrayTableEmulation(Object[] array) {
-        this(array, "array_table", null);
+        this(array, DSL.name("array_table"), null);
     }
 
-    ArrayTableEmulation(Object[] array, String alias) {
+    ArrayTableEmulation(Object[] array, Name alias) {
         this(array, alias, null);
     }
 
-    ArrayTableEmulation(Object[] array, String alias, String fieldAlias) {
-        super(alias);
+    ArrayTableEmulation(Object[] array, Name alias, Name fieldAlias) {
+        super(alias.last());
 
         this.array = array;
         this.alias = alias;
-        this.fieldAlias = fieldAlias == null ? "COLUMN_VALUE" : fieldAlias;
-        this.field = new Fields<Record>(DSL.field(name(alias, this.fieldAlias), DSL.getDataType(array.getClass().getComponentType())));
+        this.fieldAlias = fieldAlias == null ? DSL.name("COLUMN_VALUE") : fieldAlias;
+        this.field = new Fields<Record>(DSL.field(name(alias.last(), this.fieldAlias.last()), DSL.getDataType(array.getClass().getComponentType())));
     }
 
     @Override
@@ -89,18 +90,16 @@ final class ArrayTableEmulation extends AbstractTable<Record> {
     }
 
     @Override
-    public final Table<Record> as(String as) {
+    public final Table<Record> as(Name as) {
         return new ArrayTableEmulation(array, as);
     }
 
     @Override
-    public final Table<Record> as(String as, String... fieldAliases) {
-        if (fieldAliases == null) {
+    public final Table<Record> as(Name as, Name... fieldAliases) {
+        if (fieldAliases == null)
             return new ArrayTableEmulation(array, as);
-        }
-        else if (fieldAliases.length == 1) {
+        else if (fieldAliases.length == 1)
             return new ArrayTableEmulation(array, as, fieldAliases[0]);
-        }
 
         throw new IllegalArgumentException("Array table simulations can only have a single field alias");
     }
@@ -146,7 +145,7 @@ final class ArrayTableEmulation extends AbstractTable<Record> {
                 select = using(configuration).select(one().as("COLUMN_VALUE")).select().where(falseCondition());
             }
 
-            table = select.asTable(alias);
+            table = DSL.table(select).as(alias);
         }
 
         return table;
diff --git a/jOOQ/src/main/java/org/jooq/impl/Coalesce.java b/jOOQ/src/main/java/org/jooq/impl/Coalesce.java
index aa2d6c1b72..c39608ab54 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Coalesce.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Coalesce.java
@@ -51,7 +51,7 @@ final class Coalesce<T> extends AbstractField<T> {
 
     @SuppressWarnings("unchecked")
     Coalesce(DataType<T> dataType, Field<?>[] fields) {
-        super("coalesce", dataType);
+        super(DSL.name("coalesce"), dataType);
 
         this.fields = (Field[]) fields;
     }
diff --git a/jOOQ/src/main/java/org/jooq/impl/Coerce.java b/jOOQ/src/main/java/org/jooq/impl/Coerce.java
index 974e95f9ea..e826b14430 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Coerce.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Coerce.java
@@ -51,7 +51,9 @@ final class Coerce<T> extends AbstractField<T> {
     private final Field<?>    field;
 
     public Coerce(Field<?> field, DataType<T> type) {
-        super(field.getName(), type);
+
+        // [#5997] TODO Retain quotation flag
+        super(DSL.name(field.getName()), type);
 
         this.field = (field instanceof Coerce) ? ((Coerce<?>) field).field : field;
     }
diff --git a/jOOQ/src/main/java/org/jooq/impl/CommonTableExpressionImpl.java b/jOOQ/src/main/java/org/jooq/impl/CommonTableExpressionImpl.java
index ca2166c58e..b305ad6748 100644
--- a/jOOQ/src/main/java/org/jooq/impl/CommonTableExpressionImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/CommonTableExpressionImpl.java
@@ -39,6 +39,7 @@ import java.util.List;
 import org.jooq.CommonTableExpression;
 import org.jooq.Context;
 import org.jooq.Field;
+import org.jooq.Name;
 import org.jooq.Record;
 import org.jooq.Select;
 import org.jooq.Table;
@@ -71,12 +72,12 @@ final class CommonTableExpressionImpl<R extends Record> extends AbstractTable<R>
     }
 
     @Override
-    public final Table<R> as(String alias) {
+    public final Table<R> as(Name alias) {
         return new TableAlias<R>(this, alias);
     }
 
     @Override
-    public final Table<R> as(String alias, String... fieldAliases) {
+    public final Table<R> as(Name alias, Name... fieldAliases) {
         return new TableAlias<R>(this, alias, fieldAliases);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/CustomField.java b/jOOQ/src/main/java/org/jooq/impl/CustomField.java
index d64c8057b7..a1459ca4c1 100644
--- a/jOOQ/src/main/java/org/jooq/impl/CustomField.java
+++ b/jOOQ/src/main/java/org/jooq/impl/CustomField.java
@@ -41,6 +41,7 @@ import org.jooq.Condition;
 import org.jooq.Context;
 import org.jooq.DataType;
 import org.jooq.Field;
+import org.jooq.Name;
 
 /**
  * A base class for custom {@link Field} implementations in client code.
@@ -64,6 +65,10 @@ public abstract class CustomField<T> extends AbstractField<T> {
     private static final Clause[] CLAUSES          = { CUSTOM };
 
     protected CustomField(String name, DataType<T> type) {
+        this(DSL.name(name), type);
+    }
+
+    protected CustomField(Name name, DataType<T> type) {
         super(name, type);
     }
 
@@ -89,7 +94,7 @@ public abstract class CustomField<T> extends AbstractField<T> {
     }
 
     @Override
-    public final Field<T> as(String alias) {
+    public final Field<T> as(Name alias) {
         return super.as(alias);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/DerivedTable.java b/jOOQ/src/main/java/org/jooq/impl/DerivedTable.java
index 2e03617034..2655a102f3 100644
--- a/jOOQ/src/main/java/org/jooq/impl/DerivedTable.java
+++ b/jOOQ/src/main/java/org/jooq/impl/DerivedTable.java
@@ -37,6 +37,7 @@ package org.jooq.impl;
 
 import org.jooq.Clause;
 import org.jooq.Context;
+import org.jooq.Name;
 import org.jooq.Record;
 import org.jooq.Select;
 import org.jooq.Table;
@@ -61,12 +62,12 @@ final class DerivedTable<R extends Record> extends AbstractTable<R> {
     }
 
     @Override
-    public final Table<R> as(String alias) {
+    public final Table<R> as(Name alias) {
         return new TableAlias<R>(this, alias, true);
     }
 
     @Override
-    public final Table<R> as(String alias, String... fieldAliases) {
+    public final Table<R> as(Name alias, Name... fieldAliases) {
         return new TableAlias<R>(this, alias, fieldAliases, true);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/Dual.java b/jOOQ/src/main/java/org/jooq/impl/Dual.java
index cbe7714611..22d9412b4e 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Dual.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Dual.java
@@ -40,6 +40,7 @@ import static org.jooq.impl.DSL.select;
 
 import org.jooq.Context;
 import org.jooq.Field;
+import org.jooq.Name;
 import org.jooq.Record;
 import org.jooq.Schema;
 import org.jooq.Table;
@@ -75,7 +76,7 @@ final class Dual extends AbstractTable<Record> {
     }
 
     @Override
-    public final Table<Record> as(String alias) {
+    public final Table<Record> as(Name alias) {
         if (force) {
             return FORCED_DUAL.as(alias);
         }
@@ -85,7 +86,7 @@ final class Dual extends AbstractTable<Record> {
     }
 
     @Override
-    public final Table<Record> as(String alias, String... fieldAliases) {
+    public final Table<Record> as(Name alias, Name... fieldAliases) {
         if (force) {
             return FORCED_DUAL.as(alias, fieldAliases);
         }
diff --git a/jOOQ/src/main/java/org/jooq/impl/Expression.java b/jOOQ/src/main/java/org/jooq/impl/Expression.java
index 9348e7e0b0..6b050f7574 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Expression.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Expression.java
@@ -639,7 +639,7 @@ final class Expression<T> extends AbstractFunction<T> {
         private static final long serialVersionUID = -5105004317793995419L;
 
         private DefaultExpression() {
-            super(operator.toSQL(), lhs.getDataType());
+            super(operator.toName(), lhs.getDataType());
         }
 
         @Override
diff --git a/jOOQ/src/main/java/org/jooq/impl/ExpressionOperator.java b/jOOQ/src/main/java/org/jooq/impl/ExpressionOperator.java
index ec1989bf50..24bb78a30f 100644
--- a/jOOQ/src/main/java/org/jooq/impl/ExpressionOperator.java
+++ b/jOOQ/src/main/java/org/jooq/impl/ExpressionOperator.java
@@ -34,6 +34,8 @@
  */
 package org.jooq.impl;
 
+import org.jooq.Name;
+
 /**
  * The operator used in <code>Expression</code>
  *
@@ -119,12 +121,18 @@ enum ExpressionOperator {
     ;
 
     private final String sql;
+    private final Name name;
 
     private ExpressionOperator(String sql) {
         this.sql = sql;
+        this.name = DSL.name(name().toLowerCase());
     }
 
     public String toSQL() {
         return sql;
     }
+
+    public Name toName() {
+        return name;
+    }
 }
diff --git a/jOOQ/src/main/java/org/jooq/impl/FieldAlias.java b/jOOQ/src/main/java/org/jooq/impl/FieldAlias.java
index a46bb6bc23..5dfc850dd4 100644
--- a/jOOQ/src/main/java/org/jooq/impl/FieldAlias.java
+++ b/jOOQ/src/main/java/org/jooq/impl/FieldAlias.java
@@ -38,6 +38,7 @@ package org.jooq.impl;
 import org.jooq.Clause;
 import org.jooq.Context;
 import org.jooq.Field;
+import org.jooq.Name;
 
 /**
  * @author Lukas Eder
@@ -47,7 +48,7 @@ final class FieldAlias<T> extends AbstractField<T> {
     private static final long     serialVersionUID = -85277321749681553L;
     private final Alias<Field<T>> alias;
 
-    FieldAlias(Field<T> field, String alias) {
+    FieldAlias(Field<T> field, Name alias) {
         super(alias, field.getDataType());
 
         this.alias = new Alias<Field<T>>(field, alias, false);
@@ -64,7 +65,7 @@ final class FieldAlias<T> extends AbstractField<T> {
     }
 
     @Override
-    public final Field<T> as(String as) {
+    public final Field<T> as(Name as) {
         return alias.wrapped().as(as);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/FlashbackTable.java b/jOOQ/src/main/java/org/jooq/impl/FlashbackTable.java
index 2a42323859..aa4b449c93 100644
--- a/jOOQ/src/main/java/org/jooq/impl/FlashbackTable.java
+++ b/jOOQ/src/main/java/org/jooq/impl/FlashbackTable.java
@@ -156,6 +156,7 @@ package org.jooq.impl;
 
 
 
+
 
 
             
\ No newline at end of file
diff --git a/jOOQ/src/main/java/org/jooq/impl/Function.java b/jOOQ/src/main/java/org/jooq/impl/Function.java
index 1f8466f4c3..fb918bf344 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Function.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Function.java
@@ -144,7 +144,7 @@ class Function<T> extends AbstractField<T> implements
     }
 
     Function(String name, boolean distinct, DataType<T> type, QueryPart... arguments) {
-        super(name, type);
+        super(DSL.name(name), type);
 
         this.term = null;
         this.name = null;
@@ -155,7 +155,7 @@ class Function<T> extends AbstractField<T> implements
     }
 
     Function(Term term, boolean distinct, DataType<T> type, QueryPart... arguments) {
-        super(term.name().toLowerCase(), type);
+        super(term.toName(), type);
 
         this.term = term;
         this.name = null;
@@ -166,7 +166,7 @@ class Function<T> extends AbstractField<T> implements
     }
 
     Function(Name name, boolean distinct, DataType<T> type, QueryPart... arguments) {
-        super(last(name.getName()), type);
+        super(name, type);
 
         this.term = null;
         this.name = name;
@@ -176,14 +176,6 @@ class Function<T> extends AbstractField<T> implements
         this.withinGroupOrderBy = new SortFieldList();
     }
 
-    final static String last(String... strings) {
-        if (strings != null && strings.length > 0) {
-            return strings[strings.length - 1];
-        }
-
-        return null;
-    }
-
     // -------------------------------------------------------------------------
     // XXX QueryPart API
     // -------------------------------------------------------------------------
diff --git a/jOOQ/src/main/java/org/jooq/impl/FunctionTable.java b/jOOQ/src/main/java/org/jooq/impl/FunctionTable.java
index ffdf71b975..fa57449ac2 100644
--- a/jOOQ/src/main/java/org/jooq/impl/FunctionTable.java
+++ b/jOOQ/src/main/java/org/jooq/impl/FunctionTable.java
@@ -36,6 +36,7 @@ package org.jooq.impl;
 
 import org.jooq.Context;
 import org.jooq.Field;
+import org.jooq.Name;
 import org.jooq.Record;
 import org.jooq.Table;
 import org.jooq.exception.SQLDialectNotSupportedException;
@@ -65,12 +66,12 @@ final class FunctionTable<R extends Record> extends AbstractTable<R> {
     }
 
     @Override
-    public final Table<R> as(String as) {
+    public final Table<R> as(Name as) {
         return new TableAlias<R>(new FunctionTable<R>(function), as);
     }
 
     @Override
-    public final Table<R> as(String as, String... fieldAliases) {
+    public final Table<R> as(Name as, Name... fieldAliases) {
         return new TableAlias<R>(new FunctionTable<R>(function), as, fieldAliases);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/GenerateSeries.java b/jOOQ/src/main/java/org/jooq/impl/GenerateSeries.java
index 5168465348..587692ffab 100644
--- a/jOOQ/src/main/java/org/jooq/impl/GenerateSeries.java
+++ b/jOOQ/src/main/java/org/jooq/impl/GenerateSeries.java
@@ -43,6 +43,7 @@ import org.jooq.Clause;
 import org.jooq.Configuration;
 import org.jooq.Context;
 import org.jooq.Field;
+import org.jooq.Name;
 import org.jooq.QueryPart;
 import org.jooq.Record1;
 import org.jooq.Table;
@@ -106,12 +107,12 @@ final class GenerateSeries extends AbstractTable<Record1<Integer>> {
     }
 
     @Override
-    public final Table<Record1<Integer>> as(String alias) {
+    public final Table<Record1<Integer>> as(Name alias) {
         return new TableAlias<Record1<Integer>>(this, alias);
     }
 
     @Override
-    public final Table<Record1<Integer>> as(String alias, String... fieldAliases) {
+    public final Table<Record1<Integer>> as(Name alias, Name... fieldAliases) {
         return new TableAlias<Record1<Integer>>(this, alias, fieldAliases);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/HintedTable.java b/jOOQ/src/main/java/org/jooq/impl/HintedTable.java
index 45dcbabd76..5f6e127596 100644
--- a/jOOQ/src/main/java/org/jooq/impl/HintedTable.java
+++ b/jOOQ/src/main/java/org/jooq/impl/HintedTable.java
@@ -84,12 +84,12 @@ final class HintedTable<R extends Record> extends AbstractTable<R> {
     }
 
     @Override
-    public final Table<R> as(String alias) {
+    public final Table<R> as(Name alias) {
         return new HintedTable<R>(new TableAlias<R>(delegate, alias), keywords, arguments);
     }
 
     @Override
-    public final Table<R> as(String alias, String... fieldAliases) {
+    public final Table<R> as(Name alias, Name... fieldAliases) {
         return new HintedTable<R>(new TableAlias<R>(delegate, alias, fieldAliases), keywords, arguments);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/JoinTable.java b/jOOQ/src/main/java/org/jooq/impl/JoinTable.java
index 2b20caa3d4..7f81363a6e 100644
--- a/jOOQ/src/main/java/org/jooq/impl/JoinTable.java
+++ b/jOOQ/src/main/java/org/jooq/impl/JoinTable.java
@@ -92,6 +92,7 @@ import org.jooq.Context;
 import org.jooq.Field;
 import org.jooq.ForeignKey;
 import org.jooq.JoinType;
+import org.jooq.Name;
 import org.jooq.Operator;
 import org.jooq.QueryPart;
 import org.jooq.Record;
@@ -417,12 +418,12 @@ final class JoinTable extends AbstractTable<Record> implements TableOptionalOnSt
     }
 
     @Override
-    public final Table<Record> as(String alias) {
+    public final Table<Record> as(Name alias) {
         return new TableAlias<Record>(this, alias, true);
     }
 
     @Override
-    public final Table<Record> as(String alias, String... fieldAliases) {
+    public final Table<Record> as(Name alias, Name... fieldAliases) {
         return new TableAlias<Record>(this, alias, fieldAliases, true);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/Lateral.java b/jOOQ/src/main/java/org/jooq/impl/Lateral.java
index 662c35da29..914cae0a8b 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Lateral.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Lateral.java
@@ -35,6 +35,7 @@
 package org.jooq.impl;
 
 import org.jooq.Context;
+import org.jooq.Name;
 import org.jooq.Record;
 import org.jooq.Table;
 
@@ -66,12 +67,12 @@ final class Lateral<R extends Record> extends AbstractTable<R> {
     }
 
     @Override
-    public final Table<R> as(String alias) {
+    public final Table<R> as(Name alias) {
         return new Lateral<R>(table.as(alias));
     }
 
     @Override
-    public final Table<R> as(String alias, String... fieldAliases) {
+    public final Table<R> as(Name alias, Name... fieldAliases) {
         return new Lateral<R>(table.as(alias, fieldAliases));
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/LinkedTable.java b/jOOQ/src/main/java/org/jooq/impl/LinkedTable.java
index 22b0795300..7f9335c6a6 100644
--- a/jOOQ/src/main/java/org/jooq/impl/LinkedTable.java
+++ b/jOOQ/src/main/java/org/jooq/impl/LinkedTable.java
@@ -91,5 +91,6 @@ package org.jooq.impl;
 
 
 
+
 
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/Neg.java b/jOOQ/src/main/java/org/jooq/impl/Neg.java
index c287237719..128551bdf2 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Neg.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Neg.java
@@ -62,7 +62,7 @@ final class Neg<T> extends AbstractField<T> {
     private final Field<T>           field;
 
     Neg(Field<T> field, ExpressionOperator operator) {
-        super(operator.toSQL() + field.getName(), field.getDataType());
+        super(operator.toName(), field.getDataType());
 
         this.operator = operator;
         this.field = field;
diff --git a/jOOQ/src/main/java/org/jooq/impl/NotField.java b/jOOQ/src/main/java/org/jooq/impl/NotField.java
index 5d99a67c89..7c8ed5ee08 100644
--- a/jOOQ/src/main/java/org/jooq/impl/NotField.java
+++ b/jOOQ/src/main/java/org/jooq/impl/NotField.java
@@ -51,7 +51,7 @@ final class NotField extends AbstractField<Boolean> {
     private final Field<Boolean>  field;
 
     NotField(Field<Boolean> field) {
-        super("not", field.getDataType());
+        super(DSL.name("not"), field.getDataType());
         this.field = field;
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/Pivot.java b/jOOQ/src/main/java/org/jooq/impl/Pivot.java
index d737a66184..e0d2b41a31 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Pivot.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Pivot.java
@@ -47,6 +47,7 @@ import org.jooq.Condition;
 import org.jooq.Configuration;
 import org.jooq.Context;
 import org.jooq.Field;
+import org.jooq.Name;
 import org.jooq.PivotForStep;
 import org.jooq.PivotInStep;
 import org.jooq.QueryPart;
@@ -268,12 +269,12 @@ implements
         }
 
         @Override
-        public final Table<Record> as(String as) {
+        public final Table<Record> as(Name as) {
             return new TableAlias<Record>(this, as);
         }
 
         @Override
-        public final Table<Record> as(String as, String... fieldAliases) {
+        public final Table<Record> as(Name as, Name... fieldAliases) {
             return new TableAlias<Record>(this, as, fieldAliases);
         }
 
@@ -297,12 +298,12 @@ implements
     }
 
     @Override
-    public final Table<Record> as(String alias) {
+    public final Table<Record> as(Name alias) {
         return new TableAlias<Record>(this, alias, true);
     }
 
     @Override
-    public final Table<Record> as(String alias, String... fieldAliases) {
+    public final Table<Record> as(Name alias, Name... fieldAliases) {
         return new TableAlias<Record>(this, alias, fieldAliases, true);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/Prior.java b/jOOQ/src/main/java/org/jooq/impl/Prior.java
index bee9eb5ead..fcdb47d1e7 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Prior.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Prior.java
@@ -53,7 +53,7 @@ final class Prior<T> extends AbstractField<T> {
     private final Field<T>    field;
 
     Prior(Field<T> field) {
-        super("prior", nullSafe(field).getDataType());
+        super(DSL.name("prior"), nullSafe(field).getDataType());
 
         this.field = field;
     }
diff --git a/jOOQ/src/main/java/org/jooq/impl/QualifiedField.java b/jOOQ/src/main/java/org/jooq/impl/QualifiedField.java
index f90e3b4e23..7cb782dd7a 100644
--- a/jOOQ/src/main/java/org/jooq/impl/QualifiedField.java
+++ b/jOOQ/src/main/java/org/jooq/impl/QualifiedField.java
@@ -64,7 +64,7 @@ final class QualifiedField<T> extends AbstractField<T> implements TableField<Rec
     private final Table<Record> table;
 
     QualifiedField(Name name, DataType<T> type) {
-        super(defaultIfNull(name.last(), ""), type);
+        super(DSL.name(defaultIfNull(name.last(), "")), type);
 
         this.name = name;
         this.table = name.getName().length > 1
diff --git a/jOOQ/src/main/java/org/jooq/impl/QualifiedTable.java b/jOOQ/src/main/java/org/jooq/impl/QualifiedTable.java
index e0f9507ca7..c75c9bc2a0 100644
--- a/jOOQ/src/main/java/org/jooq/impl/QualifiedTable.java
+++ b/jOOQ/src/main/java/org/jooq/impl/QualifiedTable.java
@@ -86,12 +86,12 @@ final class QualifiedTable extends AbstractTable<Record> {
     }
 
     @Override
-    public final Table<Record> as(String alias) {
+    public final Table<Record> as(Name alias) {
         return new TableAlias<Record>(this, alias);
     }
 
     @Override
-    public final Table<Record> as(String alias, String... fieldAliases) {
+    public final Table<Record> as(Name alias, Name... fieldAliases) {
         return new TableAlias<Record>(this, alias, fieldAliases);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/Rollup.java b/jOOQ/src/main/java/org/jooq/impl/Rollup.java
index 2f5bb11245..243afd9059 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Rollup.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Rollup.java
@@ -52,7 +52,7 @@ final class Rollup extends AbstractField<Object> {
     private QueryPartList<FieldOrRow> arguments;
 
     Rollup(FieldOrRow... arguments) {
-        super("rollup", SQLDataType.OTHER);
+        super(DSL.name("rollup"), SQLDataType.OTHER);
 
         this.arguments = new QueryPartList<FieldOrRow>(arguments);
     }
diff --git a/jOOQ/src/main/java/org/jooq/impl/RowField.java b/jOOQ/src/main/java/org/jooq/impl/RowField.java
index 7c0f77b491..4faf0c7e26 100644
--- a/jOOQ/src/main/java/org/jooq/impl/RowField.java
+++ b/jOOQ/src/main/java/org/jooq/impl/RowField.java
@@ -40,6 +40,7 @@ import org.jooq.Context;
 import org.jooq.Converter;
 import org.jooq.DataType;
 import org.jooq.Field;
+import org.jooq.Name;
 import org.jooq.Record;
 import org.jooq.Row;
 
@@ -57,11 +58,11 @@ final class RowField<ROW extends Row, REC extends Record> extends AbstractField<
     private final Field<?>[]  emulatedFields;
 
     RowField(ROW row) {
-        this(row, "row");
+        this(row, DSL.name("row"));
     }
 
     @SuppressWarnings({ "serial", "unchecked", "rawtypes" })
-    RowField(final ROW row, String as) {
+    RowField(final ROW row, Name as) {
         super(as, (DataType) SQLDataType.RECORD, "", new DefaultBinding<Object, REC>(new Converter<Object, REC>() {
             @Override
             public REC from(final Object t) {
@@ -111,7 +112,7 @@ final class RowField<ROW extends Row, REC extends Record> extends AbstractField<
     }
 
     @Override
-    public Field<REC> as(String alias) {
+    public Field<REC> as(Name alias) {
         return new RowField<ROW, REC>(row, alias);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/RowsFrom.java b/jOOQ/src/main/java/org/jooq/impl/RowsFrom.java
index c4b9d23314..a18db6665d 100644
--- a/jOOQ/src/main/java/org/jooq/impl/RowsFrom.java
+++ b/jOOQ/src/main/java/org/jooq/impl/RowsFrom.java
@@ -40,6 +40,7 @@ import java.util.List;
 
 import org.jooq.Context;
 import org.jooq.Field;
+import org.jooq.Name;
 import org.jooq.Record;
 import org.jooq.Table;
 
@@ -67,12 +68,12 @@ final class RowsFrom extends AbstractTable<Record> {
     }
 
     @Override
-    public final Table<Record> as(String alias) {
+    public final Table<Record> as(Name alias) {
         return new TableAlias<Record>(this, alias);
     }
 
     @Override
-    public final Table<Record> as(String alias, String... fieldAliases) {
+    public final Table<Record> as(Name alias, Name... fieldAliases) {
         return new TableAlias<Record>(this, alias, fieldAliases);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/SQLField.java b/jOOQ/src/main/java/org/jooq/impl/SQLField.java
index 9874615d84..70f1deb5c8 100644
--- a/jOOQ/src/main/java/org/jooq/impl/SQLField.java
+++ b/jOOQ/src/main/java/org/jooq/impl/SQLField.java
@@ -48,7 +48,7 @@ final class SQLField<T> extends AbstractField<T> {
     private final QueryPart   delegate;
 
     SQLField(DataType<T> type, QueryPart delegate) {
-        super(delegate.toString(), type);
+        super(DSL.name(delegate.toString()), type);
 
         this.delegate = delegate;
     }
diff --git a/jOOQ/src/main/java/org/jooq/impl/SQLTable.java b/jOOQ/src/main/java/org/jooq/impl/SQLTable.java
index 43afd35257..3edb5af978 100644
--- a/jOOQ/src/main/java/org/jooq/impl/SQLTable.java
+++ b/jOOQ/src/main/java/org/jooq/impl/SQLTable.java
@@ -35,6 +35,7 @@
 package org.jooq.impl;
 
 import org.jooq.Context;
+import org.jooq.Name;
 import org.jooq.QueryPart;
 import org.jooq.Record;
 import org.jooq.Table;
@@ -64,12 +65,12 @@ final class SQLTable extends AbstractTable<Record> {
     }
 
     @Override
-    public final Table<Record> as(String alias) {
+    public final Table<Record> as(Name alias) {
         return new TableAlias<Record>(this, alias);
     }
 
     @Override
-    public final Table<Record> as(String alias, String... fieldAliases) {
+    public final Table<Record> as(Name alias, Name... fieldAliases) {
         return new TableAlias<Record>(this, alias, fieldAliases);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/ScalarSubquery.java b/jOOQ/src/main/java/org/jooq/impl/ScalarSubquery.java
index 9a50a73323..971cc85941 100644
--- a/jOOQ/src/main/java/org/jooq/impl/ScalarSubquery.java
+++ b/jOOQ/src/main/java/org/jooq/impl/ScalarSubquery.java
@@ -38,6 +38,7 @@ package org.jooq.impl;
 import org.jooq.Context;
 import org.jooq.DataType;
 import org.jooq.Field;
+import org.jooq.Name;
 import org.jooq.Select;
 
 /**
@@ -50,13 +51,13 @@ final class ScalarSubquery<T> extends AbstractField<T> {
     private final Select<?>   query;
 
     ScalarSubquery(Select<?> query, DataType<T> type) {
-        super("select", type);
+        super(DSL.name("select"), type);
 
         this.query = query;
     }
 
     @Override
-    public final Field<T> as(String alias) {
+    public final Field<T> as(Name alias) {
         return new FieldAlias<T>(this, alias);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/TableAlias.java b/jOOQ/src/main/java/org/jooq/impl/TableAlias.java
index 1088a96c92..a0a8088f86 100644
--- a/jOOQ/src/main/java/org/jooq/impl/TableAlias.java
+++ b/jOOQ/src/main/java/org/jooq/impl/TableAlias.java
@@ -43,6 +43,7 @@ import org.jooq.Context;
 import org.jooq.Field;
 import org.jooq.ForeignKey;
 import org.jooq.Identity;
+import org.jooq.Name;
 import org.jooq.Record;
 import org.jooq.Row;
 import org.jooq.Table;
@@ -59,20 +60,20 @@ final class TableAlias<R extends Record> extends AbstractTable<R> {
     final Alias<Table<R>>     alias;
     final Fields<R>           aliasedFields;
 
-    TableAlias(Table<R> table, String alias) {
+    TableAlias(Table<R> table, Name alias) {
         this(table, alias, null, false);
     }
 
-    TableAlias(Table<R> table, String alias, boolean wrapInParentheses) {
+    TableAlias(Table<R> table, Name alias, boolean wrapInParentheses) {
         this(table, alias, null, wrapInParentheses);
     }
 
-    TableAlias(Table<R> table, String alias, String[] fieldAliases) {
+    TableAlias(Table<R> table, Name alias, Name[] fieldAliases) {
         this(table, alias, fieldAliases, false);
     }
 
-    TableAlias(Table<R> table, String alias, String[] fieldAliases, boolean wrapInParentheses) {
-        super(alias, table.getSchema());
+    TableAlias(Table<R> table, Name alias, Name[] fieldAliases, boolean wrapInParentheses) {
+        super(alias.last(), table.getSchema());
 
         this.alias = new Alias<Table<R>>(table, alias, fieldAliases, wrapInParentheses);
         this.aliasedFields = init(fieldAliases);
@@ -82,18 +83,19 @@ final class TableAlias<R extends Record> extends AbstractTable<R> {
      * Register fields for this table alias
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
-    private final Fields<R> init(String[] fieldAliases) {
+    private final Fields<R> init(Name[] fieldAliases) {
         List<Field<?>> result = new ArrayList<Field<?>>();
         Row row = this.alias.wrapped().fieldsRow();
         int size = row.size();
 
         for (int i = 0; i < size; i++) {
             Field<?> field = row.field(i);
-            String name = field.getName();
 
-            if (fieldAliases != null && fieldAliases.length > i) {
+            // [#5997] TODO: Retain quotation flag
+            Name name = DSL.name(field.getName());
+
+            if (fieldAliases != null && fieldAliases.length > i)
                 name = fieldAliases[i];
-            }
 
             result.add(new TableFieldImpl(name, field.getDataType(), this, field.getComment(), field.getBinding()));
         }
@@ -153,12 +155,12 @@ final class TableAlias<R extends Record> extends AbstractTable<R> {
     }
 
     @Override
-    public final Table<R> as(String as) {
+    public final Table<R> as(Name as) {
         return alias.wrapped().as(as);
     }
 
     @Override
-    public final Table<R> as(String as, String... fieldAliases) {
+    public final Table<R> as(Name as, Name... fieldAliases) {
         return alias.wrapped().as(as, fieldAliases);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/TableFieldImpl.java b/jOOQ/src/main/java/org/jooq/impl/TableFieldImpl.java
index 30e9c5e52a..7c7614cf8d 100644
--- a/jOOQ/src/main/java/org/jooq/impl/TableFieldImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/TableFieldImpl.java
@@ -43,6 +43,7 @@ import org.jooq.Binding;
 import org.jooq.Clause;
 import org.jooq.Context;
 import org.jooq.DataType;
+import org.jooq.Name;
 import org.jooq.Record;
 import org.jooq.Table;
 import org.jooq.TableField;
@@ -58,9 +59,9 @@ final class TableFieldImpl<R extends Record, T> extends AbstractField<T> impleme
     private static final long     serialVersionUID = -2211214195583539735L;
     private static final Clause[] CLAUSES          = { FIELD, FIELD_REFERENCE };
 
-    private final Table<R>    table;
+    private final Table<R>        table;
 
-    TableFieldImpl(String name, DataType<T> type, Table<R> table, String comment, Binding<?, T> binding) {
+    TableFieldImpl(Name name, DataType<T> type, Table<R> table, String comment, Binding<?, T> binding) {
         super(name, type, comment, binding);
 
         this.table = table;
diff --git a/jOOQ/src/main/java/org/jooq/impl/TableImpl.java b/jOOQ/src/main/java/org/jooq/impl/TableImpl.java
index 8b42fea28b..86c2b46d81 100644
--- a/jOOQ/src/main/java/org/jooq/impl/TableImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/TableImpl.java
@@ -48,6 +48,7 @@ import java.util.Arrays;
 import org.jooq.Clause;
 import org.jooq.Context;
 import org.jooq.Field;
+import org.jooq.Name;
 import org.jooq.Record;
 import org.jooq.Schema;
 import org.jooq.Table;
@@ -71,33 +72,76 @@ public class TableImpl<R extends Record> extends AbstractTable<R> {
 
     protected final Field<?>[]    parameters;
 
+    /**
+     * @deprecated - 3.10 - [#5996] - Use {@link #TableImpl(Name)} instead (or
+     *             re-generated your code).
+     */
+    @Deprecated
     public TableImpl(String name) {
+        this(DSL.name(name));
+    }
+
+    /**
+     * @deprecated - 3.10 - [#5996] - Use {@link #TableImpl(Name, Schema)}
+     *             instead (or re-generated your code).
+     */
+    @Deprecated
+    public TableImpl(String name, Schema schema) {
+        this(DSL.name(name), schema);
+    }
+
+    /**
+     * @deprecated - 3.10 - [#5996] - Use {@link #TableImpl(Name, Schema, Table)}
+     *             instead (or re-generated your code).
+     */
+    @Deprecated
+    public TableImpl(String name, Schema schema, Table<R> aliased) {
+        this(DSL.name(name), schema, aliased);
+    }
+
+    /**
+     * @deprecated - 3.10 - [#5996] - Use {@link #TableImpl(Name, Schema, Table, Field[])}
+     *             instead (or re-generated your code).
+     */
+    @Deprecated
+    public TableImpl(String name, Schema schema, Table<R> aliased, Field<?>[] parameters) {
+        this(DSL.name(name), schema, aliased, parameters);
+    }
+
+    /**
+     * @deprecated - 3.10 - [#5996] - Use {@link #TableImpl(Name, Schema, Table, Field[], String)}
+     *             instead (or re-generated your code).
+     */
+    @Deprecated
+    public TableImpl(String name, Schema schema, Table<R> aliased, Field<?>[] parameters, String comment) {
+        this(DSL.name(name), schema, aliased, parameters, comment);
+    }
+
+    public TableImpl(Name name) {
         this(name, null, null, null, null);
     }
 
-    public TableImpl(String name, Schema schema) {
+    public TableImpl(Name name, Schema schema) {
         this(name, schema, null, null, null);
     }
 
-    public TableImpl(String name, Schema schema, Table<R> aliased) {
+    public TableImpl(Name name, Schema schema, Table<R> aliased) {
         this(name, schema, aliased, null, null);
     }
 
-    public TableImpl(String name, Schema schema, Table<R> aliased, Field<?>[] parameters) {
+    public TableImpl(Name name, Schema schema, Table<R> aliased, Field<?>[] parameters) {
         this(name, schema, aliased, parameters, null);
     }
 
-    public TableImpl(String name, Schema schema, Table<R> aliased, Field<?>[] parameters, String comment) {
-        super(name, schema, comment);
+    public TableImpl(Name name, Schema schema, Table<R> aliased, Field<?>[] parameters, String comment) {
+        super(name.last(), schema, comment);
 
         this.fields = new Fields<R>();
 
-        if (aliased != null) {
+        if (aliased != null)
             alias = new Alias<Table<R>>(aliased, name);
-        }
-        else {
+        else
             alias = null;
-        }
 
         this.parameters = parameters;
     }
@@ -180,7 +224,7 @@ public class TableImpl<R extends Record> extends AbstractTable<R> {
      * {@inheritDoc}
      */
     @Override
-    public Table<R> as(String as) {
+    public Table<R> as(Name as) {
         if (alias != null) {
             return alias.wrapped().as(as);
         }
@@ -196,7 +240,7 @@ public class TableImpl<R extends Record> extends AbstractTable<R> {
      * {@inheritDoc}
      */
     @Override
-    public Table<R> as(String as, String... fieldAliases) {
+    public Table<R> as(Name as, Name... fieldAliases) {
         if (alias != null) {
             return alias.wrapped().as(as, fieldAliases);
         }
diff --git a/jOOQ/src/main/java/org/jooq/impl/Term.java b/jOOQ/src/main/java/org/jooq/impl/Term.java
index 36a8160d08..94fd2f6a76 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Term.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Term.java
@@ -34,6 +34,7 @@
  */
 package org.jooq.impl;
 
+import org.jooq.Name;
 import org.jooq.SQLDialect;
 
 /**
@@ -280,11 +281,21 @@ enum Term {
 
     ;
 
+    private final Name name;
+
+    private Term() {
+        this.name = DSL.name(name());
+    }
+
     @Override
     public String toString() {
         return super.toString();
     }
 
+    public final Name toName() {
+        return name;
+    }
+
     /**
      * Translate the term to its dialect-specific variant
      */
diff --git a/jOOQ/src/main/java/org/jooq/impl/UDTFieldImpl.java b/jOOQ/src/main/java/org/jooq/impl/UDTFieldImpl.java
index 1d65b6fe41..f0e8ade043 100644
--- a/jOOQ/src/main/java/org/jooq/impl/UDTFieldImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/UDTFieldImpl.java
@@ -38,6 +38,7 @@ package org.jooq.impl;
 import org.jooq.Binding;
 import org.jooq.Context;
 import org.jooq.DataType;
+import org.jooq.Name;
 import org.jooq.UDT;
 import org.jooq.UDTField;
 import org.jooq.UDTRecord;
@@ -53,7 +54,7 @@ final class UDTFieldImpl<R extends UDTRecord<R>, T> extends AbstractField<T> imp
 
     private final UDT<R>      udt;
 
-    UDTFieldImpl(String name, DataType<T> type, UDT<R> udt, String comment, Binding<?, T> binding) {
+    UDTFieldImpl(Name name, DataType<T> type, UDT<R> udt, String comment, Binding<?, T> binding) {
         super(name, type, comment, binding);
 
         this.udt = udt;
diff --git a/jOOQ/src/main/java/org/jooq/impl/UDTImpl.java b/jOOQ/src/main/java/org/jooq/impl/UDTImpl.java
index 0f173cda53..779186a603 100644
--- a/jOOQ/src/main/java/org/jooq/impl/UDTImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/UDTImpl.java
@@ -270,7 +270,8 @@ public class UDTImpl<R extends UDTRecord<R>> extends AbstractQueryPart implement
             ? (DataType<U>) type
             : type.asConvertedDataType(actualBinding);
 
-        final UDTFieldImpl<R, U> udtField = new UDTFieldImpl<R, U>(name, actualType, udt, comment, actualBinding);
+        // [#5999] TODO: Allow for user-defined Names
+        final UDTFieldImpl<R, U> udtField = new UDTFieldImpl<R, U>(DSL.name(name), actualType, udt, comment, actualBinding);
 
         return udtField;
     }
diff --git a/jOOQ/src/main/java/org/jooq/impl/Values.java b/jOOQ/src/main/java/org/jooq/impl/Values.java
index 7611f09b00..ed6f342c9e 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Values.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Values.java
@@ -37,6 +37,7 @@ package org.jooq.impl;
 import static org.jooq.Clause.TABLE_VALUES;
 
 import org.jooq.Context;
+import org.jooq.Name;
 import org.jooq.Record;
 import org.jooq.Row;
 import org.jooq.Select;
@@ -76,12 +77,12 @@ final class Values<R extends Record> extends AbstractTable<R> {
     }
 
     @Override
-    public final Table<R> as(String alias) {
+    public final Table<R> as(Name alias) {
         return new TableAlias<R>(this, alias, true);
     }
 
     @Override
-    public final Table<R> as(String alias, String... fieldAliases) {
+    public final Table<R> as(Name alias, Name... fieldAliases) {
         return new TableAlias<R>(this, alias, fieldAliases, true);
     }
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/WithTable.java b/jOOQ/src/main/java/org/jooq/impl/WithTable.java
index 29a7ad5a69..b9849c4ce8 100644
--- a/jOOQ/src/main/java/org/jooq/impl/WithTable.java
+++ b/jOOQ/src/main/java/org/jooq/impl/WithTable.java
@@ -35,6 +35,7 @@
 package org.jooq.impl;
 
 import org.jooq.Context;
+import org.jooq.Name;
 import org.jooq.Record;
 import org.jooq.Table;
 
@@ -77,12 +78,12 @@ final class WithTable<R extends Record> extends AbstractTable<R> {
     }
 
     @Override
-    public final Table<R> as(String alias) {
+    public final Table<R> as(Name alias) {
         return new WithTable<R>(new TableAlias<R>(delegate, alias), hint);
     }
 
     @Override
-    public final Table<R> as(String alias, String... fieldAliases) {
+    public final Table<R> as(Name alias, Name... fieldAliases) {
         return new WithTable<R>(new TableAlias<R>(delegate, alias, fieldAliases), hint);
     }