Utilities and Helpers

/**
 * Utility methods for Hive DDL SQL nodes
 * Provides property validation, data type conversion, and constraint handling
 */
public class HiveDDLUtils {
    /** Column delimiter for internal use */
    public static final String COL_DELIMITER = ";";

    /**
     * Validates database properties against reserved property names
     * @param props Database properties to validate  
     * @return Validated property list
     * @throws ParseException if reserved properties are used
     */
    public static SqlNodeList checkReservedDBProperties(SqlNodeList props) throws ParseException;

    /**
     * Validates table properties against reserved property names and prefixes
     * @param props Table properties to validate
     * @return Validated property list  
     * @throws ParseException if reserved properties are used
     */
    public static SqlNodeList checkReservedTableProperties(SqlNodeList props) throws ParseException;

    /**
     * Ensures table properties do not mark table as generic
     * @param props Table properties to check
     * @return Validated property list
     * @throws ParseException if generic table creation is attempted
     */
    public static SqlNodeList ensureNonGeneric(SqlNodeList props) throws ParseException;

    /**
     * Creates table option from key-value pair
     * @param key Property key
     * @param value Property value node
     * @param pos Parser position
     * @return SqlTableOption instance
     */
    public static SqlTableOption toTableOption(String key, SqlNode value, SqlParserPos pos);

    /**
     * Creates table option from key-value strings
     * @param key Property key
     * @param value Property value string
     * @param pos Parser position
     * @return SqlTableOption instance
     */
    public static SqlTableOption toTableOption(String key, String value, SqlParserPos pos);

    /**
     * Converts data types in column list for Hive compatibility
     * @param columns Column list to convert
     * @throws ParseException if conversion fails
     */
    public static void convertDataTypes(SqlNodeList columns) throws ParseException;

    /**
     * Converts data type in single column for Hive compatibility
     * @param column Column to convert
     * @throws ParseException if conversion fails
     */
    public static void convertDataTypes(SqlRegularColumn column) throws ParseException;
}

/**
 * Constraint trait utility methods
 * Provides encoding, decoding, and manipulation of constraint traits
 */
public class HiveDDLUtils {
    /**
     * Returns default constraint trait (ENABLE NOVALIDATE RELY)
     * @return Default trait as byte encoding
     */
    public static byte defaultTrait();

    /**
     * Enables constraint in trait
     * @param trait Current trait encoding
     * @return Modified trait with enable flag set
     */
    public static byte enableConstraint(byte trait);

    /**
     * Disables constraint in trait
     * @param trait Current trait encoding
     * @return Modified trait with enable flag cleared
     */
    public static byte disableConstraint(byte trait);

    /**
     * Sets validate flag in constraint trait
     * @param trait Current trait encoding
     * @return Modified trait with validate flag set
     */
    public static byte validateConstraint(byte trait);

    /**
     * Clears validate flag in constraint trait
     * @param trait Current trait encoding
     * @return Modified trait with validate flag cleared
     */
    public static byte noValidateConstraint(byte trait);

    /**
     * Sets rely flag in constraint trait
     * @param trait Current trait encoding
     * @return Modified trait with rely flag set
     */
    public static byte relyConstraint(byte trait);

    /**
     * Clears rely flag in constraint trait
     * @param trait Current trait encoding
     * @return Modified trait with rely flag cleared
     */
    public static byte noRelyConstraint(byte trait);

    /**
     * Checks if constraint is enabled
     * @param trait Trait encoding to check
     * @return true if constraint is enabled
     */
    public static boolean requireEnableConstraint(byte trait);

    /**
     * Checks if constraint validation is enabled
     * @param trait Trait encoding to check
     * @return true if validation is enabled
     */
    public static boolean requireValidateConstraint(byte trait);

    /**
     * Checks if constraint rely is enabled
     * @param trait Trait encoding to check
     * @return true if rely is enabled
     */
    public static boolean requireRelyConstraint(byte trait);

    /**
     * Encodes constraint trait object to byte representation
     * @param trait SqlHiveConstraintTrait object
     * @return Byte encoding of the trait
     */
    public static byte encodeConstraintTrait(SqlHiveConstraintTrait trait);
}

/**
 * Data manipulation utility methods
 * Provides deep copying and data transformation functions
 */
