• Although in the table_defs.h can be defined all tables from you database it is better if you use own table_defs.h per table.
• If the tool finds nothing but you see your data it is useful to run it in debug mode.

Let's say you have found a string "abcd" in a page. Your table_defs.h is:

                      { /* int(11) */
                                name: "id",
                                type: FT_INT,
                                fixed_length: 4,

                                has_limits: TRUE,
                                limits: {
                                        can_be_null: FALSE,
                                        int_min_val: 1,
                                        int_max_val: 100000
                                },

                                can_be_null: FALSE
                        },
                        { /*  */
                                name: "DB_TRX_ID",
                                type: FT_INTERNAL,
                                fixed_length: 6,

                                can_be_null: FALSE
                        },
                        { /*  */
                                name: "DB_ROLL_PTR",
                                type: FT_INTERNAL,
                                fixed_length: 7,

                                can_be_null: FALSE
                        },
                        { /* varchar(100) */
                                name: "name",
                                type: FT_CHAR,
                                min_length: 0,
                                max_length: 100,

                                has_limits: TRUE,
                                limits: {
                                        can_be_null: TRUE,
                                        char_min_len: 0,
                                        char_max_len: 100,
                                        char_ascii_only: TRUE
                                },

                                can_be_null: TRUE
                        },

Before your "abcd" there are 4+6+7 = 17 bytes. The place where data begin is called ORIGIN. You find the origin in hex editor. Then looking for the offset equal to the origin in the debug output. Then you'll see why your record isn't found.

• Of course you don't know index id when you recover data. There are way how to find out.

- A table is identified by index id. So all pages of the same table are in one directory - If there are VARCHARS or CHARS in the table and you know possible values you can grep all tablespace to find your index id:

# grep -r "XXX-yyyy-ZzZz" pages-1217332715/
Binary file pages-1217332715/0-276/1116-00001116.page matches
Binary file pages-1217332715/0-276/596-00000596.page matches
Binary file pages-1217332715/0-276/715-00000715.page matches
Binary file pages-1217332715/0-276/1119-00001119.page matches
Binary file pages-1217332715/0-276/1237-00001237.page matches
Binary file pages-1217332715/0-276/1101-00001101.page matches
Binary file pages-1217332715/0-276/709-00000709.page matches
#

Try different strings if there are more than 1 directory is found.

• If you are you completely unaware what inside the table is or there are only INTs or DATE it is more difficult to find, but possible.

You compile sources with the respective table_defs.h. Make sure it defines only one table. Run the script below. The idea behind is: If the page is good, constraints_parser will return >0 records.

Please do appropriate changes for your case.

#!/bin/sh

f=`find pages-1217332715 -name *.page`

for i in $f
do
        n=`./constraints_parser -4f $i | wc -l`
        if [ $n -gt 0 ]
        then
                echo $i
        fi
done

It shows the pages which may have records of your table.

• If there are many table to recover this script may help you

#!/bin/sh

db=epic

tables=`mysql -u root -e "SHOW TABLES" -s $db`

for i in $tables
do
        #Check how many rows has a table
        rows=`mysql -u root -e "SELECT COUNT(*) FROM $i" -s $db`
        if [ $rows -ne 0 ]
        then
                # Prepare environment
                echo "Restoring table $i"
                table=$i
                cd include && rm -f table_defs.h && ln -s table_defs.h.$table table_defs.h
                cd ..
                make clean all
                # Restoring rows
                found=0
                while [ $found -lt 1 ]
                do
                        echo ""
                        read -p "Enter the path to directory where data of table $i might be: " dir
                        cat $dir/*.page > p
                        ./constraints_parser -4 -f p >> out.$i
                        found=`cat out.$i | wc -l`
                done

        fi
done

• If you are lucky you'll get only one index id grepping a tablespace beased on known string. What if not. It is clear the longer string the better match. Let's say you have a table ordner:

mysql> desc ordner;
+------------+--------------+------+-----+---------+-------+
| Field      | Type         | Null | Key | Default | Extra |
+------------+--------------+------+-----+---------+-------+
| id         | int(11)      | NO   | PRI |         |       |
| first_name | varchar(255) | YES  |     | NULL    |       |
| last_name  | varchar(255) | YES  |     | NULL    |       |
+------------+--------------+------+-----+---------+-------+

If you know there is John Smith in the table you can try two strings grep -r JohnSmith pages-*. This will work because there is no \0 after John.