diff --git a/Directory.Build.props b/Directory.Build.props
index cc98921..c2a8bf4 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -1,5 +1,5 @@
 <Project>
   <PropertyGroup>
-    <Version>0.1.6</Version>
+    <Version>0.2.0</Version>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/src/QAToolKit.Engine.Database.Test/MySqlTestGeneratorTests.cs b/src/QAToolKit.Engine.Database.Test/MySqlTestGeneratorTests.cs
index 43bbe20..b239130 100644
--- a/src/QAToolKit.Engine.Database.Test/MySqlTestGeneratorTests.cs
+++ b/src/QAToolKit.Engine.Database.Test/MySqlTestGeneratorTests.cs
@@ -1,7 +1,6 @@
 using ExpectedObjects;
 using QAToolKit.Engine.Database.Generators;
 using QAToolKit.Engine.Database.Models;
-using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using Xunit;
@@ -163,12 +162,61 @@ public void MySqlObjectExistScriptNullDbKindTest_Success()
         }
 
         [Fact]
-        public async Task MySqlObjectExistScriptNullOptionsTest_Fails()
+        public async Task MySqlRecordExistScriptTest_Success()
         {
-            var generator = new MySqlTestGenerator();
+            var generator = new MySqlTestGenerator(options =>
+            {
+                options.AddDatabaseRecordExitsRule(
+                    new List<DatabaseRule>()
+                    {
+                        new DatabaseRule()
+                        {
+                            TableName = "mytable",
+                            PredicateValue = "= 'myname'"
+                        }
+                    });
+            });
+
+            var results = new List<DatabaseScript>
+            {
+                new DatabaseScript(
+                        "mytable",
+                        $@"SELECT EXISTS (SELECT 1 FROM mytable WHERE = 'myname');",
+                        DatabaseTestType.RecordExist,
+                        DatabaseKind.MySQL)
+            }.ToExpectedObject();
+
+            results.ShouldEqual(await generator.Generate());
+            Assert.Equal(DatabaseKind.MySQL, generator.DatabaseKind);
+        }
 
+        [Fact]
+        public async Task MySqlRecordCountScriptTest_Success()
+        {
+            var generator = new MySqlTestGenerator(options =>
+            {
+                options.AddDatabaseRecordsCountRule(
+                    new List<DatabaseRule>()
+                    {
+                        new DatabaseRule()
+                        {
+                            TableName = "mytable",
+                            PredicateValue = "=100"
+                        }
+                    });
+            });
+
+            var results = new List<DatabaseScript>
+            {
+                new DatabaseScript(
+                        "mytable",
+                        $@"SELECT EXISTS (SELECT 1 FROM mytable WHERE (SELECT count(*) FROM mytable)=100);",
+                        DatabaseTestType.RecordCount,
+                        DatabaseKind.MySQL)
+            }.ToExpectedObject();
+
+            results.ShouldEqual(await generator.Generate());
             Assert.Equal(DatabaseKind.MySQL, generator.DatabaseKind);
-            await Assert.ThrowsAsync<ArgumentNullException>(async () => await generator.Generate());
         }
     }
 }
diff --git a/src/QAToolKit.Engine.Database.Test/PostgresqlTestGeneratorTests.cs b/src/QAToolKit.Engine.Database.Test/PostgresqlTestGeneratorTests.cs
index 8fc8501..f40c72e 100644
--- a/src/QAToolKit.Engine.Database.Test/PostgresqlTestGeneratorTests.cs
+++ b/src/QAToolKit.Engine.Database.Test/PostgresqlTestGeneratorTests.cs
@@ -1,7 +1,6 @@
 using ExpectedObjects;
 using QAToolKit.Engine.Database.Generators;
 using QAToolKit.Engine.Database.Models;
-using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using Xunit;
@@ -163,12 +162,61 @@ public void PostgresqlObjectExistScriptNullDbKindTest_Success()
         }
 
         [Fact]
