Index Check Tool - IBM i 7.1 and higher releases

Resolving The Problem

The Index Check tool is an SQL procedure that checks for consistency of an index.

For best results, the tool must be run when no activity (updates / inserts / deletes) is occurring on the physical file and indexes built over it.

If the tool is run during activity, files may be listed that should not be listed and files that should be listed may not be.

If your IBM i is at V6R1 or lower, see TechNote "Index Check Tool - IBM i V6R1 and earlier releases"
http://www.ibm.com/support/docview.wss?uid=nas8N1011809


Details on the tool

There are three options to use the tool: Option 0, Option 1, and Option 2. Each option will increase the time it takes to complete; however, it will also increase the amount of checks the option performs. Using Option 3 will run the longest, however, this option performs the most complete check available.

The procedure has three parameters that are needed when called:

Parm 1 - Library name
The name of the library that contains the indexes you want to check. This must be entered within apostrophes and is case sensitive. For example, to check indexes in library QGPL, you must specify 'QGPL'.

Parm 2 - File name
This is the partial or complete short name of the physical file for which indexes will be checked. This must also be entered within apostrophes and is case sensitive. A % wildcard is allowed and will check all files in the library listed in Parm 1.

For example, check all indexes built over file XYZ, you must specify 'XYZ'.
To check all indexes built over all files whose name starts with XYZ, you must enter 'XYZ%'

Parm 3 - Type of index check to perform
This is an integer value of 0, 1 or 2.

Option 0
Option 0 is the fastest, but least thorough check. It checks the count of keys in the index against the count of valid rows in the table.

Option 1
Option 1 is much slower; however, this option will validate the structure of the index and validate whether any keys point to the same record. If the index structure is found to be invalid, the normal SLIC processing will invalidate the index and an event will be sent to start rebuilding it. This could affect applications that are currently using the index but have been lucky enough to not hit the bad part of the index structure. If the index structure is fine, but two keys point to the same RRN, the index will not be immediately invalidated.

Option 2
Option 2 is a superset and even slower than Option 1. It will do everything in Option 1 and also read all the rows in the underlying table and verify that the keys from the index match the data.

Parm 4 (Optional) 3 - Index Library
If this optional parameters are specified, the value must be the undelimited SQL (long) name of the library.

Parm 5 (Optional) 3 - Index Name
If this optional parameters are specified, the value must be the undelimited SQL (long) name of the index.


How to create the tool

To create the tool, you should perform the following steps:

1.	Open the Run SQL Script window from IBM iSeries Navigator by: a Clicking on the Microsoft Windows Start button. b Clicking on Programs. c Clicking on IBM iSeries Access for Windows. d Clicking on iSeries Navigator. e Signing on the system, when iSeries Navigator opens. f Expanding the Database portion. g Right-clicking on the system name, and selecting Run SQL Script.
2.	Click on Connections and choose JDBC settings.
3.	Select the Format tab and make sure Naming convention is set to SQL(*SQL). Click Connect.
4.	In the Run SQL Script window, type the following starting with create procedure and ending in commit

select * from qsys2.syspartitionindexes where maximum_key_length > 1000;

-- Create an alwcpydta *NO procedure
drop procedure qgpl.execute_alwcpydta;
create procedure qgpl.execute_alwcpydta (stmt varchar(32000)) language sql
set option dbgview=*source, alwcpydta=*NO
begin
declare attributes varchar(50) default 'SENSITIVE SCROLL';

prepare s1 ATTRIBUTES attributes from stmt;
execute s1;
end;


-- Create the check index procedure
-- Version date 05/22/2017
-- Added an Optional IndexLib and IndexName parameter.
-- If the optional parameters are specified, the values must be the undelimited SQL names of the index.
-- This is because that is what comes back from SYSPARTITIONINDEXSTAT.

