Advanced Database Objects

/**
 * Gets all UDTs across all schemas
 * @returns List of all UDT definitions
 */
List<UDTDefinition> getUDTs();

/**
 * Gets UDTs within a specific schema
 * @param schema - Schema to search within
 * @returns List of UDT definitions in the schema
 */
List<UDTDefinition> getUDTs(SchemaDefinition schema);

/**
 * Gets a specific UDT by schema and name
 * @param schema - Schema containing the UDT
 * @param name - UDT name to lookup
 * @returns UDT definition or null if not found
 */
UDTDefinition getUDT(SchemaDefinition schema, String name);

/**
 * Gets a specific UDT with case sensitivity control
 * @param schema - Schema containing the UDT
 * @param name - UDT name to lookup
 * @param ignoreCase - Whether to ignore case in name matching
 * @returns UDT definition or null if not found
 */
UDTDefinition getUDT(SchemaDefinition schema, String name, boolean ignoreCase);

/**
 * Gets UDT attributes (properties/fields)
 * @returns List of attribute definitions for the UDT
 */
List<AttributeDefinition> getAttributes();

/**
 * Gets UDT methods/routines
 * @returns List of routine definitions for the UDT
 */
List<RoutineDefinition> getRoutines();

import org.jooq.meta.UDTDefinition;
import org.jooq.meta.AttributeDefinition;
import org.jooq.meta.RoutineDefinition;

// Get all UDTs
List<UDTDefinition> udts = database.getUDTs(schema);
for (UDTDefinition udt : udts) {
    System.out.println("\nUDT: " + udt.getName());
    System.out.println("  Schema: " + udt.getSchema().getName());
    System.out.println("  Comment: " + udt.getComment());
    
    // Analyze UDT attributes
    List<AttributeDefinition> attributes = udt.getAttributes();
    System.out.println("  Attributes:");
    for (AttributeDefinition attr : attributes) {
        System.out.println("    - " + attr.getName() + 
                          " (" + attr.getType().getType() + ")");
        System.out.println("      Position: " + attr.getPosition());
        System.out.println("      Nullable: " + attr.getType().isNullable());
    }
    
    // Analyze UDT methods
    List<RoutineDefinition> methods = udt.getRoutines();
    if (!methods.isEmpty()) {
        System.out.println("  Methods:");
        for (RoutineDefinition method : methods) {
            System.out.println("    - " + method.getName() + "()");
        }
    }
}

// Get specific UDT
UDTDefinition addressUDT = database.getUDT(schema, "address_type");
if (addressUDT != null) {
    System.out.println("Found UDT: " + addressUDT.getQualifiedName());
}

/**
 * Gets enum types within a specific schema
 * @param schema - Schema to search within
 * @returns List of enum definitions in the schema
 */
List<EnumDefinition> getEnums(SchemaDefinition schema);

/**
 * Gets a specific enum by schema and name
 * @param schema - Schema containing the enum
 * @param name - Enum name to lookup
 * @returns Enum definition or null if not found
 */
EnumDefinition getEnum(SchemaDefinition schema, String name);

/**
 * Gets a specific enum with case sensitivity control
 * @param schema - Schema containing the enum
 * @param name - Enum name to lookup
 * @param ignoreCase - Whether to ignore case in name matching
 * @returns Enum definition or null if not found
 */
EnumDefinition getEnum(SchemaDefinition schema, String name, boolean ignoreCase);

/**
 * Gets enum literal values
 * @returns List of enum literal definitions
 */
List<EnumLiteralDefinition> getLiterals();

import org.jooq.meta.EnumDefinition;
import org.jooq.meta.EnumLiteralDefinition;

// Get all enums in schema
List<EnumDefinition> enums = database.getEnums(schema);
for (EnumDefinition enumDef : enums) {
    System.out.println("\nEnum: " + enumDef.getName());
    System.out.println("  Values:");
    
    List<EnumLiteralDefinition> literals = enumDef.getLiterals();
    for (EnumLiteralDefinition literal : literals) {
        System.out.println("    - " + literal.getName() + 
                          " (position: " + literal.getPosition() + ")");
    }
}

