Multi-Database Support

/**
 * PostgreSQL database implementation
 * Supports advanced PostgreSQL features including arrays, enums, domains, and extensions
 */
class PostgresDatabase extends AbstractDatabase { }

/**
 * MySQL database implementation  
 * Supports MySQL-specific features including unsigned types and storage engines
 */
class MySQLDatabase extends AbstractDatabase { }

/**
 * MariaDB database implementation
 * Optimized for MariaDB-specific features and compatibility
 */
class MariaDBDatabase extends AbstractDatabase { }

/**
 * H2 database implementation
 * Supports H2 in-memory and file-based modes
 */
class H2Database extends AbstractDatabase { }

/**
 * SQLite database implementation
 * Optimized for SQLite's lightweight architecture
 */
class SQLiteDatabase extends AbstractDatabase { }

/**
 * HSQLDB database implementation
 * Supports HSQLDB in-memory and persistent modes
 */
class HSQLDBDatabase extends AbstractDatabase { }

/**
 * Derby database implementation
 * Supports both embedded and network Derby modes
 */
class DerbyDatabase extends AbstractDatabase { }

/**
 * Firebird database implementation
 * Supports Firebird-specific features and syntax
 */
class FirebirdDatabase extends AbstractDatabase { }

/**
 * ClickHouse database implementation
 * Optimized for ClickHouse analytical database features
 */
class ClickHouseDatabase extends AbstractDatabase { }

/**
 * YugabyteDB database implementation
 * Supports YugabyteDB distributed SQL features
 */
class YugabyteDBDatabase extends AbstractDatabase { }

/**
 * CUBRID database implementation
 * Supports CUBRID object-relational features
 */
class CUBRIDDatabase extends AbstractDatabase { }

/**
 * Apache Ignite database implementation
 * Supports Ignite in-memory computing platform
 */
class IgniteDatabase extends AbstractDatabase { }

import org.jooq.meta.Database;
import org.jooq.meta.postgres.PostgresDatabase;
import org.jooq.meta.mysql.MySQLDatabase;
import org.jooq.meta.h2.H2Database;
import java.sql.Connection;
import java.sql.DriverManager;

// PostgreSQL
Database postgresDb = new PostgresDatabase();
Connection pgConn = DriverManager.getConnection(
    "jdbc:postgresql://localhost:5432/mydb", "user", "pass");
postgresDb.setConnection(pgConn);

// MySQL
Database mysqlDb = new MySQLDatabase();
Connection mysqlConn = DriverManager.getConnection(
    "jdbc:mysql://localhost:3306/mydb", "user", "pass");
mysqlDb.setConnection(mysqlConn);

// H2 (in-memory)
Database h2Db = new H2Database();
Connection h2Conn = DriverManager.getConnection(
    "jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1", "sa", "");
h2Db.setConnection(h2Conn);

// Using factory method (recommended)
Database db = Databases.database(SQLDialect.POSTGRES);
db.setConnection(connection);

/**
 * Generic JDBC database implementation
 * Uses standard JDBC metadata methods for unsupported databases
 */
class JDBCDatabase extends AbstractDatabase {
    /**
     * Creates JDBC database with specific dialect
     * @param dialect - SQL dialect for the target database
     */
    public JDBCDatabase(SQLDialect dialect);
}

import org.jooq.meta.jdbc.JDBCDatabase;
import org.jooq.SQLDialect;

// Generic JDBC for Oracle (when using Oracle-specific features)
Database oracleDb = new JDBCDatabase(SQLDialect.ORACLE);
Connection oracleConn = DriverManager.getConnection(
    "jdbc:oracle:thin:@localhost:1521:xe", "user", "pass");
oracleDb.setConnection(oracleConn);

// Generic JDBC for SQL Server
Database sqlServerDb = new JDBCDatabase(SQLDialect.SQLSERVER);
Connection sqlConn = DriverManager.getConnection(
    "jdbc:sqlserver://localhost:1433;databaseName=mydb", "user", "pass");
sqlServerDb.setConnection(sqlConn);

/**
 * XML database implementation
 * Reads database metadata from XML files instead of live database connection
 */  
class XMLDatabase extends AbstractDatabase {
    /**
     * Sets XML file path for database metadata
     * @param xmlFile - Path to XML file containing database structure
     */
    void setXmlFile(String xmlFile);
    
    /**
     * Gets XML file path
     * @returns Path to XML metadata file
     */
    String getXmlFile();
}