drop procedure qgpl.check_indexes;
create procedure qgpl.check_indexes (lib varchar(10), file varchar(10), check_type int, IndexLib varchar(128) default null, IndexName varchar(128) default null) language sql
set option dbgview=*source
begin
declare postrrns bigint;
declare postinserts bigint;
declare postdeletes bigint;
declare postupdates bigint;
declare indexvalid char(10);
-- start of change 01-31-2014
declare indexvalid2 int;
-- end of change 01-31-2014
declare attributes varchar(50) default 'SENSITIVE SCROLL';
declare stmt varchar(32000);
declare dupkeys bigint;
declare ixcnt int default 0;
declare posnone int default 0;
declare Vcolumn_names2 varchar(1024);
declare Vorder varchar(1000);
declare aliasname varchar(50);
declare aliasnbr smallint default 0;
declare workaliasnbr smallint;
declare aliasrest varchar(50);
declare ixworkname varchar(50);
declare ixw2rkname varchar(50);
declare ixworknbr smallint default 0;
declare workixworknbr smallint;
declare ixw2rknbr smallint default 0;
declare workixw2rknbr smallint;
declare ixworkrest varchar(1000);
declare multids int;
declare sqler int;
declare vindex_schema varchar(10);
declare vindex_name varchar(128);
declare vindex_member varchar(10);
declare vindex_type varchar(11);
declare vpartitioned char(1);
declare vindex_valid char(1);
declare vdelayed_maint_keys bigint;
declare vsparse char(1);
declare vderived_key char(1);
declare vnumber_keys bigint;
declare vnumber_key_columns int;
declare vsrtseq_type CHAR(1);
declare vaccpth_type CHAR(1);
declare vcolumn_names varchar(1024);
declare veof int;
declare index_nbr_for_name int;
declare ixkeys bigint;
declare dskeys bigint;
declare dsixkeys bigint;
-- mja change
declare work_sqler int;

BEGIN
declare continue handler for SQLSTATE '42710' begin end;

create table qgpl.index_check_output (
check_time timestamp,
system_table_schema char(10),
system_table_name char(10),
system_table_member char(10),
index_schema char(10),
index_name varchar(128),
index_member varchar(10),
index_type char(11),
index_column_names varchar(1000),
checked char(10),
valid char(10));

END;


FOR tableloop as tablecsr CURSOR FOR
select system_table_schema, system_table_name, system_table_member, NUMBER_ROWS, inserts as ins, updates as ups, deletes as des
from qsys2.syspartitionstat
where system_table_schema = lib and trim(system_table_name) like file DO

-- performance improvement for xxxxxxx only as this eliminates output rows for empty tables
if NUMBER_ROWS = 0 THEN GOTO nextpartition; end if;

inloop: begin
declare indexloop cursor for
select index_schema, index_name, index_member, index_type, partitioned, index_valid, delayed_maint_keys, sparse, derived_key, number_keys, number_key_columns, srtseq_type, accpth_type, column_names
from qsys2.syspartitionindexstat
where system_table_schema = tableloop.system_table_schema and system_table_name = tableloop.system_table_name and system_table_member = tableloop.system_table_member
and INDEX_SCHEMA LIKE COALESCE(IndexLib, '%') and INDEX_NAME LIKE COALESCE(IndexName, '%');

declare continue handler for not found begin set veof = 1; end;

set veof = 0;
set index_nbr_for_name = 0;
open indexloop;
inloop2: loop
fetch indexloop into vindex_schema, vindex_name, vindex_member, vindex_type, vpartitioned, vindex_valid, vdelayed_maint_keys, vsparse , vderived_key, vnumber_keys, vnumber_key_columns, vsrtseq_type, vaccpth_type, vcolumn_names ;

if veof = 1 then leave inloop2; end if;
set index_nbr_for_name = index_nbr_for_name + 1;

-----------------------------------------------------------------------------------------------------------
-- Quick check
-----------------------------------------------------------------------------------------------------------
-- handle join logicals
-- V5R4 If vpartitioned = '0' then set multids = 0;
-- V5R4 else if vpartitioned = '1' then set multids = 1;
-- V6R1 If vpartitioned = '1' then set multids = 0;
-- V6R1 else if vpartitioned = '0' then set multids = 1;
If vpartitioned = '1' then set multids = 0;
else if vpartitioned = '0' then set multids = 1;
else set multids = 1; select 0 into multids from qsys2.systables where tableloop.system_table_schema = vindex_schema and tableloop.system_table_name = vindex_name;
end if;
end if;

set indexvalid = case
when tableloop.NUMBER_ROWS = 0 and vnumber_keys = 0 then 'YES'
when vindex_valid <> '1' or vdelayed_maint_keys > 0 or vsparse <> '0' or multids = 1 then null
when tableloop.NUMBER_ROWS = vnumber_keys then 'YES'
-- start of change 01-31-2014
when tableloop.NUMBER_ROWS <> vnumber_keys then 'NO2'
-- end of change 01-31-2014
else 'NO' end;

