-- phpMyAdmin SQL Dump
-- version 4.9.5deb2
-- https://www.phpmyadmin.net/
--
-- Host: localhost:3306
-- Waktu pembuatan: 14 Sep 2022 pada 11.30
-- Versi server: 10.3.34-MariaDB-0ubuntu0.20.04.1
-- Versi PHP: 7.4.3

SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
SET AUTOCOMMIT = 0;
START TRANSACTION;
SET time_zone = "+00:00";


/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8mb4 */;

--
-- Database: `tap`
--

DELIMITER $$
--
-- Prosedur
--
CREATE DEFINER=`root`@`localhost` PROCEDURE `finish` ()  READS SQL DATA
BEGIN
    DECLARE msg TEXT DEFAULT _finish(
        _get('tnumb'),
        _get('plan'),
        num_failed()
    );
    if msg IS NOT NULL AND msg <> '' THEN SELECT msg; END IF;
END$$

CREATE DEFINER=`root`@`localhost` PROCEDURE `no_plan` ()  BEGIN
    DECLARE hide TEXT DEFAULT plan(0);
END$$

CREATE DEFINER=`root`@`localhost` PROCEDURE `todo` (`how_many` INT, `why` TEXT)  BEGIN
    DECLARE hide INTEGER DEFAULT _add('todo', COALESCE(how_many, 1), COALESCE(why, ''));
END$$

CREATE DEFINER=`root`@`localhost` PROCEDURE `todo_end` ()  MODIFIES SQL DATA
    DETERMINISTIC
BEGIN
    DECLARE tid INTEGER DEFAULT _get_latest_with_value( 'todo', -1 );
    DECLARE trash TEXT;
    IF tid IS NULL THEN
        CALL _cleanup();
        SELECT  `todo_end() called without todo_start()` INTO trash;
    END IF;
    DELETE FROM __tcache__ WHERE id = tid;
END$$

CREATE DEFINER=`root`@`localhost` PROCEDURE `todo_start` (`why` TEXT)  BEGIN
    DECLARE hide INTEGER DEFAULT _add('todo', -1, COALESCE(why, ''));
END$$

CREATE DEFINER=`root`@`localhost` PROCEDURE `_cleanup` ()  MODIFIES SQL DATA
    DETERMINISTIC
BEGIN
    DELETE FROM __tcache__   WHERE cid = connection_id();
    DELETE FROM __tresults__ WHERE cid = connection_id();
end$$

CREATE DEFINER=`root`@`localhost` PROCEDURE `_idset` (`vid` INTEGER, `vvalue` INTEGER)  MODIFIES SQL DATA
    DETERMINISTIC
BEGIN
    UPDATE __tcache__
       SET value = vvalue
     WHERE id = vid;
END$$

CREATE DEFINER=`root`@`localhost` PROCEDURE `_populate_have` (IN `have` TEXT)  MODIFIES SQL DATA
    DETERMINISTIC
    COMMENT 'Create a temp table and populate with comma-separated data'
BEGIN
  DECLARE sep       CHAR(1) DEFAULT ',';
  DECLARE seplength INTEGER DEFAULT CHAR_LENGTH(sep);

  SET have = _fixCSL(have);

  DROP TEMPORARY TABLE IF EXISTS `have`;
  CREATE TEMPORARY TABLE `tap`.`have` (ident VARCHAR(64) PRIMARY KEY)
    ENGINE MEMORY CHARSET utf8 COLLATE utf8_general_ci;

  WHILE have != '' > 0 DO
    SET @val = TRIM(SUBSTRING_INDEX(have, sep, 1));
    SET @val = uqi(@val);
    IF  @val <> '' THEN
      INSERT IGNORE INTO `have` VALUE(@val);
    END IF;
    SET have = SUBSTRING(have, CHAR_LENGTH(@val) + seplength + 1);
  END WHILE;
END$$

CREATE DEFINER=`root`@`localhost` PROCEDURE `_populate_want` (IN `want` TEXT)  MODIFIES SQL DATA
    DETERMINISTIC
    COMMENT 'Create a temp table and populate with comma-separated data'
BEGIN
  DECLARE sep       CHAR(1) DEFAULT ',';
  DECLARE seplength INTEGER DEFAULT CHAR_LENGTH(sep);

  SET want = _fixCSL(want);

  DROP TEMPORARY TABLE IF EXISTS `want`;
  CREATE TEMPORARY TABLE `tap`.`want` (ident VARCHAR(64) PRIMARY KEY)
    ENGINE MEMORY CHARSET utf8 COLLATE utf8_general_ci;

  WHILE want != '' > 0 DO
    SET @val = TRIM(SUBSTRING_INDEX(want, sep, 1));
    SET @val = uqi(@val);
    IF  @val <> '' THEN
      INSERT IGNORE INTO `want` VALUE(@val);
    END IF;
    SET want = SUBSTRING(want, CHAR_LENGTH(@val) + seplength + 1);
  END WHILE;
END$$

--
-- Fungsi
--
CREATE DEFINER=`root`@`localhost` FUNCTION `add_result` (`vok` BOOL, `vaok` BOOL, `vdescr` TEXT, `vtype` TEXT, `vreason` TEXT) RETURNS INT(11) MODIFIES SQL DATA
    DETERMINISTIC
BEGIN
    DECLARE tnumb INTEGER DEFAULT _nextnumb();
    INSERT INTO __tresults__ ( numb, cid, ok, aok, descr, type, reason )
    VALUES(tnumb, connection_id(), vok, vaok, coalesce(vdescr, ''), coalesce(vtype, ''), coalesce(vreason, ''));
    RETURN tnumb;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `alike` (`got` TEXT, `pat` TEXT, `descr` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    RETURN _alike( got LIKE pat, got, pat, descr );
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `check_test` (`have` TEXT, `eok` BOOLEAN, `name` TEXT, `edescr` TEXT, `ediag` TEXT, `matchit` BOOLEAN) RETURNS TEXT CHARSET utf8mb4 MODIFIES SQL DATA
    DETERMINISTIC
BEGIN
    DECLARE tnumb   INTEGER DEFAULT _get('tnumb');
    DECLARE hok     BOOLEAN;
    DECLARE hdescr  TEXT;
    DECLARE ddescr  TEXT;
    DECLARE hdiag   TEXT;
    DECLARE tap     TEXT;
    DECLARE myok    BOOLEAN;

    
    SELECT aok, descr INTO hok ,hdescr
      FROM __tresults__ WHERE numb = tnumb;

    SET myok = CASE WHEN hok = eok THEN 1 ELSE 0 END;

    
    SET ddescr = concat(coalesce( concat(name, ' '), 'Test ' ), 'should ');

    
    UPDATE __tresults__
       SET ok     = myok,
           aok    = myok,
           descr  = concat(ddescr, CASE WHEN eok then 'pass' ELSE 'fail' END),
           type   = '',
           reason = ''
     WHERE numb = tnumb;
    SET tap = _tap(myok, tnumb, concat(ddescr, CASE WHEN eok then 'pass' ELSE 'fail' END), NULL);

    
    IF edescr IS NOT NULL THEN
        SET tap = concat(tap, '\n', eq(
            hdescr,
            edescr,
            concat(ddescr, 'have the proper description')
        ));
    END IF;

    
    IF ediag IS NOT NULL THEN
        
        SET hdiag = substring(
            have
            FROM (CASE WHEN hok THEN 4 ELSE 9 END) + char_length(tnumb)
        );

        
        IF hdescr <> '' THEN
            SET hdiag = substring( hdiag FROM 3 + char_length( diag( hdescr ) ) );
        END IF;

        
        IF NOT hok THEN
           SET hdiag = substring(
               hdiag
               FROM 14 + char_length(tnumb)
                       + CASE hdescr WHEN '' THEN 3 ELSE 3 + char_length( diag( hdescr ) ) END
           );
        END IF;

        
        SET hdiag = replace( substring(hdiag from 3), '\n# ', '\n' );

        
        IF matchit THEN
            SET tap = concat(tap, '\n', matches(
                hdiag,
                ediag,
                concat(ddescr, 'have the proper diagnostics')
            ));
        ELSE
            SET tap = concat(tap, '\n', eq(
                hdiag,
                ediag,
                concat(ddescr, 'have the proper diagnostics')
            ));
        END IF;
    END IF;

    
    RETURN tap;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `columns_are` (`sname` VARCHAR(64), `tname` VARCHAR(64), `want` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
 
  SET @want = want;
  SET @have = (SELECT GROUP_CONCAT('`',column_name,'`')
               FROM `information_schema`.`columns`
	       WHERE `table_schema` = sname
	       AND `table_name` = tname);

  IF description = '' THEN
    SET description = CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
      ' should have the correct Columns');
  END IF;

  IF NOT _has_table(sname,tname) THEN
  RETURN CONCAT(ok(FALSE, description), '\n',
    diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
      ' does not exist')));
  END IF;

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are('columns', @extras, @missing, description);

END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `column_privileges_are` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `gtee` VARCHAR(81), `ptypes` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
 
  SET @gtee = _format_user(gtee);
  SET @want = ptypes;
  SET @have = _column_privileges(sname, tname, cname, @gtee);

  IF description = '' THEN
    SET description = CONCAT('Account ', gtee, ' should have the correct column privileges');
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Column `', tname,'`.`', cname, '` does not exist')));
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are('Column Privileges', @extras, @missing, description);

