किसी टेबल/टेबल पर विदेशी कुंजियों की दोबारा जांच करने के लिए InnoDB को बाध्य करें?

DELIMITER $$

DROP PROCEDURE IF EXISTS ANALYZE_INVALID_FOREIGN_KEYS$$

CREATE
    PROCEDURE `ANALYZE_INVALID_FOREIGN_KEYS`(
        checked_database_name VARCHAR(64), 
        checked_table_name VARCHAR(64), 
        temporary_result_table ENUM('Y', 'N'))

    LANGUAGE SQL
    NOT DETERMINISTIC
    READS SQL DATA

    BEGIN
        DECLARE TABLE_SCHEMA_VAR VARCHAR(64);
        DECLARE TABLE_NAME_VAR VARCHAR(64);
        DECLARE COLUMN_NAME_VAR VARCHAR(64); 
        DECLARE CONSTRAINT_NAME_VAR VARCHAR(64);
        DECLARE REFERENCED_TABLE_SCHEMA_VAR VARCHAR(64);
        DECLARE REFERENCED_TABLE_NAME_VAR VARCHAR(64);
        DECLARE REFERENCED_COLUMN_NAME_VAR VARCHAR(64);
        DECLARE KEYS_SQL_VAR VARCHAR(1024);

        DECLARE done INT DEFAULT 0;

        DECLARE foreign_key_cursor CURSOR FOR
            SELECT
                `TABLE_SCHEMA`,
                `TABLE_NAME`,
                `COLUMN_NAME`,
                `CONSTRAINT_NAME`,
                `REFERENCED_TABLE_SCHEMA`,
                `REFERENCED_TABLE_NAME`,
                `REFERENCED_COLUMN_NAME`
            FROM 
                information_schema.KEY_COLUMN_USAGE 
            WHERE 
                `CONSTRAINT_SCHEMA` LIKE checked_database_name AND
                `TABLE_NAME` LIKE checked_table_name AND
                `REFERENCED_TABLE_SCHEMA` IS NOT NULL;

        DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = 1;

        IF temporary_result_table = 'N' THEN
            DROP TEMPORARY TABLE IF EXISTS INVALID_FOREIGN_KEYS;
            DROP TABLE IF EXISTS INVALID_FOREIGN_KEYS;

            CREATE TABLE INVALID_FOREIGN_KEYS(
                `TABLE_SCHEMA` VARCHAR(64), 
                `TABLE_NAME` VARCHAR(64), 
                `COLUMN_NAME` VARCHAR(64), 
                `CONSTRAINT_NAME` VARCHAR(64),
                `REFERENCED_TABLE_SCHEMA` VARCHAR(64),
                `REFERENCED_TABLE_NAME` VARCHAR(64),
                `REFERENCED_COLUMN_NAME` VARCHAR(64),
                `INVALID_KEY_COUNT` INT,
                `INVALID_KEY_SQL` VARCHAR(1024)
            );
        ELSEIF temporary_result_table = 'Y' THEN
            DROP TEMPORARY TABLE IF EXISTS INVALID_FOREIGN_KEYS;
            DROP TABLE IF EXISTS INVALID_FOREIGN_KEYS;

            CREATE TEMPORARY TABLE INVALID_FOREIGN_KEYS(
                `TABLE_SCHEMA` VARCHAR(64), 
                `TABLE_NAME` VARCHAR(64), 
                `COLUMN_NAME` VARCHAR(64), 
                `CONSTRAINT_NAME` VARCHAR(64),
                `REFERENCED_TABLE_SCHEMA` VARCHAR(64),
                `REFERENCED_TABLE_NAME` VARCHAR(64),
                `REFERENCED_COLUMN_NAME` VARCHAR(64),
                `INVALID_KEY_COUNT` INT,
                `INVALID_KEY_SQL` VARCHAR(1024)
            );
        END IF;


        OPEN foreign_key_cursor;
        foreign_key_cursor_loop: LOOP
            FETCH foreign_key_cursor INTO 
            TABLE_SCHEMA_VAR, 
            TABLE_NAME_VAR, 
            COLUMN_NAME_VAR, 
            CONSTRAINT_NAME_VAR, 
            REFERENCED_TABLE_SCHEMA_VAR, 
            REFERENCED_TABLE_NAME_VAR, 
            REFERENCED_COLUMN_NAME_VAR;
            IF done THEN
                LEAVE foreign_key_cursor_loop;
            END IF;


            SET @from_part = CONCAT('FROM ', '`', TABLE_SCHEMA_VAR, '`.`', TABLE_NAME_VAR, '`', ' AS REFERRING ', 
                 'LEFT JOIN `', REFERENCED_TABLE_SCHEMA_VAR, '`.`', REFERENCED_TABLE_NAME_VAR, '`', ' AS REFERRED ', 
                 'ON (REFERRING', '.`', COLUMN_NAME_VAR, '`', ' = ', 'REFERRED', '.`', REFERENCED_COLUMN_NAME_VAR, '`', ') ', 
                 'WHERE REFERRING', '.`', COLUMN_NAME_VAR, '`', ' IS NOT NULL ',
                 'AND REFERRED', '.`', REFERENCED_COLUMN_NAME_VAR, '`', ' IS NULL');
            SET @full_query = CONCAT('SELECT COUNT(*) ', @from_part, ' INTO @invalid_key_count;');
            PREPARE stmt FROM @full_query;

            EXECUTE stmt;
            IF @invalid_key_count > 0 THEN
                INSERT INTO 
                    INVALID_FOREIGN_KEYS 
                SET 
                    `TABLE_SCHEMA` = TABLE_SCHEMA_VAR, 
                    `TABLE_NAME` = TABLE_NAME_VAR, 
                    `COLUMN_NAME` = COLUMN_NAME_VAR, 
                    `CONSTRAINT_NAME` = CONSTRAINT_NAME_VAR, 
                    `REFERENCED_TABLE_SCHEMA` = REFERENCED_TABLE_SCHEMA_VAR, 
                    `REFERENCED_TABLE_NAME` = REFERENCED_TABLE_NAME_VAR, 
                    `REFERENCED_COLUMN_NAME` = REFERENCED_COLUMN_NAME_VAR, 
                    `INVALID_KEY_COUNT` = @invalid_key_count,
                    `INVALID_KEY_SQL` = CONCAT('SELECT ', 
                        'REFERRING.', '`', COLUMN_NAME_VAR, '` ', 'AS "Invalid: ', COLUMN_NAME_VAR, '", ', 
                        'REFERRING.* ', 
                        @from_part, ';');
            END IF;
            DEALLOCATE PREPARE stmt; 

        END LOOP foreign_key_cursor_loop;
    END$$

