diff --git a/jOOQ-codegen/src/main/java/org/jooq/util/AbstractGenerator.java b/jOOQ-codegen/src/main/java/org/jooq/util/AbstractGenerator.java
index be39065ce5..d2a4c09203 100644
--- a/jOOQ-codegen/src/main/java/org/jooq/util/AbstractGenerator.java
+++ b/jOOQ-codegen/src/main/java/org/jooq/util/AbstractGenerator.java
@@ -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;
diff --git a/jOOQ-codegen/src/main/java/org/jooq/util/GenerationTool.java b/jOOQ-codegen/src/main/java/org/jooq/util/GenerationTool.java
index 31a7b49e43..e899ec82a1 100644
--- a/jOOQ-codegen/src/main/java/org/jooq/util/GenerationTool.java
+++ b/jOOQ-codegen/src/main/java/org/jooq/util/GenerationTool.java
@@ -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());
diff --git a/jOOQ-codegen/src/main/java/org/jooq/util/Generator.java b/jOOQ-codegen/src/main/java/org/jooq/util/Generator.java
index 7fb0c45621..238adc0701 100644
--- a/jOOQ-codegen/src/main/java/org/jooq/util/Generator.java
+++ b/jOOQ-codegen/src/main/java/org/jooq/util/Generator.java
@@ -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)
      */
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 2d75830d36..b3aabd2db2 100644
--- a/jOOQ-codegen/src/main/java/org/jooq/util/JavaGenerator.java
+++ b/jOOQ-codegen/src/main/java/org/jooq/util/JavaGenerator.java
@@ -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
diff --git a/jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java
index 2d145680bd..fb38e0d6f4 100644
--- a/jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java
+++ b/jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java
@@ -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) {
diff --git a/jOOQ-meta/src/main/java/org/jooq/util/Database.java b/jOOQ-meta/src/main/java/org/jooq/util/Database.java
index fd7fc7fa31..caddde8f43 100644
--- a/jOOQ-meta/src/main/java/org/jooq/util/Database.java
+++ b/jOOQ-meta/src/main/java/org/jooq/util/Database.java
@@ -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.
      */
diff --git a/jOOQ-meta/src/main/java/org/jooq/util/firebird/FirebirdDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/firebird/FirebirdDatabase.java
index 153ff3d8c3..3c01351ea4 100644
--- a/jOOQ-meta/src/main/java/org/jooq/util/firebird/FirebirdDatabase.java
+++ b/jOOQ-meta/src/main/java/org/jooq/util/firebird/FirebirdDatabase.java
@@ -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)) {
 
diff --git a/jOOQ-meta/src/main/java/org/jooq/util/postgres/PostgresDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/postgres/PostgresDatabase.java
index 4a1062fd83..df5eece7cb 100644
--- a/jOOQ-meta/src/main/java/org/jooq/util/postgres/PostgresDatabase.java
+++ b/jOOQ-meta/src/main/java/org/jooq/util/postgres/PostgresDatabase.java
@@ -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())
diff --git a/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.8.0.xsd b/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.8.0.xsd
index 905825419e..8f480128d2 100644
--- a/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.8.0.xsd
+++ b/jOOQ-meta/src/main/resources/xsd/jooq-codegen-3.8.0.xsd
@@ -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>