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

[jOOQ/jOOQ#13069] Revert prototype

Browse Source
This commit is contained in:
Lukas Eder 2022-06-07 12:01:24 +02:00
parent 151cd06a82
commit b3a044b621
7 changed files with 0 additions and 1062 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
jOOQ-codegen/src/main/java/org/jooq/codegen/AbstractGenerator.java
View File

@ -71,11 +71,6 @@ abstract class AbstractGenerator implements Generator {
boolean generateRelations = true;
boolean generateImplicitJoinPathsToOne = true;
boolean generateImplicitJoinPathsAsKotlinProperties = true;
boolean generateExistsConvenienceOneToMany = false;
boolean generateExistsConvenienceManyToMany = false;
boolean generateRowConvenienceToOne = false;
boolean generateMultisetConvenienceOneToMany = false;
boolean generateMultisetConvenienceManyToMany = false;
boolean generateInstanceFields = true;
VisibilityModifier generateVisibilityModifier = VisibilityModifier.DEFAULT;
boolean generateGeneratedAnnotation = false;
@ -311,56 +306,6 @@ abstract class AbstractGenerator implements Generator {
this.generateImplicitJoinPathsAsKotlinProperties = generateImplicitJoinPathsAsKotlinProperties;
}
@Override
public boolean generateExistsConvenienceOneToMany() {
return generateExistsConvenienceOneToMany && generateRelations();
}
@Override
public void setGenerateExistsConvenienceOneToMany(boolean generateExistsConvenienceOneToMany) {
this.generateExistsConvenienceOneToMany = generateExistsConvenienceOneToMany;
}
@Override
public boolean generateExistsConvenienceManyToMany() {
return generateExistsConvenienceManyToMany && generateRelations();
}
@Override
public void setGenerateExistsConvenienceManyToMany(boolean generateExistsConvenienceManyToMany) {
this.generateExistsConvenienceManyToMany = generateExistsConvenienceManyToMany;
}
@Override
public boolean generateRowConvenienceToOne() {
return generateRowConvenienceToOne && generateRelations();
}
@Override
public void setGenerateRowConvenienceToOne(boolean generateRowConvenienceToOne) {
this.generateRowConvenienceToOne = generateRowConvenienceToOne;
}
@Override
public boolean generateMultisetConvenienceOneToMany() {
return generateMultisetConvenienceOneToMany && generateRelations();
}
@Override
public void setGenerateMultisetConvenienceOneToMany(boolean generateMultisetConvenienceOneToMany) {
this.generateMultisetConvenienceOneToMany = generateMultisetConvenienceOneToMany;
}
@Override
public boolean generateMultisetConvenienceManyToMany() {
return generateMultisetConvenienceManyToMany && generateRelations();
}
@Override
public void setGenerateMultisetConvenienceManyToMany(boolean generateMultisetConvenienceManyToMany) {
this.generateMultisetConvenienceManyToMany = generateMultisetConvenienceManyToMany;
}
@Override
public boolean generateTableValuedFunctions() {
return generateTableValuedFunctions;

10
jOOQ-codegen/src/main/java/org/jooq/codegen/GenerationTool.java
View File

@ -720,16 +720,6 @@ public class GenerationTool {
generator.setGenerateImplicitJoinPathsToOne(g.getGenerate().isImplicitJoinPathsToOne());
if (g.getGenerate().isImplicitJoinPathsAsKotlinProperties() != null)
generator.setGenerateImplicitJoinPathsAsKotlinProperties(g.getGenerate().isImplicitJoinPathsAsKotlinProperties());
if (g.getGenerate().isExistsConvenienceOneToMany() != null)
generator.setGenerateExistsConvenienceOneToMany(g.getGenerate().isExistsConvenienceOneToMany());
if (g.getGenerate().isExistsConvenienceManyToMany() != null)
generator.setGenerateExistsConvenienceManyToMany(g.getGenerate().isExistsConvenienceManyToMany());
if (g.getGenerate().isRowConvenienceToOne() != null)
generator.setGenerateRowConvenienceToOne(g.getGenerate().isRowConvenienceToOne());
if (g.getGenerate().isMultisetConvenienceOneToMany() != null)
generator.setGenerateMultisetConvenienceOneToMany(g.getGenerate().isMultisetConvenienceOneToMany());
if (g.getGenerate().isMultisetConvenienceManyToMany() != null)
generator.setGenerateMultisetConvenienceManyToMany(g.getGenerate().isMultisetConvenienceManyToMany());
if (g.getGenerate().isDeprecated() != null)
generator.setGenerateDeprecated(g.getGenerate().isDeprecated());
if (g.getGenerate().isDeprecationOnUnknownTypes() != null)

60
jOOQ-codegen/src/main/java/org/jooq/codegen/Generator.java
View File

@ -143,66 +143,6 @@ public interface Generator {
*/
void setGenerateImplicitJoinPathsAsKotlinProperties(boolean generateImplicitJoinPathsAsKotlinProperties);
/**
* Whether <code>EXISTS</code> convenience syntax for one-to-many
* relationships should be generated.
*/
boolean generateExistsConvenienceOneToMany();
/**
* Whether <code>EXISTS</code> convenience syntax for one-to-many
* relationships should be generated.
*/
void setGenerateExistsConvenienceOneToMany(boolean generateExistsConvenienceOneToMany);
/**
* Whether <code>EXISTS</code> convenience syntax for many-to-many
* relationships should be generated.
*/
boolean generateExistsConvenienceManyToMany();
/**
* Whether <code>EXISTS</code> convenience syntax for many-to-many
* relationships should be generated.
*/
void setGenerateExistsConvenienceManyToMany(boolean generateExistsConvenienceManyToMany);
/**
* Whether <code>ROW</code> convenience syntax for to-one relationships
* should be generated.
*/
boolean generateRowConvenienceToOne();
/**
* Whether <code>ROW</code> convenience syntax for to-one relationships
* should be generated.
*/
void setGenerateRowConvenienceToOne(boolean generateRowConvenienceToOne);
/**
* Whether <code>MULTISET</code> convenience syntax for one-to-many
* relationships should be generated.
*/
boolean generateMultisetConvenienceOneToMany();
/**
* Whether <code>MULTISET</code> convenience syntax for one-to-many
* relationships should be generated.
*/
void setGenerateMultisetConvenienceOneToMany(boolean generateMultisetConvenienceOneToMany);
/**
* Whether <code>MULTISET</code> convenience syntax for many-to-many
* relationships should be generated.
*/
boolean generateMultisetConvenienceManyToMany();
/**
* Whether <code>MULTISET</code> convenience syntax for many-to-many
* relationships should be generated.
*/
void setGenerateMultisetConvenienceManyToMany(boolean generateMultisetConvenienceManyToMany);
/**
* Whether table-valued functions should be generated as tables.
*/

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

@ -6533,389 +6533,6 @@ public class JavaGenerator extends AbstractGenerator {
}
}
}
}
List<CheckConstraintDefinition> cc = table.getCheckConstraints();

230
jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Generate.java
View File

@ -42,16 +42,6 @@ public class Generate implements Serializable, XMLAppendable
protected Boolean implicitJoinPathsUseTableNameForUnambiguousFKs = true;
@XmlElement(defaultValue = "true")
protected Boolean implicitJoinPathsAsKotlinProperties = true;
@XmlElement(defaultValue = "false")
protected Boolean existsConvenienceOneToMany = false;
@XmlElement(defaultValue = "false")
protected Boolean existsConvenienceManyToMany = false;
@XmlElement(defaultValue = "false")
protected Boolean rowConvenienceToOne = false;
@XmlElement(defaultValue = "false")
protected Boolean multisetConvenienceOneToMany = false;
@XmlElement(defaultValue = "false")
protected Boolean multisetConvenienceManyToMany = false;
@XmlElement(defaultValue = "true")
protected Boolean deprecated = true;
@XmlElement(defaultValue = "true")
@ -396,146 +386,6 @@ public class Generate implements Serializable, XMLAppendable
this.implicitJoinPathsAsKotlinProperties = value;
}
/**
* Generate <code>EXISTS</code> convenience syntax for one-to-many relationships.
* <p>
* This is EXPERIMENTAL functionality. Please expect the API and implementations to change, in the future.
* <p>
* This feature is available in the commercial distribution only.
*
* @return
* possible object is
* {@link Boolean }
*
*/
public Boolean isExistsConvenienceOneToMany() {
return existsConvenienceOneToMany;
}
/**
* Sets the value of the existsConvenienceOneToMany property.
*
* @param value
* allowed object is
* {@link Boolean }
*
*/
public void setExistsConvenienceOneToMany(Boolean value) {
this.existsConvenienceOneToMany = value;
}
/**
* Generate <code>EXISTS</code> convenience syntax for many-to-many relationships. A many-to-many relationship is achieved when a child table has 2 non-nullable foreign keys that are part of a unique key.
* <p>
* This is EXPERIMENTAL functionality. Please expect the API and implementations to change, in the future.
* <p>
* This feature is available in the commercial distribution only.
*
* @return
* possible object is
* {@link Boolean }
*
*/
public Boolean isExistsConvenienceManyToMany() {
return existsConvenienceManyToMany;
}
/**
* Sets the value of the existsConvenienceManyToMany property.
*
* @param value
* allowed object is
* {@link Boolean }
*
*/
public void setExistsConvenienceManyToMany(Boolean value) {
this.existsConvenienceManyToMany = value;
}
/**
* Generate <code>ROW</code> convenience syntax for to-one relationships.
* <p>
* This is EXPERIMENTAL functionality. Please expect the API and implementations to change, in the future.
* <p>
* This feature is available in the commercial distribution only.
*
* @return
* possible object is
* {@link Boolean }
*
*/
public Boolean isRowConvenienceToOne() {
return rowConvenienceToOne;
}
/**
* Sets the value of the rowConvenienceToOne property.
*
* @param value
* allowed object is
* {@link Boolean }
*
*/
public void setRowConvenienceToOne(Boolean value) {
this.rowConvenienceToOne = value;
}
/**
* Generate <code>MULTISET</code> convenience syntax for one-to-many relationships.
* <p>
* This is EXPERIMENTAL functionality. Please expect the API and implementations to change, in the future.
* <p>
* This feature is available in the commercial distribution only.
*
* @return
* possible object is
* {@link Boolean }
*
*/
public Boolean isMultisetConvenienceOneToMany() {
return multisetConvenienceOneToMany;
}
/**
* Sets the value of the multisetConvenienceOneToMany property.
*
* @param value
* allowed object is
* {@link Boolean }
*
*/
public void setMultisetConvenienceOneToMany(Boolean value) {
this.multisetConvenienceOneToMany = value;
}
/**
* Generate <code>MULTISET</code> convenience syntax for many-to-many relationships. A many-to-many relationship is achieved when a child table has 2 non-nullable foreign keys that are part of a unique key.
* <p>
* This is EXPERIMENTAL functionality. Please expect the API and implementations to change, in the future.
* <p>
* This feature is available in the commercial distribution only.
*
* @return
* possible object is
* {@link Boolean }
*
*/
public Boolean isMultisetConvenienceManyToMany() {
return multisetConvenienceManyToMany;
}
/**
* Sets the value of the multisetConvenienceManyToMany property.
*
* @param value
* allowed object is
* {@link Boolean }
*
*/
public void setMultisetConvenienceManyToMany(Boolean value) {
this.multisetConvenienceManyToMany = value;
}
/**
* Generate deprecated code for backwards compatibility
*
@ -2693,31 +2543,6 @@ public class Generate implements Serializable, XMLAppendable
return this;
}
public Generate withExistsConvenienceOneToMany(Boolean value) {
setExistsConvenienceOneToMany(value);
return this;
}
public Generate withExistsConvenienceManyToMany(Boolean value) {
setExistsConvenienceManyToMany(value);
return this;
}
public Generate withRowConvenienceToOne(Boolean value) {
setRowConvenienceToOne(value);
return this;
}
public Generate withMultisetConvenienceOneToMany(Boolean value) {
setMultisetConvenienceOneToMany(value);
return this;
}
public Generate withMultisetConvenienceManyToMany(Boolean value) {
setMultisetConvenienceManyToMany(value);
return this;
}
public Generate withDeprecated(Boolean value) {
setDeprecated(value);
return this;
@ -3234,11 +3059,6 @@ public class Generate implements Serializable, XMLAppendable
builder.append("implicitJoinPathsToOne", implicitJoinPathsToOne);
builder.append("implicitJoinPathsUseTableNameForUnambiguousFKs", implicitJoinPathsUseTableNameForUnambiguousFKs);
builder.append("implicitJoinPathsAsKotlinProperties", implicitJoinPathsAsKotlinProperties);
builder.append("existsConvenienceOneToMany", existsConvenienceOneToMany);
builder.append("existsConvenienceManyToMany", existsConvenienceManyToMany);
builder.append("rowConvenienceToOne", rowConvenienceToOne);
builder.append("multisetConvenienceOneToMany", multisetConvenienceOneToMany);
builder.append("multisetConvenienceManyToMany", multisetConvenienceManyToMany);
builder.append("deprecated", deprecated);
builder.append("deprecationOnUnknownTypes", deprecationOnUnknownTypes);
builder.append("instanceFields", instanceFields);
@ -3405,51 +3225,6 @@ public class Generate implements Serializable, XMLAppendable
return false;
}
}
if (existsConvenienceOneToMany == null) {
if (other.existsConvenienceOneToMany!= null) {
return false;
}
} else {
if (!existsConvenienceOneToMany.equals(other.existsConvenienceOneToMany)) {
return false;
}
}
if (existsConvenienceManyToMany == null) {
if (other.existsConvenienceManyToMany!= null) {
return false;
}
} else {
if (!existsConvenienceManyToMany.equals(other.existsConvenienceManyToMany)) {
return false;
}
}
if (rowConvenienceToOne == null) {
if (other.rowConvenienceToOne!= null) {
return false;
}
} else {
if (!rowConvenienceToOne.equals(other.rowConvenienceToOne)) {
return false;
}
}
if (multisetConvenienceOneToMany == null) {
if (other.multisetConvenienceOneToMany!= null) {
return false;
}
} else {
if (!multisetConvenienceOneToMany.equals(other.multisetConvenienceOneToMany)) {
return false;
}
}
if (multisetConvenienceManyToMany == null) {
if (other.multisetConvenienceManyToMany!= null) {
return false;
}
} else {
if (!multisetConvenienceManyToMany.equals(other.multisetConvenienceManyToMany)) {
return false;
}
}
if (deprecated == null) {
if (other.deprecated!= null) {
return false;
@ -4282,11 +4057,6 @@ public class Generate implements Serializable, XMLAppendable
result = ((prime*result)+((implicitJoinPathsToOne == null)? 0 :implicitJoinPathsToOne.hashCode()));
result = ((prime*result)+((implicitJoinPathsUseTableNameForUnambiguousFKs == null)? 0 :implicitJoinPathsUseTableNameForUnambiguousFKs.hashCode()));
result = ((prime*result)+((implicitJoinPathsAsKotlinProperties == null)? 0 :implicitJoinPathsAsKotlinProperties.hashCode()));
result = ((prime*result)+((existsConvenienceOneToMany == null)? 0 :existsConvenienceOneToMany.hashCode()));
result = ((prime*result)+((existsConvenienceManyToMany == null)? 0 :existsConvenienceManyToMany.hashCode()));
result = ((prime*result)+((rowConvenienceToOne == null)? 0 :rowConvenienceToOne.hashCode()));
result = ((prime*result)+((multisetConvenienceOneToMany == null)? 0 :multisetConvenienceOneToMany.hashCode()));
result = ((prime*result)+((multisetConvenienceManyToMany == null)? 0 :multisetConvenienceManyToMany.hashCode()));
result = ((prime*result)+((deprecated == null)? 0 :deprecated.hashCode()));
result = ((prime*result)+((deprecationOnUnknownTypes == null)? 0 :deprecationOnUnknownTypes.hashCode()));
result = ((prime*result)+((instanceFields == null)? 0 :instanceFields.hashCode()));

40
jOOQ-meta/src/main/resources/org/jooq/meta/xsd/jooq-codegen-3.17.0.xsd
View File

@ -1854,46 +1854,6 @@ This flag allows for turning off this default behaviour.]]></jxb:javadoc></jxb:p
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Whether implicit join path constructors should be offered as properties in Kotlin.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</element>
<element name="existsConvenienceOneToMany" type="boolean" default="false" minOccurs="0" maxOccurs="1">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Generate <code>EXISTS</code> convenience syntax for one-to-many relationships.
<p>
This is EXPERIMENTAL functionality. Please expect the API and implementations to change, in the future.
<p>
This feature is available in the commercial distribution only.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</element>
<element name="existsConvenienceManyToMany" type="boolean" default="false" minOccurs="0" maxOccurs="1">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Generate <code>EXISTS</code> convenience syntax for many-to-many relationships. A many-to-many relationship is achieved when a child table has 2 non-nullable foreign keys that are part of a unique key.
<p>
This is EXPERIMENTAL functionality. Please expect the API and implementations to change, in the future.
<p>
This feature is available in the commercial distribution only.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</element>
<element name="rowConvenienceToOne" type="boolean" default="false" minOccurs="0" maxOccurs="1">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Generate <code>ROW</code> convenience syntax for to-one relationships.
<p>
This is EXPERIMENTAL functionality. Please expect the API and implementations to change, in the future.
<p>
This feature is available in the commercial distribution only.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</element>
<element name="multisetConvenienceOneToMany" type="boolean" default="false" minOccurs="0" maxOccurs="1">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Generate <code>MULTISET</code> convenience syntax for one-to-many relationships.
<p>
This is EXPERIMENTAL functionality. Please expect the API and implementations to change, in the future.
<p>
This feature is available in the commercial distribution only.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</element>
<element name="multisetConvenienceManyToMany" type="boolean" default="false" minOccurs="0" maxOccurs="1">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Generate <code>MULTISET</code> convenience syntax for many-to-many relationships. A many-to-many relationship is achieved when a child table has 2 non-nullable foreign keys that are part of a unique key.
<p>
This is EXPERIMENTAL functionality. Please expect the API and implementations to change, in the future.
<p>
This feature is available in the commercial distribution only.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</element>
<element name="deprecated" type="boolean" default="true" minOccurs="0" maxOccurs="1">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Generate deprecated code for backwards compatibility]]></jxb:javadoc></jxb:property></appinfo></annotation>
</element>

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

@ -299,290 +299,6 @@ implements
return null;
}
/**
* Create a <code>ROW</code> to-one parent table expression from this table.
*/
@org.jooq.Internal
@NotNull
protected <O1 extends Record, O2 extends Record> Field<O2> toOneRow(
ForeignKey<R, O1> path,
Function<? super Table<O1>, ? extends TableLike<O2>> f
) {
if (CONFIG.commercial()) {
}
throw new DataAccessException("The to-one ROW convenience feature is available in the commercial jOOQ distribution only. Please consider upgrading to the jOOQ Professional Edition or jOOQ Enterprise Edition.");
}
/**
* Create a <code>MULTISET</code> one-to-many child table expression from
* this table.
*/
@org.jooq.Internal
@NotNull
protected <O1 extends Record, O2 extends Record> Field<Result<O2>> oneToManyMultiset(
ForeignKey<O1, R> path,
Function<? super Table<O1>, ? extends TableLike<O2>> f
) {
if (CONFIG.commercial()) {
}
throw new DataAccessException("The one-to-many MULTISET convenience feature is available in the commercial jOOQ distribution only. Please consider upgrading to the jOOQ Professional Edition or jOOQ Enterprise Edition.");
}
/**
* Create a <code>MULTISET</code> many-to-many child table expression from
* this table.
*/
@org.jooq.Internal
@NotNull
protected <O1 extends Record, X extends Record, O2 extends Record> Field<Result<O2>> manyToManyMultiset(
ForeignKey<O1, R> path1,
ForeignKey<O1, X> path2,
Function<? super Table<X>, ? extends TableLike<O2>> f
) {
if (CONFIG.commercial()) {
}
throw new DataAccessException("The many-to-many MULTISET convenience feature is available in the commercial jOOQ distribution only. Please consider upgrading to the jOOQ Professional Edition or jOOQ Enterprise Edition.");
}
/**
* Create a <code>MULTISET</code> one-to-many child table expression from
* this table.
*/
@org.jooq.Internal
@NotNull
protected <O1 extends Record> Condition oneToManyExists(
ForeignKey<O1, R> path,
Function<? super Table<O1>, ? extends TableLike<?>> f
) {
if (CONFIG.commercial()) {
}
throw new DataAccessException("The one-to-many EXISTS convenience feature is available in the commercial jOOQ distribution only. Please consider upgrading to the jOOQ Professional Edition or jOOQ Enterprise Edition.");
}
/**
* Create a <code>MULTISET</code> many-to-many child table expression from
* this table.
*/
@org.jooq.Internal
@NotNull
protected <O1 extends Record, X extends Record> Condition manyToManyExists(
ForeignKey<O1, R> path1,
ForeignKey<O1, X> path2,
Function<? super Table<X>, ? extends TableLike<?>> f
) {
if (CONFIG.commercial()) {
}
throw new DataAccessException("The many-to-many EXISTS convenience feature is available in the commercial jOOQ distribution only. Please consider upgrading to the jOOQ Professional Edition or jOOQ Enterprise Edition.");
}
/**
* Check if this table already aliases another one.