Inclusion dependencies are a well studied property of relational data sources and mainly serve the detection of foreign key relationships. As an integral part of most data profiling efforts, they further support schema reconstruction, data exploration, and database maintenance. This is the repeatability page for the following research contribution:

• Repeatability for INDs discovery Algorithms
• Experimental Evaluation of Ten INDs Algorithms
• Foreign Key Detection

This is a repeatability section for IND discovery algorithms. The algorithms are provided in the state their results have been published, but they may not represent the most recent version of their implementations. To get the more up-to-date version of the algorithms, use the binaries provided here.

The following IND discovery algorithms are available for the Metanome data profiling tool:

• BINDER - unary and n-ary IND detection
  - BINDERDatabase.jar
  - BINDERFile.jar
• SPIDER - unary IND detection
  - SPIDERDatabase.jar
  - SPIDERFile.jar
• FAIDA - approximate unary and n-ary IND detection
  - FAIDAAlgorithm.jar
• SINDY, SANDY, ANDY - family of distributed algorithms for unary (SINDY), partial (SANDY), and n-ary (ANDY) inclusion dependency discovery
  - Repository
  - Releases

Besides that, we provide the following algorithms that are not yet integrated with Metanome:

• CINDERELLA - conditional IND detection
  - Source code

This section is dedecated to provide all materials have been used for experimentally comparing ten INDs discovery algorithms. IND discovery is one of the hardest tasks in data profiling: It is NP-hard, as well as one of the first real-world problems proven to be W[3]-complete. This complexity is mainly due to the large and complex search space and the expensive candidate checks required to find maximum Inds. Current Ind discovery algorithms still have specific shortcomings when running on different datasets. We evaluated and compared the following ten well-known algorithms for discovering Inds:

The code for all this algorithm and for repeating the experiments can be found in GitHub and Metanome algorithms repository. The evaluation framework and run instructions are also available.  (S-INDD++ code is available on request due to copyright)

Once discovered, INDs serve to identify foreign key constraints in relational schemata. In our WebDB'09 paper A Machine Learning Approach to Foreign Key Discovery, we proposed machine learning techniques to solve this task. Please find supplementary material below:

• Algorithm that first implemented the proposed heuristics (zip, Java)
• Training data and models for the proposed machine learning approach (zip for WEKA)

The IND algorithms have been exhaustively tested on datasets of the following sources. The links refer to the original source website. Due to the large size of most datasets, we provide the actual data only upon request:

[1] Crawled from the Wikipedia knowledge base.

[2] Extracted from linked open data on famous persons; stored in relational format.

[3] Generated using our own db-tesma data generator (binaries for Windows 32 Bit).

[4] Streamed anonymized web log data from Plista.

[5] Generated using the dbgen data generator (binaries for Debian 64 Bit DB2).

[6] Obtained by partitioning the Freebase triples from the BTC 2012 dataset by their predicate.

[7] Generated using this generator.

*Numbers in brackets are the numbers we got when these datasets used for the experimental comparison among IND algorithms with NULL equal semantic