Question

我有大约100万名员工的大数据。我已将此数据存储到一个名为“ employess”的Redis密钥中。现在有一个屏幕，我想在某个字段上执行搜索并在每个列上进行分页。

为此，我创建了可以正常工作的以下代码。但平均需要大约1.2秒至2秒的时间。

我想将其减少到200毫秒（要求）

有人可以指导我如何实现这种性能，或者我在以下代码中做错了什么。

我正在使用C＃代码和ServiceStack.Redis客户端。如果需要，我可以自由使用任何其他Redis客户端。

public class Employee
    {
        public int EmployeeId { get; set; }
        public string LastName { get; set; }
        public string FirstName { get; set; }
        public DateTime DOB { get; set; }
        public char Gender { get; set; }
        public string Street { get; set; }
        public string City { get; set; }
        public string State { get; set; }
        public string Zip { get; set; }
        public string Department { get; set; }
        public string Occupation { get; set; }
        public decimal Salary { get; set; }
    }

//用于处理Redis的排序，搜索，分页和获取数据的方法。

  private GeneralResponse<IEnumerable<Employee>> GetEmp(SearchParam filter, int initialPage, int pageSize, out int totalRecords, out int recordFilterd,
           int sortColumn, string sortDirection)
        {
            var response = new GeneralResponse<IEnumerable<Employee>>();
            totalRecords = 0;
            recordFilterd = 0;

            try
            {
                var data = Enumerable.Empty<Employee>().AsQueryable();
                try
                {
                    using (var redisClient = new RedisClient(Common.redisUrl, Common.redisPort))
                    {


                        var rdata = redisClient.Get<IEnumerable<Employee>>("employess");
                        data = rdata.AsQueryable();
                        ViewBag.source = "redis";
                    }
                }
                catch (Exception e)
                {
                    data = Common.EmployeesList.AsQueryable();
                    ViewBag.source = "Database";
                }


                totalRecords = data.Count();
                //filter 
                if (!string.IsNullOrWhiteSpace(filter.FirstName))
                {
                    data = data.Where(x =>
                        x.FirstName.ToLower().Contains(filter.FirstName.Trim().ToLower())
                    );

                }
                if (!string.IsNullOrWhiteSpace(filter.LastName))
                {
                    data = data.Where(x =>
                        x.LastName.ToLower().Contains(filter.LastName.Trim().ToLower())
                    );
                }
                if (!string.IsNullOrWhiteSpace(filter.Department))
                {
                    data = data.Where(x =>
                        x.Department.ToLower() == filter.Department.Trim().ToLower()
                    );
                }
                if (filter.FromDob != null && filter.FromDob != default(DateTime))
                {
                    data = data.Where(x => x.DOB >= filter.FromDob);
                }
                if (filter.ToDob != null && filter.ToDob != default(DateTime))
                {
                    filter.ToDob = filter.ToDob.AddHours(23).AddMinutes(59);
                    data = data.Where(x => x.DOB <= filter.ToDob);

                }
                recordFilterd = data.Count();

                //sort 
                var ascending = sortDirection == "asc";
                switch (sortColumn)
                {
                    case 0:
                        data = data.OrderBy(p => p.EmployeeId, ascending);
                        break;
                    case 1:
                        data = data.OrderBy(p => p.LastName, ascending);
                        break;
                    case 2:
                        data = data.OrderBy(p => p.FirstName, ascending);
                        break;
                    case 3:
                        data = data.OrderBy(p => p.DOB, ascending);
                        break;
                    case 4:
                        data = data.OrderBy(p => p.Gender, ascending);
                        break;
                    case 5:
                        data = data.OrderBy(p => p.Street, ascending);
                        break;
                    case 6:
                        data = data.OrderBy(p => p.City, ascending);
                        break;
                    case 7:
                        data = data.OrderBy(p => p.State, ascending);
                        break;
                    case 8:
                        data = data.OrderBy(p => p.Zip, ascending);
                        break;
                    case 9:
                        data = data.OrderBy(p => p.Department, ascending);
                        break;
                    case 10:
                        data = data.OrderBy(p => p.Occupation, ascending);
                        break;
                    case 11:
                        data = data.OrderBy(p => p.Occupation, ascending);
                        break;
                    default:
                        data = data.OrderBy(p => p.Salary, ascending);
                        break;
                }

                data = data
                    .Skip(initialPage * pageSize)
                    .Take(pageSize);

                var result = data.ToList();
                response.Data = result;

            }
            catch (Exception e)
            {
                response.Error = true;
                response.Exception = e;
            }
            return response;
        }

任何帮助或指导将不胜感激。以下是我想要提高速度的参考屏幕。

Answer 1

经过深入研究，我终于发现Redis不是执行这些操作的好选择。除此之外，我们可以使用AWS CloudSearch，它具有完整的Sort，Search和Pagination功能。

Answer 2

如上所述，在您的评论和您的回答中，redis可能不是解决此问题的最佳选择，而AWS CloudSearch可能是解决方案。

在解决类似问题时，我发现最大的瓶颈是使用“ query.Where（x => x.String.Contains（filterText））”。

在全文搜索的列（您的解决方案的名字/姓氏）上添加全文索引，使我们能够直接以令人满意的性能（大约100万行表为100-200ms）使用SQL。 https://www.mssqltips.com/sqlservertutorial/9136/sql-server-full-text-indexes/

Answer 3

您好，如果您为每个索引文档添加一个整数 int_id ，则可以执行以下查询：“ @ int_id ：[1 10]”。此查询选择1-10之间的所有文档。

更多信息：https://oss.redislabs.com/redisearch/Query_Syntax.html

使用Redis实现排序，搜索和分页的最佳方法，以实现最佳性能

3 个答案: