github/jooq
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[#5996] Add Field.as(Name) and Table.as(Name), Table.as(Name, Name...)

Browse Source
This commit is contained in:
lukaseder 2017-03-22 16:08:21 +01:00
parent f2b239a37d
commit 04af931dd8
49 changed files with 464 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
jOOQ-codegen/src/main/java/org/jooq/util/JavaGenerator.java
View File

@ -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("}");
}

17
jOOQ/src/main/java/org/jooq/Field.java
View File

@ -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>

117
jOOQ/src/main/java/org/jooq/Table.java
View File

@ -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>

34
jOOQ/src/main/java/org/jooq/impl/AbstractField.java
View File

@ -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();
}
}

2
jOOQ/src/main/java/org/jooq/impl/AbstractFunction.java
View File

@ -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;
}

9
jOOQ/src/main/java/org/jooq/impl/AbstractParam.java
View File

@ -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)
);
}
// ------------------------------------------------------------------------

4
jOOQ/src/main/java/org/jooq/impl/AbstractRoutine.java
View File

@ -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

43
jOOQ/src/main/java/org/jooq/impl/AbstractTable.java
View File

@ -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());
}

30
jOOQ/src/main/java/org/jooq/impl/Alias.java
View File

@ -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 = ", ";
}

2
jOOQ/src/main/java/org/jooq/impl/Array.java
View File

@ -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);
}

37
jOOQ/src/main/java/org/jooq/impl/ArrayTable.java
View File

@ -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

29
jOOQ/src/main/java/org/jooq/impl/ArrayTableEmulation.java
View File

@ -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;

2
jOOQ/src/main/java/org/jooq/impl/Coalesce.java
View File

@ -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;
}

4
jOOQ/src/main/java/org/jooq/impl/Coerce.java
View File

@ -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;
}

5
jOOQ/src/main/java/org/jooq/impl/CommonTableExpressionImpl.java
View File

@ -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);
}

7
jOOQ/src/main/java/org/jooq/impl/CustomField.java
View File

@ -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);
}

5
jOOQ/src/main/java/org/jooq/impl/DerivedTable.java
View File

@ -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);
}

5
jOOQ/src/main/java/org/jooq/impl/Dual.java
View File

@ -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);
}

2
jOOQ/src/main/java/org/jooq/impl/Expression.java
View File

@ -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

8
jOOQ/src/main/java/org/jooq/impl/ExpressionOperator.java
View File

@ -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;
}
}

5
jOOQ/src/main/java/org/jooq/impl/FieldAlias.java
View File

@ -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);
}

1
jOOQ/src/main/java/org/jooq/impl/FlashbackTable.java
View File

@ -156,6 +156,7 @@ package org.jooq.impl;

14
jOOQ/src/main/java/org/jooq/impl/Function.java
View File

@ -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
// -------------------------------------------------------------------------

5
jOOQ/src/main/java/org/jooq/impl/FunctionTable.java
View File

@ -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);
}

5
jOOQ/src/main/java/org/jooq/impl/GenerateSeries.java
View File

@ -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);
}

4
jOOQ/src/main/java/org/jooq/impl/HintedTable.java
View File

@ -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);
}

5
jOOQ/src/main/java/org/jooq/impl/JoinTable.java
View File

@ -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);
}

5
jOOQ/src/main/java/org/jooq/impl/Lateral.java
View File

@ -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));
}

1
jOOQ/src/main/java/org/jooq/impl/LinkedTable.java
View File

@ -91,5 +91,6 @@ package org.jooq.impl;

2
jOOQ/src/main/java/org/jooq/impl/Neg.java
View File

@ -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;

2
jOOQ/src/main/java/org/jooq/impl/NotField.java
View File

@ -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;
}

9
jOOQ/src/main/java/org/jooq/impl/Pivot.java
View File

@ -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);
}

2
jOOQ/src/main/java/org/jooq/impl/Prior.java
View File

@ -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;
}

2
jOOQ/src/main/java/org/jooq/impl/QualifiedField.java
View File

@ -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

4
jOOQ/src/main/java/org/jooq/impl/QualifiedTable.java
View File

@ -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);
}

2
jOOQ/src/main/java/org/jooq/impl/Rollup.java
View File

@ -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);
}

7
jOOQ/src/main/java/org/jooq/impl/RowField.java
View File

@ -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);
}

5
jOOQ/src/main/java/org/jooq/impl/RowsFrom.java
View File

@ -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);
}

2
jOOQ/src/main/java/org/jooq/impl/SQLField.java
View File

@ -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;
}

5
jOOQ/src/main/java/org/jooq/impl/SQLTable.java
View File

@ -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);
}

5
jOOQ/src/main/java/org/jooq/impl/ScalarSubquery.java
View File

@ -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);
}

24
jOOQ/src/main/java/org/jooq/impl/TableAlias.java
View File

@ -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);
}

5
jOOQ/src/main/java/org/jooq/impl/TableFieldImpl.java
View File

@ -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;

66
jOOQ/src/main/java/org/jooq/impl/TableImpl.java
View File

@ -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);
}

11
jOOQ/src/main/java/org/jooq/impl/Term.java
View File

@ -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
*/

3
jOOQ/src/main/java/org/jooq/impl/UDTFieldImpl.java
View File

@ -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;

3
jOOQ/src/main/java/org/jooq/impl/UDTImpl.java
View File

@ -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;
}

5
jOOQ/src/main/java/org/jooq/impl/Values.java
View File

@ -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);
}

5
jOOQ/src/main/java/org/jooq/impl/WithTable.java
View File

@ -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);
}