// Get specific enum
EnumDefinition statusEnum = database.getEnum(schema, "order_status");
if (statusEnum != null) {
    List<EnumLiteralDefinition> values = statusEnum.getLiterals();
    System.out.println("Order status values: " + 
        values.stream().map(EnumLiteralDefinition::getName)
              .collect(Collectors.joining(", ")));
}

/**
 * Gets all domains across all schemas
 * @returns List of all domain definitions
 */
List<DomainDefinition> getDomains();

/**
 * Gets domains within a specific schema
 * @param schema - Schema to search within
 * @returns List of domain definitions in the schema
 */
List<DomainDefinition> getDomains(SchemaDefinition schema);

/**
 * Gets a specific domain by schema and name
 * @param schema - Schema containing the domain
 * @param name - Domain name to lookup
 * @returns Domain definition or null if not found
 */
DomainDefinition getDomain(SchemaDefinition schema, String name);

/**
 * Gets the base type for the domain
 * @returns DataTypeDefinition for the underlying base type
 */
DataTypeDefinition getBaseType();

/**
 * Gets check constraints defined on the domain
 * @returns List of check constraint definitions for the domain
 */
List<CheckConstraintDefinition> getCheckConstraints();

import org.jooq.meta.DomainDefinition;
import org.jooq.meta.DataTypeDefinition;
import org.jooq.meta.CheckConstraintDefinition;

// Get all domains
List<DomainDefinition> domains = database.getDomains(schema);
for (DomainDefinition domain : domains) {
    System.out.println("\nDomain: " + domain.getName());
    
    DataTypeDefinition baseType = domain.getBaseType();
    System.out.println("  Base Type: " + baseType.getType());
    System.out.println("  Length: " + baseType.getLength());
    System.out.println("  Nullable: " + baseType.isNullable());
    
    List<CheckConstraintDefinition> constraints = domain.getCheckConstraints();
    if (!constraints.isEmpty()) {
        System.out.println("  Constraints:");
        for (CheckConstraintDefinition constraint : constraints) {
            System.out.println("    - " + constraint.getName() + 
                              ": " + constraint.getCheckClause());
        }
    }
}

// Get specific domain
DomainDefinition emailDomain = database.getDomain(schema, "email_domain");
if (emailDomain != null) {
    System.out.println("Email domain base type: " + 
                      emailDomain.getBaseType().getType());
}

/**
 * Gets array types within a specific schema
 * @param schema - Schema to search within
 * @returns List of array definitions in the schema
 */
List<ArrayDefinition> getArrays(SchemaDefinition schema);

/**
 * Gets a specific array by schema and name
 * @param schema - Schema containing the array
 * @param name - Array name to lookup
 * @returns Array definition or null if not found
 */
ArrayDefinition getArray(SchemaDefinition schema, String name);

/**
 * Gets the element type for the array
 * @returns DataTypeDefinition for the array element type
 */
DataTypeDefinition getElementType();

import org.jooq.meta.ArrayDefinition;
import org.jooq.meta.DataTypeDefinition;

// Get all arrays in schema
List<ArrayDefinition> arrays = database.getArrays(schema);
for (ArrayDefinition array : arrays) {
    System.out.println("\nArray: " + array.getName());
    
    DataTypeDefinition elementType = array.getElementType();
    System.out.println("  Element Type: " + elementType.getType());
    System.out.println("  Element Java Type: " + elementType.getJavaType());
}

// Get specific array type
ArrayDefinition tagsArray = database.getArray(schema, "tag_array");
if (tagsArray != null) {
    System.out.println("Tags array element type: " + 
                      tagsArray.getElementType().getType());
}

/**
 * Gets routines within a specific schema
 * @param schema - Schema to search within
 * @returns List of routine definitions in the schema
 */
List<RoutineDefinition> getRoutines(SchemaDefinition schema);

/**
 * Gets a specific routine by schema and name
 * @param schema - Schema containing the routine
 * @param name - Routine name to lookup
 * @returns Routine definition or null if not found
 */
RoutineDefinition getRoutine(SchemaDefinition schema, String name);

/**
 * Gets input parameters for the routine
 * @returns List of input parameter definitions
 */
List<ParameterDefinition> getInParameters();

/**
 * Gets output parameters for the routine
 * @returns List of output parameter definitions
 */
List<ParameterDefinition> getOutParameters();