-- start of change 01-31-2014
if indexvalid = 'NO2' then set indexvalid = 'NO'; set indexvalid2 = 1;
else set indexvalid2 = 0;
end if;
-- end of change 01-31-2014

set posnone = POSSTR(vcolumn_names,'*NONE');

-- Thorough checks column_names temp test
set sqler = 0;
if check_type > 0 and vderived_key = '0' and vcolumn_names <> '' and posnone = 0 and (tableloop.NUMBER_ROWS > 0 or vnumber_keys > 0) and vindex_valid = '1' and multids = 0 then

-----------------------------------------------------------------------------------------------------------
-- Index duplicate key check
-----------------------------------------------------------------------------------------------------------
set ixcnt = ixcnt +1;
BEGIN
declare continue handler for SQLSTATE '42704' begin end;

BEGIN
declare continue handler for SQLSTATE '42710'
begin
set aliasnbr = aliasnbr+1;
set aliasname = 'qtemp.ixalias' CONCAT digits(aliasnbr);
set stmt = 'create alias ' CONCAT aliasname CONCAT aliasrest;
end;

-- For a logical over a single DS, we need to use the logical since the key name may be different from the physical
set aliasname = 'qtemp.ixalias' CONCAT digits(aliasnbr);
if vindex_type = 'LOGICAL' and multids = 0 then
set aliasrest = ' for ' CONCAT
TRIM(vindex_schema) CONCAT '.' CONCAT
TRIM(vindex_name) CONCAT '(' CONCAT
TRIM(vindex_member) CONCAT ')';
else
set aliasrest = ' for ' CONCAT
TRIM(tableloop.system_table_schema) CONCAT '.' CONCAT
TRIM(tableloop.system_table_name) CONCAT '(' CONCAT
TRIM(tableloop.system_table_member) CONCAT ')';
end if;
set stmt = 'create alias ' CONCAT aliasname CONCAT aliasrest;

loop1: loop
set workaliasnbr = aliasnbr;
execute immediate stmt;
if workaliasnbr = aliasnbr then leave loop1; end if;
end loop;

END;

-- need to create table since ROWID not allowed in DGTT
-- a bit of a hack - does not cover all cases
-- Eliminate DESC in column list
set Vcolumn_names2 = vcolumn_names;
If vnumber_key_columns = 1 then
set Vcolumn_names2 = REPLACE(Vcolumn_names2, ', DESC', ', "DESC"');
if RIGHT(trim(Vcolumn_names2),5) = ' DESC' THEN
set Vcolumn_names2 = SUBSTR(trim(Vcolumn_names2),1,length(trim(Vcolumn_names2))-5);
end if;
else
set Vcolumn_names2 = REPLACE(Vcolumn_names2, ', DESC,', ', "DESC",');
set Vcolumn_names2 = REPLACE(Vcolumn_names2, ' DESC,', ',');
end if;

set Vorder = vcolumn_names;

IF vcolumn_names LIKE '%USER%' or
vcolumn_names LIKE '%ORDER%' or
vcolumn_names LIKE '%NODENAME%' then

if vnumber_key_columns = 1 then
if Vcolumn_names2 = 'USER' THEN set Vcolumn_names2 = '"USER"' ; end if;
if Vorder = 'ORDER' THEN set Vorder = '"ORDER"' ; end if;
if Vorder= 'ORDER DESC' THEN set Vorder = '"ORDER" DESC' ; end if;
if Vorder = 'NODENAME' THEN set Vorder = '"NODENAME"' ; set Vcolumn_names2 = '"NODENAME"' ; end if;
if Vorder = 'NODENAME DESC' THEN set Vorder = '"NODENAME" DESC' ; set Vcolumn_names2 = '"NODENAME"' ; end if;

else