import org.jooq.meta.xml.XMLDatabase;

// XML-based database for testing
XMLDatabase xmlDb = new XMLDatabase();
xmlDb.setXmlFile("/path/to/database-structure.xml");
// No JDBC connection needed for XML database

List<TableDefinition> tables = xmlDb.getTables();
// Reads table definitions from XML file

/**
 * Gets Database implementation class for SQL dialect
 * @param dialect - SQL dialect to get implementation for
 * @returns Class object for database implementation
 */
static Class<? extends Database> databaseClass(SQLDialect dialect);

/**
 * Creates Database instance for SQL dialect
 * @param dialect - SQL dialect to create database for
 * @returns Database instance for the dialect
 */
static Database database(SQLDialect dialect);

/**
 * Creates Database instance with immediate connection
 * @param dialect - SQL dialect
 * @param connection - Database connection
 * @returns Connected Database instance
 */
static Database database(SQLDialect dialect, Connection connection);

import org.jooq.meta.Databases;
import org.jooq.SQLDialect;

// Discover available implementations
Class<? extends Database> pgClass = Databases.databaseClass(SQLDialect.POSTGRES);
Class<? extends Database> mysqlClass = Databases.databaseClass(SQLDialect.MYSQL);

System.out.println("PostgreSQL implementation: " + pgClass.getSimpleName());
System.out.println("MySQL implementation: " + mysqlClass.getSimpleName());

// Create instances using factory
Database postgres = Databases.database(SQLDialect.POSTGRES);
Database mysql = Databases.database(SQLDialect.MYSQL);
Database h2 = Databases.database(SQLDialect.H2);

// Create with immediate connection
Connection conn = DriverManager.getConnection("jdbc:h2:mem:test");
Database h2Connected = Databases.database(SQLDialect.H2, conn);

/**
 * PostgreSQL-specific features supported:
 * - Array types (integer[], text[], etc.)
 * - Enum types with literal values
 * - Domain types with constraints
 * - PostgreSQL extensions and schemas
 * - JSON/JSONB column types
 * - Range types and geometric types
 * - Composite types and custom aggregates
 */
class PostgresDatabase extends AbstractDatabase {
    // Inherits all Database interface methods
    // Optimized for PostgreSQL system catalogs (pg_catalog)
}

/**
 * MySQL-specific features supported:
 * - Unsigned integer types (TINYINT UNSIGNED, etc.)
 * - MySQL-specific data types (YEAR, GEOMETRY, etc.)
 * - Storage engine information
 * - MySQL partitioning metadata
 * - Full-text indexes and spatial indexes
 * - MySQL-specific constraints and triggers
 */
class MySQLDatabase extends AbstractDatabase {
    // Inherits all Database interface methods
    // Optimized for MySQL information_schema and SHOW commands
}

/**
 * H2-specific features supported:
 * - In-memory and file-based databases
 * - H2-specific data types and functions
 * - Mixed-mode connections
 * - H2 compatibility modes (MySQL, PostgreSQL, etc.)
 * - H2-specific indexes and constraints
 */
class H2Database extends AbstractDatabase {
    // Inherits all Database interface methods
    // Optimized for H2 INFORMATION_SCHEMA
}

/**
 * Sets whether database supports unsigned types
 * @param supportsUnsignedTypes - true if database supports unsigned types
 */
void setSupportsUnsignedTypes(boolean supportsUnsignedTypes);

/**
 * Gets unsigned type support flag
 * @returns true if database supports unsigned types
 */
boolean supportsUnsignedTypes();

/**
 * Sets whether to include integer display widths in metadata
 * @param integerDisplayWidths - true to include display widths
 */
void setIntegerDisplayWidths(boolean integerDisplayWidths);

/**
 * Gets integer display width inclusion setting
 * @returns true if display widths are included
 */
boolean integerDisplayWidths();

/**
 * Sets whether to ignore procedure return values
 * @param ignoreProcedureReturnValues - true to ignore return values
 */
void setIgnoreProcedureReturnValues(boolean ignoreProcedureReturnValues);

/**
 * Gets procedure return value handling setting
 * @returns true if return values are ignored
 */
boolean ignoreProcedureReturnValues();

/**
 * Sets whether DATE columns should be treated as TIMESTAMP
 * @param dateAsTimestamp - true to treat DATE as TIMESTAMP
 */
void setDateAsTimestamp(boolean dateAsTimestamp);

/**
 * Gets DATE as TIMESTAMP treatment setting
 * @returns true if DATE is treated as TIMESTAMP
 */