public class HiveDDLUtils {
    /**
     * Creates deep copy of column list
     * @param colList Original column list
     * @return Deep copy of the column list
     */
    public static SqlNodeList deepCopyColList(SqlNodeList colList);

    /**
     * Creates deep copy of table column
     * @param column Original column definition
     * @return Deep copy of the column
     */
    public static SqlRegularColumn deepCopyTableColumn(SqlRegularColumn column);
}

/**
 * String processing utility methods
 * Handles string literal escaping and unescaping for SQL compatibility
 */
public class HiveDDLUtils {
    /**
     * Unescapes string literals in property list
     * @param properties Property list containing string literals
     */
    public static void unescapeProperties(SqlNodeList properties);

    /**
     * Unescapes single string literal
     * @param literal String literal to unescape
     * @return Unescaped string literal
     */
    public static SqlCharStringLiteral unescapeStringLiteral(SqlCharStringLiteral literal);

    /**
     * Unescapes partition specification values
     * @param partSpec Partition specification to unescape
     */
    public static void unescapePartitionSpec(SqlNodeList partSpec);
}

// Validate table properties before table creation
SqlNodeList tableProps = new SqlNodeList(SqlParserPos.ZERO);
tableProps.add(new SqlTableOption("owner", "data_team", SqlParserPos.ZERO));
tableProps.add(new SqlTableOption("environment", "production", SqlParserPos.ZERO));

try {
    // Validate against reserved properties
    SqlNodeList validatedProps = HiveDDLUtils.checkReservedTableProperties(tableProps);
    
    // Ensure non-generic table creation
    SqlNodeList finalProps = HiveDDLUtils.ensureNonGeneric(validatedProps);
    
    System.out.println("Properties validated successfully");
} catch (ParseException e) {
    System.err.println("Property validation failed: " + e.getMessage());
}

// Example of reserved property that would fail validation
SqlNodeList invalidProps = new SqlNodeList(SqlParserPos.ZERO);
invalidProps.add(new SqlTableOption("hive.location-uri", "/data/test", SqlParserPos.ZERO)); // Reserved!

try {
    HiveDDLUtils.checkReservedTableProperties(invalidProps);
} catch (ParseException e) {
    System.err.println("Expected failure for reserved property: " + e.getMessage());
}

// Create column list with data types that need conversion
SqlNodeList columns = new SqlNodeList(SqlParserPos.ZERO);

// TIMESTAMP column (will be converted for Hive compatibility)
SqlDataTypeSpec timestampType = new SqlDataTypeSpec(
    new SqlBasicTypeNameSpec(SqlTypeName.TIMESTAMP, SqlParserPos.ZERO), 
    SqlParserPos.ZERO
);
SqlRegularColumn timestampCol = new SqlRegularColumn(
    SqlParserPos.ZERO,
    new SqlIdentifier("created_at", SqlParserPos.ZERO),
    timestampType,
    null, null
);
columns.add(timestampCol);

// BINARY column (will be converted for Hive compatibility)  
SqlDataTypeSpec binaryType = new SqlDataTypeSpec(
    new SqlBasicTypeNameSpec(SqlTypeName.BINARY, SqlParserPos.ZERO),
    SqlParserPos.ZERO
);
SqlRegularColumn binaryCol = new SqlRegularColumn(
    SqlParserPos.ZERO,
    new SqlIdentifier("data_payload", SqlParserPos.ZERO),
    binaryType,
    null, null
);
columns.add(binaryCol);

try {
    // Convert data types for Hive compatibility
    HiveDDLUtils.convertDataTypes(columns);
    System.out.println("Data types converted successfully");
} catch (ParseException e) {
    System.err.println("Data type conversion failed: " + e.getMessage());
}

// Working with constraint traits
byte defaultTrait = HiveDDLUtils.defaultTrait();

System.out.println("Default trait - Enable: " + HiveDDLUtils.requireEnableConstraint(defaultTrait));
System.out.println("Default trait - Validate: " + HiveDDLUtils.requireValidateConstraint(defaultTrait));  
System.out.println("Default trait - Rely: " + HiveDDLUtils.requireRelyConstraint(defaultTrait));

// Modify constraint traits
byte strictTrait = HiveDDLUtils.validateConstraint(defaultTrait);
byte lenientTrait = HiveDDLUtils.disableConstraint(defaultTrait);
byte optimizerOnlyTrait = HiveDDLUtils.noValidateConstraint(defaultTrait);