set Vcolumn_names2 = REPLACE(Vcolumn_names2, ' USER,', '"USER",');
if LEFT(trim(Vcolumn_names2),5) = 'USER,' THEN Set Vcolumn_names2 = REPLACE(Vcolumn_names2, 'USER,', '"USER",'); end if;
if RIGHT(trim(Vcolumn_names2),5) = ' USER' THEN Set Vcolumn_names2 = REPLACE(Vcolumn_names2, ' USER', '"USER"'); end if;
set Vcolumn_names2 = REPLACE(Vcolumn_names2, ' NODENAME,', ' "NODENAME",');
set Vcolumn_names2 = REPLACE(Vcolumn_names2, ' NODENAME DESC,', ' "NODENAME",');
if LEFT(trim(Vcolumn_names2),10) = 'NODENAME, ' THEN Set Vcolumn_names2 = REPLACE(Vcolumn_names2, 'NODENAME, ', '"NODENAME", '); end if;
if RIGHT(trim(Vcolumn_names2),10) = ', NODENAME' THEN Set Vcolumn_names2 = REPLACE(Vcolumn_names2, ', NODENAME', ', "NODENAME"'); end if;

set Vorder = REPLACE(vcolumn_names, ' ORDER,', ' "ORDER",');
set Vorder = REPLACE(Vorder, ' ORDER DESC,', ' "ORDER" DESC,');
if LEFT(trim(Vorder),7) = 'ORDER, ' THEN Set Vorder = REPLACE(Vorder, 'ORDER, ', '"ORDER", '); end if;
if RIGHT(trim(Vorder),7) = ', ORDER' THEN Set Vorder = REPLACE(Vorder, ', ORDER', ', "ORDER"'); end if;
set Vorder = REPLACE(Vorder, ' NODENAME,', ' "NODENAME",');
set Vorder = REPLACE(Vorder, ' NODENAME DESC,', ' "NODENAME" DESC,');
if LEFT(trim(Vorder),10) = 'NODENAME, ' THEN Set Vorder = REPLACE(Vorder, 'NODENAME, ', '"NODENAME", '); end if;
if RIGHT(trim(Vorder),10) = ', NODENAME' THEN Set Vorder = REPLACE(Vorder, ', NODENAME', ', "NODENAME"'); end if;
end if;

end if;


END;

-- Retreive all the keys by using ALWCPYDTA(*NO) and ORDER BY
-- This will essentially force use of the index
begin
declare continue handler for SQLSTATE '42710'
begin
set ixworknbr = ixworknbr+1;
set ixworkname = 'qgpl.ixwork' CONCAT digits(ixworknbr);
set stmt = 'CREATE TABLE ' CONCAT ixworkname CONCAT ixworkrest;
end;
-- mja change
declare continue handler for sqlexception
begin get diagnostics condition 1 work_sqler = db2_returned_sqlcode; if sqler = 0 then set sqler = work_sqler; end if; END;

set sqler = 0;
set ixworkname = 'qgpl.ixwork' CONCAT digits(ixworknbr);

set ixworkrest = ' AS (select rrn(x) as rrn, ' CONCAT
Vcolumn_names2 CONCAT
' from ' CONCAT
aliasname CONCAT
' x order by ' CONCAT
Vorder CONCAT
' optimize for 1 row) WITH DATA';
set stmt = 'CREATE TABLE ' CONCAT ixworkname CONCAT ixworkrest;

loop2: loop
set workixworknbr = ixworknbr;
call qgpl.execute_alwcpydta(stmt);
if workixworknbr = ixworknbr then leave loop2; end if;
end loop;

END;





if sqler >= 0 then
-- Get the RRNs that are in the index twice
set dupkeys = 0;
set stmt = 'DECLARE GLOBAL TEMPORARY TABLE ixduprrns AS ( ' CONCAT
'select "RRN" from ' CONCAT ixworkname CONCAT ' group by "RRN" having count("RRN") > 1 ) WITH DATA WITH REPLACE NOT LOGGED';
call qgpl.execute_alwcpydta(stmt);
select count(*) into dupkeys from session.ixduprrns;

-- Get and save the keys for the duplicates
if dupkeys > 0 then
set indexvalid = 'DUPKEYS';
set stmt = 'CREATE TABLE qgpl.ixdups_' CONCAT
TRIM(tableloop.system_table_schema) CONCAT '_' CONCAT TRIM(tableloop.system_table_name) CONCAT '_' CONCAT
DIGITS(index_nbr_for_name) CONCAT DIGITS(ixcnt) CONCAT
' AS (select * FROM ' CONCAT ixworkname CONCAT ' x where rrn(x) in (select "RRN" from session.ixduprrns) ) WITH DATA';
prepare s1 ATTRIBUTES attributes from stmt;
execute s1;
else

