Table.java

import java.util.ArrayList;
import java.util.List;

public class Table {

    private List<String> fieldNames;
    private List<String> fieldTypes;
    private List<String> primaryKeys;
    private List<String> secondaryKeys;
    private String tableName;
    private List<Row> rows;

    public Table(String tableName, List<String> fieldNames,
                 List<String> fieldTypes, List<String> primaryKeys) {
        this(tableName, fieldNames, fieldTypes, primaryKeys, new ArrayList<>());
    }

    public Table(String tableName, List<String> fieldNames,
                 List<String> fieldTypes, List<String> primaryKeys,
                 List<String> secondaryKeys) {
        this.tableName     = tableName;
        this.fieldNames    = new ArrayList<>(fieldNames);
        this.fieldTypes    = new ArrayList<>(fieldTypes);
        this.primaryKeys   = new ArrayList<>(primaryKeys);
        this.secondaryKeys = new ArrayList<>(secondaryKeys);
        this.rows          = new ArrayList<>();
    }

    public String getTableName() { return tableName; }
    public List<String> getFieldNames() { return fieldNames; }
    public List<String> getFieldTypes() { return fieldTypes; }
    public List<String> getPrimaryKeys() { return primaryKeys; }
    public List<String> getSecondaryKeys() { return secondaryKeys; }
    public List<Row> getRows() { return rows; }

    public boolean isPrimaryKey(String fieldName) {
        return primaryKeys.contains(fieldName);
    }

    public boolean isSecondaryKey(String fieldName) {
        return secondaryKeys.contains(fieldName);
    }

    public boolean isKeyField(String fieldName) {
        return isPrimaryKey(fieldName) || isSecondaryKey(fieldName);
    }

    private boolean hasDuplicateLongValue(String fieldName, Long value) {
        for (Row row : rows) {
            if (value.equals(row.getLong(fieldName))) {
                return true;
            }
        }
        return false;
    }

    private boolean hasDuplicateStringValue(String fieldName, String value) {
        for (Row row : rows) {
            if (value.equals(row.getString(fieldName))) {
                return true;
            }
        }
        return false;
    }

    public List<String> getMissingFields(Row row) {
        List<String> missing = new ArrayList<>();
        for (String field : fieldNames) {
            if (!row.hasField(field)) {
                missing.add(field);
            }
        }
        return missing;
    }

    public String findDuplicatePrimaryKey(Row row) {
        for (String pk : primaryKeys) {
            String pkType = getFieldType(pk);
            if (pkType.equals("LONG")) {
                Long value = row.getLong(pk);
                if (hasDuplicateLongValue(pk, value)) {
                    return pk;
                }
            } else if (pkType.equals("STRING")) {
                String value = row.getString(pk);
                if (hasDuplicateStringValue(pk, value)) {
                    return pk;
                }
            }
        }
        return null;
    }

    public boolean insert(Row row) {
        if (findDuplicatePrimaryKey(row) != null) {
            return false;
        }
        rows.add(row);
        return true;
    }

    public Row getByStringKey(String keyField, String keyValue) {
        if (!isKeyField(keyField)) {
            return null;
        }
        for (Row row : rows) {
            if (keyValue.equals(row.getString(keyField))) {
                return row;
            }
        }
        return null;
    }

    public Row getByLongKey(String keyField, Long keyValue) {
        if (!isKeyField(keyField)) {
            return null;
        }
        for (Row row : rows) {
            if (keyValue.equals(row.getLong(keyField))) {
                return row;
            }
        }
        return null;
    }

    public boolean updateField(String keyField, Long keyValue,
                               String targetField, String newValue) {
        Row row = getByLongKey(keyField, keyValue);
        if (row == null) {
            return false;
        }
        row.setString(targetField, newValue);
        return true;
    }

    public boolean updateField(String keyField, Long keyValue,
                               String targetField, Long newValue) {
        Row row = getByLongKey(keyField, keyValue);
        if (row == null) {
            return false;
        }
        row.setLong(targetField, newValue);
        return true;
    }

    public boolean updateField(String keyField, String keyValue,
                               String targetField, String newValue) {
        Row row = getByStringKey(keyField, keyValue);
        if (row == null) {
            return false;
        }
        row.setString(targetField, newValue);
        return true;
    }

    public boolean updateField(String keyField, String keyValue,
                               String targetField, Long newValue) {
        Row row = getByStringKey(keyField, keyValue);
        if (row == null) {
            return false;
        }
        row.setLong(targetField, newValue);
        return true;
    }

    public boolean updateRow(String keyField, Long keyValue, Row newRow) {
        for (int i = 0; i < rows.size(); i++) {
            if (keyValue.equals(rows.get(i).getLong(keyField))) {
                rows.set(i, newRow);
                return true;
            }
        }
        return false;
    }

    public int deleteByLongKey(String keyField, Long keyValue) {
        if (!isKeyField(keyField)) {
            return 0;
        }
        int before = rows.size();
        rows.removeIf(r -> keyValue.equals(r.getLong(keyField)));
        return before - rows.size();
    }

    public int deleteByStringKey(String keyField, String keyValue) {
        if (!isKeyField(keyField)) {
            return 0;
        }
        int before = rows.size();
        rows.removeIf(r -> keyValue.equals(r.getString(keyField)));
        return before - rows.size();
    }

    public void printAll() {
        System.out.println("=== Table: " + tableName + " ===");
        if (rows.isEmpty()) {
            System.out.println("  (empty)");
        } else {
            for (Row row : rows) {
                System.out.println("  " + row);
            }
        }
    }

    public List<String> getKeyValuesAsStrings(String keyField) {
        List<String> values = new ArrayList<>();
        for (Row row : rows) {
            Object value = row.get(keyField);
            if (value != null) {
                values.add(value.toString());
            }
        }
        return values;
    }

    public int size() { return rows.size(); }

    public String getFieldType(String fieldName) {
        int index = fieldNames.indexOf(fieldName);
        if (index == -1) {
            return null;
        }
        return fieldTypes.get(index);
    }
}