-        public async Task PostgresqlObjectExistScriptNullOptionsTest_Fails()
+        public async Task PostgresqlRecordExistScriptTest_Success()
         {
-            var generator = new PostgresqlTestGenerator();
+            var generator = new PostgresqlTestGenerator(options =>
+            {
+                options.AddDatabaseRecordExitsRule(
+                new List<DatabaseRule>()
+                {
+                    new DatabaseRule()
+                    {
+                        TableName = "mytable",
+                        PredicateValue = "= 'myname'"
+                    }
+                });
+            });
+
+            var results = new List<DatabaseScript>
+            {
+                new DatabaseScript(
+                        "mytable",
+                        $@"SELECT EXISTS (SELECT 1 FROM mytable WHERE = 'myname');",
+                        DatabaseTestType.RecordExist,
+                        DatabaseKind.PostgreSQL)
+            }.ToExpectedObject();
+
+            results.ShouldEqual(await generator.Generate());
+            Assert.Equal(DatabaseKind.PostgreSQL, generator.DatabaseKind);
+        }
 
+        [Fact]
+        public async Task PostgresqlRecordCountScriptTest_Success()
+        {
+            var generator = new PostgresqlTestGenerator(options =>
+            {
+                options.AddDatabaseRecordsCountRule(
+                new List<DatabaseRule>()
+                {
+                    new DatabaseRule()
+                    {
+                        TableName = "mytable",
+                        PredicateValue = "=100"
+                    }
+                });
+            });
+
+            var results = new List<DatabaseScript>
+            {
+                new DatabaseScript(
+                        "mytable",
+                        $@"SELECT EXISTS (SELECT 1 FROM mytable WHERE (SELECT count(*) FROM mytable)=100);",
+                        DatabaseTestType.RecordCount,
+                        DatabaseKind.PostgreSQL)
+            }.ToExpectedObject();
+
+            results.ShouldEqual(await generator.Generate());
             Assert.Equal(DatabaseKind.PostgreSQL, generator.DatabaseKind);
-            await Assert.ThrowsAsync<ArgumentNullException>(async () => await generator.Generate());
         }
     }
 }
diff --git a/src/QAToolKit.Engine.Database.Test/SqlServerTestGeneratorTests.cs b/src/QAToolKit.Engine.Database.Test/SqlServerTestGeneratorTests.cs
index 87dad97..c6cf3ef 100644
--- a/src/QAToolKit.Engine.Database.Test/SqlServerTestGeneratorTests.cs
+++ b/src/QAToolKit.Engine.Database.Test/SqlServerTestGeneratorTests.cs
@@ -1,7 +1,6 @@
 using ExpectedObjects;
 using QAToolKit.Engine.Database.Generators;
 using QAToolKit.Engine.Database.Models;
-using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using Xunit;
@@ -162,13 +161,63 @@ public void SqlServerObjectExistScriptNullDbKindTest_Success()
             Assert.Equal(DatabaseKind.SQLServer, generator.DatabaseKind);
         }
 
+
         [Fact]
-        public async Task SqlServerObjectExistScriptNullOptionsTest_Fails()
+        public async Task SqlServerRecordExistScriptTest_Success()
         {
-            var generator = new SqlServerTestGenerator();
+            var generator = new SqlServerTestGenerator(options =>
+            {
+                options.AddDatabaseRecordExitsRule(
+                new List<DatabaseRule>()
+                {
+                    new DatabaseRule()
+                    {
+                        TableName = "mytable",
+                        PredicateValue = "= 'myname'"
+                    }
+                });
+            });
+
+            var results = new List<DatabaseScript>
+            {
+                new DatabaseScript(
+                        "mytable",
+                        $@"IF EXISTS(SELECT 1 FROM mytable WHERE = 'myname') BEGIN Select 1 END ELSE BEGIN Select 0 END",
+                        DatabaseTestType.RecordExist,
+                        DatabaseKind.SQLServer)
+            }.ToExpectedObject();
+
+            results.ShouldEqual(await generator.Generate());
+            Assert.Equal(DatabaseKind.SQLServer, generator.DatabaseKind);
+        }
 
