dolthub/dolt

AI Summary: `dolt diff` incorrectly displays `NULL` values for virtual generated columns when showing added rows, because these columns are not physically stored and their expressions are not evaluated during the diff process. The proposed solution is to exclude these virtual columns entirely from `dolt diff` output, as they don't represent actual data changes.

AI Summary: The task is to debug and fix a bug in Dolt where modifying an enum column to a varchar column results in the varchar column storing the index of the enum value instead of the text representation. The fix needs to ensure that the text representation of the enum values is correctly stored in the varchar column after the modification.

AI Summary: The task is to debug a bug in Dolt's SQL parser where check constraints added via `MODIFY COLUMN` statements are not correctly applied. The issue demonstrates a discrepancy between Dolt's and MySQL's behavior when handling check constraints within `ALTER TABLE MODIFY COLUMN` statements. The solution requires investigating Dolt's SQL parsing and constraint enforcement logic to ensure consistency with MySQL's behavior.

AI Summary: The task is to investigate and resolve inconsistencies in Dolt's handling of time types (`time`, `timestamp`, `datetime`) within foreign key constraints. The issue involves zero-padding problems preventing insertions and unexpected constraint violations when comparing seemingly equal `datetime` and `timestamp` values. The solution requires understanding MySQL's behavior with these types and implementing compatible logic in Dolt to ensure correct constraint enforcement.

AI Summary: The task requires debugging and fixing a bug in Dolt's handling of the `auto_increment` constraint, specifically addressing cases where maximum integer values cause overflow errors to be ignored and the `AUTO_INCREMENT` value is incorrectly reported. This involves analyzing the provided issue description, potentially reviewing related test cases and code (linked in the issue), and implementing a solution that correctly handles overflow errors and reports the `AUTO_INCREMENT` value accurately.

AI Summary: The issue describes a problem with the `SET` data type in Dolt (a Git-like system for data) where casting to `char` or `binary` types is not working correctly. The task requires investigating and fixing this casting issue, likely involving debugging the Dolt codebase and writing/running tests to ensure the fix is correct. Tests were previously skipped in a related issue (dolthub/go-mysql-server#3095), suggesting a need to address this omission as well.

AI Summary: The task is to resolve an inconsistency between Dolt's and MySQL's handling of foreign keys referencing DECIMAL columns with varying precision and scale. Currently, Dolt doesn't allow this, unlike MySQL, leading to insert failures unless precision and scale are identical. The solution involves modifying Dolt's foreign key constraint enforcement to match MySQL's more flexible behavior, potentially requiring changes to the underlying data type handling and constraint checking logic. This may involve reviewing existing test cases and adding new ones to ensure the fix doesn't introduce regressions.

AI Summary: The task is to investigate and resolve an issue related to foreign key constraints in a SQL database. Specifically, the issue involves allowing mixed string types (`char`, `varchar`, `binary`, `varbinary`) to be used in foreign key relationships, potentially requiring modifications to the database schema or the underlying code to ensure compatibility and proper constraint enforcement. The provided project information details a version-controlled SQL database (Dolt) and its associated tools, which may be relevant to the solution.

AI Summary: The task is to debug and fix a bug in Dolt's handling of empty strings within `SET` operations. The bug causes inconsistencies in how empty strings are displayed and filtered compared to standard MySQL behavior. The issue involves investigating test failures linked to a pull request (https://github.com/dolthub/go-mysql-server/pull/3077) to identify the root cause and implement a solution that ensures consistent behavior with MySQL.

AI Summary: The task is to debug a discrepancy in how Dolt (a Git-like SQL database) handles `ENUM` type string comparisons within `CASE` statements compared to MySQL. The issue is that Dolt returns the underlying integer representation of the `ENUM` instead of the string value in certain `CASE` statement scenarios. The solution requires investigating the Dolt codebase, specifically the skipped test in the referenced pull request, to identify and correct the incorrect string conversion logic for `ENUM` types within `CASE` statements to ensure consistent behavior with MySQL.

AI Summary: The task involves removing error handling and associated logic related to the `auto_increment` constraint in the Dolt project's Go MySQL Server (GMS) component. This is because `auto_increment` should only be allowed on `INT` type columns. The current error handling is partially implemented on the Dolt side and needs to be moved entirely into GMS, eliminating the need for the `ErrNonAutoIncType` error and related code in `doltcore/schema/col_coll.go`.

AI Summary: The task involves investigating and resolving a discrepancy in the behavior of foreign key constraints over SET columns in Dolt compared to MySQL. This requires analyzing the skipped tests linked in the issue description (https://github.com/dolthub/go-mysql-server/pull/3077) to understand the nature of the difference and then implementing a fix to ensure consistent behavior between Dolt and MySQL.

AI Summary: The task requires fixing a bug in the Dolt SQL database where numeric default values are not allowed for columns with the `SET` data type, even though numeric values are acceptable during insertion. The issue involves resolving a conflict between the expected behavior and the current implementation of default values for `SET` columns.

AI Summary: The task is to fix a bug in Dolt where `SET` column types cannot be `auto_increment`. This involves investigating the skipped tests linked in the issue description (https://github.com/dolthub/go-mysql-server/pull/3077), understanding why `SET` columns are incompatible with `auto_increment`, and implementing a solution that allows `SET` columns to support `auto_increment` functionality while maintaining data integrity and compatibility with MySQL standards.

AI Summary: The task requires fixing a bug in Dolt where `SET` data types are not correctly converted to strings in certain contexts. This involves investigating the issue, likely debugging the codebase (potentially referencing a related `ENUM` issue), writing unit tests, and implementing a solution to ensure proper string conversion for `SET` types.

AI Summary: The task is to investigate why Dolt's SQL engine doesn't allow the `DEFAULT` keyword to update generated columns, as MySQL does. The goal is to either implement support for this behavior in Dolt to match MySQL's functionality or provide a clear explanation of why it's not supported and if it should be.

AI Summary: The task is to fix a bug in Dolt where user-defined and system variables are allowed in the `default` and `generated` column values of SQL `CREATE TABLE` statements. Currently, Dolt allows this, while MySQL correctly throws an error. The solution requires modifying Dolt's SQL parser and/or query execution to enforce the same restriction as MySQL, preventing the use of such variables in these contexts.

AI Summary: The task is to resolve an issue where Dolt, a SQL database with Git-like version control, does not allow a `0` value for `enum` types when `STRICT_TRANS_TABLES` or `STRICT_ALL_TABLES` `sql_mode` is enabled. This requires investigating the underlying `go-mysql-server` library, potentially modifying its behavior to accommodate `0` values in enums under strict SQL modes, and ensuring compatibility with Dolt's version control features. Testing will be crucial to verify the fix doesn't introduce regressions.

AI Summary: The task is to investigate and fix a bug where `enum` columns in a Dolt database cannot be set with `auto_increment`. A skipped test in the `go-mysql-server` project (linked in the issue description) needs to be addressed as part of the solution.

AI Summary: The task is to investigate and potentially fix an issue related to foreign key constraints in Dolt, specifically when dealing with `enum` columns. The issue is that foreign key constraints currently allow mismatched `enum` types between parent and child columns, which is unexpected behavior. The goal is to determine if this is a bug and, if so, implement a fix that enforces stricter type matching for `enum` foreign keys.

AI Summary: The task is to modify the Dolt CLI's `checkout` command to behave similarly to Git's `checkout` command. Currently, if one of the specified tables doesn't exist, Dolt prevents checking out any of the others. The desired behavior is for Dolt to check out the existing tables and only report errors for the missing ones.