/**
 * Gets input/output parameters for the routine
 * @returns List of input/output parameter definitions
 */
List<ParameterDefinition> getInOutParameters();

/**
 * Gets all parameters for the routine
 * @returns List of all parameter definitions
 */
List<ParameterDefinition> getAllParameters();

/**
 * Gets the return value parameter
 * @returns Parameter definition for return value or null
 */
ParameterDefinition getReturnValue();

/**
 * Gets the return type
 * @returns DataTypeDefinition for return type or null
 */
DataTypeDefinition getReturnType();

/**
 * Checks if routine is a function (vs procedure)
 * @returns true if the routine is a function
 */
boolean isFunction();

/**
 * Checks if routine is an aggregate function
 * @returns true if the routine is an aggregate function
 */
boolean isAggregate();

import org.jooq.meta.RoutineDefinition;
import org.jooq.meta.ParameterDefinition;
import org.jooq.meta.DataTypeDefinition;

// Get all routines
List<RoutineDefinition> routines = database.getRoutines(schema);
for (RoutineDefinition routine : routines) {
    System.out.println("\nRoutine: " + routine.getName());
    System.out.println("  Type: " + (routine.isFunction() ? "FUNCTION" : "PROCEDURE"));
    System.out.println("  Aggregate: " + routine.isAggregate());
    
    // Analyze parameters
    List<ParameterDefinition> inParams = routine.getInParameters();
    if (!inParams.isEmpty()) {
        System.out.println("  Input Parameters:");
        for (ParameterDefinition param : inParams) {
            System.out.println("    - " + param.getName() + 
                              " (" + param.getType().getType() + ")");
            if (param.getDefaultValue() != null) {
                System.out.println("      Default: " + param.getDefaultValue());
            }
        }
    }
    
    List<ParameterDefinition> outParams = routine.getOutParameters();
    if (!outParams.isEmpty()) {
        System.out.println("  Output Parameters:");
        for (ParameterDefinition param : outParams) {
            System.out.println("    - " + param.getName() + 
                              " (" + param.getType().getType() + ")");
        }
    }
    
    // Check return type for functions
    if (routine.isFunction()) {
        DataTypeDefinition returnType = routine.getReturnType();
        if (returnType != null) {
            System.out.println("  Return Type: " + returnType.getType());
        }
    }
}

// Get specific routine
RoutineDefinition calculateTax = database.getRoutine(schema, "calculate_tax");
if (calculateTax != null && calculateTax.isFunction()) {
    System.out.println("Tax calculation function return type: " + 
                      calculateTax.getReturnType().getType());
}

/**
 * Gets all sequences across all schemas
 * @returns List of all sequence definitions
 */
List<SequenceDefinition> getSequences();

/**
 * Gets sequences within a specific schema
 * @param schema - Schema to search within
 * @returns List of sequence definitions in the schema
 */
List<SequenceDefinition> getSequences(SchemaDefinition schema);

/**
 * Gets a specific sequence by schema and name
 * @param schema - Schema containing the sequence
 * @param name - Sequence name to lookup
 * @returns Sequence definition or null if not found
 */
SequenceDefinition getSequence(SchemaDefinition schema, String name);

/**
 * Gets a specific sequence with case sensitivity control
 * @param schema - Schema containing the sequence
 * @param name - Sequence name to lookup
 * @param ignoreCase - Whether to ignore case in name matching
 * @returns Sequence definition or null if not found
 */
SequenceDefinition getSequence(SchemaDefinition schema, String name, boolean ignoreCase);

import org.jooq.meta.SequenceDefinition;

// Get all sequences
List<SequenceDefinition> sequences = database.getSequences(schema);
for (SequenceDefinition sequence : sequences) {
    System.out.println("Sequence: " + sequence.getName());
    System.out.println("  Schema: " + sequence.getSchema().getName());
    System.out.println("  Qualified Name: " + sequence.getQualifiedName());
    
    if (sequence.getComment() != null) {
        System.out.println("  Comment: " + sequence.getComment());
    }
}

// Get specific sequence
SequenceDefinition userIdSeq = database.getSequence(schema, "user_id_seq");
if (userIdSeq != null) {
    System.out.println("Found user ID sequence: " + userIdSeq.getQualifiedName());
}