+        [Fact]
+        public async Task SqlServerRecordCountScriptTest_Success()
+        {
+            var generator = new SqlServerTestGenerator(options =>
+            {
+                options.AddDatabaseRecordsCountRule(
+                new List<DatabaseRule>()
+                {
+                    new DatabaseRule()
+                    {
+                        TableName = "mytable",
+                        PredicateValue = "=100"
+                    }
+                });
+            });
+
+            var results = new List<DatabaseScript>
+            {
+                new DatabaseScript(
+                        "mytable",
+                        $@"IF EXISTS(SELECT 1 FROM mytable WHERE (SELECT count(*) FROM mytable)=100) BEGIN Select 1 END ELSE BEGIN Select 0 END",
+                        DatabaseTestType.RecordCount,
+                        DatabaseKind.SQLServer)
+            }.ToExpectedObject();
+
+            results.ShouldEqual(await generator.Generate());
             Assert.Equal(DatabaseKind.SQLServer, generator.DatabaseKind);
-            await Assert.ThrowsAsync<ArgumentNullException>(async () => await generator.Generate());
         }
     }
 }
diff --git a/src/QAToolKit.Engine.Database/DatabaseTestGeneratorOptions.cs b/src/QAToolKit.Engine.Database/DatabaseTestGeneratorOptions.cs
index 86cec76..de9b083 100644
--- a/src/QAToolKit.Engine.Database/DatabaseTestGeneratorOptions.cs
+++ b/src/QAToolKit.Engine.Database/DatabaseTestGeneratorOptions.cs
@@ -9,6 +9,8 @@ namespace QAToolKit.Engine.Database
     public class DatabaseTestGeneratorOptions
     {
         internal Dictionary<DatabaseObjectType, string[]> DatabaseObjectsExistRules { get; private set; }
+        internal List<DatabaseRule> DatabaseRecordsCountRules { get; private set; }
+        internal List<DatabaseRule> DatabaseRecordsExitsRules { get; private set; }
 
         /// <summary>
         /// Add database object exist rules
@@ -27,5 +29,39 @@ public DatabaseTestGeneratorOptions AddDatabaseObjectExitsRule(string[] objects,
 
             return this;
         }
+
+        /// <summary>
+        /// Add database record count rules
+        /// </summary>
+        /// <param name="objects"></param>
+        /// <returns></returns>
+        public DatabaseTestGeneratorOptions AddDatabaseRecordsCountRule(List<DatabaseRule> objects)
+        {
+            if (DatabaseRecordsCountRules == null)
+            {
+                DatabaseRecordsCountRules = new List<DatabaseRule>();
+            }
+
+            DatabaseRecordsCountRules.AddRange(objects);
+
+            return this;
+        }
+
+        /// <summary>
+        /// Add database record exsit rules
+        /// </summary>
+        /// <param name="objects"></param>
+        /// <returns></returns>
+        public DatabaseTestGeneratorOptions AddDatabaseRecordExitsRule(List<DatabaseRule> objects)
+        {
+            if (DatabaseRecordsExitsRules == null)
+            {
+                DatabaseRecordsExitsRules = new List<DatabaseRule>();
+            }
+
+            DatabaseRecordsExitsRules.AddRange(objects);
+
+            return this;
+        }
     }
 }
diff --git a/src/QAToolKit.Engine.Database/Generators/MySqlTestGenerator.cs b/src/QAToolKit.Engine.Database/Generators/MySqlTestGenerator.cs
index bb2caf2..4dedea7 100644
--- a/src/QAToolKit.Engine.Database/Generators/MySqlTestGenerator.cs
+++ b/src/QAToolKit.Engine.Database/Generators/MySqlTestGenerator.cs
@@ -45,5 +45,25 @@ protected override string GetStoredProcedureExistScript(string storedProcedure)
         {
             return $@"SELECT EXISTS(SELECT * FROM information_schema.routines WHERE routine_name = '{storedProcedure}');";
         }
+
+        /// <summary>
+        /// Get MySQL script to check if record exist
+        /// </summary>
+        /// <param name="recordExist"></param>
+        /// <returns></returns>
+        protected override string GetRecordExistScript(DatabaseRule recordExist)
+        {
+            return $@"SELECT EXISTS (SELECT 1 FROM {recordExist.TableName} WHERE {recordExist.PredicateValue});";
+        }
+
+        /// <summary>
+        /// Get MySQL script to count the records in a table
+        /// </summary>
+        /// <param name="recordCount"></param>
+        /// <returns></returns>
+        protected override string GetRecordCountScript(DatabaseRule recordCount)
+        {
+            return $@"SELECT EXISTS (SELECT 1 FROM {recordCount.TableName} WHERE (SELECT count(*) FROM {recordCount.TableName}){recordCount.PredicateValue});";
+        }
     }
 }