-----------------------------------------------------------------------------------------------------------
-- Data Space check
-----------------------------------------------------------------------------------------------------------
if check_type >= 2 then

-- Retreive all the keys by using ALWCPYDTA(*NO) but without ORDER BY
-- This will essentially force us to NOT use of the index
begin
declare continue handler for SQLSTATE '42710'
begin
set ixw2rknbr = ixw2rknbr+1;
set ixw2rkname = 'qgpl.ixw2rk' CONCAT digits(ixw2rknbr);
set stmt = 'CREATE TABLE ' CONCAT ixw2rkname CONCAT ixworkrest;
end;
-- mja change
declare continue handler for sqlexception
begin get diagnostics condition 1 work_sqler = db2_returned_sqlcode; if sqler = 0 then set sqler = work_sqler; end if; END;

-- mja change
-- set sqler = 0;
set ixw2rkname = 'qgpl.ixw2rk' CONCAT digits(ixw2rknbr);

set ixworkrest = ' AS (select rrn(x) as rrn, ' CONCAT
Vcolumn_names2 CONCAT
' from ' CONCAT
aliasname CONCAT
' x ) WITH DATA';
set stmt = 'CREATE TABLE ' CONCAT ixw2rkname CONCAT ixworkrest;

loop3: loop
set workixw2rknbr = ixw2rknbr;
call qgpl.execute_alwcpydta(stmt);
if workixw2rknbr = ixw2rknbr then leave loop3; end if;
end loop;

END;

if sqler >= 0 then
-- See if the keys and RRNs match

set stmt = 'DECLARE GLOBAL TEMPORARY TABLE ixcounts AS ( ' CONCAT
'select count(*) as ixkeys from ' CONCAT ixworkname CONCAT ') WITH DATA WITH REPLACE NOT LOGGED';
call qgpl.execute_alwcpydta(stmt);
select * into ixkeys from session.ixcounts;

set stmt = 'DECLARE GLOBAL TEMPORARY TABLE ixcounts AS ( ' CONCAT
'select count(*) as ixkeys from ' CONCAT ixw2rkname CONCAT ') WITH DATA WITH REPLACE NOT LOGGED';
call qgpl.execute_alwcpydta(stmt);
select * into dskeys from session.ixcounts;

set stmt = 'DECLARE GLOBAL TEMPORARY TABLE ixcounts AS ( ' CONCAT
'with x as (select * from ' CONCAT ixw2rkname CONCAT ' UNION select * from ' CONCAT ixworkname CONCAT ') select count(*) as ixkeys from x) WITH DATA WITH REPLACE NOT LOGGED';
execute immediate stmt;
select * into dsixkeys from session.ixcounts;

-- a mismatch - may not mean anything if RRNCHGS
if ixkeys <> dskeys or ixkeys <> dsixkeys then
set indexvalid = 'MISMATCH';
else
set stmt = 'DROP TABLE ' CONCAT ixw2rkname;
execute immediate stmt;
end if;

end if;

end if;

set stmt = 'DROP TABLE ' CONCAT ixworkname;
execute immediate stmt;

end if;

-- drop the alias
--set stmt = 'drop alias ' concat aliasname;
--execute immediate stmt;

end if;

-- drop the alias
set stmt = 'drop alias ' concat aliasname;
execute immediate stmt;


select NUMBER_ROWS, inserts, updates, deletes INTO postrrns, postinserts, postupdates, postdeletes
from qsys2.syspartitionstat a
where a.system_table_schema = tableloop.system_table_schema
and a.system_table_name = tableloop.system_table_name
and a.system_table_member = tableloop.system_table_member ;

-- If the number of rows is now different and the keys did not match the rows earlier, null the indexvalid value
if indexvalid = 'NO' and tableloop.NUMBER_ROWS <> postrrns then set indexvalid = null; end if;

end if;

