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

[#4838] Add code generation flag <tableValuedFunctions/> to turn off generation of table-valued functions

Browse Source
This commit is contained in:
lukaseder 2015-12-22 14:49:13 +01:00
parent 9e121215d7
commit 1b8b773e14
9 changed files with 91 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -75,6 +75,7 @@ abstract class AbstractGenerator implements Generator {
boolean generateGlobalUDTReferences = true;
boolean fluentSetters = false;
String fullyQualifiedTypes = "";
boolean generateTableValuedFunctions = true;
protected GeneratorStrategyWrapper strategy;
final Language language;
@ -119,6 +120,16 @@ abstract class AbstractGenerator implements Generator {
this.generateRelations = generateRelations;
}
@Override
public boolean generateTableValuedFunctions() {
return generateTableValuedFunctions;
}
@Override
public void setGenerateTableValuedFunctions(boolean generateTableValuedFunctions) {
this.generateTableValuedFunctions = generateTableValuedFunctions;
}
@Override
public boolean generateInstanceFields() {
return generateInstanceFields;

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

@ -448,6 +448,8 @@ public class GenerationTool {
generator.setUseSchemaVersionProvider(true);
if (!StringUtils.isBlank(g.getDatabase().getCatalogVersionProvider()))
generator.setUseCatalogVersionProvider(true);
if (g.getDatabase().isTableValuedFunctions() != null)
generator.setGenerateTableValuedFunctions(g.getDatabase().isTableValuedFunctions());
// Generator properties that should in fact be strategy properties
strategy.setInstanceFields(generator.generateInstanceFields());

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

@ -85,6 +85,16 @@ public interface Generator {
*/
void setGenerateRelations(boolean generateRelations);
/**
* Whether table-valued functions should be generated as tables.
*/
boolean generateTableValuedFunctions();
/**
* Whether table-valued functions should be generated as tables.
*/
void setGenerateTableValuedFunctions(boolean generateTableValuedFunctions);
/**
* Whether instance fields should be generated (as opposed to static fields)
*/

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

@ -200,6 +200,7 @@ public class JavaGenerator extends AbstractGenerator {
this.database = db;
this.database.addFilter(new AvoidAmbiguousClassesFilter());
this.database.setIncludeRelations(generateRelations());
this.database.setTableValuedFunctions(generateTableValuedFunctions());
String url = "";
try {
@ -245,6 +246,7 @@ public class JavaGenerator extends AbstractGenerator {
log.info(" daos", generateDaos());
log.info(" relations", generateRelations()
+ ((!generateRelations && generateDaos) ? " (forced to true because of <daos/>)" : ""));
log.info(" table-valued functions", generateTableValuedFunctions());
log.info(" global references", generateGlobalObjectReferences());
log.info("----------------------------------------------------------");
@ -4370,7 +4372,6 @@ public class JavaGenerator extends AbstractGenerator {
return;
}
final String className = out.ref(getStrategy().getFullJavaClassName(function));
final String recordClassName = out.ref(getStrategy().getFullJavaClassName(function, Mode.RECORD));
// [#3456] Local variables should not collide with actual function arguments

11
jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java
View File

@ -141,6 +141,7 @@ public abstract class AbstractDatabase implements Database {
private List<PackageDefinition> packages;
private Relations relations;
private boolean includeRelations = true;
private boolean tableValuedFunctions = true;
private transient Map<SchemaDefinition, List<SequenceDefinition>> sequencesBySchema;
private transient Map<SchemaDefinition, List<IdentityDefinition>> identitiesBySchema;
@ -720,6 +721,16 @@ public abstract class AbstractDatabase implements Database {
return includeRelations;
}
@Override
public final void setTableValuedFunctions(boolean tableValuedFunctions) {
this.tableValuedFunctions = tableValuedFunctions;
}
@Override
public final boolean tableValuedFunctions() {
return tableValuedFunctions;
}
@Override
public final List<SequenceDefinition> getSequences(SchemaDefinition schema) {
if (sequences == null) {

10
jOOQ-meta/src/main/java/org/jooq/util/Database.java
View File

@ -469,6 +469,16 @@ public interface Database {
*/
boolean includeRelations();
/**
* [#4838] Whether table-valued functions should be reported as tables.
*/
void setTableValuedFunctions(boolean tableValuedFunctions);
/**
* [#4838] Whether table-valued functions should be reported as tables.
*/
boolean tableValuedFunctions();
/**
* Check for the existence of a table in the dictionary views.
*/

5
jOOQ-meta/src/main/java/org/jooq/util/firebird/FirebirdDatabase.java
View File

@ -42,8 +42,10 @@ package org.jooq.util.firebird;
import static org.jooq.impl.DSL.choose;
import static org.jooq.impl.DSL.decode;
import static org.jooq.impl.DSL.falseCondition;
import static org.jooq.impl.DSL.inline;
import static org.jooq.impl.DSL.select;
import static org.jooq.impl.DSL.trueCondition;
import static org.jooq.util.firebird.rdb.Tables.RDB$GENERATORS;
import static org.jooq.util.firebird.rdb.Tables.RDB$INDEX_SEGMENTS;
import static org.jooq.util.firebird.rdb.Tables.RDB$PROCEDURES;
@ -249,6 +251,9 @@ public class FirebirdDatabase extends AbstractDatabase {
// "selectable" procedures
.where(RDB$PROCEDURES.RDB$PROCEDURE_TYPE.eq((short) 1))
.and(tableValuedFunctions()
? trueCondition()
: falseCondition())
)
.orderBy(1)) {

44
jOOQ-meta/src/main/java/org/jooq/util/postgres/PostgresDatabase.java
View File

@ -42,15 +42,19 @@
package org.jooq.util.postgres;
import static org.jooq.impl.DSL.array;
import static org.jooq.impl.DSL.condition;
import static org.jooq.impl.DSL.count;
import static org.jooq.impl.DSL.decode;
import static org.jooq.impl.DSL.falseCondition;
import static org.jooq.impl.DSL.field;
import static org.jooq.impl.DSL.inline;
import static org.jooq.impl.DSL.max;
import static org.jooq.impl.DSL.name;
import static org.jooq.impl.DSL.not;
import static org.jooq.impl.DSL.row;
import static org.jooq.impl.DSL.select;
import static org.jooq.impl.DSL.selectOne;
import static org.jooq.impl.DSL.trueCondition;
import static org.jooq.impl.DSL.upper;
import static org.jooq.impl.DSL.val;
import static org.jooq.util.postgres.PostgresDSL.arrayAppend;
@ -85,8 +89,10 @@ import org.jooq.Record;
import org.jooq.Record2;
import org.jooq.Record4;
import org.jooq.Record5;
import org.jooq.Record6;
import org.jooq.Result;
import org.jooq.SQLDialect;
import org.jooq.Select;
import org.jooq.exception.DataAccessException;
import org.jooq.impl.DSL;
import org.jooq.tools.JooqLogger;
@ -256,6 +262,10 @@ public class PostgresDatabase extends AbstractDatabase {
List<TableDefinition> result = new ArrayList<TableDefinition>();
Map<Name, PostgresTableDefinition> map = new HashMap<Name, PostgresTableDefinition>();
Select<Record6<String, String, String, Boolean, Boolean, String>> empty =
select(inline(""), inline(""), inline(""), inline(false), inline(false), inline(""))
.where(falseCondition());
for (Record record : create()
.select()
.from(
@ -310,19 +320,23 @@ public class PostgresDatabase extends AbstractDatabase {
// [#3375] [#3376] Include table-valued functions in the set of tables
.unionAll(
select(
ROUTINES.ROUTINE_SCHEMA,
ROUTINES.ROUTINE_NAME,
ROUTINES.SPECIFIC_NAME,
inline(true).as("table_valued_function"),
inline(false).as("materialized_view"),
inline(""))
.from(ROUTINES)
.join(PG_NAMESPACE).on(ROUTINES.SPECIFIC_SCHEMA.eq(PG_NAMESPACE.NSPNAME))
.join(PG_PROC).on(PG_PROC.PRONAMESPACE.eq(oid(PG_NAMESPACE)))
.and(PG_PROC.PRONAME.concat("_").concat(oid(PG_PROC)).eq(ROUTINES.SPECIFIC_NAME))
.where(ROUTINES.ROUTINE_SCHEMA.in(getInputSchemata()))
.and(PG_PROC.PRORETSET))
tableValuedFunctions()
? select(
ROUTINES.ROUTINE_SCHEMA,
ROUTINES.ROUTINE_NAME,
ROUTINES.SPECIFIC_NAME,
inline(true).as("table_valued_function"),
inline(false).as("materialized_view"),
inline(""))
.from(ROUTINES)
.join(PG_NAMESPACE).on(ROUTINES.SPECIFIC_SCHEMA.eq(PG_NAMESPACE.NSPNAME))
.join(PG_PROC).on(PG_PROC.PRONAMESPACE.eq(oid(PG_NAMESPACE)))
.and(PG_PROC.PRONAME.concat("_").concat(oid(PG_PROC)).eq(ROUTINES.SPECIFIC_NAME))
.where(ROUTINES.ROUTINE_SCHEMA.in(getInputSchemata()))
.and(PG_PROC.PRORETSET)
: empty)
.asTable("tables"))
.orderBy(1, 2)
.fetch()) {
@ -683,7 +697,9 @@ public class PostgresDatabase extends AbstractDatabase {
.join(PG_PROC).on(PG_PROC.PRONAMESPACE.eq(oid(PG_NAMESPACE)))
.and(PG_PROC.PRONAME.concat("_").concat(oid(PG_PROC)).eq(r1.SPECIFIC_NAME))
.where(r1.ROUTINE_SCHEMA.in(getInputSchemata()))
.andNot(PG_PROC.PRORETSET)
.and(tableValuedFunctions()
? condition(not(PG_PROC.PRORETSET))
: trueCondition())
.orderBy(
r1.ROUTINE_SCHEMA.asc(),
r1.ROUTINE_NAME.asc())

10
jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.8.0.xsd
View File

@ -543,6 +543,16 @@
artefacts (e.g. in combination with enumTypes)
-->
<element name="forcedTypes" type="tns:ForcedTypes" minOccurs="0" maxOccurs="1"/>
<!--
Whether table valued functions should be reported as tables.
If this is deactivated, such functions are not generated as tables, but
as ordinary routines. This is particularly useful for backwards-
compatibility between jOOQ 3.8 and previous versions, when using TABLE
and VARRAY types in Oracle
-->
<element name="tableValuedFunctions" type="boolean" default="true" minOccurs="0" maxOccurs="1" />
</all>
</complexType>