diff --git a/src/QAToolKit.Engine.Database/Generators/PostgresqlTestGenerator.cs b/src/QAToolKit.Engine.Database/Generators/PostgresqlTestGenerator.cs
index 1de9529..9ce0e85 100644
--- a/src/QAToolKit.Engine.Database/Generators/PostgresqlTestGenerator.cs
+++ b/src/QAToolKit.Engine.Database/Generators/PostgresqlTestGenerator.cs
@@ -45,5 +45,25 @@ protected override string GetStoredProcedureExistScript(string storedProcedure)
         {
             return $@"SELECT EXISTS (SELECT * FROM information_schema.routines WHERE routine_name = '{storedProcedure}');";
         }
+
+        /// <summary>
+        /// Get PostgreSQL script to check if record exist
+        /// </summary>
+        /// <param name="recordExist"></param>
+        /// <returns></returns>
+        protected override string GetRecordExistScript(DatabaseRule recordExist)
+        {
+            return $@"SELECT EXISTS (SELECT 1 FROM {recordExist.TableName} WHERE {recordExist.PredicateValue});";
+        }
+
+        /// <summary>
+        /// Get PostgreSQL script to count the records in a table
+        /// </summary>
+        /// <param name="recordCount"></param>
+        /// <returns></returns>
+        protected override string GetRecordCountScript(DatabaseRule recordCount)
+        {
+            return $@"SELECT EXISTS (SELECT 1 FROM {recordCount.TableName} WHERE (SELECT count(*) FROM {recordCount.TableName}){recordCount.PredicateValue});";
+        }
     }
 }
diff --git a/src/QAToolKit.Engine.Database/Generators/RelationalDatabaseTestGenerator.cs b/src/QAToolKit.Engine.Database/Generators/RelationalDatabaseTestGenerator.cs
index 46986a7..6ccaa4b 100644
--- a/src/QAToolKit.Engine.Database/Generators/RelationalDatabaseTestGenerator.cs
+++ b/src/QAToolKit.Engine.Database/Generators/RelationalDatabaseTestGenerator.cs
@@ -41,28 +41,84 @@ public Task<IEnumerable<DatabaseScript>> Generate()
         {
             if (_databaseTestOptions == null)
             {
-                throw new ArgumentNullException($"DatabaseTestOptions is null.");
+                throw new ArgumentNullException($"{nameof(_databaseTestOptions)} is null.");
             }
 
             var results = new List<DatabaseScript>();
 
             results.AddRange(GenerateObjectExistScripts());
+            results.AddRange(GenerateCountRecordsScripts());
+            results.AddRange(GenerateRecordsExistScripts());
 
             return Task.FromResult(results.AsEnumerable());
         }
 
-        private IEnumerable<DatabaseScript> GenerateObjectExistScripts()
+        private IEnumerable<DatabaseScript> GenerateCountRecordsScripts()
         {
-            if (_databaseTestOptions.DatabaseObjectsExistRules == null)
+            var results = new List<DatabaseScript>();
+
+            if (_databaseTestOptions.DatabaseRecordsCountRules != null)
             {
-                throw new ArgumentNullException($"{nameof(_databaseTestOptions.DatabaseObjectsExistRules)} is null.");
+                results.AddRange(GetRecordCountScripts());
             }
 
+            return results;
+        }
+
+        private IEnumerable<DatabaseScript> GetRecordCountScripts()
+        {
             var results = new List<DatabaseScript>();
 
-            results.AddRange(GetTableExistScripts());
-            results.AddRange(GetViewExistScripts());
-            results.AddRange(GetStoredProcedureExistScripts());
+            foreach (var record in _databaseTestOptions.DatabaseRecordsCountRules)
+            {
+                results.Add(new DatabaseScript(
+                    record.TableName,
+                    GetRecordCountScript(record),
+                    DatabaseTestType.RecordCount,
+                    DatabaseKind));
+            }
+
+            return results;
+        }
+
+        private IEnumerable<DatabaseScript> GenerateRecordsExistScripts()
+        {
+            var results = new List<DatabaseScript>();
+
+            if (_databaseTestOptions.DatabaseRecordsExitsRules != null)
+            {
+                results.AddRange(GetRecordsExistScripts());
+            }
+
+            return results;
+        }
+
+        private IEnumerable<DatabaseScript> GetRecordsExistScripts()
+        {
+            var results = new List<DatabaseScript>();
+
+            foreach (var record in _databaseTestOptions.DatabaseRecordsExitsRules)
+            {
+                results.Add(new DatabaseScript(
+                    record.TableName,
+                    GetRecordExistScript(record),
+                    DatabaseTestType.RecordExist,
+                    DatabaseKind));
+            }
+
+            return results;
+        }
+
+        private IEnumerable<DatabaseScript> GenerateObjectExistScripts()
+        {
+            var results = new List<DatabaseScript>();
+
+            if (_databaseTestOptions.DatabaseObjectsExistRules != null)
+            {
+                results.AddRange(GetTableExistScripts());
+                results.AddRange(GetViewExistScripts());
+                results.AddRange(GetStoredProcedureExistScripts());
+            }
 
             return results;
         }