insert into qgpl.index_check_output values(
current_timestamp,
tableloop.system_table_schema,
tableloop.system_table_name,
tableloop.system_table_member,
vindex_schema,
vindex_name,
vindex_member,
vindex_type,
vcolumn_names,
case
when vindex_valid <> '1' then 'INVALID'
when tableloop.NUMBER_ROWS = 0 and vnumber_keys = 0 then 'YES'
-- start of change 01-31-2014
when indexvalid2 = 1 then 'NBR KEYS'
-- end of change 01-31-2014
when vdelayed_maint_keys > 0 then 'DELAYED'
when vsparse <> 0 then 'SPARSE'
when multids <> 0 then 'SPANNER'
when vsrtseq_type <> '0' then 'SRTSEQ'
when vaccpth_type = '2' then 'EVI'
when vderived_key > '0' then 'DERIVED'
when vcolumn_names ='' then 'SPANNER'
when posnone > 0 then '*NONEKEY'
when sqler < 0 then digits(sqler)
when tableloop.NUMBER_ROWS <> postrrns or
tableloop.ins <> postinserts or
tableloop.ups <> postupdates or
tableloop.des <> postdeletes
then 'RRNCHGS'
else 'YES' end,
-- mja change
-- start of change 01-31-2014
case when sqler < 0 then null when indexvalid2 = 1 then 'YES'
else indexvalid end);
-- end of change 01-31-2014
end loop inloop2;

close indexloop;
end inloop;

nextpartition: BEGIN END;

end for;

end;
commit;

5. Go to Run, and select All.



How to run the tool

1.	Go into RUN SQL Scripts again by following Steps 1 and 2 above.
2.	Delete any previous SQL statements to get a clean Run SQL Script window.
3.	Type the following: call qgpl.check_indexes ('Parm1', 'Parm2', Parm3); o Example 1 will check all files in QGPL using Option 0 - call qgpl.check_indexes ('QGPL', '%', 0); o Example 2 will check all files with names that start with ORDER in lib QGPL with Option 1- call qgpl.check_indexes ('QGPL', 'order%', 1); o Example 3 will check only indexes for file PF1 in QGPL with Option 2 - call qgpl.check_indexes ('QGPL', 'PF1', 2); o Example 4 will check a specific index qgpl.check_indexes ('QGPL', '%', 0, 'QGPL', 'QAAPFILE');
4.	Go to Run and select All.

Note: If you want to run in batch, you should open a new source member using STRSEU and add the procedure call you want to run in batch. Then you should submit to batch the CL command RUNSQLSTM and reference that source file member.


Checking the results after the tool is run

The results of the tool are stored in a table QGPL.INDEX_CHECK_OUTPUT.

The following query will return those indexes that could not be checked:

select * from qgpl.index_check_output where checked <> 'YES';

The values other than YES that are returned for the CHECKED column are as follows:

INVALID	The index is already invalid. Perhaps because its *REBLD maintenance. You can ignore this one.
DELAYED	The index is delayed maintenance that there are delayed key changes that have not yet been applied. You can open the file that uses the index and it will be caught up then run the tool against it again.
SPARSE	The index is a select/omit index.
SPANNER	The index is build over multiple data spaces.
SRTSEQ	The index uses a sort sequence.
EVI	The index is an EVI index.
DERIVED	The index has a key that is an expression.
*NONEKEY	The index is a DDS-created logical file that contains a *NONE key.
A number	An error occurred when doing the thorough check. The only case seen on a test system was a single index that was built over an file that contained nonnumeric data in a numeric field.
NBR KEYS	Most likely means the tool was ran at a time when the file is being changed by another job. It indicates at that moment in time the number of keys in the index does not match the number of rows in the file. The tool should be re-ran for that file at a time it is not in-use.
RRNCHGS	The number of records changed between the time the check started and ended for an index.

The following query will return those indexes that are suspect:
select * from qgpl.index_check_output where valid <> 'YES';

If Option 2 is performed, the following query will return those indexes that are bad because no data changed during the checking:
select * from qgpl.index_check_output where valid <> 'YES' and checked <> 'RRNCHGS';

This query will return the indexes that are for sure suspect or the tool can't determine because of other criteria like select/omit:
select * from qgpl/index_check_output where checked <> 'YES'
or valid = 'NO'

Restrictions

A few index types cannot be checked at all:
o Indexes that are invalid (probably because of *REBLD maintenance)
o Indexes that have delayed_maint_keys
o Indexes that are sparse
o Indexes that span multiple data spaces

A few index types are only eligible for a quick check:
o Indexes that use a sort sequence
o Indexes with derived keys
o Indexes that are EVI
o Indexes with *NONE as a key in a DDS logical file

A file with a read trigger will return a 443 error.

Disclaimer: This is an "as is" only tool. Customized assistance with it will require a consulting agreement.