Constraints and Relationships

/**
 * Gets the table's primary key constraint
 * @returns UniqueKeyDefinition for primary key or null if none
 */
UniqueKeyDefinition getPrimaryKey();

/**
 * Gets all primary keys across all schemas
 * @returns List of all primary key definitions
 */
List<UniqueKeyDefinition> getPrimaryKeys();

/**
 * Gets primary keys within a specific schema
 * @param schema - Schema to search within
 * @returns List of primary key definitions in the schema
 */
List<UniqueKeyDefinition> getPrimaryKeys(SchemaDefinition schema);

/**
 * Checks if a unique key is a primary key
 * @returns true if this unique key is the primary key
 */
boolean isPrimaryKey();

import org.jooq.meta.TableDefinition;
import org.jooq.meta.UniqueKeyDefinition;
import org.jooq.meta.ColumnDefinition;

// Get table primary key
TableDefinition table = database.getTable(schema, "users");
UniqueKeyDefinition primaryKey = table.getPrimaryKey();

if (primaryKey != null) {
    System.out.println("Primary Key: " + primaryKey.getName());
    List<ColumnDefinition> keyColumns = primaryKey.getKeyColumns();
    System.out.println("Key Columns: ");
    
    for (ColumnDefinition column : keyColumns) {
        System.out.println("  - " + column.getName() + " (" + column.getType().getType() + ")");
    }
}

// Get all primary keys in schema
List<UniqueKeyDefinition> allPrimaryKeys = database.getPrimaryKeys(schema);
for (UniqueKeyDefinition pk : allPrimaryKeys) {
    System.out.println("Table: " + pk.getTable().getName() + 
                      ", PK: " + pk.getName() + 
                      ", Columns: " + pk.getKeyColumns().size());
}

/**
 * Gets all unique constraints for the table
 * @returns List of unique key definitions (including primary key)
 */
List<UniqueKeyDefinition> getUniqueKeys();

/**
 * Gets all unique keys across all schemas
 * @returns List of all unique key definitions
 */
List<UniqueKeyDefinition> getUniqueKeys();

/**
 * Gets unique keys within a specific schema
 * @param schema - Schema to search within
 * @returns List of unique key definitions in the schema
 */
List<UniqueKeyDefinition> getUniqueKeys(SchemaDefinition schema);

/**
 * Gets combined primary and unique keys
 * @returns List of all key definitions (primary + unique)
 */
List<UniqueKeyDefinition> getKeys();

/**
 * Gets combined primary and unique keys for a schema
 * @param schema - Schema to search within
 * @returns List of all key definitions in the schema
 */
List<UniqueKeyDefinition> getKeys(SchemaDefinition schema);

import org.jooq.meta.UniqueKeyDefinition;
import org.jooq.meta.ColumnDefinition;

// Get all unique constraints for table
List<UniqueKeyDefinition> uniqueKeys = table.getUniqueKeys();
for (UniqueKeyDefinition key : uniqueKeys) {
    System.out.println("Unique Key: " + key.getName());
    System.out.println("  Primary: " + key.isPrimaryKey());
    System.out.println("  Columns: ");
    
    for (ColumnDefinition column : key.getKeyColumns()) {
        System.out.println("    - " + column.getName());
    }
}

// Separate primary key from other unique keys
List<UniqueKeyDefinition> allKeys = table.getUniqueKeys();
UniqueKeyDefinition primaryKey = allKeys.stream()
    .filter(UniqueKeyDefinition::isPrimaryKey)
    .findFirst()
    .orElse(null);

List<UniqueKeyDefinition> uniqueConstraints = allKeys.stream()
    .filter(key -> !key.isPrimaryKey())
    .collect(Collectors.toList());

/**
 * Gets all foreign keys for the table
 * @returns List of foreign key definitions
 */
List<ForeignKeyDefinition> getForeignKeys();

/**
 * Gets all foreign keys across all schemas
 * @returns List of all foreign key definitions
 */
List<ForeignKeyDefinition> getForeignKeys();

/**
 * Gets foreign keys within a specific schema
 * @param schema - Schema to search within
 * @returns List of foreign key definitions in the schema
 */
List<ForeignKeyDefinition> getForeignKeys(SchemaDefinition schema);

/**
 * Gets foreign key columns (referencing columns)
 * @returns List of columns that are part of this foreign key
 */
List<ColumnDefinition> getKeyColumns();