System.out.println("Strict trait validates: " + HiveDDLUtils.requireValidateConstraint(strictTrait));
System.out.println("Lenient trait enabled: " + HiveDDLUtils.requireEnableConstraint(lenientTrait));
System.out.println("Optimizer trait validates: " + HiveDDLUtils.requireValidateConstraint(optimizerOnlyTrait));

// Encode constraint trait object
SqlHiveConstraintTrait traitObj = new SqlHiveConstraintTrait(
    SqlHiveConstraintEnable.ENABLE.symbol(SqlParserPos.ZERO),
    SqlHiveConstraintValidate.VALIDATE.symbol(SqlParserPos.ZERO),
    SqlHiveConstraintRely.RELY.symbol(SqlParserPos.ZERO)
);

byte encodedTrait = HiveDDLUtils.encodeConstraintTrait(traitObj);
System.out.println("Encoded trait matches strict: " + (encodedTrait == strictTrait));

// Process string literals with escaping
SqlNodeList properties = new SqlNodeList(SqlParserPos.ZERO);

// Add properties with escaped values
properties.add(new SqlTableOption("description", "Data contains\\ttabs and\\nnewlines", SqlParserPos.ZERO));
properties.add(new SqlTableOption("path", "/data/files with spaces/table", SqlParserPos.ZERO));
properties.add(new SqlTableOption("pattern", "*.txt", SqlParserPos.ZERO));

// Unescape all property values
HiveDDLUtils.unescapeProperties(properties);

// Unescape individual string literal
SqlCharStringLiteral escapedLiteral = SqlLiteral.createCharString("Value with\\tescapes\\n", SqlParserPos.ZERO);
SqlCharStringLiteral unescapedLiteral = HiveDDLUtils.unescapeStringLiteral(escapedLiteral);

System.out.println("Original: " + escapedLiteral.getValueAs(String.class));
System.out.println("Unescaped: " + unescapedLiteral.getValueAs(String.class));

// Process partition specifications
SqlNodeList partSpec = new SqlNodeList(SqlParserPos.ZERO);
partSpec.add(new SqlTableOption("date_str", "2023-12-01", SqlParserPos.ZERO));
partSpec.add(new SqlTableOption("path_segment", "/data/special\\tchars", SqlParserPos.ZERO));

HiveDDLUtils.unescapePartitionSpec(partSpec);

// Deep copy column definitions for modification
SqlNodeList originalColumns = new SqlNodeList(SqlParserPos.ZERO);

SqlRegularColumn originalCol = new SqlRegularColumn(
    SqlParserPos.ZERO,
    new SqlIdentifier("user_id", SqlParserPos.ZERO),
    new SqlDataTypeSpec(new SqlBasicTypeNameSpec(SqlTypeName.BIGINT, SqlParserPos.ZERO), SqlParserPos.ZERO),
    null, null
);
originalColumns.add(originalCol);

// Create deep copy for modification
SqlNodeList copiedColumns = HiveDDLUtils.deepCopyColList(originalColumns);
SqlRegularColumn copiedCol = HiveDDLUtils.deepCopyTableColumn(originalCol);

// Modify copied version without affecting original
// (Modification logic would depend on specific use case)

System.out.println("Original and copied columns are independent");
System.out.println("Original column count: " + originalColumns.size());
System.out.println("Copied column count: " + copiedColumns.size());

public class HiveUtilityService {
    
    /**
     * Validates and prepares table properties for Hive table creation
     */
    public SqlNodeList prepareTableProperties(Map<String, String> userProperties) throws ParseException {
        SqlNodeList properties = new SqlNodeList(SqlParserPos.ZERO);
        
        // Convert map to SqlNodeList
        for (Map.Entry<String, String> entry : userProperties.entrySet()) {
            SqlTableOption option = HiveDDLUtils.toTableOption(
                entry.getKey(), 
                entry.getValue(), 
                SqlParserPos.ZERO
            );
            properties.add(option);
        }
        
        // Validate properties
        properties = HiveDDLUtils.checkReservedTableProperties(properties);
        properties = HiveDDLUtils.ensureNonGeneric(properties);
        
        // Unescape string values
        HiveDDLUtils.unescapeProperties(properties);
        
        return properties;
    }
    
