public enum Filter
    {
        Active,
        Suggested,
        Merge
    }

    public enum Tab
    {
        Newest,
        Master,
        Synonym,
        Votes,
        Creator,
        Renames
    }

    public class DB : DbContext
    {
        public DbSet<TagSynonym> TagSynonyms { get; set; }
        public DbSet<Tag> Tags { get; set; }
        public DbSet<UserTagTotal> UserTagTotals { get; set; }
        public DbSet<User> Users { get; set; }
    }

    public class User
    {
        public int Id { get; set; }
        public string DisplayName { get; set; }
    }

    public class Tag
    {
        public string Name { get; set; }
        public int Id { get; set; }
        public int Count { get; set; }
    }

    public class TagSynonym
    {
        public DateTime? ApprovalDate { get; set; }

        [Key]
        [Column(Order = 2)] 

        public string TargetTagName { get; set; }

        public DateTime CreationDate { get; set; }

        public string AutoRenameCount { get; set; }

        [Key]
        [Column(Order = 1)] 

        public string SourceTagName { get; set; }

        public int Score { get; set; }
        public int OwnerUserId { get; set; }
    }

    public class UserTagTotal
    {
        [Key]
        [Column(Order = 1)]
        public int TagId { get; set; }

        [Key]
        [Column(Order = 2)]
        public int UserId { get; set; }

        public int TotalAnswerScore { get; set; }
    }

static void TestEf(DB db, Filter filter, Tab tab, bool isAnonymous, bool isModerarator, int currentUserId, string search)
    {
        var baseQuery = db.TagSynonyms as IQueryable<TagSynonym>;

        if (filter == Filter.Active)
        {
            baseQuery = baseQuery.Where(t => t.ApprovalDate != null);
        }
        else if (filter == Filter.Suggested)
        {
            baseQuery = baseQuery.Where(t => t.ApprovalDate == null);
            if (!isAnonymous && !isModerarator)
            {
                // exclude ones I can not vote on
                baseQuery = from ts in db.TagSynonyms
                            join tags in db.Tags on ts.TargetTagName equals tags.Name
                            join stats in db.UserTagTotals on
                                new { Id = tags.Id, UserId = currentUserId }
                                equals
                                new { Id = stats.TagId, UserId = stats.UserId }
                            where ts.ApprovalDate == null && stats.TotalAnswerScore > 100
                            select ts;
            }
        }

        switch (tab)
        {
            case Tab.Newest:
                baseQuery = baseQuery.OrderByDescending(s => s.CreationDate);
                break;
            case Tab.Master:
                baseQuery = baseQuery.OrderBy(t => t.TargetTagName).ThenBy(t => t.AutoRenameCount);
                break;
            case Tab.Synonym:
                baseQuery = baseQuery.OrderBy(t => t.SourceTagName).ThenBy(t => t.AutoRenameCount);
                break;
            case Tab.Votes:
                baseQuery = baseQuery.OrderByDescending(t => t.Score).ThenBy(t => t.TargetTagName).ThenBy(t => t.AutoRenameCount);
                break;
            case Tab.Creator:
                baseQuery = (
                                from s in baseQuery
                                join users1 in db.Users on s.OwnerUserId equals users1.Id into users1temp
                                from users in users1temp.DefaultIfEmpty()
                                orderby users == null ? "" : users.DisplayName
                                select s
                            );
                break;
            case Tab.Renames:
                baseQuery = baseQuery.OrderByDescending(t => t.AutoRenameCount).ThenBy(t => t.TargetTagName);
                break;

            default:
                break;
        }

        if (search != null)
        {
            baseQuery = baseQuery.Where(t => t.SourceTagName.Contains(search) || t.TargetTagName.Contains(search));
        }


        var query = from synonym in baseQuery
                    join sourceTagsTemp in db.Tags on synonym.SourceTagName equals sourceTagsTemp.Name into sourceTagsTemp1
                    join targetTagsTemp in db.Tags on synonym.TargetTagName equals targetTagsTemp.Name into targetTagsTemp1
                    from sourceTag in sourceTagsTemp1.DefaultIfEmpty()
                    from targetTag in targetTagsTemp1.DefaultIfEmpty()
                    where filter != Filter.Merge || (synonym.ApprovalDate != null && sourceTag != null && sourceTag.Count > 0)
                    select new { SourceTag = sourceTag, TargetTag = targetTag, TagSynonym = synonym };
        query.Load();
    }
}

static TimeSpan RandomTest()
{
    using (var db = new DB())
    {
        var rnd = new Random();

        var filterValues = (Filter[]) Enum.GetValues(typeof (Filter));
        var filter = filterValues[rnd.Next(filterValues.Length)];

        var tabValues = (Tab[]) Enum.GetValues(typeof (Tab));
        var tab = tabValues[rnd.Next(filterValues.Length)];

        var sw = Stopwatch.StartNew();
        TestEf(db, filter, tab, rnd.Next(2) == 0, rnd.Next(2) == 0, rnd.Next(1000),
            rnd.Next(2) == 0 ? "aaaa" : "");
        sw.Stop();
        return sw.Elapsed;
    }
}