@@ -150,5 +206,19 @@ private IEnumerable<DatabaseScript> GetStoredProcedureExistScripts()
         /// <param name="storedProcedure"></param>
         /// <returns></returns>
         protected abstract string GetStoredProcedureExistScript(string storedProcedure);
+
+        /// <summary>
+        /// Get script to check if record exist
+        /// </summary>
+        /// <param name="recordExist"></param>
+        /// <returns></returns>
+        protected abstract string GetRecordExistScript(DatabaseRule recordExist);
+
+        /// <summary>
+        /// Get script to count the records in a table
+        /// </summary>
+        /// <param name="recordCount"></param>
+        /// <returns></returns>
+        protected abstract string GetRecordCountScript(DatabaseRule recordCount);
     }
 }
diff --git a/src/QAToolKit.Engine.Database/Generators/SqlServerTestGenerator.cs b/src/QAToolKit.Engine.Database/Generators/SqlServerTestGenerator.cs
index 633bbc0..3bb1281 100644
--- a/src/QAToolKit.Engine.Database/Generators/SqlServerTestGenerator.cs
+++ b/src/QAToolKit.Engine.Database/Generators/SqlServerTestGenerator.cs
@@ -45,5 +45,25 @@ protected override string GetStoredProcedureExistScript(string storedProcedure)
         {
             return $@"IF EXISTS(SELECT 1 FROM sys.procedures WHERE Name = '{storedProcedure}') BEGIN Select 1 END ELSE BEGIN Select 0 END";
         }
+
+        /// <summary>
+        /// Get SQLServer script to check if record exist
+        /// </summary>
+        /// <param name="recordExist"></param>
+        /// <returns></returns>
+        protected override string GetRecordExistScript(DatabaseRule recordExist)
+        {
+            return $@"IF EXISTS(SELECT 1 FROM {recordExist.TableName} WHERE {recordExist.PredicateValue}) BEGIN Select 1 END ELSE BEGIN Select 0 END";
+        }
+
+        /// <summary>
+        /// Get SQLServer script to count the records in a table
+        /// </summary>
+        /// <param name="recordCount"></param>
+        /// <returns></returns>
+        protected override string GetRecordCountScript(DatabaseRule recordCount)
+        {
+            return $@"IF EXISTS(SELECT 1 FROM {recordCount.TableName} WHERE (SELECT count(*) FROM {recordCount.TableName}){recordCount.PredicateValue}) BEGIN Select 1 END ELSE BEGIN Select 0 END";
+        }
     }
 }
diff --git a/src/QAToolKit.Engine.Database/Models/DatabaseRule.cs b/src/QAToolKit.Engine.Database/Models/DatabaseRule.cs
new file mode 100644
index 0000000..3af52fb
--- /dev/null
+++ b/src/QAToolKit.Engine.Database/Models/DatabaseRule.cs
@@ -0,0 +1,17 @@
+namespace QAToolKit.Engine.Database.Models
+{
+    /// <summary>
+    /// Database rule
+    /// </summary>
+    public class DatabaseRule
+    {
+        /// <summary>
+        /// Database table name
+        /// </summary>
+        public string TableName { get; set; }
+        /// <summary>
+        /// Predicate value
+        /// </summary>
+        public string PredicateValue { get; set; }
+    }
+}