    /**
     * Prepares column definitions with proper data type conversion
     */
    public SqlNodeList prepareColumns(List<ColumnDefinition> columnDefs) throws ParseException {
        SqlNodeList columns = new SqlNodeList(SqlParserPos.ZERO);
        
        for (ColumnDefinition colDef : columnDefs) {
            SqlDataTypeSpec typeSpec = createDataTypeSpec(colDef.getType());
            SqlRegularColumn column = new SqlRegularColumn(
                SqlParserPos.ZERO,
                new SqlIdentifier(colDef.getName(), SqlParserPos.ZERO),
                typeSpec,
                null, // default value
                null  // constraint
            );
            columns.add(column);
        }
        
        // Convert types for Hive compatibility
        HiveDDLUtils.convertDataTypes(columns);
        
        return columns;
    }
    
    /**
     * Creates constraint trait based on enforcement policy
     */
    public byte createConstraintTrait(String enforcementPolicy) {
        byte trait = HiveDDLUtils.defaultTrait();
        
        switch (enforcementPolicy.toUpperCase()) {
            case "STRICT":
                trait = HiveDDLUtils.enableConstraint(trait);
                trait = HiveDDLUtils.validateConstraint(trait);
                trait = HiveDDLUtils.relyConstraint(trait);
                break;
            case "OPTIMIZER_ONLY":
                trait = HiveDDLUtils.enableConstraint(trait);
                trait = HiveDDLUtils.noValidateConstraint(trait);
                trait = HiveDDLUtils.relyConstraint(trait);
                break;
            case "DISABLED":
                trait = HiveDDLUtils.disableConstraint(trait);
                trait = HiveDDLUtils.noValidateConstraint(trait);
                trait = HiveDDLUtils.noRelyConstraint(trait);
                break;
            default: // STANDARD
                // Use default trait (ENABLE NOVALIDATE RELY)
                break;
        }
        
        return trait;
    }
    
    private SqlDataTypeSpec createDataTypeSpec(String typeString) {
        // Implementation would parse type string and create appropriate SqlDataTypeSpec
        // This is a simplified example
        SqlTypeNameSpec typeNameSpec;
        
        switch (typeString.toUpperCase()) {
            case "STRING":
                typeNameSpec = new SqlBasicTypeNameSpec(SqlTypeName.VARCHAR, SqlParserPos.ZERO);
                break;
            case "BIGINT":
                typeNameSpec = new SqlBasicTypeNameSpec(SqlTypeName.BIGINT, SqlParserPos.ZERO);
                break;
            case "TIMESTAMP":
                typeNameSpec = new SqlBasicTypeNameSpec(SqlTypeName.TIMESTAMP, SqlParserPos.ZERO);
                break;
            default:
                throw new IllegalArgumentException("Unsupported type: " + typeString);
        }
        
        return new SqlDataTypeSpec(typeNameSpec, SqlParserPos.ZERO);
    }
    
    public static class ColumnDefinition {
        private final String name;
        private final String type;
        
        public ColumnDefinition(String name, String type) {
            this.name = name;
            this.type = type;
        }
        
        public String getName() { return name; }
        public String getType() { return type; }
    }
}

// Usage
HiveUtilityService service = new HiveUtilityService();

// Prepare table properties
Map<String, String> userProps = Map.of(
    "owner", "data_team",
    "environment", "production",
    "description", "Sales data with\\ttabs"
);

SqlNodeList tableProperties = service.prepareTableProperties(userProps);

// Prepare columns
List<HiveUtilityService.ColumnDefinition> columnDefs = List.of(
    new HiveUtilityService.ColumnDefinition("id", "BIGINT"),
    new HiveUtilityService.ColumnDefinition("name", "STRING"),
    new HiveUtilityService.ColumnDefinition("created_at", "TIMESTAMP")
);

SqlNodeList columns = service.prepareColumns(columnDefs);

// Create constraint trait
byte strictTrait = service.createConstraintTrait("STRICT");
byte optimizerTrait = service.createConstraintTrait("OPTIMIZER_ONLY");

System.out.println("Strict constraint validates: " + HiveDDLUtils.requireValidateConstraint(strictTrait));
System.out.println("Optimizer constraint validates: " + HiveDDLUtils.requireValidateConstraint(optimizerTrait));