public static class SqlHelper
{
    private const string ForeignKeyColumnsQuery = @"
SELECT
    obj.name AS [fk_name],
    fk_schema.name AS [fk_schema],
    fk_table.name AS [fk_table],
    fk_column.name AS [fk_column],
    pk_schema.name AS [pk_schema],
    pk_table.name AS [pk_table],
    pk_column.name AS [pk_column]
FROM
    sys.foreign_key_columns fkc
    INNER JOIN sys.objects obj ON obj.object_id = fkc.constraint_object_id

    INNER JOIN sys.tables fk_table ON fk_table.object_id = fkc.parent_object_id
    INNER JOIN sys.schemas fk_schema ON fk_table.schema_id = fk_schema.schema_id
    INNER JOIN sys.columns fk_column ON fk_column.column_id = parent_column_id AND fk_column.object_id = fk_table.object_id

    INNER JOIN sys.tables pk_table ON pk_table.object_id = fkc.referenced_object_id
    INNER JOIN sys.schemas pk_schema ON pk_table.schema_id = pk_schema.schema_id
    INNER JOIN sys.columns pk_column ON pk_column.column_id = referenced_column_id AND pk_column.object_id = pk_table.object_id
";

    public static IList<AlterTableConstraint> GetAlterTableConstraints(this SqlConnection connection, Func<ConstraintInfo, bool> predicate = null)
    {
        return
            connection
                .Query<ConstraintInfo>(ForeignKeyColumnsQuery)
                .Where((predicate ?? (_ => true)))
                .GroupBy(x => x.fk_name)
                .Select(AlterTableConstraint.Create)
                .ToList();
    }

}

public class AlterTableConstraint : IGrouping<string, ConstraintInfo>
{
    private readonly IEnumerable<ConstraintInfo> _contraintInfos;

    private AlterTableConstraint(IGrouping<string, ConstraintInfo> cig)
    {
        Key = cig.Key;
        _contraintInfos = cig;

        var ci = cig.First();

        var fk_table = $"[{ci.fk_schema}].[{ci.fk_table}]";
        var pk_table = $"[{ci.pk_schema}].[{ci.pk_table}]";

        var constraint = $"[{ci.fk_name}]";
        var fk = string.Join(", ", cig.Select(x => $"[{x.fk_column}]"));
        var pk = string.Join(", ", cig.Select(x => $"[{x.pk_column}]"));

        Drop = $"ALTER TABLE {fk_table} DROP CONSTRAINT {constraint}";
        Add = $"ALTER TABLE {fk_table} WITH CHECK ADD CONSTRAINT {constraint} FOREIGN KEY({fk}) REFERENCES {pk_table}({pk})";
        Check = $"ALTER TABLE {fk_table} CHECK CONSTRAINT {constraint}";
    }

    public string Key { get; }

    public string Drop { get; }
    public string Add { get; }
    public string Check { get; }

    // LINQPad
    private object ToDump()
    {
        return new
        {
            Key,
            Drop,
            Add,
            Check
        };
    }

    public static AlterTableConstraint Create(IGrouping<string, ConstraintInfo> cig)
    {
        return new AlterTableConstraint(cig);
    }

    public IEnumerator<ConstraintInfo> GetEnumerator()
    {
        return _contraintInfos.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class ConstraintInfo
{
    // Using sql naming convention here to avoid mapping.

    public string fk_name { get; set; }

    public string fk_schema { get; set; }
    public string fk_table { get; set; }
    public string fk_column { get; set; }

    public string fk_full => $"[{fk_schema}].[{fk_table}].[{fk_column}]";

    public string pk_schema { get; set; }
    public string pk_table { get; set; }
    public string pk_column { get; set; }

    public string pk_full => $"[{pk_schema}].[{pk_table}].[{pk_column}]";
}

SqlHelper.Execute(ConnectonString, connection =>
{
    var tableNames = new[] { "TimeRange", "Message" };
    var alterTables = connection.GetAlterTableConstraints(ci => tableNames.Contains(ci.fk_table, StringComparer.OrdinalIgnoreCase));

    foreach (var alterTable in alterTables)
    {
        connection.ExecuteNonQuery(alterTable.Drop);
    }

    connection.Seed(new SqlFourPartName("Message") { SchemaName = "smq" }, messages);
    connection.Seed(new SqlFourPartName("TimeRange") { SchemaName = "smq" }, timeRanges);

    foreach (var alterTable in alterTables)
    {
        connection.ExecuteNonQuery(alterTable.Add);
        connection.ExecuteNonQuery(alterTable.Check);
    }
});