/**
 * Gets the referenced unique key
 * @returns UniqueKeyDefinition that this foreign key references
 */
UniqueKeyDefinition getReferencedKey();

/**
 * Gets referenced columns (columns being referenced)
 * @returns List of columns in the referenced table
 */
List<ColumnDefinition> getReferencedColumns();

import org.jooq.meta.ForeignKeyDefinition;
import org.jooq.meta.UniqueKeyDefinition;
import org.jooq.meta.ColumnDefinition;

// Analyze foreign keys for table
List<ForeignKeyDefinition> foreignKeys = table.getForeignKeys();
for (ForeignKeyDefinition fk : foreignKeys) {
    System.out.println("\nForeign Key: " + fk.getName());
    
    // Get referencing columns
    List<ColumnDefinition> keyColumns = fk.getKeyColumns();
    System.out.println("  Referencing Columns:");
    for (ColumnDefinition col : keyColumns) {
        System.out.println("    - " + col.getName());
    }
    
    // Get referenced table and columns
    UniqueKeyDefinition referencedKey = fk.getReferencedKey();
    System.out.println("  Referenced Table: " + referencedKey.getTable().getName());
    System.out.println("  Referenced Key: " + referencedKey.getName());
    
    List<ColumnDefinition> referencedColumns = fk.getReferencedColumns();
    System.out.println("  Referenced Columns:");
    for (ColumnDefinition col : referencedColumns) {
        System.out.println("    - " + col.getName());
    }
}

// Find relationships between specific tables
TableDefinition ordersTable = database.getTable(schema, "orders");
TableDefinition customersTable = database.getTable(schema, "customers");

List<ForeignKeyDefinition> ordersFKs = ordersTable.getForeignKeys();
for (ForeignKeyDefinition fk : ordersFKs) {
    if (fk.getReferencedKey().getTable().equals(customersTable)) {
        System.out.println("Found relationship: orders -> customers via " + fk.getName());
    }
}

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

/**
 * Gets check constraints within a specific schema
 * @param schema - Schema to search within
 * @returns List of check constraint definitions in the schema
 */
List<CheckConstraintDefinition> getCheckConstraints(SchemaDefinition schema);

/**
 * Gets the check constraint expression
 * @returns SQL expression string for the check constraint
 */
String getCheckClause();

import org.jooq.meta.CheckConstraintDefinition;

// Analyze check constraints
List<CheckConstraintDefinition> checkConstraints = table.getCheckConstraints();
for (CheckConstraintDefinition check : checkConstraints) {
    System.out.println("Check Constraint: " + check.getName());
    System.out.println("  Expression: " + check.getCheckClause());
    System.out.println("  Table: " + check.getTable().getName());
}

// Find constraints with specific patterns
List<CheckConstraintDefinition> ageConstraints = table.getCheckConstraints().stream()
    .filter(check -> check.getCheckClause().contains("age"))
    .collect(Collectors.toList());

/**
 * Gets all indexes for the table
 * @returns List of index definitions
 */
List<IndexDefinition> getIndexes();

/**
 * Gets indexes within a specific schema
 * @param schema - Schema to search within
 * @returns List of index definitions in the schema
 */
List<IndexDefinition> getIndexes(SchemaDefinition schema);

/**
 * Gets indexes for a specific table
 * @param table - Table to get indexes for
 * @returns List of index definitions for the table
 */
List<IndexDefinition> getIndexes(TableDefinition table);

/**
 * Gets the table this index belongs to
 * @returns TableDefinition for the indexed table
 */
TableDefinition getTable();

/**
 * Gets index column definitions
 * @returns List of index column definitions with sort order
 */
List<IndexColumnDefinition> getIndexColumns();

/**
 * Checks if index is unique
 * @returns true if index enforces uniqueness
 */
boolean isUnique();

import org.jooq.meta.IndexDefinition;
import org.jooq.meta.IndexColumnDefinition;

// Analyze table indexes
List<IndexDefinition> indexes = table.getIndexes();
for (IndexDefinition index : indexes) {
    System.out.println("\nIndex: " + index.getName());
    System.out.println("  Unique: " + index.isUnique());
    System.out.println("  Table: " + index.getTable().getName());
    System.out.println("  Columns:");
    
    for (IndexColumnDefinition indexCol : index.getIndexColumns()) {
        System.out.println("    - " + indexCol.getColumn().getName() + 
                          " (" + indexCol.getSortOrder() + ")");
    }
}