DELIMITER ;

CALL ANALYZE_INVALID_FOREIGN_KEYS('%', '%', 'Y');
DROP PROCEDURE IF EXISTS ANALYZE_INVALID_FOREIGN_KEYS;

SELECT * FROM INVALID_FOREIGN_KEYS;

आप अमान्य विदेशी कुंजियों के लिए सभी डेटाबेस की जांच करने के लिए इस संग्रहीत कार्यविधि का उपयोग कर सकते हैं। परिणाम INVALID_FOREIGN_KEYS में लोड किया जाएगा। तालिका। ANALYZE_INVALID_FOREIGN_KEYS . के पैरामीटर :

1. डेटाबेस नाम पैटर्न (शैली की तरह)
2. तालिका नाम पैटर्न (शैली की तरह)

3. क्या परिणाम अस्थायी होगा। यह हो सकता है:'Y' , 'N' , NULL ।

   • 'Y' . के मामले में ANALYZE_INVALID_FOREIGN_KEYS परिणाम तालिका अस्थायी तालिका होगी। अस्थायी तालिका अन्य सत्रों के लिए दिखाई नहीं देगी। आप एकाधिक ANALYZE_INVALID_FOREIGN_KEYS(...) निष्पादित कर सकते हैं अस्थायी परिणाम तालिका के साथ समानांतर रूप से संग्रहीत प्रक्रिया।
   • लेकिन यदि आप किसी अन्य सत्र के आंशिक परिणाम में रुचि रखते हैं, तो आपको 'N' का उपयोग करना चाहिए , फिर SELECT * FROM INVALID_FOREIGN_KEYS; execute निष्पादित करें दूसरे सत्र से।

   • आपको NULL . का उपयोग करना चाहिए लेन-देन में परिणाम तालिका निर्माण को छोड़ने के लिए, क्योंकि MySQL CREATE TABLE ... के लिए लेनदेन में निहित प्रतिबद्धता को निष्पादित करता है और DROP TABLE ... , इसलिए परिणाम तालिका के निर्माण से लेन-देन में समस्या होगी। इस मामले में आपको BEGIN; COMMIT/ROLLBACK; ब्लॉक करें:

     CREATE TABLE INVALID_FOREIGN_KEYS(
         `TABLE_SCHEMA` VARCHAR(64), 
         `TABLE_NAME` VARCHAR(64), 
         `COLUMN_NAME` VARCHAR(64), 
         `CONSTRAINT_NAME` VARCHAR(64),
         `REFERENCED_TABLE_SCHEMA` VARCHAR(64),
         `REFERENCED_TABLE_NAME` VARCHAR(64),
         `REFERENCED_COLUMN_NAME` VARCHAR(64),
         `INVALID_KEY_COUNT` INT,
         `INVALID_KEY_SQL` VARCHAR(1024)
     );
     

     अंतर्निहित प्रतिबद्धता के बारे में MySQL साइट पर जाएँ:http://dev। mysql.com/doc/refman/5.6/hi/implicit-commit.html

INVALID_FOREIGN_KEYS पंक्तियों में केवल अमान्य डेटाबेस, तालिका, स्तंभ का नाम होगा। लेकिन आप अमान्य रेफ़रिंग पंक्तियों को INVALID_KEY_SQL के मान के निष्पादन के साथ देख सकते हैं INVALID_FOREIGN_KEYS . का कॉलम अगर कोई है।

यदि रेफ़रिंग कॉलम (उर्फ विदेशी इंडेक्स) और रेफ़र किए गए कॉलम (आमतौर पर प्राथमिक कुंजी) पर इंडेक्स हैं, तो यह संग्रहीत कार्यविधि बहुत तेज़ होगी।