/**
 * Gets packages within a specific schema
 * @param schema - Schema to search within
 * @returns List of package definitions in the schema
 */
List<PackageDefinition> getPackages(SchemaDefinition schema);

/**
 * Gets a specific package by schema and name
 * @param schema - Schema containing the package
 * @param inputName - Package name to lookup
 * @returns Package definition or null if not found
 */
PackageDefinition getPackage(SchemaDefinition schema, String inputName);

/**
 * Gets UDTs within a specific package
 * @param pkg - Package to search within
 * @returns List of UDT definitions in the package
 */
List<UDTDefinition> getUDTs(PackageDefinition pkg);

/**
 * Gets all XML schema collections
 * @returns List of all XML schema collection definitions
 */
List<XMLSchemaCollectionDefinition> getXMLSchemaCollections();

/**
 * Gets XML schema collections within a specific schema
 * @param schema - Schema to search within
 * @returns List of XML schema collection definitions in the schema
 */
List<XMLSchemaCollectionDefinition> getXMLSchemaCollections(SchemaDefinition schema);

/**
 * Gets a specific XML schema collection by schema and name
 * @param schema - Schema containing the collection
 * @param name - Collection name to lookup
 * @returns XML schema collection definition or null if not found
 */
XMLSchemaCollectionDefinition getXMLSchemaCollection(SchemaDefinition schema, String name);

interface UDTDefinition extends PackageDefinition {
    List<AttributeDefinition> getAttributes();
    List<RoutineDefinition> getRoutines();
}

interface AttributeDefinition extends TypedElementDefinition<UDTDefinition>, PositionedDefinition {
    UDTDefinition getContainer();
    DataTypeDefinition getType();
    int getPosition();
}

interface EnumDefinition extends Definition {
    List<EnumLiteralDefinition> getLiterals();
}

interface EnumLiteralDefinition extends Definition, PositionedDefinition {
    String getName();
    int getPosition();
}

interface DomainDefinition extends Definition {
    DataTypeDefinition getBaseType();
    List<CheckConstraintDefinition> getCheckConstraints();
}

interface ArrayDefinition extends Definition {
    DataTypeDefinition getElementType();
}

interface RoutineDefinition extends Definition {
    List<ParameterDefinition> getInParameters();
    List<ParameterDefinition> getOutParameters();
    List<ParameterDefinition> getInOutParameters();
    List<ParameterDefinition> getAllParameters();
    ParameterDefinition getReturnValue();
    DataTypeDefinition getReturnType();
    boolean isFunction();
    boolean isAggregate();
}

interface ParameterDefinition extends TypedElementDefinition<RoutineDefinition>, PositionedDefinition {
    RoutineDefinition getContainer();
    boolean isIn();
    boolean isOut();
    boolean isInOut();
    boolean isReturn();
    String getDefaultValue();
    int getPosition();
}

interface SequenceDefinition extends Definition {
    String getName();
    SchemaDefinition getSchema();
}

interface PackageDefinition extends Definition {
    String getName();
    SchemaDefinition getSchema();
}

import org.jooq.meta.*;

// Comprehensive analysis of advanced objects
SchemaDefinition schema = database.getSchema("public");

// Analyze all advanced object types
System.out.println("=== Advanced Database Objects Analysis ===");

// UDTs
List<UDTDefinition> udts = database.getUDTs(schema);
System.out.println("\nUser-Defined Types: " + udts.size());

// Enums  
List<EnumDefinition> enums = database.getEnums(schema);
System.out.println("Enum Types: " + enums.size());

// Domains
List<DomainDefinition> domains = database.getDomains(schema);
System.out.println("Domain Types: " + domains.size());

// Arrays
List<ArrayDefinition> arrays = database.getArrays(schema);
System.out.println("Array Types: " + arrays.size());

// Routines
List<RoutineDefinition> routines = database.getRoutines(schema);
long functions = routines.stream().filter(RoutineDefinition::isFunction).count();
long procedures = routines.size() - functions;
System.out.println("Functions: " + functions);
System.out.println("Procedures: " + procedures);

// Sequences
List<SequenceDefinition> sequences = database.getSequences(schema);
System.out.println("Sequences: " + sequences.size());

// Packages
List<PackageDefinition> packages = database.getPackages(schema);
System.out.println("Packages: " + packages.size());