boolean dateAsTimestamp();

/**
 * Sets whether to use java.time types instead of java.sql types
 * @param javaTimeTypes - true to use java.time types
 */
void setJavaTimeTypes(boolean javaTimeTypes);

/**
 * Gets java.time type usage setting
 * @returns true if java.time types are used
 */
boolean javaTimeTypes();

import org.jooq.meta.mysql.MySQLDatabase;
import org.jooq.meta.postgres.PostgresDatabase;

// MySQL-specific configuration
MySQLDatabase mysqlDb = new MySQLDatabase();
mysqlDb.setSupportsUnsignedTypes(true);      // MySQL supports unsigned types
mysqlDb.setIntegerDisplayWidths(true);       // Include MySQL display widths
mysqlDb.setConnection(mysqlConnection);

// PostgreSQL-specific configuration  
PostgresDatabase pgDb = new PostgresDatabase();
pgDb.setSupportsUnsignedTypes(false);        // PostgreSQL doesn't have unsigned
pgDb.setJavaTimeTypes(true);                 // Use java.time types
pgDb.setConnection(pgConnection);

// Database-specific optimizations are automatically applied
List<TableDefinition> mysqlTables = mysqlDb.getTables();
List<EnumDefinition> pgEnums = pgDb.getEnums(schema);

/**
 * Sets slow query logging threshold
 * @param logSlowQueriesAfterSeconds - Threshold in seconds for query logging
 */
void setLogSlowQueriesAfterSeconds(int logSlowQueriesAfterSeconds);

/**
 * Sets slow result logging threshold  
 * @param logSlowResultsAfterSeconds - Threshold in seconds for result logging
 */
void setLogSlowResultsAfterSeconds(int logSlowResultsAfterSeconds);

/**
 * Checks if array type detection is optimized
 * @param dataType - Data type string to check
 * @returns true if the type is an array type
 */
boolean isArrayType(String dataType);

abstract class AbstractDatabase implements Database {
    // Common implementation for all database vendors
    // Provides standard JDBC-based metadata extraction
    // Subclasses override methods for vendor-specific optimizations
}

interface Database extends AutoCloseable {
    // All database implementations provide the same interface
    // Vendor-specific optimizations are transparent to users
    SQLDialect getDialect();
    void setDialect(SQLDialect dialect);
    Connection getConnection();
    void setConnection(Connection connection);
}

import org.jooq.meta.*;
import org.jooq.SQLDialect;

// Multi-database application support
public class MultiDatabaseAnalyzer {
    
    public void analyzeDatabase(SQLDialect dialect, Connection connection) {
        try (Database database = Databases.database(dialect)) {
            database.setConnection(connection);
            
            // Same API works across all database vendors
            List<SchemaDefinition> schemas = database.getSchemata();
            System.out.println("Database: " + dialect.getName());
            System.out.println("Schemas: " + schemas.size());
            
            for (SchemaDefinition schema : schemas) {
                List<TableDefinition> tables = database.getTables(schema);
                System.out.println("  Schema " + schema.getName() + 
                                 ": " + tables.size() + " tables");
                
                // Vendor-specific features are automatically handled
                if (dialect.family() == SQLDialect.POSTGRES) {
                    List<EnumDefinition> enums = database.getEnums(schema);
                    System.out.println("    Enums: " + enums.size());
                }
                
                if (dialect.family() == SQLDialect.MYSQL) {
                    // MySQL unsigned types are properly detected
                    tables.stream()
                        .flatMap(t -> t.getColumns().stream())
                        .filter(c -> c.getType().getType().contains("UNSIGNED"))
                        .forEach(c -> System.out.println("    Unsigned: " + 
                                                       c.getName()));
                }
            }
        }
    }
    
    public static void main(String[] args) {
        MultiDatabaseAnalyzer analyzer = new MultiDatabaseAnalyzer();
        
        // Analyze PostgreSQL
        Connection pgConn = DriverManager.getConnection(/*...*/);
        analyzer.analyzeDatabase(SQLDialect.POSTGRES, pgConn);
        
        // Analyze MySQL  
        Connection mysqlConn = DriverManager.getConnection(/*...*/);
        analyzer.analyzeDatabase(SQLDialect.MYSQL, mysqlConn);
        
        // Analyze H2
        Connection h2Conn = DriverManager.getConnection(/*...*/);
        analyzer.analyzeDatabase(SQLDialect.H2, h2Conn);
    }
}