// Find unique indexes
List<IndexDefinition> uniqueIndexes = table.getIndexes().stream()
    .filter(IndexDefinition::isUnique)
    .collect(Collectors.toList());

// Find indexes on specific columns
String columnName = "email";
List<IndexDefinition> emailIndexes = table.getIndexes().stream()
    .filter(index -> index.getIndexColumns().stream()
        .anyMatch(col -> col.getColumn().getName().equals(columnName)))
    .collect(Collectors.toList());

/**
 * Gets identity columns within a specific schema
 * @param schema - Schema to search within
 * @returns List of identity definitions in the schema
 */
List<IdentityDefinition> getIdentities(SchemaDefinition schema);

/**
 * Gets the identity column for the table
 * @returns IdentityDefinition or null if no identity column
 */
IdentityDefinition getIdentity();

/**
 * Gets the column that is the identity column
 * @returns ColumnDefinition for the identity column
 */
ColumnDefinition getColumn();

/**
 * Gets the relationship manager for the database
 * @returns Relations instance for relationship navigation
 */
Relations getRelations();

/**
 * Gets primary key using relations manager
 * @param table - Table to get primary key for
 * @returns UniqueKeyDefinition for primary key
 */
UniqueKeyDefinition getPrimaryKey(TableDefinition table);

/**
 * Gets unique keys using relations manager
 * @param table - Table to get unique keys for
 * @returns List of unique key definitions
 */
List<UniqueKeyDefinition> getUniqueKeys(TableDefinition table);

/**
 * Gets foreign keys using relations manager
 * @param table - Table to get foreign keys for
 * @returns List of foreign key definitions
 */
List<ForeignKeyDefinition> getForeignKeys(TableDefinition table);

/**
 * Gets exported foreign keys (keys referencing this table)
 * @param table - Table to get exported keys for
 * @returns List of foreign keys that reference this table
 */
List<ForeignKeyDefinition> getExportedKeys(TableDefinition table);

interface UniqueKeyDefinition extends ConstraintDefinition {
    boolean isPrimaryKey();
    List<ColumnDefinition> getKeyColumns();
    List<ForeignKeyDefinition> getReferencingForeignKeys();
    TableDefinition getTable();
}

interface ForeignKeyDefinition extends ConstraintDefinition {
    List<ColumnDefinition> getKeyColumns();
    UniqueKeyDefinition getReferencedKey();
    List<ColumnDefinition> getReferencedColumns();
    TableDefinition getTable();
}

interface CheckConstraintDefinition extends ConstraintDefinition {
    String getCheckClause();
    TableDefinition getTable();
}

interface IndexDefinition extends Definition {
    TableDefinition getTable();
    List<IndexColumnDefinition> getIndexColumns();
    boolean isUnique();
}

interface IdentityDefinition extends Definition {
    ColumnDefinition getColumn();
    TableDefinition getTable();
}

interface Relations {
    UniqueKeyDefinition getPrimaryKey(TableDefinition table);
    List<UniqueKeyDefinition> getUniqueKeys(TableDefinition table);
    List<ForeignKeyDefinition> getForeignKeys(TableDefinition table);
    List<ForeignKeyDefinition> getExportedKeys(TableDefinition table);
}

import org.jooq.meta.Relations;
import org.jooq.meta.UniqueKeyDefinition;
import org.jooq.meta.ForeignKeyDefinition;

// Complete relationship analysis using Relations
Relations relations = database.getRelations();

TableDefinition customersTable = database.getTable(schema, "customers");
TableDefinition ordersTable = database.getTable(schema, "orders");

// Get primary keys
UniqueKeyDefinition customerPK = relations.getPrimaryKey(customersTable);
UniqueKeyDefinition orderPK = relations.getPrimaryKey(ordersTable);

// Get foreign keys
List<ForeignKeyDefinition> customerFKs = relations.getForeignKeys(customersTable);
List<ForeignKeyDefinition> orderFKs = relations.getForeignKeys(ordersTable);

// Get exported keys (foreign keys that reference this table)
List<ForeignKeyDefinition> customerExported = relations.getExportedKeys(customersTable);

System.out.println("Tables referencing customers:");
for (ForeignKeyDefinition exportedFK : customerExported) {
    System.out.println("  " + exportedFK.getTable().getName() + 
                      " via " + exportedFK.getName());
}