END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_character_set_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `cset` VARCHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN col_charset_is(sname, tname, cname, cset, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_charset_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `cset` VARCHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
      ' should have Character Set ' , quote_ident(cset));
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN eq(_col_charset(sname, tname, cname), cset, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_collation_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `ccoll` VARCHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Column ', quote_ident(tname), '.',
      quote_ident(cname), ' should have collation ' , quote_ident(ccoll));
  END IF;

  IF NOT _has_column(sname, tname, cname)THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN eq(_col_collation(sname, tname, cname), ccoll, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_column_type_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `ctype` LONGTEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
      ' should have Column Type ', qv(ctype));
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description),'\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN eq(_column_type(sname, tname, cname), ctype, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_data_type_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `dtype` LONGTEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
      ' should have Data Type ', qv(dtype));
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description),'\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN eq(_data_type(sname, tname, cname), dtype, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_default_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `cdefault` LONGTEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
      ' should have Default ', qv(cdefault));
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description),'\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN eq(_col_default(sname, tname, cname), cdefault, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_extra_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `cextra` VARCHAR(30), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' should have Extra ', quote_ident(cextra));
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
       diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
         ' does not exist')));
  END IF;

  RETURN eq(_col_extra_is(sname, tname, cname), cextra, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_hasnt_default` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
   SET description = CONCAT('Column ',
      quote_ident(tname), '.', quote_ident(cname), ' should not have a default');
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description),'\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN ok(NOT _col_has_default(sname, tname, cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_hasnt_index_key` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Column ',
        quote_ident(tname), '.', quote_ident(cname), ' should not have Index Key');
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN ok(NOT _col_has_index_key(sname, tname, cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_hasnt_named_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `kname` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET kname := COALESCE(kname, cname); 
  IF description = '' THEN
    SET description = CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
      ' should not have INDEX Key ', quote_ident(kname));
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN ok(NOT _col_has_named_index(sname, tname, cname, kname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_hasnt_non_unique_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 READS SQL DATA
    DETERMINISTIC
BEGIN
  IF description = '' THEN
    SET description = concat('Column ',
       quote_ident(tname), '.', quote_ident(cname), ' should not have non unique INDEX');
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN ok(NOT _col_has_non_unique_index(sname, tname, cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_hasnt_pos_in_named_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `kname` VARCHAR(64), `pos` INT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET kname := COALESCE(kname, cname); 

  IF description = '' THEN
    SET description = CONCAT('Column ',
      quote_ident(tname), '.', quote_ident(cname), ' should not have position ',
        pos, ' in INDEX ', quote_ident(kname));
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN ok(NOT _col_has_pos_in_named_index(sname, tname, cname, kname, pos), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_hasnt_primary_key` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Column ',
      quote_ident(tname), '.', quote_ident(cname), ' should not be a Primary Key (or part thereof)');
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN ok(NOT _col_has_primary_key(sname, tname, cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_hasnt_unique_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 READS SQL DATA
    DETERMINISTIC
BEGIN
  IF description = '' THEN
    SET description = concat('Column ',
      quote_ident(tname), '.', quote_ident(cname), ' should not have unique INDEX');
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN ok(NOT _col_has_unique_index(sname, tname, cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_has_default` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Column ',
      quote_ident(tname), '.', quote_ident(cname), ' should have a default');
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description),'\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN ok(_col_has_default(sname, tname, cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_has_index_key` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Column ',
      quote_ident(tname), '.', quote_ident(cname), ' should have Index Key');
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN ok(_col_has_index_key(sname, tname, cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_has_named_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `kname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 NO SQL
    DETERMINISTIC
BEGIN
  SET kname := COALESCE(kname, cname); 

  IF description = '' THEN
    SET description = concat('Column ', quote_ident(tname), '.', quote_ident(cname),
      ' should have Index Key ', quote_ident(kname));
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
' does not exist')));
  END IF;

  RETURN ok(_col_has_named_index(sname, tname, cname, kname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_has_non_unique_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 READS SQL DATA
    DETERMINISTIC
BEGIN
  IF description = '' THEN
    SET description = concat('Column ',
      quote_ident(tname), '.', quote_ident(cname), ' should have non unique INDEX');
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN ok( _col_has_non_unique_index(sname, tname, cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_has_pos_in_named_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `kname` VARCHAR(64), `pos` INT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET kname := COALESCE(kname, cname); 

  IF description = '' THEN
    SET description = concat('Column ',
      quote_ident(tname), '.', quote_ident(cname), ' should have position ',
        pos, ' in Index ', quote_ident(kname));
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN ok(_col_has_pos_in_named_index(sname, tname, cname, kname, pos), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_has_primary_key` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Column ',
      quote_ident(tname), '.', quote_ident(cname), ' should be a Primary Key (or part thereof)');
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN ok(_col_has_primary_key(sname, tname, cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_has_type` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `ctype` LONGTEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 NO SQL
    DETERMINISTIC
BEGIN
  IF description = '' THEN
    SET description = CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' should have Column Type ', qv(ctype));
    END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN ok(_col_has_type(sname, tname, cname, ctype), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_has_unique_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 READS SQL DATA
    DETERMINISTIC
BEGIN
  IF description = '' THEN
    SET description = concat('Column ',
      quote_ident(tname), '.', quote_ident(cname), ' should have unique INDEX');
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN ok(_col_has_unique_index(sname, tname, cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_is_null` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Column ',
      quote_ident(tname), '.', quote_ident(cname), ' should allow NULL');
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN eq(_col_nullable(sname, tname, cname),'YES', description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_is_pk` (`sname` VARCHAR(64), `tname` VARCHAR(64), `want` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF NOT LOCATE(',', want) AND NOT LOCATE('`', want) THEN
    SET want = CONCAT('`', want, '`'); 
  END IF;

  IF description = '' THEN
    SET description = CONCAT('Primary Key for ', quote_ident(sname), '.', quote_ident(tname),
      ' should exist on ', want);
  END IF;

  IF NOT _has_table( sname, tname ) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
      ' does not exist')));
  END IF;

  RETURN ok(_col_is_pk( sname, tname, want), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_is_unique` (`sname` VARCHAR(64), `tname` VARCHAR(64), `want` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  
  IF NOT LOCATE(',', want) AND NOT LOCATE('`', want) THEN
    SET want = CONCAT('`', want, '`');
  END IF;

  IF description = '' THEN
    SET description = CONCAT('Unique Index for ', quote_ident(sname), '.', quote_ident(tname),
      ' should exist on ', want);
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;
  
  RETURN ok(_col_is_unique( sname, tname, want), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `col_not_null` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Column ',
      quote_ident(tname), '.', quote_ident(cname), ' should be NOT NULL');
  END IF;

  IF NOT _has_column(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Column ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN eq(_col_nullable(sname, tname, cname), 'NO', description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `constraints_are` (`sname` VARCHAR(64), `tname` VARCHAR(64), `want` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET @want = want;
  SET @have = (SELECT GROUP_CONCAT('`', `constraint_name`,'`')
               FROM `information_schema`.`table_constraints`
               WHERE `table_schema` = sname
               AND `table_name` = tname);

  IF description = '' THEN
    SET description = CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
      ' should have the correct Constraints');
  END IF;

  IF NOT _has_table( sname, tname ) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist' )));
  END IF;

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are('constraints', @extras, @missing, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `constraint_type_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `ctype` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Constraint ', quote_ident(tname), '.', quote_ident(cname),
      ' should have Constraint Type ' , qv(ctype));
  END IF;
    
  IF NOT _has_constraint(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Constraint ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN eq(_constraint_type(sname, tname, cname), ctype, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `diag` (`msg` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    RETURN concat('# ', replace(
       replace(
            replace( msg, '\r\n', '\n# ' ),
            '\n',
            '\n# '
        ),
        '\r',
        '\n# '
    ));
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `doesnt_match` (`got` TEXT, `pat` TEXT, `descr` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    RETURN _unalike( got NOT REGEXP pat, got, pat, descr );
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `dqv` (`val` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    IF ISNULL(val) THEN
      RETURN 'NULL';
    END IF;

    
    IF val REGEXP '^[[:digit:]]+$' THEN
      RETURN val;
    END IF;

    RETURN CONCAT('"', REPLACE(val, '''', '\\\''), '"');
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `engine_is_default` (`ename` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
  SET description = CONCAT('Storage Engine ', quote_ident(ename),
    ' should be the default');
  END IF;

  IF NOT _has_engine(ename) THEN
    RETURN CONCAT(ok(FALSE, description),'\n',
      diag (CONCAT('Storage engine ', quote_ident(ename), ' is not available')));
  END IF;

  RETURN eq(_engine_default(), ename, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `eq` (`have` TEXT, `want` TEXT, `descr` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    IF _eq(have, want) THEN RETURN ok(1, descr); END IF;

    
    RETURN concat( ok(0, descr), '\n', diag(concat(
           '        have: ', COALESCE(have, 'NULL'),
         '\n        want: ', COALESCE(want, 'NULL')
    )));
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `events_are` (`sname` VARCHAR(64), `want` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET @want = want;
  SET @have = (SELECT GROUP_CONCAT('`',`event_name`,'`')
               FROM `information_schema`.`events`
               WHERE `event_schema` = sname);

  IF description = '' THEN
    SET description = CONCAT('Schema ', quote_ident(sname), ' should have the correct Events');
  END IF;

  IF NOT _has_schema(sname) THEN
    RETURN CONCAT( ok(FALSE, description), '\n',
      diag(CONCAT('Schema ', quote_ident(sname), ' does not exist' )));
  END IF;

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are('events', @extras, @missing, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `event_interval_field_is` (`sname` VARCHAR(64), `ename` VARCHAR(64), `ifield` VARCHAR(18), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  DECLARE valid ENUM('YEAR','QUARTER','MONTH','DAY','HOUR','MINUTE ',
              'WEEK','SECOND','YEAR_MONTH','DAY_HOUR','DAY_MINUTE',
	      'DAY_SECOND','HOUR_MINUTE','HOUR_SECOND','MINUTE_SECOND');
  
  DECLARE CONTINUE HANDLER FOR 1265
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag('Event Interval must be { YEAR | QUARTER | MONTH | DAY | HOUR | MINUTE |
              WEEK | SECOND | YEAR_MONTH | DAY_HOUR | DAY_MINUTE |
              DAY_SECOND | HOUR_MINUTE | HOUR_SECOND | MINUTE_SECOND }'));
  
  IF description = '' THEN
    SET description = CONCAT('Event ', quote_ident(sname), '.', quote_ident(ename),
      ' should have Interval Field ', qv(ifield));
  END IF;

  SET valid = ifield;

  IF NOT _has_event(sname,ename) THEN
    RETURN CONCAT(ok(FALSE, description), '\n', 
      diag(CONCAT('Event ', quote_ident(sname), '.', quote_ident(ename),
        ' does not exist')));
    END IF;

    RETURN eq(_event_interval_field(sname, ename), ifield, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `event_interval_value_is` (`sname` VARCHAR(64), `ename` VARCHAR(64), `ivalue` VARCHAR(256), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Event ', quote_ident(sname), '.', quote_ident(ename),
      ' should have Interval Value ', qv(ivalue));
  END IF;

  IF NOT _has_event(sname,ename) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Event ', quote_ident(sname), '.', quote_ident(ename),
        ' does not exist')));
  END IF;

  RETURN eq(_event_interval_value(sname, ename), ivalue, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `event_status_is` (`sname` VARCHAR(64), `ename` VARCHAR(64), `stat` VARCHAR(18), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  DECLARE valid ENUM('ENABLED','DISABLED','SLAVESIDE DISABLED');
  
  DECLARE CONTINUE HANDLER FOR 1265
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag('Event Status must be { ENABLED | DISABLED | SLAVESIDE DISABLED }'));

  IF description = '' THEN
    SET description = CONCAT('Event ', quote_ident(sname), '.', quote_ident(ename),
      ' should have Status ', qv(stat));
  END IF;

  SET valid = stat;

  IF NOT _has_event(sname,ename) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Event ', quote_ident(sname), '.', quote_ident(ename),
        ' does not exist')));
  END IF;

  RETURN eq(_event_status(sname, ename), stat, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `event_type_is` (`sname` VARCHAR(64), `ename` VARCHAR(64), `etype` VARCHAR(9), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  DECLARE valid ENUM('ONE TIME','RECURRING');
  
  DECLARE CONTINUE HANDLER FOR 1265
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag('Event Type must be { ONE TIME | RECURRING }'));
  
  IF description = '' THEN
    SET description = CONCAT('Event ', quote_ident(sname), '.', quote_ident(ename),
      ' should have Event Type ', qv(etype));
  END IF;

  SET valid = etype;

  IF NOT _has_event(sname,ename) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Event ', quote_ident(sname), '.', quote_ident(ename),
        ' does not exist')));
  END IF;

  RETURN eq(_event_type(sname, ename), etype, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `fail` (`descr` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    RETURN ok(0, descr);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `fk_ok` (`csch` VARCHAR(64), `ctab` VARCHAR(64), `ccol` TEXT, `usch` VARCHAR(64), `utab` VARCHAR(64), `ucol` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN

  IF NOT LOCATE(',', ccol) AND NOT LOCATE('`', ccol) THEN
    SET ccol = CONCAT('`', ccol, '`');
  END IF;

  IF NOT LOCATE(',', ucol) AND NOT LOCATE('`', ucol) THEN
    SET ucol = CONCAT('`', ucol, '`');
  END IF;

  IF description = '' THEN
    SET description = CONCAT('Constraint Foreign Key ', quote_ident(ctab), '(', ccol,
      ') should reference ' , quote_ident(utab), '(', ucol, ')');
  END IF;

  IF NOT _has_table(csch, ctab) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(csch), '.', quote_ident(ctab),
        ' does not exist')));
  END IF;

  IF NOT _has_table(usch, utab) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(usch), '.', quote_ident(utab),
        ' does not exist')));
  END IF;

  RETURN ok(_fk_ok(csch, ctab, ccol, usch, utab, ucol), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `fk_on_delete` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `rule` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Constraint ', quote_ident(tname), '.', quote_ident(cname),
      ' should have rule ON DELETE ', qv(rule));
  END IF;

  IF NOT _has_constraint(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Constraint ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN eq(_fk_on_delete(sname, tname, cname), rule, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `fk_on_update` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `rule` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Constraint ', quote_ident(tname), '.', quote_ident(cname),
      ' should have rule ON UPDATE ' , qv(rule));
  END IF;

  IF NOT _has_constraint(sname, tname, cname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Constraint ', quote_ident(tname), '.', quote_ident(cname),
        ' does not exist')));
  END IF;

  RETURN eq(_fk_on_update(sname, tname, cname), rule, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `function_data_type_is` (`sname` VARCHAR(64), `rname` VARCHAR(64), `dtype` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Function ', quote_ident(sname), '.', quote_ident(rname),
      ' should return ', quote_ident(_datatype(dtype)));
  END IF;

  IF NOT _has_routine(sname, rname, 'FUNCTION') THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Function ', quote_ident(sname),'.', quote_ident(rname),
        ' does not exist')));
  END IF;

  RETURN eq(_function_data_type(sname, rname), _datatype(dtype), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `function_is_deterministic` (`sname` VARCHAR(64), `rname` VARCHAR(64), `val` VARCHAR(3), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN routine_is_deterministic(sname, rname, 'Function', val, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `function_security_type_is` (`sname` VARCHAR(64), `rname` VARCHAR(64), `stype` VARCHAR(7), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN routine_security_type_is(sname, rname, 'Function', stype, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `function_sql_data_access_is` (`sname` VARCHAR(64), `rname` VARCHAR(64), `sda` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN routine_sql_data_access_is(sname, rname, 'Function', sda, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `global_is` (`var` VARCHAR(64), `want` VARCHAR(1024), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('@@GLOBAL.' , var, ' should be correctly set');
  END IF;

  IF NOT tap.mysql_version() >= 507006 THEN
    RETURN CONCAT(ok(FALSE, description),'\n',
      diag (CONCAT('This version of MySQL requires the previous version of this function')));
  END IF;

  RETURN eq(_global_var(var), want, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `global_privileges_are` (`gtee` VARCHAR(81), `ptypes` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
 
  SET @gtee = _format_user(gtee);
  SET @want = ptypes;
  SET @have = _global_privileges(@gtee);

  IF description = '' THEN
    SET description = CONCAT('Account ', gtee, ' should have the correct global privileges');
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are('Global Privileges', @extras, @missing, description);

END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_character_set` (`cname` VARCHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN hasnt_charset(cname, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_charset` (`cname` VARCHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Character Set ', quote_ident(cname), ' should not be available' );
  END IF;

  RETURN ok(NOT _has_charset(cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_collation` (`cname` VARCHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Collation ', quote_ident(cname), ' should not be available');
  END IF;

  RETURN ok(NOT _has_collation(cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_column` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Column ',
      quote_ident(tname), '.', quote_ident(cname), ' should not exist');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

RETURN ok(NOT _has_column(sname, tname, cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_column_privilege` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `gtee` VARCHAR(81), `ptype` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  
  SET @gtee = _format_user(gtee);

  IF description = '' THEN
    SET description = concat('Account ', gtee,
       ' should not have column privilege ''', ptype, '''');
  END IF;

  IF NOT _has_column(sname,tname,cname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Column `', tname, '`.`', cname, '` does not exist')));
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  IF NOT _column_privs(ptype) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Privilege ''', ptype, ''' is not a valid column privilege type')));
  END IF;

  RETURN ok(NOT _has_column_priv(sname, tname, cname, @gtee, ptype), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_constraint` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Constraint ', quote_ident(tname),'.',quote_ident(cname),
      ' should not exist');
  END IF;

  IF NOT _has_table( sname, tname ) THEN
    RETURN CONCAT( ok( FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

  RETURN ok(NOT _has_constraint(sname, tname, cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_event` (`sname` VARCHAR(64), `ename` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Event ', quote_ident(sname), '.', quote_ident(ename),
      ' should not exist');
  END IF;

  IF NOT _has_schema(sname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Schema ', quote_ident(sname), ' does not exist')));
    END IF;

  RETURN ok(NOT _has_event(sname, ename), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_fk` (`sname` VARCHAR(64), `tname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
      ' should not have a Foreign Key');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

  RETURN ok(NOT _has_constraint_type(sname, tname, 'FOREIGN KEY'), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_function` (`sname` VARCHAR(64), `rname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN hasnt_routine(sname, rname, 'Function', description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_global_privilege` (`gtee` VARCHAR(81), `ptype` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  
  SET @gtee = _format_user(gtee);

  IF description = '' THEN
    SET description = concat('Account ', gtee, ' should not have global privilege ''', ptype, '''');
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  IF NOT _global_privs(ptype) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Privilege ''', ptype, ''' is not a valid global privilege type')));
  END IF;

  RETURN ok(NOT _has_global_priv(@gtee, ptype), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `iname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Index ', quote_ident(tname), '.', quote_ident(iname),
      ' should not exist');
  END IF;
    
  IF NOT _has_table( sname, tname ) THEN
    RETURN CONCAT( ok( FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

  RETURN ok(NOT _has_index(sname, tname, iname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_partition` (`sname` VARCHAR(64), `tname` VARCHAR(64), `part` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Partition ', quote_ident(tname), '.', quote_ident(part),
      ' should not exist');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
    END IF;

    RETURN ok(NOT _has_partition(sname, tname, part), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_pk` (`sname` VARCHAR(64), `tname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
      ' should not have a Primary Key');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;
  
  RETURN ok(NOT _has_constraint(sname, tname, 'PRIMARY'), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_privilege` (`gtee` VARCHAR(81), `ptype` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  
  SET @gtee = _format_user(gtee);

  IF description = '' THEN
    SET description = concat('Account ', gtee, ' should not have privilege ''', ptype, '''');
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  RETURN ok(NOT _has_priv(@gtee, ptype), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_procedure` (`sname` VARCHAR(64), `rname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN hasnt_routine(sname, rname, 'Procedure', description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_role` (`rname` CHAR(97), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET @rname = _format_user(rname);

  IF description = '' THEN
    SET description = CONCAT('Role ', rname, ' should not be active');
  END IF;

  
  RETURN ok(NOT _has_role(@rname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_routine` (`sname` VARCHAR(64), `rname` VARCHAR(64), `rtype` VARCHAR(9), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT(rtype ,' ',
      quote_ident(sname), '.', quote_ident(rname), ' should not exist');
  END IF;

  RETURN ok(NOT _has_routine(sname, rname, rtype), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_schema` (`sname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Schema ', quote_ident(sname), ' should not exist');
  END IF;

  RETURN ok(NOT _has_schema(sname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_schema_privilege` (`sname` VARCHAR(64), `gtee` VARCHAR(81), `ptype` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  
  SET @gtee = _format_user(gtee);

  IF description = '' THEN
    SET description = concat('Account ', gtee, ' should not have schema privilege ''', ptype, '''');
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  IF NOT _has_schema(sname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Schema ', sname, ' does not exist')));
  END IF;

  IF NOT _schema_privs(ptype) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Privilege ''', ptype, ''' is not a valid schema privilege type')));
  END IF;

  RETURN ok(NOT _has_schema_priv(sname, @gtee, ptype), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_subpartition` (`sname` VARCHAR(64), `tname` VARCHAR(64), `subp` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Subpartition ', quote_ident(tname),
       '.', quote_ident(subp), ' should not exist');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
    END IF;

  RETURN ok(NOT _has_subpartition(sname, tname, subp), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_table` (`sname` VARCHAR(64), `tname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Table ',
      quote_ident(sname), '.', quote_ident(tname), ' should not exist');
  END IF;

  RETURN ok(NOT _has_table(sname, tname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_table_privilege` (`sname` VARCHAR(64), `tname` VARCHAR(64), `gtee` VARCHAR(81), `ptype` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  
  SET @gtee = _format_user(gtee);

  IF description = '' THEN
    SET description = concat('Account ', gtee, ' should not have table privilege ''', ptype, '''');
  END IF;

  IF NOT _has_table(sname,tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table `', sname, '`.`', tname, '` does not exist')));
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  IF NOT _table_privs(ptype) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Privilege ''', ptype, ''' is not a valid table privilege type')));
  END IF;

  RETURN ok(NOT _has_table_priv(sname, tname, @gtee, ptype), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_timezones` (`description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Table `mysql`.`time_zone_data` should be empty');
  END IF;

  RETURN ok(NOT _has_timezones(), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_trigger` (`sname` VARCHAR(64), `tname` VARCHAR(64), `trgr` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Trigger ', quote_ident(tname), '.', quote_ident(trgr),
      ' should not exist');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
    END IF;

    RETURN ok(NOT _has_trigger(sname, tname, trgr), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_user` (`hname` CHAR(60), `uname` CHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('User \'', uname, '\'@\'', hname, '\' should not exist');
  END IF;

  RETURN ok(NOT _has_user(hname, uname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_user_at_host` (`uname` CHAR(97), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN

  SET @uname = _format_user(uname);

  IF description = '' THEN
    SET description = CONCAT('User ', uname, ' should not exist');
  END IF;

  RETURN ok(NOT _has_user_at_host(@uname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `hasnt_view` (`sname` VARCHAR(64), `vname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('View ',
      quote_ident(sname), '.', quote_ident(vname), ' should not exist' );
  END IF;

  RETURN ok(NOT _has_view(sname, vname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_character_set` (`cname` VARCHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN has_charset(cname, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_charset` (`cname` VARCHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Character Set ', quote_ident(cname), ' should be available');
  END IF;

  RETURN ok(_has_charset(cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_collation` (`cname` VARCHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Collation ', quote_ident(cname), ' should be available');
  END IF; 

  RETURN ok(_has_collation(cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_column` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Column ',
      quote_ident(tname), '.', quote_ident(cname), ' should exist');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

  RETURN ok(_has_column(sname, tname, cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_column_privilege` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `gtee` VARCHAR(81), `ptype` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  
  SET @gtee = _format_user(gtee);

  IF description = '' THEN
    SET description = concat('Account ', gtee, ' should have column privilege ''', ptype, '''');
  END IF;

  IF NOT _has_column(sname,tname,cname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Column `', tname, '`.`', cname, '` does not exist')));
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  IF NOT _column_privs(ptype) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Privilege ''', ptype, ''' is not a valid column privilege type')));
  END IF;

  RETURN ok(_has_column_priv(sname, tname, cname, @gtee, ptype), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_constraint` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Constraint ', quote_ident(tname), '.', quote_ident(cname),
      ' should exist');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

  RETURN ok(_has_constraint(sname, tname, cname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_engine` (`ename` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Storage Engine ', quote_ident(ename), ' should be available');
  END IF;

  RETURN ok(_has_engine(ename), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_event` (`sname` VARCHAR(64), `ename` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Event ', quote_ident(sname), '.', quote_ident(ename),
      ' should exist');
  END IF;

  IF NOT _has_schema(sname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Schema ', quote_ident(sname), ' does not exist')));
    END IF;

    RETURN ok(_has_event(sname, ename), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_fk` (`sname` VARCHAR(64), `tname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
      ' should have a Foreign Key');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

  RETURN ok(_has_constraint_type(sname, tname, 'FOREIGN KEY'), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_function` (`sname` VARCHAR(64), `rname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN has_routine(sname, rname, 'Function', description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_global_privilege` (`gtee` VARCHAR(81), `ptype` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  
  SET @gtee = _format_user(gtee);

  IF description = '' THEN
    SET description = concat('Account ', gtee, ' should have global privilege ''', ptype, '''');
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  IF NOT _global_privs(ptype) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Privilege ''', ptype, ''' is not a valid global privilege type')));
  END IF;

  RETURN ok(_has_global_priv(@gtee, ptype), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `iname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Index ', quote_ident(tname), '.', quote_ident(iname),
      ' should exist');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

  RETURN ok(_has_index( sname, tname, iname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_partition` (`sname` VARCHAR(64), `tname` VARCHAR(64), `part` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Partition ', quote_ident(tname), '.', quote_ident(part),
      ' should exist');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

    RETURN ok(_has_partition(sname, tname, part), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_partitioning` (`description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = 'Partitioning should be active';
  END IF;

  IF tap.mysql_version() >= 800011 THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag('Partitioning support is part of specific ENGINE post 8.0.11'));
  END IF;

RETURN ok(_has_partitioning(), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_pk` (`sname` VARCHAR(64), `tname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
      ' should have a Primary Key');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

  RETURN ok(_has_constraint(sname, tname, 'PRIMARY'), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_privilege` (`gtee` VARCHAR(81), `ptype` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  
  SET @gtee = _format_user(gtee);

  IF description = '' THEN
    SET description = CONCAT('Account ', gtee, ' should have privilege ''', ptype, '''');
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description),'\n',
      diag (CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  RETURN ok(_has_priv(@gtee, ptype), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_procedure` (`sname` VARCHAR(64), `rname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN has_routine(sname, rname, 'Procedure', description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_role` (`rname` CHAR(97), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET @rname = _format_user(rname);

  IF description = '' THEN
    SET description = CONCAT('Role ', rname, ' should be active');
  END IF;

  IF NOT _has_user_at_host(@rname) THEN
    RETURN CONCAT(ok(FALSE, description),'\n',
      diag (CONCAT('Role ', rname, ' is not defined')));
  END IF;

  RETURN ok(_has_role(@rname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_routine` (`sname` VARCHAR(64), `rname` VARCHAR(64), `rtype` VARCHAR(9), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT(rtype ,' ',
      quote_ident(sname), '.', quote_ident(rname), ' should exist');
  END IF;

  RETURN ok(_has_routine(sname, rname, rtype), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_schema` (`sname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Schema ', quote_ident(sname), ' should exist');
  END IF;

  RETURN ok(_has_schema(sname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_schema_privilege` (`sname` VARCHAR(64), `gtee` VARCHAR(81), `ptype` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  
  SET @gtee = _format_user(gtee);

  IF description = '' THEN
    SET description = concat('Account ', gtee, ' should have schema privilege ''', ptype, '''');
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  IF NOT _has_schema(sname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Schema ', sname, ' does not exist')));
  END IF;

  IF NOT _schema_privs(ptype) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Privilege ''', ptype, ''' is not a valid schema privilege type')));
  END IF;

  RETURN ok(_has_schema_priv(sname, @gtee, ptype), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_security_definer` (`sname` VARCHAR(64), `vname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('View ',
      quote_ident(sname), '.', quote_ident(vname), ' should have security DEFINER');
  END IF;

  IF NOT _has_view(sname, vname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('View ', quote_ident(sname), '.', quote_ident(vname),
        ' does not exist')));
  END IF;

  RETURN ok(_has_security(sname, vname, 'DEFINER'), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_security_invoker` (`sname` VARCHAR(64), `vname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('View ',
      quote_ident(sname), '.', quote_ident(vname), ' should have security INVOKER');
  END IF;

  IF NOT _has_view(sname, vname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('View ', quote_ident(sname), '.', quote_ident(vname),
        ' does not exist')));
  END IF;
  
  RETURN ok(_has_security(sname, vname, 'INVOKER'), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_subpartition` (`sname` VARCHAR(64), `tname` VARCHAR(64), `subp` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Subpartition ', quote_ident(tname),
      '.' , quote_ident(subp), ' should exist');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

  RETURN ok(_has_subpartition(sname, tname, subp), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_table` (`sname` VARCHAR(64), `tname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Table ',
      quote_ident(sname), '.', quote_ident(tname), ' should exist');
  END IF;

  RETURN ok(_has_table(sname, tname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_table_privilege` (`sname` VARCHAR(64), `tname` VARCHAR(64), `gtee` VARCHAR(81), `ptype` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  
  SET @gtee = _format_user(gtee);

  IF description = '' THEN
    SET description = concat('Account ', gtee, ' should have table privilege ''', ptype, '''');
  END IF;

  IF NOT _has_table(sname,tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table `', sname, '`.`', tname, '` does not exist')));
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  IF NOT _table_privs(ptype) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Privilege ''', ptype, ''' is not a valid table privilege type')));
  END IF;

  RETURN ok(_has_table_priv(sname, tname, @gtee, ptype), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_timezones` (`description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Table `mysql`.`time_zone_data` should be populated');
  END IF; 

  RETURN ok(_has_timezones(), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_trigger` (`sname` VARCHAR(64), `tname` VARCHAR(64), `trgr` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Trigger ', quote_ident(tname), '.', quote_ident(trgr),
      ' should exist');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

    RETURN ok(_has_trigger(sname, tname, trgr), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_unique` (`sname` VARCHAR(64), `tname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN 
    SET description = CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
      ' should have a Unique Index');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

  RETURN ok(_has_unique(sname, tname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_user` (`hname` CHAR(60), `uname` CHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('User \'', uname, '\'@\'', quote_ident(hname), '\' should exist');
  END IF;

  RETURN ok(_has_user (hname, uname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_user_at_host` (`uname` CHAR(97), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN

  SET @uname = _format_user(uname);

  IF description = '' THEN
    SET description = CONCAT('User ', uname, ' should exist');
  END IF;

  RETURN ok(_has_user_at_host(@uname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `has_view` (`sname` VARCHAR(64), `vname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('View ',
      quote_ident(sname), '.', quote_ident(vname), ' should exist');
  END IF;

  RETURN ok(_has_view(sname, vname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `indexes_are` (`sname` VARCHAR(64), `tname` VARCHAR(64), `want` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET @want = want;
  SET @have = (SELECT GROUP_CONCAT('`', s.`index_name`,'`')
               FROM `information_schema`.`statistics` s
               LEFT JOIN `information_schema`.`table_constraints` c
               ON (s.`table_schema` = c.`table_schema`
                   AND s.`table_name` = c.`table_name` 
                   AND s.`index_name` = c.`constraint_name`)
               WHERE s.`table_schema` = sname
               AND s.`table_name` = tname
               AND c.`constraint_name` IS NULL);

  IF description = '' THEN
    SET description = CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
      ' should have the correct indexes');
  END IF;
    
  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n', 
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist' )));
  END IF;

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are('indexes', @extras, @missing, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `index_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `iname` VARCHAR(64), `want` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Index ', quote_ident(tname), '.', quote_ident(iname),
      ' should exist on ' , want);
  END IF;

  IF NOT _has_index(sname, tname, iname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Index ', quote_ident(tname), '.', quote_ident(iname),
        ' does not exist' )));
  END IF;

  RETURN eq(_index_def(sname, tname, iname), want, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `index_is_type` (`sname` VARCHAR(64), `tname` VARCHAR(64), `iname` VARCHAR(64), `itype` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
     SET description = CONCAT('Index ', quote_ident(tname), '.', quote_ident(iname),
      ' should be of Type ', qv(itype));
  END IF;

  IF NOT _has_table( sname, tname ) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        'does not exist' )));
  END IF;


  
  IF NOT _has_index( sname, tname, iname ) THEN
    RETURN CONCAT(ok(FALSE,description),'\n',
      diag(CONCAT('Index ', quote_ident(tname), '.', quote_ident(iname), 
        ' does not exist')));
  END IF;

  RETURN eq(_index_type( sname, tname, iname), itype, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `in_todo` () RETURNS TINYINT(1) READS SQL DATA
BEGIN
    RETURN CASE WHEN _get('todo') IS NULL THEN 0 ELSE 1 END;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `is_indexed` (`sname` VARCHAR(64), `tname` VARCHAR(64), `want` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN 
    SET description = CONCAT('Index for ', quote_ident(sname), '.', quote_ident(tname),
      ' should exist on ' , want);
  END IF;

  IF NOT _has_table( sname, tname ) THEN
    RETURN CONCAT(ok( FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist' )));
  END IF;

  RETURN ok(_is_indexed(sname, tname, want), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `is_reserved` (`word` TEXT) RETURNS TINYINT(1) BEGIN
    RETURN UPPER(word) IN (
        'ADD',                    'ALL',                    'ALTER',
        'ANALYZE',                'AND',                    'AS',
        'ASC',                    'ASENSITIVE',             'BEFORE',
        'BETWEEN',                'BIGINT',                 'BINARY',
        'BLOB',                   'BOTH',                   'BY',
        'CALL',                   'CASCADE',                'CASE',
        'CHANGE',                 'CHAR',                   'CHARACTER',
        'CHECK',                  'COLLATE',                'COLUMN',
        'CONDITION',              'CONSTRAINT',             'CONTINUE',
        'CONVERT',                'CREATE',                 'CROSS',
        'CURRENT_DATE',           'CURRENT_TIME',           'CURRENT_TIMESTAMP',
        'CURRENT_USER',           'CURSOR',                 'DATABASE',
        'DATABASES',              'DAY_HOUR',               'DAY_MICROSECOND',
        'DAY_MINUTE',             'DAY_SECOND',             'DEC',
        'DECIMAL',                'DECLARE',                'DEFAULT',
        'DELAYED',                'DELETE',                 'DESC',
        'DESCRIBE',               'DETERMINISTIC',          'DISTINCT',
        'DISTINCTROW',            'DIV',                    'DOUBLE',
        'DROP',                   'DUAL',                   'EACH',
        'ELSE',                   'ELSEIF',                 'ENCLOSED',
        'ESCAPED',                'EXISTS',                 'EXIT',
        'EXPLAIN',                'FALSE',                  'FETCH',
        'FLOAT',                  'FLOAT4',                 'FLOAT8',
        'FOR',                    'FORCE',                  'FOREIGN',
        'FROM',                   'FULLTEXT',               'GRANT',
        'GROUP',                  'HAVING',                 'HIGH_PRIORITY',
        'HOUR_MICROSECOND',       'HOUR_MINUTE',            'HOUR_SECOND',
        'IF',                     'IGNORE',                 'IN',
        'INDEX',                  'INFILE',                 'INNER',
        'INOUT',                  'INSENSITIVE',            'INSERT',
        'INT',                    'INT1',                   'INT2',
        'INT3',                   'INT4',                   'INT8',
        'INTEGER',                'INTERVAL',               'INTO',
        'IS',                     'ITERATE',                'JOIN',
        'KEY',                    'KEYS',                   'KILL',
        'LEADING',                'LEAVE',                  'LEFT',
        'LIKE',                   'LIMIT',                  'LINES',
        'LOAD',                   'LOCALTIME',              'LOCALTIMESTAMP',
        'LOCK',                   'LONG',                   'LONGBLOB',
        'LONGTEXT',               'LOOP',                   'LOW_PRIORITY',
        'MATCH',                  'MEDIUMBLOB',             'MEDIUMINT',
        'MEDIUMTEXT',             'MIDDLEINT',              'MINUTE_MICROSECOND',
        'MINUTE_SECOND',          'MOD',                    'MODIFIES',
        'NATURAL',                'NOT',                    'NO_WRITE_TO_BINLOG',
        'NULL',                   'NUMERIC',                'ON',
        'OPTIMIZE',               'OPTION',                 'OPTIONALLY',
        'OR',                     'ORDER',                  'OUT',
        'OUTER',                  'OUTFILE',                'PRECISION',
        'PRIMARY',                'PROCEDURE',              'PURGE',
        'RAID0',                  'READ',                   'READS',
        'REAL',                   'REFERENCES',             'REGEXP',
        'RELEASE',                'RENAME',                 'REPEAT',
        'REPLACE',                'REQUIRE',                'RESTRICT',
        'RETURN',                 'REVOKE',                 'RIGHT',
        'RLIKE',                  'SCHEMA',                 'SCHEMAS',
        'SECOND_MICROSECOND',     'SELECT',                 'SENSITIVE',
        'SEPARATOR',              'SET',                    'SHOW',
        'SMALLINT',               'SONAME',                 'SPATIAL',
        'SPECIFIC',               'SQL',                    'SQLEXCEPTION',
        'SQLSTATE',               'SQLWARNING',             'SQL_BIG_RESULT',
        'SQL_CALC_FOUND_ROWS',    'SQL_SMALL_RESULT',       'SSL',
        'STARTING',               'STRAIGHT_JOIN',          'TABLE',
        'TERMINATED',             'THEN',                   'TINYBLOB',
        'TINYINT',                'TINYTEXT',               'TO',
        'TRAILING',               'TRIGGER',                'TRUE',
        'UNDO',                   'UNION',                  'UNIQUE',
        'UNLOCK',                 'UNSIGNED',               'UPDATE',
        'USAGE',                  'USE',                    'USING',
        'UTC_DATE',               'UTC_TIME',               'UTC_TIMESTAMP',
        'VALUES',                 'VARBINARY',              'VARCHAR',
        'VARCHARACTER',           'VARYING',                'WHEN',
        'WHERE',                  'WHILE',                  'WITH',
        'WRITE',                  'X509',                   'XOR',
        'YEAR_MONTH',             'ZEROFILL',
        'ASENSITIVE',             'CALL',                   'CONDITION',
        'CONTINUE',               'CURSOR',                 'DECLARE',
        'DETERMINISTIC',          'EACH',                   'ELSEIF',
        'EXIT',                   'FETCH',                  'INOUT',
        'INSENSITIVE',            'ITERATE',                'LEAVE',
        'LOOP',                   'MODIFIES',               'OUT',
        'READS',                  'RELEASE',                'REPEAT',
        'RETURN',                 'SCHEMA',                 'SCHEMAS',
        'SENSITIVE',              'SPECIFIC',               'SQL',
        'SQLEXCEPTION',           'SQLSTATE',               'SQLWARNING',
        'TRIGGER',                'UNDO',                   'WHILE',
        'ACTION', 'BIT', 'DATE', 'ENUM', 'NO', 'TEXT', 'TIME', 'TIMESTAMP'
    );
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `matches` (`got` TEXT, `pat` TEXT, `descr` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    RETURN _alike( got REGEXP pat, got, pat, descr );
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `mysql_variant` () RETURNS VARCHAR(7) CHARSET utf8mb4 BEGIN
   RETURN (SELECT
           CASE
	     WHEN version() REGEXP 'MariaDB' = 1 THEN 'MariaDB'
	     WHEN version() REGEXP 'Percona' = 1 THEN 'Percona'
	     ELSE 'MySQL'
	   END);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `mysql_version` () RETURNS INT(11) BEGIN
    RETURN (substring_index(version(), '.', 1) * 100000)
         + (substring_index(substring_index(version(), '.', 2), '.', -1) * 1000)
         + CAST(substring_index(substring_index(substring_index(version(), '-', 1),'.', 3), '.', -1) AS UNSIGNED);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `mytap_version` () RETURNS VARCHAR(10) CHARSET utf8mb4 NO SQL
    DETERMINISTIC
BEGIN
    RETURN '1.0';
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `not_eq` (`have` TEXT, `want` TEXT, `descr` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    IF NOT _eq(have, want) THEN RETURN ok(1, descr); END IF;

    
    RETURN concat( ok(0, descr), '\n', diag(concat(
           '        have: ', COALESCE(have, 'NULL'),
         '\n        want: anything else'
    )));
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `num_failed` () RETURNS INT(11) READS SQL DATA
BEGIN
    DECLARE ret integer;
    SELECT COUNT(*) INTO ret
      FROM __tresults__
     WHERE cid = connection_id()
       AND ok  = 0;
    RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `ok` (`aok` BOOLEAN, `descr` TEXT) RETURNS TEXT CHARSET utf8mb4 MODIFIES SQL DATA
    DETERMINISTIC
BEGIN
    DECLARE todo_why TEXT DEFAULT _todo();
    DECLARE ok BOOLEAN;
    DECLARE test_num INTEGER;

    SET ok = CASE
        WHEN aok THEN aok
        WHEN todo_why IS NULL THEN COALESCE(aok, 0)
        ELSE 1
    END;

    SET test_num = add_result(
        ok,
        COALESCE(aok, false),
        descr,
        CASE WHEN todo_why IS NULL THEN '' ELSE 'todo' END,
        COALESCE(todo_why, '')
    );

    RETURN _tap(aok, test_num, descr, todo_why);

END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `partitions_are` (`sname` VARCHAR(64), `tname` VARCHAR(64), `want` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET @want = want;
  SET @have = (SELECT GROUP_CONCAT('`', COALESCE(`subpartition_name`, `partition_name`) ,'`')
               FROM `information_schema`.`partitions`
               WHERE `table_schema` = sname
               AND `table_name` = tname);
	  
  IF description = '' THEN 
     SET description = CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
      ' should have the correct partitions');
  END IF;

  IF NOT _has_table(sname,tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are('partitions', @extras, @missing, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `partition_count_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cnt` SMALLINT, `description` TEXT) RETURNS LONGTEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
      ' should have a Partition Count of ', qv(cnt));
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok( FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname),'.', quote_ident(tname),
        ' does not exist')));
  END IF;

  RETURN eq(_partition_count(sname, tname), cnt, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `partition_expression_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `part` VARCHAR(64), `expr` LONGTEXT, `description` TEXT) RETURNS LONGTEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Partition ', quote_ident(tname), '.', quote_ident(part),
      ' should have Partition Expression ', qv(TRIM(expr)));
  END IF;

  IF NOT _has_partition(sname, tname, part) THEN
    RETURN CONCAT(ok( FALSE, description), '\n',
      diag(CONCAT('Partition ', quote_ident(tname),'.', quote_ident(part),
        ' does not exist')));
  END IF;

  RETURN eq(_partition_expression(sname, tname, part), TRIM(expr), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `partition_method_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `part` VARCHAR(64), `pmeth` VARCHAR(18), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  DECLARE valid ENUM('RANGE', 'LIST', 'HASH', 'LINEAR HASH', 'KEY', 'LINEAR KEY');
  
  DECLARE EXIT HANDLER FOR 1265
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag('Partitioning Method must be { RANGE | LIST | HASH | LINEAR HASH | KEY | LINEAR KEY }'));

  IF description = '' THEN
    SET description = CONCAT('Partition ', quote_ident(tname), '.', quote_ident(part),
      ' should have Partition Method ', qv(pmeth));
  END IF;

  SET valid = pmeth;

  IF NOT _has_partition(sname, tname, part) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Partition ', quote_ident(tname),'.', quote_ident(part),
        ' does not exist')));
  END IF;

  RETURN eq(_partition_method(sname, tname, part), pmeth, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `pass` (`descr` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    RETURN ok(1, descr);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `plan` (`numb` INTEGER) RETURNS TEXT CHARSET utf8mb4 READS SQL DATA
    DETERMINISTIC
BEGIN
    DECLARE trash TEXT;
    IF _get('plan') IS NOT NULL THEN
        CALL _cleanup();
        
        SELECT `You tried to plan twice!` INTO trash;
    END IF;

    RETURN concat('1..', _set('plan', numb, NULL ));
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `procedure_is_deterministic` (`sname` VARCHAR(64), `rname` VARCHAR(64), `val` VARCHAR(3), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN routine_is_deterministic(sname, rname, 'Procedure', val, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `procedure_security_type_is` (`sname` VARCHAR(64), `rname` VARCHAR(64), `stype` VARCHAR(7), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN routine_security_type_is(sname, rname, 'Procedure', stype, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `procedure_sql_data_access_is` (`sname` VARCHAR(64), `rname` VARCHAR(64), `sda` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN routine_sql_data_access_is(sname, rname, 'Procedure', sda, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `qi` (`ident` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN






  IF LEFT(ident,1) = '`' AND RIGHT(ident,1) = '`' THEN
	  RETURN ident;
  END IF;

  IF LEFT(ident,1) = '"' AND RIGHT(ident,1) = '"' THEN
	  RETURN CONCAT('`', TRIM(BOTH '"' FROM ident) ,'`');
  END IF;

  RETURN CONCAT('`', ident, '`');
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `qs` (`val` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    IF ISNULL(val) THEN
      RETURN 'NULL';
    END IF;

    RETURN CONCAT('\'', REPLACE(val, '''', '\\\''), '\'');
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `quote_ident` (`ident` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    IF ISNULL(ident) THEN
      RETURN 'NULL';
    END IF;

    IF ident = '' THEN
      RETURN '\'\'';
    END IF;

    IF LOCATE('ANSI_QUOTES', @@SQL_MODE) > 0 THEN
        IF is_reserved(ident) OR locate('"', ident) > 0 THEN
            RETURN concat('"', replace(ident, '"', '""'), '"');
        END IF;
    ELSE
        IF is_reserved(ident) OR locate('`', ident) > 0 THEN
            RETURN concat('`', replace(ident, '`', '``'), '`');
        END IF;
    END IF;

    RETURN ident;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `qv` (`val` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    IF ISNULL(val) THEN
      RETURN 'NULL';
    END IF;

    
    IF val REGEXP '^[[:digit:]]+$' THEN
      RETURN val;
    END IF;

    RETURN CONCAT('\'', REPLACE(val, '''', '\\\''), '\'');
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `role_isnt_default` (`rname` CHAR(97), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET @rname = _format_user(rname);

  IF description = '' THEN
    SET description = CONCAT('Role ', rname, ' should not be a DEFAULT role');
  END IF;

  
  RETURN ok(NOT _role_is_default(@rname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `role_is_default` (`rname` CHAR(97), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET @rname = _format_user(rname);

  IF description = '' THEN
    SET description = CONCAT('Role ', rname, ' should be a DEFAULT role');
  END IF;

  IF NOT _has_user_at_host(@rname) THEN
    RETURN CONCAT(ok(FALSE, description),'\n',
      diag (CONCAT('Role ', rname, ' is not defined')));
  END IF;

  RETURN ok(_role_is_default(@rname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `routines_are` (`sname` VARCHAR(64), `rtype` VARCHAR(9), `want` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET @want = want;
  SET @have = (SELECT GROUP_CONCAT('`',routine_name,'`')
               FROM `information_schema`.`routines`
	       WHERE `routine_schema` = sname
	       AND `routine_type` = rtype);

  IF description = '' THEN
    SET description = CONCAT('Schema ', quote_ident(sname),
      ' should have the correct ', LOWER(rtype), 's');
  END IF;

  IF NOT _has_schema(sname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Schema ', quote_ident(sname), ' does not exist')));
  END IF;

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are(CONCAT(rtype, 's'), @extras, @missing, description);

END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `routine_has_sql_mode` (`sname` VARCHAR(64), `rname` VARCHAR(64), `rtype` VARCHAR(64), `smode` VARCHAR(8192), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN

  
  
  
  DECLARE valid ENUM('REAL_AS_FLOAT','PIPES_AS_CONCAT','ANSI_QUOTES','IGNORE_SPACE',
      'NOT_USED','ONLY_FULL_GROUP_BY','NO_UNSIGNED_SUBTRACTION','NO_DIR_IN_CREATE',
      'POSTGRESQL','ORACLE','MSSQL','DB2','MAXDB','NO_KEY_OPTIONS','NO_TABLE_OPTIONS',
      'NO_FIELD_OPTIONS','MYSQL323','MYSQL40','ANSI','NO_AUTO_VALUE_ON_ZERO','NO_BACKSLASH_ESCAPES',
      'STRICT_TRANS_TABLES','STRICT_ALL_TABLES','NO_ZERO_IN_DATE','NO_ZERO_DATE','INVALID_DATES',
      'ERROR_FOR_DIVISION_BY_ZERO','TRADITIONAL','NO_AUTO_CREATE_USER','HIGH_NOT_PRECEDENCE',
      'NO_ENGINE_SUBSTITUTION','PAD_CHAR_TO_FULL_LENGTH');

  DECLARE EXIT HANDLER FOR 1265 
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag(CONCAT('SQL Mode ', quote_ident(smode), ' is invalid')));

  IF description = '' THEN
    SET description = CONCAT(UPPER(rtype), ' ', quote_ident(sname), '.', quote_ident(rname),
      ' requires SQL Mode ', quote_ident(smode));
  END IF;

  SET valid = smode;

  IF NOT _has_routine(sname, rname, 'FUNCTION') THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT(UPPER(rtype),' ', quote_ident(sname), '.', quote_ident(rname), ' does not exist')));
  END IF;

  RETURN ok(_routine_has_sql_mode(sname, rname, rtype, smode), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `routine_is_deterministic` (`sname` VARCHAR(64), `rname` VARCHAR(64), `rtype` VARCHAR(9), `val` VARCHAR(3), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT(rtype, ' ', quote_ident(sname), '.', quote_ident(rname),
      ' should have IS_DETERMINISTIC ', quote_ident(val));
  END IF;

  IF val NOT IN('YES','NO') THEN
    RETURN CONCAT(ok(FALSE, description),'\n',
      diag('Is Deterministic must be { YES | NO }'));
  END IF;

  IF NOT _has_routine(sname, rname, rtype) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT(ucf(rtype), ' ', quote_ident(sname), '.', quote_ident(rname),
        ' does not exist')));
  END IF;

  RETURN eq(_routine_is_deterministic(sname, rname, rtype), val, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `routine_privileges_are` (`sname` VARCHAR(64), `rtype` VARCHAR(9), `rname` VARCHAR(64), `gtee` VARCHAR(81), `ptypes` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
 
  SET @gtee = _format_user(gtee);
  SET @want = ptypes;
  SET @have = _routine_privileges(sname, rtype, rname, @gtee);

  IF description = '' THEN
    SET description = CONCAT('Account ', gtee, ' should have the correct routine privileges');
  END IF;

  IF NOT _has_routine(sname, rname, rtype) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT(rtype, ' `', sname, '`.`', rname, '` does not exist')));
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are('Routine Privileges', @extras, @missing, description);

END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `routine_security_type_is` (`sname` VARCHAR(64), `rname` VARCHAR(64), `rtype` VARCHAR(9), `stype` VARCHAR(7), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT(rtype, ' ', quote_ident(sname), '.', quote_ident(rname),
      ' should have Security Type ' , quote_ident(stype));
  END IF;

  IF stype NOT IN('INVOKER','DEFINER') THEN
    RETURN CONCAT(ok(FALSE, description),'\n',
      diag('Security Type must be { INVOKER | DEFINER }'));
  END IF;

  IF NOT _has_routine(sname, rname, rtype) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT(ucf(rtype), ' ', quote_ident(sname), '.', quote_ident(rname), ' does not exist')));
  END IF;

  RETURN eq(_routine_security_type(sname, rname, rtype), stype, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `routine_sha1_is` (`sname` VARCHAR(64), `rname` VARCHAR(64), `rtype` VARCHAR(9), `sha1` VARCHAR(40), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT(ucf(rtype), ' ', quote_ident(sname), '.', quote_ident(rname),
      ' definition should match expected value');
  END IF;

  IF NOT _has_routine(sname, rname, rtype) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT(ucf(rtype), ' ', quote_ident(sname), '.', quote_ident(rname), ' does not exist')));
  END IF;

  
  RETURN eq(LEFT(_routine_sha1(sname, rname, rtype), LENGTH(sha1)), sha1, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `routine_sql_data_access_is` (`sname` VARCHAR(64), `rname` VARCHAR(64), `rtype` VARCHAR(9), `sda` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT(rtype ,' ', quote_ident(sname), '.', quote_ident(rname),
      ' should have SQL Data Access ', quote_ident(sda));
  END IF;

  IF NOT rtype IN('FUNCTION','PROCEDURE') THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag('Routine Type must be { FUNCTION | PROCEDURE }'));
  END IF;

  IF NOT sda IN('CONTAINS SQL','NO SQL','READS SQL DATA','MODIFIES SQL DATA') THEN
    RETURN CONCAT(ok(FALSE,description), '\n',
      diag('SQL Data Access must be { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }'));
  END IF;

  IF NOT _has_routine(sname, rname, rtype) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT(ucf(rtype), ' ', quote_ident(sname), '.', quote_ident(rname), ' does not exist')));
  END IF;

  RETURN eq(_routine_sql_data_access(sname, rname, rtype), sda, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `scheduler_is` (`want` VARCHAR(3), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = 'Event scheduler process should be correctly set';
  END IF;

  RETURN eq(_scheduler(), want, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `schemas_are` (`want` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET @want = want;
  SET @have = (SELECT GROUP_CONCAT('`', `schema_name` ,'`')
               FROM `information_schema`.`schemata`);
	  
  IF description = '' THEN
    SET description = 'The correct Schemas should be defined';
  END IF;

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are('schemas', @extras, @missing, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `schema_character_set_is` (`sname` VARCHAR(64), `cname` VARCHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN schema_charset_is(sname, cname, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `schema_charset_is` (`sname` VARCHAR(64), `cname` VARCHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Schema ', quote_ident(sname),
      ' should use Character Set ',  quote_ident(cname));
  END IF;

  IF NOT _has_schema(sname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Schema ', quote_ident(sname), ' does not exist')));
  END IF;

  IF NOT _has_charset(cname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Character Set ', quote_ident(cname), ' is not available')));
  END IF;

  RETURN eq(_schema_charset_is(sname), cname, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `schema_collation_is` (`sname` VARCHAR(64), `cname` VARCHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Schema ', quote_ident(sname), ' should have Collation ',  qv(cname));
  END IF;

  IF NOT _has_schema(sname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Schema ', quote_ident(sname), ' does not exist')));
  END IF;

  IF NOT _has_collation(cname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Collation ', quote_ident(cname), ' is not available')));
  END IF;

  RETURN eq(_schema_collation_is(sname), cname , description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `schema_privileges_are` (`sname` VARCHAR(64), `gtee` VARCHAR(81), `ptypes` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
 
  SET @gtee = _format_user(gtee);
  SET @want = ptypes;
  SET @have = _schema_privileges(sname, @gtee);

  IF description = '' THEN
    SET description = CONCAT('Account ', gtee, ' should have the correct schema privileges');
  END IF;

  IF NOT _has_schema(sname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Schema ', sname, ' does not exist')));
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are('Schema Privileges', @extras, @missing, description);

END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `single_schema_privileges` (`sname` VARCHAR(64), `gtee` VARCHAR(81), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  
  SET @gtee = _format_user(gtee);

  IF description = '' THEN
    SET description = concat('Account ', gtee, ' should have privileges on a single schema');
  END IF;

  IF NOT _has_schema(sname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Schema `', sname, '` does not exist')));
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  RETURN ok(_single_schema_priv(sname, @gtee), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `single_table_privileges` (`sname` VARCHAR(64), `tname` VARCHAR(64), `gtee` VARCHAR(81), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  
  SET @gtee = _format_user(gtee);

  IF description = '' THEN
    SET description = concat('Account ', gtee, ' should have privileges on a single table');
  END IF;

  IF NOT _has_table(sname,tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table `', sname, '`.`', tname, '` does not exist')));
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  RETURN ok(_single_table_priv(sname, tname, @gtee), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `skip` (`how_many` INT, `why` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    DECLARE tap TEXT DEFAULT '';
    REPEAT
        SET tap = concat(
            tap,
            CASE WHEN tap = '' THEN '' ELSE '\n' END,
            ok(1, concat('SKIP: ', COALESCE(why, '')))
        );
        SET how_many = how_many - 1;
    UNTIL how_many = 0 END REPEAT;
    RETURN tap;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `subpartition_expression_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `subp` VARCHAR(64), `expr` LONGTEXT, `description` TEXT) RETURNS LONGTEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Subpartition ', quote_ident(tname), '.', quote_ident(subp),
      ' should have Subpartition Expression ', qv(TRIM(expr)));
  END IF;

  IF NOT _has_subpartition(sname, tname, subp) THEN
    RETURN CONCAT(ok( FALSE, description), '\n',
      diag(CONCAT('Subpartition ', quote_ident(tname), '.', quote_ident(subp),
        ' does not exist')));
  END IF;

  RETURN eq(_subpartition_expression(sname, tname, subp), TRIM(expr), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `subpartition_method_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `subp` VARCHAR(64), `smeth` VARCHAR(18), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  DECLARE valid ENUM('HASH', 'LINEAR HASH', 'KEY', 'LINEAR KEY');
  
  DECLARE EXIT HANDLER FOR 1265
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag('Subpartition Method must be { HASH | LINEAR HASH | KEY | LINEAR KEY }'));

  IF description = '' THEN
    SET description = CONCAT('Subpartition ', quote_ident(tname), '.', quote_ident(subp),
      ' should have SubPartition Method ', qv(smeth));
  END IF;

  SET valid = smeth;

  IF NOT _has_subpartition(sname, tname, subp) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Subpartition ', quote_ident(tname),'.', quote_ident(subp),
        ' does not exist')));
  END IF;

  RETURN eq(_subpartition_method(sname, tname, subp), smeth, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `tables_are` (`sname` VARCHAR(64), `want` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET @want = want;
  SET @have = (SELECT GROUP_CONCAT('`',table_name,'`')
               FROM `information_schema`.`tables`
	       WHERE `table_schema` = sname
	       AND `table_type` = 'BASE TABLE');

  IF description = '' THEN
    SET description = CONCAT('Schema ', quote_ident(sname),
      ' should have the correct Tables');
  END IF;

  IF NOT _has_schema(sname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Schema ', quote_ident(sname), ' does not exist')));
  END IF;

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are('tables', @extras, @missing, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `table_character_set_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Table ', quote_ident(sname), '.',
      quote_ident(tname), ' should have Character Set ',  qv(cname));
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

  IF NOT _has_charset(cname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Character Set ', quote_ident(cname), ' is not available')));
  END IF;

  RETURN eq(_table_character_set(sname, tname), cname, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `table_collation_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Table ', quote_ident(sname), '.',
      quote_ident(tname), ' should have Collation ',  qv(cname));
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.',
        quote_ident(tname), ' does not exist')));
  END IF;

  IF NOT _has_collation(cname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Collation ', quote_ident(cname), ' is not available')));
  END IF;

  RETURN eq(_table_collation(sname, tname), cname, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `table_engine_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `ename` VARCHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Table ', quote_ident(sname), '.',
      quote_ident(tname), ' should have Storage Engine ',  quote_ident(ename));
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname), ' does not exist')));
  END IF;

  IF NOT _has_engine(ename) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Storage Engine ', quote_ident(ename), ' is not available')));
  END IF;

  RETURN eq(_table_engine(sname, tname), ename , description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `table_privileges_are` (`sname` VARCHAR(64), `tname` VARCHAR(64), `gtee` VARCHAR(81), `ptypes` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
 
  SET @gtee = _format_user(gtee);
  SET @want = ptypes;
  SET @have = _table_privileges(sname, tname, @gtee);

  IF description = '' THEN
    SET description = CONCAT('Account ', gtee, ' should have the correct table privileges');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table `', sname,'`.`', tname, '` does not exist')));
  END IF;

  IF NOT _has_user_at_host(@gtee) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Account ', gtee, ' does not exist')));
  END IF;

  

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are('Table Privileges', @extras, @missing, description);

END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `table_sha1_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `sha1` VARCHAR(40), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
      ' definition should match expected value');
  END IF;

  IF NOT _has_table(sname, tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname), ' does not exist')));
  END IF;

  
  RETURN eq(LEFT(_table_sha1(sname, tname), LENGTH(sha1)), sha1, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `timezones_updated` (`description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Timezones data should be updated for changes');
  END IF; 

  IF NOT _has_timezones() THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table `mysql`.`time_zone_data` is empty')));
  END IF;

  RETURN ok(_timezones_updated(), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `triggers_are` (`sname` VARCHAR(64), `tname` VARCHAR(64), `want` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET @want = want;
  SET @have = (SELECT GROUP_CONCAT('`', `trigger_name` ,'`')
               FROM `information_schema`.`triggers`
               WHERE `trigger_schema` = sname
               AND `event_object_table` = tname);
	  
  IF description = '' THEN 
     SET description = CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
      ' should have the correct Triggers');
  END IF;

  IF NOT _has_table(sname,tname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Table ', quote_ident(sname), '.', quote_ident(tname),
        ' does not exist')));
  END IF;

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are('triggers', @extras, @missing, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `trigger_event_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `trgr` VARCHAR(64), `evnt` VARCHAR(6), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = concat('Trigger ', quote_ident(tname), '.', quote_ident(trgr),
      ' Event should occur for ', qv(UPPER(evnt)));
  END IF;

  IF NOT _has_trigger(sname, tname, trgr) THEN
    RETURN CONCAT(ok( FALSE, description), '\n',
      diag(CONCAT('Trigger ', quote_ident(tname),'.', quote_ident(trgr),
        ' does not exist')));
  END IF;

  RETURN eq(_trigger_event(sname, tname, trgr), evnt, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `trigger_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `trgr` VARCHAR(64), `act_state` LONGTEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Trigger ', quote_ident(tname), '.', quote_ident(trgr), 
      ' should have the correct action');
  END IF;

  IF NOT _has_trigger(sname, tname, trgr) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Trigger ', quote_ident(tname),'.', quote_ident(trgr),
        ' does not exist')));
  END IF;

  RETURN eq(_trigger_is(sname, tname, trgr), act_state, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `trigger_order_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `trgr` VARCHAR(64), `seq` BIGINT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Trigger ', quote_ident(tname), '.', quote_ident(trgr),
      ' should have Action Order ', qv(seq));
  END IF;

  IF NOT _has_trigger(sname, tname, trgr) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Trigger ', quote_ident(tname),'.', quote_ident(trgr),
        ' does not exist')));
  END IF;

  RETURN eq(_trigger_order(sname, tname, trgr), seq, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `trigger_timing_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `trgr` VARCHAR(64), `timing` VARCHAR(6), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('Trigger ', quote_ident(tname), '.', quote_ident(trgr),
      ' should have Timing ', qv(UPPER(timing)));
  END IF;

  IF NOT _has_trigger(sname, tname, trgr) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Trigger ', quote_ident(tname),'.', quote_ident(trgr),
        ' does not exist')));
  END IF;

  RETURN eq(_trigger_timing(sname, tname, trgr), timing, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `ucf` (`val` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  RETURN CONCAT(UPPER(LEFT(val, 1)), LOWER(SUBSTRING(val, 2)));
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `unalike` (`got` TEXT, `pat` TEXT, `descr` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    RETURN _unalike( got NOT LIKE pat, got, pat, descr );
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `uqi` (`ident` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN


  IF LEFT(ident,1) = '`' AND RIGHT(ident,1) = '`' THEN
	  RETURN TRIM(BOTH '`' FROM REPLACE(ident,'``','`'));
  END IF;

  IF LEFT(ident,1) = '"' AND RIGHT(ident,1) = '"' THEN
	  RETURN TRIM(BOTH '"' FROM REPLACE(ident,'""','"'));
  END IF;

  RETURN ident;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `user_hasnt_lifetime` (`hname` CHAR(60), `uname` CHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('User \'', uname, '\'@\'', hname, '\' Password should not expire');
  END IF;

  IF NOT _has_user(hname, uname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('User \'', uname, '\'@\'', hname, '\' does not exist')));
  END IF;

  RETURN ok(NOT _user_has_lifetime(hname, uname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `user_has_lifetime` (`hname` CHAR(60), `uname` CHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('User \'', uname, '\'@\'', hname, '\' Password should expire');
  END IF;

  IF NOT _has_user(hname, uname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('User \'', uname, '\'@\'', hname, '\' does not exist')));
  END IF;

  RETURN ok(_user_has_lifetime(hname, uname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `user_not_ok` (`hname` CHAR(60), `uname` CHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('User \'', uname, '\'@\'',
      hname, '\' should be locked out or have an expired password');
  END IF;

  IF NOT _has_user(hname, uname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('User \'', uname, '\'@\'', hname, '\' does not exist')));
  END IF;

  RETURN ok(NOT _user_ok( hname, uname ), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `user_ok` (`hname` CHAR(60), `uname` CHAR(32), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('User \'', uname, '\'@\'',
      hname, '\' should not be locked or have expired password');
  END IF;

  IF NOT _has_user(hname, uname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('User \'', uname, '\'@\'', hname, '\' does not exist')));
  END IF;

  RETURN ok(_user_ok(hname, uname), description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `views_are` (`sname` VARCHAR(64), `want` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  SET @want = want;
  SET @have = (SELECT GROUP_CONCAT('`',table_name,'`')
               FROM `information_schema`.`tables`
	       WHERE `table_schema` = sname
	       AND `table_type` = 'VIEW');

  IF description = '' THEN
    SET description = CONCAT('Schema ', quote_ident(sname),
      ' should have the correct Views');
  END IF;

  IF NOT _has_schema(sname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('Schema ', quote_ident(sname), ' does not exist')));
  END IF;

  CALL _populate_want(@want);
  CALL _populate_have(@have);

  SET @missing = (SELECT _missing(@have)); 
  SET @extras  = (SELECT _extra(@want));

  RETURN _are('views', @extras, @missing, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `view_check_option_is` (`sname` VARCHAR(64), `vname` VARCHAR(64), `copt` VARCHAR(8), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('View ', quote_ident(sname), '.', quote_ident(vname),
      ' should have Check Option ', qv(copt));
  END IF;

  IF NOT _has_view(sname, vname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('View ', quote_ident(sname), '.', quote_ident(vname),
        ' does not exist')));
  END IF;

  RETURN eq(_view_check_option(sname, vname), copt, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `view_definer_is` (`sname` VARCHAR(64), `vname` VARCHAR(64), `dfnr` VARCHAR(93), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('View ',
       quote_ident(sname), '.', quote_ident(vname), ' should have Definer ', qv(dfnr));
  END IF;

  IF NOT _has_view(sname, vname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('View ', quote_ident(sname), '.', quote_ident(vname),
        ' does not exist')));
  END IF;

  RETURN eq(_view_definer(sname, vname), dfnr, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `view_is_updatable` (`sname` VARCHAR(64), `vname` VARCHAR(64), `updl` VARCHAR(3), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('View ', quote_ident(sname), '.', quote_ident(vname),
    ' should have Is Updatable ', qv(updl));
  END IF;

  IF NOT _has_view(sname, vname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('View ', quote_ident(sname), '.', quote_ident(vname),
        ' does not exist')));
  END IF;

  RETURN eq(_view_is_updatable(sname, vname), updl, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `view_security_type_is` (`sname` VARCHAR(64), `vname` VARCHAR(64), `stype` VARCHAR(7), `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  IF description = '' THEN
    SET description = CONCAT('View ', quote_ident(sname), '.', quote_ident(vname),
       ' should have Security Type ', qv(stype));
  END IF;

  IF NOT _has_view(sname, vname) THEN
    RETURN CONCAT(ok(FALSE, description), '\n',
      diag(CONCAT('View ', quote_ident(sname), '.', quote_ident(vname),
        ' does not exist')));
  END IF;

  RETURN eq(_view_security_type( sname, vname), stype, description);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_add` (`vlabel` TEXT, `vvalue` INTEGER, `vnote` TEXT) RETURNS INT(11) MODIFIES SQL DATA
    DETERMINISTIC
BEGIN
    INSERT INTO __tcache__ (label, cid, value, note)
    VALUES (vlabel, connection_id(), vvalue, COALESCE(vnote, ''));
    RETURN vvalue;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_alike` (`res` BOOLEAN, `got` TEXT, `pat` TEXT, `descr` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    IF res THEN RETURN  ok( res, descr ); END IF;
    RETURN concat(ok(res, descr), '\n',  diag(concat(
           '                  ', COALESCE( quote(got), 'NULL' ),
        '\n   doesn''t match: ', COALESCE( quote(pat), 'NULL' )
    )));
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_are` (`what` TEXT, `extras` TEXT, `missing` TEXT, `description` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
DECLARE msg TEXT    DEFAULT '';
DECLARE res BOOLEAN DEFAULT TRUE;

  IF extras <> '' THEN
    SET res = FALSE;
    SET msg = CONCAT('\n', CONCAT('\n'
      '    Extra ', what, ':\n       ' , REPLACE( extras, ',', '\n       ')));
  END IF;

  IF missing <> '' THEN
    SET res = FALSE;
    SET msg = CONCAT(msg, CONCAT('\n'
      '    Missing ', what, ':\n       ' , REPLACE( missing, ',', '\n       ')));
  END IF;

  RETURN CONCAT(ok(res, description), diag(msg));
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_column_privileges` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `gtee` VARCHAR(81)) RETURNS TEXT CHARSET utf8mb4 BEGIN
  DECLARE rtn TEXT;
   
  IF @rollup = 1 THEN
    SELECT GROUP_CONCAT(`privilege_type`) INTO rtn
    FROM
      ( SELECT `privilege_type`
        FROM `information_schema`.`user_privileges`
        WHERE `grantee` = gtee AND _column_privs(`privilege_type`) > 0 
      UNION
        SELECT `privilege_type`
        FROM `information_schema`.`schema_privileges`
        WHERE `grantee` = gtee AND `table_schema` = sname AND _column_privs (`privilege_type`) > 0
      UNION
        SELECT `privilege_type`
        FROM `information_schema`.`table_privileges`
        WHERE `grantee` = gtee AND `table_schema` = sname AND `table_name` = tname AND _column_privs (`privilege_type`) > 0
      UNION
        SELECT `privilege_type`
        FROM `information_schema`.`column_privileges`
        WHERE `grantee` = gtee AND `table_schema` = sname AND `table_name` = tname AND `column_name` = cname
      ) u;
   ELSE
     SELECT GROUP_CONCAT(`privilege_type`) INTO rtn
     FROM `information_schema`.`column_privileges`
     WHERE `grantee` = gtee AND `table_schema` = sname AND `table_name` = tname AND `column_name` = cname;
  END IF;

  RETURN rtn;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_column_privs` (`ptype` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  RETURN FIND_IN_SET(ptype, 'INSERT,REFERENCES,SELECT,UPDATE');
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_column_type` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS LONGTEXT CHARSET utf8mb4 READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret LONGTEXT;

  SELECT `column_type` INTO ret
  FROM `information_schema`.`columns`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_charset` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS VARCHAR(32) CHARSET utf8mb4 READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret VARCHAR(32);

  SELECT `character_set_name` INTO ret
  FROM `information_schema`.`columns`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_collation` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS VARCHAR(32) CHARSET utf8mb4 READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret VARCHAR(32);

  SELECT `collation_name` INTO ret
  FROM `information_schema`.`columns`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_default` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS LONGTEXT CHARSET utf8mb4 READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret LONGTEXT;

  SELECT `column_default` INTO ret
  FROM `information_schema`.`columns`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname;

  RETURN ret ;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_extra_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS VARCHAR(30) CHARSET utf8mb4 READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret VARCHAR(30);

  SELECT `extra` INTO ret
  FROM `information_schema`.`columns`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname;

  RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_has_default` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS TINYINT(1) READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`columns`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname
  AND CASE tap.mysql_variant()
    WHEN 'MariaDB' THEN `column_default` <> 'NULL'
    ELSE `column_default` IS NOT NULL
  END;

  RETURN coalesce(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_has_index_key` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS TINYINT(1) READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`statistics`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname
  AND `index_name` <> 'PRIMARY'
  LIMIT 1;

  RETURN coalesce(ret, false);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_has_named_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `kname` VARCHAR(64)) RETURNS TINYINT(1) READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`statistics`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname
  AND `index_name` = kname;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_has_non_unique_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS TINYINT(1) READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret BOOLEAN;

  SELECT true into ret
  FROM `information_schema`.`statistics`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname
  AND `index_name` <> 'PRIMARY'
  AND `non_unique` = 1
  limit 1; 

  RETURN coalesce(ret, false);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_has_pos_in_named_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `kname` VARCHAR(64), `pos` INT) RETURNS TINYINT(1) READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`statistics`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname
  AND `index_name` = kname
  AND `seq_in_index` = pos;

  RETURN coalesce(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_has_primary_key` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS TINYINT(1) READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`columns`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname
  AND `column_key` = 'PRI';

  RETURN coalesce(ret, false);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_has_type` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `ctype` LONGTEXT) RETURNS TINYINT(1) READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`columns`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname
  AND `column_type` = ctype;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_has_unique_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS TINYINT(1) READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret BOOLEAN;

  SELECT true into ret
  FROM `information_schema`.`statistics`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname
  AND `index_name` <> 'PRIMARY'
  AND `non_unique` = 0
  limit 1; 

  RETURN coalesce(ret, false);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_is_pk` (`sname` VARCHAR(64), `tname` VARCHAR(64), `want` TEXT) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT COUNT(`indexdef`) INTO ret
  FROM 
    (
      SELECT `table_name`, `index_name`,
      GROUP_CONCAT(CONCAT('`', `column_name`, '`') ORDER BY `seq_in_index`) AS `indexdef`
      FROM `information_schema`.`statistics`
      WHERE `table_schema` = sname
      AND `table_name` = tname
      GROUP BY `table_name`,`index_name`
    ) indices
  WHERE `index_name` = 'PRIMARY'
  AND `indexdef` = want;

  RETURN IF(ret <> 0 , TRUE, FALSE);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_is_unique` (`sname` VARCHAR(64), `tname` VARCHAR(64), `want` TEXT) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT COUNT(`indexdef`) INTO ret
  FROM
    (
      SELECT `table_name`, `index_name`,
      GROUP_CONCAT(CONCAT('`', `column_name`, '`') ORDER BY `seq_in_index`) AS `indexdef`
      FROM `information_schema`.`statistics`
      WHERE `table_schema` = sname
      AND `table_name` = tname
      AND `non_unique` = 0
      GROUP BY `table_name`,`index_name`
     ) indices 
  WHERE `indexdef` = want;

  RETURN IF(ret > 0 , 1, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_col_nullable` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS VARCHAR(3) CHARSET utf8mb4 READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret VARCHAR(3);

  SELECT `is_nullable` INTO ret
  FROM `information_schema`.`columns`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname;

  RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_constraint_type` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS VARCHAR(64) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(64);

  SELECT `constraint_type` INTO ret
  FROM `information_schema`.`table_constraints`
  WHERE `constraint_schema` = sname
  AND `table_name` = tname
  AND `constraint_name` = cname;

  RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_datatype` (`word` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN

  SET word =
    CASE
      WHEN word IN ('BOOL', 'BOOLEAN') THEN 'TINYINT'
      WHEN word =  'INTEGER' THEN 'INT'
      WHEN word IN ('DEC', 'NUMERIC', 'FIXED') THEN 'DECIMAL'
      WHEN word IN ('DOUBLE_PRECISION') THEN 'DOUBLE'
      WHEN word = 'REAL' THEN IF (INSTR(@@GLOBAL.sql_mode, 'REAL_AS_FLOAT') > 0 , 'FLOAT' , 'DOUBLE')
      WHEN word IN ('NCHAR', 'CHARACTER', 'NATIONAL_CHARACTER') THEN 'CHAR'
      WHEN word IN ('NVARCHAR', 'VARCHARACTER', 'CHARACTER_VARYING', 'NATIONAL_VARCHAR') THEN 'VARCHAR'
      WHEN word = 'CHAR_BYTE' THEN 'BIT'
      ELSE word
	END ;

  RETURN word;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_data_type` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS LONGTEXT CHARSET utf8mb4 READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret LONGTEXT;

  SELECT `data_type` INTO ret
  FROM `information_schema`.`columns`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_engine_default` () RETURNS VARCHAR(64) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(64);

  SELECT `engine` INTO ret
  FROM `information_schema`.`engines`
  WHERE `support` = 'DEFAULT';

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_eq` (`have` TEXT, `want` TEXT) RETURNS TINYINT(1) BEGIN
    RETURN (have IS NOT NULL AND want IS NOT NULL AND have = want)
        OR (have IS NULL AND want IS NULL)
        OR 0;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_event_interval_field` (`sname` VARCHAR(64), `ename` VARCHAR(64)) RETURNS VARCHAR(18) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(18);

  SELECT `interval_field` INTO ret
  FROM `information_schema`.`events`
  WHERE `event_schema` = sname
  AND `event_name` = ename;

  RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_event_interval_value` (`sname` VARCHAR(64), `ename` VARCHAR(64)) RETURNS VARCHAR(256) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(256);

  SELECT `interval_value` INTO ret
  FROM `information_schema`.`events`
  WHERE `event_schema` = sname
  AND `event_name` = ename;

  RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_event_status` (`sname` VARCHAR(64), `ename` VARCHAR(64)) RETURNS VARCHAR(18) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(18);

  SELECT `status` INTO ret
  FROM `information_schema`.`events`
  WHERE `event_schema` = sname
  AND `event_name` = ename;

  RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_event_type` (`sname` VARCHAR(64), `ename` VARCHAR(64)) RETURNS VARCHAR(9) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(9);

  SELECT `event_type` INTO ret
  FROM `information_schema`.`events`
  WHERE `event_schema` = sname
  AND `event_name` = ename;

  RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_extra` (`want` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  DECLARE ret TEXT;

  SET @want = REPLACE(want,'`','');

  SELECT GROUP_CONCAT(qi(`ident`)) INTO ret
  FROM `have`
  WHERE NOT COALESCE(FIND_IN_SET(`ident`, @want),0);

  RETURN COALESCE(ret, '');
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_finish` (`curr_test` INTEGER, `exp_tests` INTEGER, `num_faild` INTEGER) RETURNS TEXT CHARSET utf8mb4 MODIFIES SQL DATA
    DETERMINISTIC
BEGIN
    DECLARE ret    TEXT DEFAULT '';
    DECLARE plural CHAR DEFAULT '';
    IF exp_tests = 1 THEN SET plural = 's'; END IF;

    IF curr_test IS NULL THEN
        CALL _cleanup();
        
        SELECT `# No tests run!` INTO ret;
    END IF;

    IF exp_tests = 0 OR exp_tests IS NULL THEN
         
        SET exp_tests = curr_test;
        SET ret = concat('1..', COALESCE(exp_tests, 0));
    END IF;

    IF curr_test <> exp_tests THEN
        SET ret = concat(ret, CASE WHEN ret THEN '\n' ELSE '' END, diag(concat(
            'Looks like you planned ', exp_tests, ' test',
            plural, ' but ran ', curr_test
        )));
    ELSEIF num_faild > 0 THEN
        SET ret = concat(ret, CASE WHEN ret THEN '\n' ELSE '' END, diag(concat(
            'Looks like you failed ', num_faild, ' test',
            CASE num_faild WHEN 1 THEN '' ELSE 's' END,
            ' of ', exp_tests
        )));
    END IF;

    
    CALL _cleanup();
    RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_fixCSL` (`want` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN

	SET want = REPLACE(want, '''','');
	SET want = REPLACE(want, '"','');
	SET want = REPLACE(want, '\n','');






	RETURN want;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_fk_ok` (`csch` VARCHAR(64), `ctab` VARCHAR(64), `ccol` TEXT, `usch` VARCHAR(64), `utab` VARCHAR(64), `ucol` TEXT) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT COUNT(*) INTO ret
  FROM 
    (
      SELECT kc.`constraint_schema` AS `csch`,
             kc.`table_name` AS `ctab`,
             GROUP_CONCAT(CONCAT('`',kc.`column_name`,'`') ORDER BY kc.`ordinal_position`) AS `cols1`,
             kc.`referenced_table_schema` AS `usch`,
             kc.`referenced_table_name` AS `utab`,
             GROUP_CONCAT(CONCAT('`',kc.`referenced_column_name`,'`') ORDER BY `position_in_unique_constraint`) AS `cols2`
      FROM `information_schema`.`key_column_usage` kc 
      WHERE kc.`constraint_schema` = csch AND kc.`referenced_table_schema` = usch
      AND kc.`table_name` = ctab AND kc.`referenced_table_name` = utab
      GROUP BY 1,2,4,5
      HAVING GROUP_CONCAT(CONCAT('`',kc.`column_name`,'`') ORDER BY kc.`ordinal_position`) = ccol
         AND GROUP_CONCAT(CONCAT('`',kc.`referenced_column_name`,'`') ORDER BY `position_in_unique_constraint`) = ucol
    ) fkey;

  RETURN COALESCE(ret,0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_fk_on_delete` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS VARCHAR(64) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(64);

  SELECT `delete_rule` INTO ret
  FROM `information_schema`.`referential_constraints`
  WHERE `constraint_schema` = sname
  AND `table_name` = tname
  AND `constraint_name` = cname;

  RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_fk_on_update` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS VARCHAR(64) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(64);

  SELECT `update_rule` INTO ret
  FROM `information_schema`.`referential_constraints`
  WHERE `constraint_schema` = sname
  AND `table_name` = tname
  AND `constraint_name` = cname;

  RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_format_user` (`uname` CHAR(97)) RETURNS CHAR(97) CHARSET utf8mb4 BEGIN

  SET @uname = uname;
  SET @uname = REPLACE(@uname, '"','''');
  SET @uname = REPLACE(@uname, '`','''');

  IF @uname REGEXP '@' = 0 THEN
    SET @uname = CONCAT(@uname, '@\'%\'');
  END IF;

  IF LEFT(@uname,1) != '''' THEN
    SET @uname = CONCAT('''', @uname);
  END IF;

  IF LOCATE('''@', @uname) = 0 THEN
    SET @uname = REPLACE(@uname, '@', '''@');
  END IF;

  IF LOCATE('@''', @uname) = 0 THEN
    SET @uname = REPLACE(@uname, '@', '@''');
  END IF;

  IF RIGHT(@uname,1) != '''' THEN
    SET @uname = CONCAT(@uname,'''');
  END IF;

  RETURN @uname;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_function_data_type` (`sname` VARCHAR(64), `rname` VARCHAR(64)) RETURNS VARCHAR(64) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(64);

  SELECT `data_type` INTO ret
  FROM `information_schema`.`routines`
  WHERE `routine_schema` = sname
  AND `routine_name` = rname
  AND `routine_type` = 'FUNCTION';

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_get` (`vlabel` TEXT) RETURNS INT(11) READS SQL DATA
BEGIN
    DECLARE ret integer;
    SELECT value INTO ret
      FROM __tcache__
     WHERE cid   = connection_id()
       AND label = vlabel LIMIT 1;
    RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_get_latest_id` (`vlabel` TEXT) RETURNS INT(11) READS SQL DATA
BEGIN
    DECLARE ret integer;
    SELECT id INTO ret
      FROM __tcache__
     WHERE cid = connection_id()
       AND label = vlabel
       AND id = (SELECT MAX(id) FROM __tcache__ WHERE cid = connection_id() AND label = vlabel)
     LIMIT 1;
    RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_get_latest_value` (`vlabel` TEXT) RETURNS INT(11) READS SQL DATA
BEGIN
    DECLARE ret integer;
    SELECT value INTO ret
      FROM __tcache__
     WHERE cid = connection_id()
       AND label = vlabel
       AND id = (SELECT MAX(id) FROM __tcache__ WHERE cid = connection_id() AND label = vlabel)
     LIMIT 1;
    RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_get_latest_with_value` (`vlabel` TEXT, `vvalue` INTEGER) RETURNS INT(11) READS SQL DATA
BEGIN
    DECLARE ret integer;
    SELECT MAX(id)
      INTO ret
      FROM __tcache__
     WHERE label = vlabel
       AND value = vvalue
       AND cid = connection_id();
    RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_get_note_by_id` (`vid` INTEGER) RETURNS TEXT CHARSET utf8mb4 READS SQL DATA
BEGIN
    DECLARE ret TEXT;
    SELECT note INTO ret FROM __tcache__ WHERE id = vid  LIMIT 1;
    RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_global_privileges` (`gtee` VARCHAR(81)) RETURNS TEXT CHARSET utf8mb4 BEGIN
   DECLARE rtn TEXT;
   SELECT GROUP_CONCAT(`privilege_type`) INTO rtn
   FROM `information_schema`.`user_privileges`
   WHERE `grantee` = gtee;

   RETURN rtn;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_global_privs` (`ptype` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  RETURN FIND_IN_SET(ptype,
  'ALTER,ALTER ROUTINE,CREATE,CREATE ROUTINE,CREATE TABLESPACE,CREATE TEMPORARY TABLES,CREATE USER,CREATE VIEW,DELETE,DROP,EVENT,EXECUTE,FILE,GRANT,INDEX,INSERT,LOCK TABLES,PROCESS,REFERENCES,RELOAD,REPLICATION CLIENT,REPLICATION SLAVE,SELECT,SHOW DATABASES,SHOW VIEW,SHUTDOWN,SUPER,TRIGGER,UPDATE,USAGE');
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_global_var` (`var` VARCHAR(64)) RETURNS VARCHAR(1024) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(1024);

  SELECT `variable_value` INTO ret
  FROM `performance_schema`.`global_variables`
  WHERE `variable_name` = var;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_charset` (`cname` VARCHAR(32)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`character_sets`
  WHERE `character_set_name` = cname;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_collation` (`cname` VARCHAR(32)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`collations`
  WHERE `collation_name` = cname
  AND `is_compiled` = 'YES';

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_column` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS TINYINT(1) READS SQL DATA
    DETERMINISTIC
BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`columns`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `column_name` = cname;

  RETURN coalesce(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_column_priv` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64), `gtee` VARCHAR(81), `ptype` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE rtn INT;

  IF @rollup = 1 THEN
    SELECT SUM(priv) INTO rtn
    FROM
    (
      SELECT 1 AS priv
      FROM `information_schema`.`user_privileges`
      WHERE `grantee` = gtee
      AND `privilege_type` = ptype
    UNION ALL
      SELECT 1 AS priv
      FROM `information_schema`.`schema_privileges`
      WHERE `grantee` = gtee
      AND `privilege_type` = ptype
      AND `table_schema` = sname
   UNION ALL
     SELECT 1 AS priv
     FROM `information_schema`.`table_privileges`
     WHERE `grantee` = gtee
     AND `privilege_type` = ptype
     AND `table_schema` = sname
     AND `table_name` = tname
   UNION ALL
     SELECT 1 AS priv
     FROM `information_schema`.`column_privileges`
     WHERE `grantee` = gtee
     AND `privilege_type` = ptype
     AND `table_schema` = sname
     AND `table_name` = tname
     AND `column_name` = cname
   ) a;
  ELSE
    SELECT 1 INTO rtn
    FROM `information_schema`.`column_privileges`
    WHERE `grantee` = gtee
    AND `privilege_type` = ptype
    AND `table_schema` = sname
    AND `table_name` = tname
    AND `column_name` = cname;
  END IF;

  RETURN IF(rtn > 0, 1, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_constraint` (`sname` VARCHAR(64), `tname` VARCHAR(64), `cname` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE ret INT;

  SELECT COUNT(*) INTO ret
  FROM `information_schema`.`table_constraints`
  WHERE `constraint_schema` = sname
  AND `table_name` = tname
  AND `constraint_name` = cname;

  RETURN IF(ret > 0 , 1, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_constraint_type` (`sname` VARCHAR(64), `tname` VARCHAR(64), `ctype` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE ret INT;

  SELECT COUNT(*) INTO ret
  FROM `information_schema`.`table_constraints`
  WHERE `constraint_schema` = sname
  AND `table_name` = tname
  AND `constraint_type` = ctype;

  RETURN IF(ret > 0 , 1, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_engine` (`ename` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`engines`
  WHERE `engine` = ename
  AND (`support` = 'YES' OR `support` = 'DEFAULT');

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_event` (`sname` VARCHAR(64), `ename` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`events`
  WHERE `event_schema` = sname
  AND `event_name` = ename;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_global_priv` (`gtee` VARCHAR(81), `ptype` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE rtn INT DEFAULT 0;

  SELECT 1 INTO rtn
  FROM `information_schema`.`user_privileges`
  WHERE `grantee` = gtee
  AND `privilege_type` = ptype;

  RETURN rtn;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_index` (`sname` VARCHAR(64), `tname` VARCHAR(64), `iname` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`statistics`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `index_name` = iname
  LIMIT 1; 

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_partition` (`sname` VARCHAR(64), `tname` VARCHAR(64), `part` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`partitions`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `partition_name` = part
  LIMIT 1;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_partitioning` () RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`plugins`
  WHERE `plugin_type`='STORAGE ENGINE'
  AND `plugin_name` = 'partition'
  AND `plugin_status` = 'active';

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_priv` (`gtee` VARCHAR(81), `ptype` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE rtn INT;
  SELECT SUM(priv) INTO rtn
  FROM
  ( 
    SELECT 1 AS priv
    FROM `information_schema`.`user_privileges`
    WHERE `grantee` = gtee
    AND `privilege_type` = ptype
  UNION ALL
    SELECT 1 AS priv
    FROM `information_schema`.`schema_privileges`
    WHERE `grantee` = gtee
    AND `privilege_type` = ptype
  UNION ALL
    SELECT 1 AS priv
    FROM `information_schema`.`table_privileges`
    WHERE `grantee` = gtee
    AND `privilege_type` = ptype
  UNION ALL
    SELECT 1 AS priv
    FROM `information_schema`.`column_privileges`
    WHERE `grantee` = gtee
    AND `privilege_type` = ptype
  ) a;

  RETURN IF(rtn > 0, 1, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_role` (`rname` CHAR(93)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT COUNT(*) INTO ret
  FROM `mysql`.`role_edges`
  WHERE CONCAT('''', `from_user`, '''@''', from_host, '''') = rname;

  RETURN IF(ret > 0, 1, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_routine` (`sname` VARCHAR(64), `rname` VARCHAR(64), `rtype` VARCHAR(9)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`routines`
  WHERE `routine_schema` = sname
  AND `routine_name` = rname
  AND `routine_type` = rtype;

  RETURN COALESCE(ret,0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_schema` (`sname` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`schemata`
  WHERE `schema_name` = sname;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_schema_priv` (`sname` VARCHAR(64), `gtee` VARCHAR(81), `ptype` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE rtn INT;

  IF @rollup = 1 THEN
    SELECT SUM(priv) INTO rtn
    FROM
    (
      SELECT 1 AS priv
      FROM `information_schema`.`user_privileges`
      WHERE `grantee` = gtee
      AND `privilege_type` = ptype
    UNION ALL
      SELECT 1 AS priv
      FROM `information_schema`.`schema_privileges`
      WHERE `grantee` = gtee
      AND `privilege_type` = ptype
      AND `table_schema` = sname
    ) a;
  ELSE
    SELECT 1 INTO rtn
    FROM `information_schema`.`schema_privileges`
    WHERE `grantee` = gtee
    AND `privilege_type` = ptype
    AND `table_schema` = sname;
  END IF;

  RETURN IF(rtn > 0, 1, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_security` (`sname` VARCHAR(64), `vname` VARCHAR(64), `vsecurity` VARCHAR(9)) RETURNS TINYINT(1) BEGIN
  DECLARE ret boolean;

  SELECT 1 INTO ret
  FROM `information_schema`.`views`
  WHERE `table_schema` = sname
  AND `table_name` = vname
  AND `security_type` = vsecurity;

  RETURN coalesce(ret, false);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_subpartition` (`sname` VARCHAR(64), `tname` VARCHAR(64), `subp` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`partitions`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `subpartition_name` = subp;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_table` (`sname` VARCHAR(64), `tname` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`tables`
  WHERE `table_name` = tname
  AND `table_schema` = sname;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_table_priv` (`sname` VARCHAR(64), `tname` VARCHAR(64), `gtee` VARCHAR(81), `ptype` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE rtn INT;

  IF @rollup = 1 THEN
    SELECT SUM(priv) INTO rtn
    FROM
    (
      SELECT 1 AS priv
      FROM `information_schema`.`user_privileges`
      WHERE `grantee` = gtee
      AND `privilege_type` = ptype
    UNION ALL
      SELECT 1 AS priv
      FROM `information_schema`.`schema_privileges`
      WHERE `grantee` = gtee
      AND `privilege_type` = ptype
      AND `table_schema` = sname
    UNION ALL
      SELECT 1 AS priv
      FROM `information_schema`.`table_privileges`
      WHERE `grantee` = gtee
      AND `privilege_type` = ptype
      AND `table_schema` = sname
      AND `table_name` = tname
     ) a;
  ELSE
    SELECT 1 INTO rtn
    FROM `information_schema`.`table_privileges`
    WHERE `grantee` = gtee
    AND `privilege_type` = ptype
    AND `table_schema` = sname
    AND `table_name` = tname;
  END IF;
  
  RETURN IF(rtn > 0, 1, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_timezones` () RETURNS TINYINT(1) BEGIN
  DECLARE ret INT;

  SELECT count(*) INTO ret
  FROM `mysql`.`time_zone_name`;

  RETURN IF(ret > 0, 1, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_trigger` (`sname` VARCHAR(64), `tname` VARCHAR(64), `trgr` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`triggers`
  WHERE `trigger_schema` = sname
  AND `event_object_table` = tname
  AND `trigger_name` = trgr;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_unique` (`sname` VARCHAR(64), `tname` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT COUNT(`table_name`) INTO ret
  FROM `information_schema`.`statistics`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `non_unique` = 0;

  RETURN IF(ret <> 0 , TRUE, FALSE);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_user` (`hname` CHAR(60), `uname` CHAR(32)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `mysql`.`user`
  WHERE `host` = hname
  AND `user` = uname;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_user_at_host` (`uname` CHAR(97)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `mysql`.`user`
  WHERE CONCAT('\'',`user`, '\'@\'', `host`, '\'') = uname;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_has_view` (`sname` VARCHAR(64), `vname` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM `information_schema`.`tables`
  WHERE `table_schema` = sname
  AND `table_name` = vname
  AND `table_type` = 'VIEW';

  RETURN coalesce(ret, false);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_index_def` (`sname` VARCHAR(64), `tname` VARCHAR(64), `iname` VARCHAR(64)) RETURNS TEXT CHARSET utf8mb4 BEGIN
  DECLARE ret TEXT;

  SELECT GROUP_CONCAT(CONCAT('`', `column_name`, '`'),
  IF(`sub_part` IS NULL, '', CONCAT('(', `sub_part`, ')'))) AS 'column_name' INTO ret
  FROM `information_schema`.`statistics`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `index_name` = iname
  ORDER BY `seq_in_index`;

  RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_index_type` (`sname` VARCHAR(64), `tname` VARCHAR(64), `iname` VARCHAR(64)) RETURNS VARCHAR(16) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(16);

  SELECT `index_type` INTO ret
  FROM `information_schema`.`statistics`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `index_name` = iname
  LIMIT 1; 

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_is_indexed` (`sname` VARCHAR(64), `tname` VARCHAR(64), `want` TEXT) RETURNS TINYINT(1) BEGIN
    DECLARE ret BOOLEAN;

    SELECT COUNT(`indexdef`) INTO ret
    FROM
      (
        SELECT `table_name`, `index_name`,
        GROUP_CONCAT(CONCAT('`', `column_name`, '`') ORDER BY `seq_in_index`) AS `indexdef`
        FROM `information_schema`.`statistics`
        WHERE `table_schema` = sname
        AND `table_name` = tname
        GROUP BY `table_name`,`index_name`
      ) indices
    WHERE `indexdef` = want;

    RETURN IF(ret <> 0 , TRUE, FALSE);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_missing` (`have` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
  DECLARE ret TEXT;

  SET @have = REPLACE(have,'`','');

  SELECT GROUP_CONCAT(qi(`ident`)) INTO ret
  FROM `want`

  WHERE NOT COALESCE(FIND_IN_SET(`ident`, @have),0);

  RETURN COALESCE(ret, '');
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_nextnumb` () RETURNS INT(11) BEGIN
    DECLARE nextnumb INTEGER DEFAULT COALESCE(_get('tnumb'), 0) + 1;
    RETURN _set('tnumb', nextnumb, '');
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_partition_count` (`sname` VARCHAR(64), `tname` VARCHAR(64)) RETURNS SMALLINT(6) BEGIN
  DECLARE ret SMALLINT;

  SELECT COUNT(*) INTO ret
  FROM `information_schema`.`partitions`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `partition_name` IS NOT NULL;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_partition_expression` (`sname` VARCHAR(64), `tname` VARCHAR(64), `part` VARCHAR(64)) RETURNS LONGTEXT CHARSET utf8mb4 BEGIN
  DECLARE ret LONGTEXT;

  SELECT TRIM(`partition_expression`) INTO ret
  FROM `information_schema`.`partitions`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `partition_name` = part
  LIMIT 1;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_partition_method` (`sname` VARCHAR(64), `tname` VARCHAR(64), `part` VARCHAR(64)) RETURNS VARCHAR(18) CHARSET utf8mb4 BEGIN
DECLARE ret VARCHAR(18);

  SELECT `partition_method` INTO ret
  FROM `information_schema`.`partitions`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `partition_name` = part
  LIMIT 1;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_role_is_default` (`rname` CHAR(93)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT COUNT(*) INTO ret
  FROM `mysql`.`default_roles`
  WHERE CONCAT('''', `default_role_user`, '''@''', `default_role_host`, '''') = rname;

  RETURN IF(ret > 0, 1, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_routine_has_sql_mode` (`sname` VARCHAR(64), `rname` VARCHAR(64), `rtype` VARCHAR(9), `smode` VARCHAR(8192)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT LOCATE(smode, `sql_mode`) INTO ret
  FROM `information_schema`.`routines`
  WHERE `routine_schema` = sname
  AND `routine_name` = rname
  AND `routine_type` = rtype;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_routine_is_deterministic` (`sname` VARCHAR(64), `rname` VARCHAR(64), `rtype` VARCHAR(9)) RETURNS VARCHAR(3) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(3);

  SELECT `is_deterministic` INTO ret
  FROM `information_schema`.`routines`
  WHERE `routine_schema` = sname
  AND `routine_name` = rname
  AND `routine_type` = rtype;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_routine_privileges` (`sname` VARCHAR(64), `rtype` VARCHAR(9), `rname` VARCHAR(64), `gtee` VARCHAR(81)) RETURNS TEXT CHARSET utf8mb4 BEGIN
  DECLARE rtn TEXT;

  IF @rollup = 1 THEN
  SELECT GROUP_CONCAT(`privilege_type`) INTO rtn
  FROM
    ( SELECT `privilege_type`
      FROM `information_schema`.`user_privileges`
      WHERE `grantee` = gtee AND _routine_privs(`privilege_type`) > 0   
    UNION
      SELECT `privilege_type`
      FROM `information_schema`.`schema_privileges`
      WHERE `table_schema` = sname AND `grantee` = gtee AND _routine_privs(`privilege_type`) > 0
    UNION
      SELECT `privilege_type`
      FROM `tap`.`proc_privileges`
      WHERE `routine_schema` = sname AND `routine_name` = rname AND `routine_type` = rtype AND `grantee` = gtee
    ) u;
  ELSE
    SELECT GROUP_CONCAT(`privilege_type`) INTO rtn
    FROM `tap`.`proc_privileges`
    WHERE `routine_schema` = sname AND `routine_name` = rname AND `routine_type` = rtype AND `grantee` = gtee;
  END IF;  

  RETURN rtn;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_routine_privs` (`ptype` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  RETURN FIND_IN_SET(ptype, 'ALTER ROUTINE,CREATE ROUTINE,EXECUTE,GRANT');
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_routine_security_type` (`sname` VARCHAR(64), `rname` VARCHAR(64), `rtype` VARCHAR(9)) RETURNS VARCHAR(7) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(7);

  SELECT `security_type` INTO ret
  FROM `information_schema`.`routines`
  WHERE `routine_schema` = sname
  AND `routine_name` = rname
  AND `routine_type` = rtype ;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_routine_sha1` (`sname` VARCHAR(64), `rname` VARCHAR(64), `rtype` VARCHAR(9)) RETURNS CHAR(40) CHARSET utf8mb4 BEGIN
  DECLARE ret CHAR(40);

  SELECT SHA1(`routine_definition`) INTO ret
  FROM `information_schema`.`routines`
  WHERE `routine_schema` = sname
  AND `routine_name` = rname;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_routine_sql_data_access` (`sname` VARCHAR(64), `rname` VARCHAR(64), `rtype` VARCHAR(9)) RETURNS VARCHAR(64) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(64);

  SELECT `sql_data_access` INTO ret
  FROM `information_schema`.`routines`
  WHERE `routine_schema` = sname
  AND `routine_name` = rname
  AND `routine_type` = rtype ;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_scheduler` () RETURNS VARCHAR(3) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(3);
    
  SELECT @@GLOBAL.event_scheduler INTO ret;

  RETURN ret;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_schema_charset_is` (`sname` VARCHAR(64)) RETURNS VARCHAR(32) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(32);

  SELECT `default_character_set_name` INTO ret
  FROM `information_schema`.`schemata`
  WHERE `schema_name` = sname;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_schema_collation_is` (`sname` VARCHAR(64)) RETURNS VARCHAR(32) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(32);

  SELECT `default_collation_name` INTO ret
  FROM `information_schema`.`schemata`
  WHERE `schema_name` = sname;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_schema_privileges` (`sname` VARCHAR(64), `gtee` VARCHAR(81)) RETURNS TEXT CHARSET utf8mb4 BEGIN
   DECLARE rtn TEXT;
   
   IF @rollup = 1 THEN
     SELECT GROUP_CONCAT(`privilege_type`) INTO rtn
     FROM
     ( SELECT `privilege_type`
       FROM `information_schema`.`user_privileges`
       WHERE `grantee` = gtee AND _schema_privs(`privilege_type`) > 0 
     UNION 
       SELECT `privilege_type`
       FROM `information_schema`.`schema_privileges`
       WHERE `grantee` = gtee AND `table_schema` = sname
     ) u;
   ELSE
     SELECT GROUP_CONCAT(`privilege_type`) INTO rtn
     FROM `information_schema`.`schema_privileges`
     WHERE `grantee` = gtee AND `table_schema` = sname;
   END IF;
   
   RETURN rtn;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_schema_privs` (`ptype` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  RETURN FIND_IN_SET(ptype,
    'ALTER,ALTER ROUTINE,CREATE,CREATE ROUTINE,CREATE TEMPORARY TABLES,CREATE VIEW,DELETE,DROP,EVENT,EXECUTE,GRANT,INDEX,INSERT,LOCK TABLES,REFERENCES,SELECT,SHOW VIEW,TRIGGER,UPDATE'); 
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_set` (`vlabel` TEXT, `vvalue` INTEGER, `vnote` TEXT) RETURNS INT(11) READS SQL DATA
BEGIN
    UPDATE __tcache__
       SET value = vvalue,
           note  = COALESCE(vnote, '')
     WHERE cid   = connection_id()
       AND label = vlabel;
    IF ROW_COUNT() = 0 THEN
        RETURN _add( vlabel, vvalue, vnote );
    END IF;
    RETURN vvalue;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_single_schema_priv` (`sname` VARCHAR(64), `gtee` VARCHAR(81)) RETURNS TINYINT(1) BEGIN
  DECLARE rtn INT;

  SELECT COUNT(DISTINCT `table_schema`) INTO rtn
  FROM `information_schema`.`schema_privileges`
  WHERE `grantee` = gtee
  AND `table_schema` = sname
  AND NOT EXISTS (
    SELECT *
    FROM information_schema.schema_privileges
    WHERE `grantee` = gtee
    AND `table_schema` != sname
  )
  AND NOT EXISTS (
    SELECT *
    FROM `information_schema`.`user_privileges`
    WHERE `grantee` = gtee
    AND _schema_privs(`privilege_type`) > 0
  )
  AND NOT EXISTS (
    SELECT *
    FROM `information_schema`.`table_privileges`
    WHERE `grantee` = gtee
    AND `table_schema` != sname
  )
  AND NOT EXISTS (
  SELECT *
  FROM `information_schema`.`column_privileges`
  WHERE `grantee` = gtee
  AND `table_schema` != sname
  )
  AND NOT EXISTS (
  SELECT *
  FROM `tap`.`proc_privileges`
  WHERE `grantee` = gtee
  AND `routine_schema` != sname
  );
  
  RETURN rtn; 
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_single_table_priv` (`sname` VARCHAR(64), `tname` VARCHAR(64), `gtee` VARCHAR(81)) RETURNS TINYINT(1) BEGIN
  DECLARE rtn INT;

  SELECT COUNT(DISTINCT `table_name`) INTO rtn
  FROM `information_schema`.`table_privileges`
  WHERE `grantee` = gtee
  AND `table_schema` = sname
  AND `table_name` = tname
  AND NOT EXISTS (
    SELECT *
    FROM `information_schema`.`table_privileges`
    WHERE `grantee` = gtee
    AND `table_name` != tname
  )
  AND NOT EXISTS (
    SELECT *
    FROM `information_schema`.`user_privileges`
    WHERE `grantee` = gtee
    AND _table_privs(`privilege_type`) > 0 
  )
  AND NOT EXISTS (
    SELECT *
    FROM `information_schema`.`schema_privileges`
    WHERE `grantee` = gtee
    AND _table_privs(`privilege_type`) > 0
  )
  AND NOT EXISTS (
    SELECT *
    FROM `information_schema`.`column_privileges`
    WHERE `grantee` = gtee
    AND `table_name` != tname
  );
  
  RETURN rtn; 
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_subpartition_expression` (`sname` VARCHAR(64), `tname` VARCHAR(64), `subp` VARCHAR(64)) RETURNS LONGTEXT CHARSET utf8mb4 BEGIN
  DECLARE ret LONGTEXT;

  SELECT TRIM(`subpartition_expression`) INTO ret
  FROM `information_schema`.`partitions`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `subpartition_name` = subp;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_subpartition_method` (`sname` VARCHAR(64), `tname` VARCHAR(64), `subp` VARCHAR(64)) RETURNS VARCHAR(12) CHARSET utf8mb4 BEGIN
DECLARE ret VARCHAR(12);

  SELECT `subpartition_method` INTO ret
  FROM `information_schema`.`partitions`
  WHERE `table_schema` = sname
  AND `table_name` = tname
  AND `subpartition_name` = subp;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_table_character_set` (`sname` VARCHAR(64), `tname` VARCHAR(64)) RETURNS VARCHAR(32) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(32);

  SELECT c.`character_set_name` INTO ret
  FROM `information_schema`.`tables` AS t
  INNER JOIN `information_schema`.`collation_character_set_applicability` AS c
    ON (t.`table_collation` = c.`collation_name`)
  WHERE t.`table_schema` = sname
  AND t.`table_name` = tname;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_table_collation` (`sname` VARCHAR(64), `tname` VARCHAR(64)) RETURNS VARCHAR(32) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(32);

  SELECT `table_collation` INTO ret
  FROM `information_schema`.`tables`
  WHERE `table_schema` = sname
  AND `table_name` = tname;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_table_engine` (`sname` VARCHAR(64), `tname` VARCHAR(64)) RETURNS VARCHAR(32) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(32);

  SELECT `engine` INTO ret
  FROM `information_schema`.`tables`
  WHERE `table_schema` = sname
  AND `table_name` = tname;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_table_privileges` (`sname` VARCHAR(64), `tname` VARCHAR(64), `gtee` VARCHAR(81)) RETURNS TEXT CHARSET utf8mb4 BEGIN
  DECLARE rtn TEXT;
   
  IF @rollup = 1 THEN    
    SELECT GROUP_CONCAT(`privilege_type`) INTO rtn
    FROM
     ( SELECT `privilege_type`
       FROM `information_schema`.`user_privileges`
       WHERE `grantee` = gtee AND _table_privs(`privilege_type`) > 0 
     UNION 
       SELECT `privilege_type`
       FROM `information_schema`.`schema_privileges`
       WHERE `grantee` = gtee AND `table_schema` = sname AND _table_privs (`privilege_type`) > 0
     UNION
       SELECT `privilege_type`
       FROM `information_schema`.`table_privileges`
       WHERE `grantee` = gtee AND `table_schema` = sname AND `table_name` = tname
     ) u;
  ELSE
    SELECT GROUP_CONCAT(`privilege_type`) INTO rtn
    FROM `information_schema`.`table_privileges`
    WHERE `grantee` = gtee AND `table_schema` = sname AND `table_name` = tname;
  END IF;
  
  RETURN rtn;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_table_privs` (`ptype` VARCHAR(64)) RETURNS TINYINT(1) BEGIN
  RETURN FIND_IN_SET(ptype,
    'ALTER,CREATE,CREATE VIEW,DELETE,DROP,GRANT,INDEX,INSERT,REFERENCES,SELECT,SHOW VIEW,TRIGGER,UPDATE'); 
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_table_sha1` (`sname` VARCHAR(64), `tname` VARCHAR(64)) RETURNS CHAR(40) CHARSET utf8mb4 BEGIN
  DECLARE ret CHAR(40);

  SELECT SHA1(GROUP_CONCAT(sha)) INTO ret
  FROM 
    (
      (SELECT SHA1( 
        GROUP_CONCAT(
          SHA1(
             CONCAT_WS('',`table_catalog`,`table_schema`,`table_name`,`column_name`,
              `ordinal_position`,`column_default`,`is_nullable`,`data_type`,
              `character_maximum_length`,`character_octet_length`,`numeric_precision`,
	            `numeric_scale`,`datetime_precision`,`character_set_name`,`collation_name`,
              `column_type`,`column_key`,`extra`,`privileges`,`column_comment`,
              `generation_expression`,`srs_id`)
          ))) sha
      FROM `information_schema`.`columns`
      WHERE `table_schema` = sname
      AND `table_name` = tname
      ORDER BY `table_name` ASC,`column_name` ASC) 
  UNION ALL
      (SELECT SHA1( 
        GROUP_CONCAT(
          SHA1(
            CONCAT_WS('',`constraint_catalog`,`constraint_schema`,`constraint_name`,
            `unique_constraint_catalog`,`unique_constraint_schema`,`unique_constraint_name`,
            `match_option`,`update_rule`,`delete_rule`,`table_name`,`referenced_table_name`)
      ))) sha
      FROM `information_schema`.`referential_constraints`
      WHERE `constraint_schema` = sname
      AND `table_name` = tname
      ORDER BY `table_name` ASC,`constraint_name` ASC)
  UNION ALL
      (SELECT SHA1( 
        GROUP_CONCAT(
          SHA1(
            CONCAT_WS('',`table_catalog`,`table_schema`,`table_name`,`non_unique`,
              `index_schema`,`index_name`,`seq_in_index`,`column_name`,`collation`,`cardinality`,
              `sub_part`,`packed`,`nullable`,`index_type`,`comment`,`index_comment`,`is_visible`)
      ))) sha
      FROM `information_schema`.`statistics`
      WHERE `table_schema` = sname
      AND `table_name` = tname
      ORDER BY `table_name` ASC,`index_name` ASC,`seq_in_index` ASC)
  UNION ALL
      (SELECT SHA1( 
        GROUP_CONCAT(
          SHA1(
           CONCAT_WS('',`trigger_catalog`,`trigger_schema`,`trigger_name`,`event_manipulation`,
            `event_object_catalog`,`event_object_schema`,`event_object_table`,`action_order`,
            `action_condition`,`action_statement`,`action_orientation`,`action_timing`,
            `action_reference_old_table`,`action_reference_new_table`,`action_reference_old_row`,
            `action_reference_new_row`,`sql_mode`,`definer`,`database_collation`)
      ))) sha
      FROM `information_schema`.`triggers`
      WHERE `trigger_schema` = sname
      AND `event_object_table` = tname
      ORDER BY `event_object_table` ASC,`trigger_name` ASC)
 ) objects;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_tap` (`aok` BOOLEAN, `test_num` INTEGER, `descr` TEXT, `todo_why` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    RETURN concat(CASE aok WHEN TRUE THEN '' ELSE 'not ' END,
        'ok ', test_num,
        CASE descr WHEN '' THEN '' ELSE COALESCE( concat(' - ', substr(diag( descr ), 3)), '' ) END,
        COALESCE( concat(' ', diag( concat('TODO ', todo_why) )), ''),
        CASE WHEN aok THEN '' ELSE concat('\n',
            diag(concat('Failed ',
                CASE WHEN todo_why IS NULL THEN '' ELSE '(TODO) ' END,
                'test ', test_num,
                CASE descr WHEN '' THEN '' ELSE COALESCE(concat(': "', descr, '"'), '') END,
                CASE WHEN aok IS NULL THEN concat('\n', '    (test result was NULL)') ELSE '' END
        ))) END
    );
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_timezones_updated` () RETURNS TINYINT(1) BEGIN

  DECLARE pre DATETIME;
  DECLARE post DATETIME;
  
  SET pre =  (SELECT CONVERT_TZ('2007-03-11 2:00:00','US/Eastern','US/Central'));
  SET post = (SELECT CONVERT_TZ('2007-03-11 3:00:00','US/Eastern','US/Central'));
 
  RETURN IF(pre = post, 1, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_todo` () RETURNS TEXT CHARSET utf8mb4 MODIFIES SQL DATA
    DETERMINISTIC
BEGIN
    
    
    
    DECLARE todos   INTEGER DEFAULT _get_latest_value('todo');
    DECLARE todo_id INTEGER;
    DECLARE note    TEXT;

    IF todos IS NULL THEN
        
        RETURN NULL;
    END IF;

    SET todo_id = _get_latest_id('todo');
    IF todos = 0 THEN
        
        DELETE FROM __tcache__ WHERE id = todo_id;
        RETURN NULL;
    END IF;
    
    IF todos <> -1 THEN
        CALL _idset(todo_id, todos - 1);
    END IF;

    SET note = _get_note_by_id(todo_id);
    IF todos = 1 THEN
        
        DELETE FROM __tcache__ WHERE id = todo_id;
    END IF;
    RETURN note;
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_trigger_event` (`sname` VARCHAR(64), `tname` VARCHAR(64), `trgr` VARCHAR(64)) RETURNS VARCHAR(6) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(6);

  SELECT `event_manipulation` INTO ret
  FROM `information_schema`.`triggers`
  WHERE `event_object_schema` = sname
  AND `event_object_table` = tname
  AND `trigger_name` = trgr;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_trigger_is` (`sname` VARCHAR(64), `tname` VARCHAR(64), `trgr` VARCHAR(64)) RETURNS LONGTEXT CHARSET utf8mb4 BEGIN
  DECLARE ret LONGTEXT;

  SELECT `action_statement` INTO ret
  FROM `information_schema`.`triggers`
  WHERE `event_object_schema` = sname
  AND `event_object_table` = tname
  AND `trigger_name` = trgr;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_trigger_order` (`sname` VARCHAR(64), `tname` VARCHAR(64), `trgr` VARCHAR(64)) RETURNS BIGINT(20) BEGIN
  DECLARE ret BIGINT;

  SELECT `action_order` INTO ret
  FROM `information_schema`.`triggers`
  WHERE `event_object_schema` = sname
  AND `event_object_table` = tname
  AND `trigger_name` = trgr;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_trigger_timing` (`sname` VARCHAR(64), `tname` VARCHAR(64), `trgr` VARCHAR(64)) RETURNS VARCHAR(6) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(6);

  SELECT `action_timing` INTO ret
  FROM `information_schema`.`triggers`
  WHERE `event_object_schema` = sname
  AND `event_object_table` = tname
  AND `trigger_name` = trgr;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_unalike` (`res` BOOLEAN, `got` TEXT, `pat` TEXT, `descr` TEXT) RETURNS TEXT CHARSET utf8mb4 BEGIN
    IF res THEN RETURN  ok( res, descr ); END IF;
    RETURN concat(ok(res, descr), '\n',  diag(concat(
           '                  ', COALESCE( quote(got), 'NULL' ),
        '\n          matches: ', COALESCE( quote(pat), 'NULL' )
    )));
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_user_has_lifetime` (`hname` CHAR(60), `uname` CHAR(32)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM tap.mysql__user
  WHERE `Host` = hname
  AND `User` = uname
  AND `password_lifetime` IS NOT NULL AND `password_lifetime` != 0;

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_user_ok` (`hname` CHAR(60), `uname` CHAR(32)) RETURNS TINYINT(1) BEGIN
  DECLARE ret BOOLEAN;

  SELECT 1 INTO ret
  FROM tap.mysql__user
  WHERE `host` = hname
  AND `user` = uname
  AND `password_expired` <> 'Y'
  AND `account_locked` <> 'Y';

  RETURN COALESCE(ret, 0);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_view_check_option` (`sname` VARCHAR(64), `vname` VARCHAR(64)) RETURNS VARCHAR(8) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(8);

  SELECT `check_option` INTO ret
  FROM `information_schema`.`views`
  WHERE `table_schema` = sname
  AND `table_name` = vname;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_view_definer` (`sname` VARCHAR(64), `vname` VARCHAR(64)) RETURNS VARCHAR(93) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(93);

  SELECT `definer` INTO ret
  FROM `information_schema`.`views`
  WHERE `table_schema` = sname
  AND `table_name` = vname;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_view_is_updatable` (`sname` VARCHAR(64), `vname` VARCHAR(64)) RETURNS VARCHAR(3) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(3);

  SELECT `is_updatable` INTO ret
  FROM `information_schema`.`views`
  WHERE `table_schema` = sname
  AND `table_name` = vname;

  RETURN COALESCE(ret, NULL);
END$$

CREATE DEFINER=`root`@`localhost` FUNCTION `_view_security_type` (`sname` VARCHAR(64), `vname` VARCHAR(64)) RETURNS VARCHAR(7) CHARSET utf8mb4 BEGIN
  DECLARE ret VARCHAR(7);

  SELECT `security_type` INTO ret
  FROM `information_schema`.`views`
  WHERE `table_schema` = sname
  AND `table_name` = vname;

  RETURN COALESCE(ret, NULL);

END$$

DELIMITER ;

-- --------------------------------------------------------

--
-- Stand-in struktur untuk tampilan `proc_privileges`
-- (Lihat di bawah untuk tampilan aktual)
--
CREATE TABLE `proc_privileges` (
`GRANTEE` varchar(145)
,`ROUTINE_SCHEMA` char(64)
,`ROUTINE_NAME` char(64)
,`ROUTINE_TYPE` varchar(12)
,`PRIVILEGE_TYPE` varchar(13)
);

-- --------------------------------------------------------

--
-- Struktur dari tabel `__tcache__`
--

CREATE TABLE `__tcache__` (
  `id` int(11) NOT NULL,
  `cid` int(11) NOT NULL,
  `label` text NOT NULL,
  `value` int(11) NOT NULL,
  `note` text NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- --------------------------------------------------------

--
-- Struktur dari tabel `__tresults__`
--

CREATE TABLE `__tresults__` (
  `numb` int(11) NOT NULL,
  `cid` int(11) NOT NULL,
  `ok` tinyint(1) NOT NULL DEFAULT 1,
  `aok` tinyint(1) NOT NULL DEFAULT 1,
  `descr` text NOT NULL,
  `type` text NOT NULL,
  `reason` text NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- --------------------------------------------------------

--
-- Struktur untuk view `proc_privileges`
--
DROP TABLE IF EXISTS `proc_privileges`;

CREATE ALGORITHM=UNDEFINED DEFINER=`root`@`localhost` SQL SECURITY DEFINER VIEW `proc_privileges`  AS  select concat('\'',`mysql`.`procs_priv`.`User`,'\'@\'',`mysql`.`procs_priv`.`Host`,'\'') AS `GRANTEE`,`mysql`.`procs_priv`.`Db` AS `ROUTINE_SCHEMA`,`mysql`.`procs_priv`.`Routine_name` AS `ROUTINE_NAME`,`mysql`.`procs_priv`.`Routine_type` AS `ROUTINE_TYPE`,'EXECUTE' AS `PRIVILEGE_TYPE` from `mysql`.`procs_priv` where find_in_set('EXECUTE',`mysql`.`procs_priv`.`Proc_priv`) > 0 union select concat('\'',`mysql`.`procs_priv`.`User`,'\'@\'',`mysql`.`procs_priv`.`Host`,'\'') AS `GRANTEE`,`mysql`.`procs_priv`.`Db` AS `ROUTINE_SCHEMA`,`mysql`.`procs_priv`.`Routine_name` AS `ROUTINE_NAME`,`mysql`.`procs_priv`.`Routine_type` AS `ROUTINE_TYPE`,'ALTER ROUTINE' AS `PRIVILEGE_TYPE` from `mysql`.`procs_priv` where find_in_set('ALTER ROUTINE',`mysql`.`procs_priv`.`Proc_priv`) > 0 union select concat('\'',`mysql`.`procs_priv`.`User`,'\'@\'',`mysql`.`procs_priv`.`Host`,'\'') AS `GRANTEE`,`mysql`.`procs_priv`.`Db` AS `ROUTINE_SCHEMA`,`mysql`.`procs_priv`.`Routine_name` AS `ROUTINE_NAME`,`mysql`.`procs_priv`.`Routine_type` AS `ROUTINE_TYPE`,'GRANT' AS `PRIVILEGE_TYPE` from `mysql`.`procs_priv` where find_in_set('GRANT',`mysql`.`procs_priv`.`Proc_priv`) > 0 ;

--
-- Indexes for dumped tables
--

--
-- Indeks untuk tabel `__tcache__`
--
ALTER TABLE `__tcache__`
  ADD PRIMARY KEY (`id`);

--
-- AUTO_INCREMENT untuk tabel yang dibuang
--

--
-- AUTO_INCREMENT untuk tabel `__tcache__`
--
ALTER TABLE `__tcache__`
  MODIFY `id` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=909;
COMMIT;

/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;