Method is_compatible

src/sql-server-util/src/inspect.rs:623–691

Returns true if the DDL event is a compatible change, or false if it is not. This performs a naive parsing of the DDL command looking for modification of columns 1. ALTER TABLE .. ALTER COLUMN 2. ALTER TABLE .. DROP COLUMN See

(&self, included_columns: &[Arc<str>])

    ///
    /// See <https://learn.microsoft.com/en-us/sql/t-sql/statements/alter-table-transact-sql?view=sql-server-ver17>
    pub fn is_compatible(&self, included_columns: &[Arc<str>]) -> bool {
        // TODO (maz): This is currently a basic check that doesn't take into account type changes.
        // At some point, we will need to move this to SqlServerTableDesc and expand it.
        let mut words = self.ddl_command.split_ascii_whitespace();
        match (
            words.next().map(str::to_ascii_lowercase).as_deref(),
            words.next().map(str::to_ascii_lowercase).as_deref(),
        ) {
            (Some("alter"), Some("table")) => {
                let mut peekable = words.peekable();
                let mut compatible = true;
                while compatible && let Some(token) = peekable.next() {
                    compatible = match token.to_ascii_lowercase().as_str() {
                        "alter" | "drop" => {
                            let target = peekable.next();
                            match target {
                                // Targeting a column
                                Some(t) if t.eq_ignore_ascii_case("column") => {
                                    let mut all_excluded = true;
                                    while let Some(tok) = peekable.next() {
                                        // The column name(s) can be preceeded by the pair of keywords "IF EXISTS", so we want to skip those.
                                        match tok.to_ascii_lowercase().as_str() {
                                            "if" | "exists" | "," | "column" => continue,
                                            col_str => {
                                                // If any column is in the included list, then it is not okay to alter/drop it
                                                // The col_str token may be a comma-separated list of columns as whitespace is not required
                                                // between column names in SQL Server DDL.
                                                if !col_str.trim_matches(',').split(',').all(
                                                    |col_name| {
                                                        !included_columns.iter().any(|included| {
                                                            included.eq_ignore_ascii_case(
                                                                col_name.trim_matches(
                                                                    ['[', ']', '"'].as_ref(),
                                                                ),
                                                            )
                                                        })
                                                    },
                                                ) {
                                                    all_excluded = false;
                                                    break;
                                                }
                                                // If this is the only/last column, then we can break out of the while loop.
                                                // Check if this string has no trailing comma, and if not, peek to see if the next token
                                                // contains a leading comma.
                                                if !col_str.ends_with(",") {
                                                    match peekable.peek() {
                                                        Some(x) if x.starts_with(",") => continue,
                                                        _ => break,
                                                    }
                                                }
                                            }
                                        };
                                    }
                                    all_excluded
                                }
                                // No target token after "alter" or "drop"
                                None => false,
                                // Other targets are considered compatible