精华内容
下载资源
问答
  • LInq动态组装条件查询,去重组装条件1 例:s=>s.id=1组装条件2不带值 例:s=>s.id,适用去重 组装条件1 例:s=>s.id=1 /// <summary> /// 动态组建Linq条件 例如 s=>s.id=1 /// </summary> /...

    组装条件1 例:s=>s.id=1

     /// <summary>
            /// 动态组建Linq条件  例如 s=>s.id=1
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <typeparam name="Tkey"></typeparam>
            /// <param name="propertyName">传入的属性名称</param>
            /// <param name="Value">传入的属性值</param>
            /// <returns></returns>
            public static Expression<Func<T, Tkey>> WhereData<T, Tkey>(string propertyName, object Value)
            {
                Type cType = typeof(T);
                ParameterExpression paramEx = Expression.Parameter(cType, "s");
                Expression equal = Expression.Property(paramEx, cType, propertyName);
                Expression right = Expression.Constant(Value);
                Expression fi = Expression.Equal(equal, right);
                Expression<Func<T, Tkey>> lambda = Expression.Lambda<Func<T, Tkey>>(fi, paramEx);
                return lambda;
            }
    

    使用

    class Program
        {
            static void Main(string[] args)
            {
                var res = new List<CorrespondingDataModel>()
                {
                    new CorrespondingDataModel(){ A=1,B=2,C=3},
                    new CorrespondingDataModel(){ A=1,B=3,C=2},
                    new CorrespondingDataModel(){ A=2,B=1,C=3}
                };
    
                if (res != null && res.Any())
                {
                    //下面2种都可以
                    //var obj = res.AsQueryable().Where(LinqUntil.WhereData<CorrespondingDataModel, bool>("A", 1)).ToList();
                    var obj = res.AsQueryable().Where(LinqUntil.WhereData<CorrespondingDataModel, bool>(CorrespondingEnum.A.ToString(), 1)).ToList();
                    //等价于
                    var obj = res.AsQueryable().Where(s=>s.A==1).ToList();
                    res.ForEach(s => Console.WriteLine("A:{0},B:{1},C{2}", s.A, s.B, s.C));
                }
                Console.ReadKey();
            }
    
        }
        public class CorrespondingDataModel
        {
            public int A { get; set; }
            public int B { get; set; }
            public int C { get; set; }
        }
        public enum CorrespondingEnum
        {
            A,
            B,
            C
        }
    

    结果: 结果

    组装条件2不带值 例:s=>s.id,适用去重

    /// <summary>
            /// 组建条件,例如 s=>s.id
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <typeparam name="Tkey"></typeparam>
            /// <param name="propertyName"></param>
            /// <returns></returns>
            public static Func<T, Tkey> WhereDataNoValue<T, Tkey>(string propertyName)
            {
                ParameterExpression p = Expression.Parameter(typeof(T), "s");
                Expression body = Expression.Property(p, typeof(T).GetProperty(propertyName));
                var lambda = Expression.Lambda<Func<T, Tkey>>(body, p);
                return lambda.Compile();
            }
            /// <summary>
            /// Linq去重
            /// 用法例子:List.AsQueryable().DistinctBy(s => s.要去重的参数).ToList();
            /// </summary>
            /// <typeparam name="TSource"></typeparam>
            /// <typeparam name="TKey"></typeparam>
            /// <param name="source"></param>
            /// <param name="keySelector"></param>
            /// <returns></returns>
            public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
            {
                HashSet<TKey> seenKeys = new HashSet<TKey>();
                foreach (TSource element in source)
                {
                    if (seenKeys.Add(keySelector(element)))
                    {
                        yield return element;
                    }
                }
            }
    

    使用

     var res = new List<CorrespondingDataModel>()
                {
                    new CorrespondingDataModel(){ A=1,B=2,C=3},
                    new CorrespondingDataModel(){ A=1,B=3,C=2},
                    new CorrespondingDataModel(){ A=2,B=1,C=3}
                };
    //去重,查询 s->s.id
                    //res = res.AsQueryable().DistinctBy(LinqUntil.WhereDataNoValue<CorrespondingDataModel, int>(CorrespondingEnum.A.ToString())).ToList();
                    res = res.AsQueryable().DistinctBy(LinqUntil.WhereDataNoValue<CorrespondingDataModel, int>("A")).ToList();
                    //等价于
                    res = res.AsQueryable().DistinctBy(s=>s.A).ToList();
                    res.ForEach(s => Console.WriteLine("A:{0},B:{1},C{2}", s.A, s.B, s.C));
    

    结果: 在这里插入图片描述
    第二种

    public static IEnumerable<TSource> DistinctBy<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
    {
        HashSet<TKey> seenKeys = new HashSet<TKey>();
        foreach (TSource element in source)
        {
            if (seenKeys.Add(keySelector(element)))
            {
                yield return element;
            }
        }
    }
    

    使用

    var query = people.DistinctBy(p => new { p.Id, p.Name });
    var query = people.DistinctBy(p => p.Id);
    
    展开全文
  • Pandas条件查询去重

    2020-02-23 19:19:41
    例如:查询 name=kim 且 age>5的数据: print(df[(df.name == 'kim') & (df.age > 5)]) 以name列去重: df = pd.DataFrame(result).drop_duplicates( subset=['name'], # 去重列,按这些列进行去重 keep=...

    生成Pandas Dataframe,代码及输出结果如下:

    import random
    import pandas as pd
    
    name_list = ['kim', 'kim', 'Amy', 'John', 'Amy', 'Bob']
    
    result = []
    for  i in range(len(name_list)):
        dt = {
            "name": name_list[i],
            "age": i + random.randint(1, 10),
            "weight": i * random.randint(1, 10)
        }
        result.append(dt)
    
    df = pd.DataFrame(result)
    print(df)
    

    输出结果:
    在这里插入图片描述
    例如:查询 name=kim 且 age>5的数据:

    print(df[(df.name == 'kim') & (df.age > 5)])
    

    在这里插入图片描述
    以name列去重:

    df = pd.DataFrame(result).drop_duplicates(
            subset=['name'],  # 去重列,按这些列进行去重
            keep='first'  # 保存第一条重复数据
        )
    
    print(df)
    

    在这里插入图片描述
    其中,subset可以多字段为参数,keep可选参数为‘first’, ‘last’,分别对应保留第一条和最后一条

    展开全文
  • Mysql多个条件查询去重数据

    千次阅读 2019-08-29 15:04:58
    mysql查询多个条件去重 SELECT * FROM tb_user_customer a WHERE CONCAT(agent_id, '-', client_id) IN ( SELECT CONCAT(agent_id, '-', client_id) AS ACID FROM tb_user_customer GROUP BY ACID HAVING ...

    mysql查询多个条件去重

    SELECT * FROM tb_user_customer a WHERE CONCAT(agent_id, '-', client_id) IN 
    (
    	SELECT CONCAT(agent_id, '-', client_id) AS ACID
    	FROM tb_user_customer 
    	GROUP BY ACID HAVING COUNT(ACID) > 1
    );

     

    展开全文
  • 今天接收到一个新的接口需求:1、查询24小时内数据2、对该数据进行的report_time 进行进行去重排序3、根据去过重的report_time获取forecast_time,然后对forecast_time进行去重、排序数据库数据格式:{ "short...

    今天接收到一个新的接口需求:

    1、获取24小时内最近的2条信息,生成这样的json格式

      

    [-{
    	"report_time": "20180705000000",
    	-"forecast": [-{
    		"forecast_time": "20180705000000"
    	}, -{
    		"forecast_time": "20180706030000"
    	}]
    }, -{
    	"report_time": "20180704120000",
    	-"forecast": [-{
    		"forecast_time": "20180704120000"
    	}, -{
    		"forecast_time": "20180704150000"
    	}]
    }]
    

    mongoDB数据库数据格式:

    {
            "shortName": "~",
            "report_time": "20180704120000",
            "forecast_time": "20180704120000",
            "level": NumberInt("850"),
            "startLatitude": 60.0,
            "startLongitude": 60.0,
            "endLatitude": -10.0,
            "endLongitude": 150.0,
            "index": NumberInt("0"),
            "path": "/*************************************"
        },
    {
            "shortName": "~",
            "report_time": "20180704120000",
            "forecast_time": "20180704150000",
            "level": NumberInt("850"),
            "startLatitude": 60.0,
            "startLongitude": 60.0,
            "endLatitude": -10.0,
            "endLongitude": 150.0,
            "index": NumberInt("0"),
            "path": "/*************************************"
        }

    分析需求:可以分为3步:

    1、查询24小时内数据

    2、对该数据进行的report_time 进行进行去重排序

    3、根据去过重的report_time获取forecast_time,然后对forecast_time进行去重、排序


    提到去重,于是想到了两种方法:

    1、通过mongodb提供的distinct方法去重

    2、通过需要去重的字段分组就可以去重

    --------------------------------------------------------------------------------------------------------------------------------

    1、mongodb提供的distinct方法

    	public DistinctIterable<String> distinctData(String tableName,String fieldName,Bson query,Class<String> resultClass) {
    		collection = mongoDatabase.getCollection(tableName);
    		
    	    return	collection.distinct(fieldName,query, resultClass);
    	}
    	

    真正用的时候发现,发现distinct方法没有提供排序功能,准备手动排序,但是发现DistinctIterable类型只能通过迭代器或者foreach遍历,要想排序还得把其中的数据遍历到数组或者集合,然后排序,想到需要多次遍历感觉可不爽。

    ----------------------------------------------------------------------------------------------------------------------------------

    2、通过需要去重的字段分组就可以去重。

        分组的话知道mongodb提供了聚合函数Aggregates,于是开始查询Aggregates资料,发现网上都是用的mongodb提供的DBobject数据格式来操作Aggregates的,但是我这儿用的Bson格式的数据格式,本想的这俩应该差不多,按照DBobjct格式去处理,发现不行,只好查API了,最后发现只需要把自己需要查询的条件放入聚合管道就可以了,具体方法如下:

                  1、获取集合

    	/**
    	 * 用聚合函数筛选数据
    	 * @param list 聚合条件
    	 * @return 
    	 */
    	public AggregateIterable<Document> findByAggregate(String tableName,List<Bson> list) {
    		collection = mongoDatabase.getCollection(tableName);
    		
    		return  collection.aggregate(list);
    	}

                 2、按照条件操作

               

    	/**
    	 *
    	 * 
    	 * @param tableName  集合名称
    	 * @return
    	 */
    	public String getNearByReportTime(String windTableName) {
    
    		JSONArray array = new JSONArray();
    		Calendar cal = Calendar.getInstance();
    
    		cal.add(Calendar.HOUR_OF_DAY, -32);
    		String date = String.format("%04d%02d%02d%02d0000", cal.get(Calendar.YEAR), cal.get(Calendar.MONTH) + 1,
    				cal.get(Calendar.DAY_OF_MONTH), cal.get(Calendar.HOUR_OF_DAY));
     
    		AggregateIterable<Document> reportTimeList =	 repository.findByAggregate(windTableName, Arrays.asList(Aggregates.match(Filters.gte("report_time", date)), //查询24小时内数据
    					Aggregates.sort(Filters.eq("report_time", 1)),  //数据按照 report_time 排序
    					Aggregates.group("$report_time",new BsonField[] { new BsonField("report_time", Filters.eq("$first", "$report_time"))}), //按照report_time分组,并且,获取分组以后的第一个document中report_time的值
    					 Aggregates.project(Filters.eq("_id", 0)), //查询结果不需要_id 这个字段
    					 Aggregates.limit(2)  //只要最近的两条数据
    					)				   
    				 );
          
    		for (Document document : reportTimeList) {
    		   JSONObject obj = new JSONObject();
    		   String report_time = document.getString("report_time");
    		   obj.put("report_time", report_time);
    		   AggregateIterable<Document> temp = repository.findByAggregate(windTableName, 
    				   Arrays.asList(Aggregates.match(Filters.eq("report_time", report_time)),
    							
    							Aggregates.group("$forecast_time",new BsonField[] { new BsonField("forecast_time", Filters.eq("$first", "$forecast_time"))}),
    							 Aggregates.project(Filters.eq("_id", 0)),
    							 Aggregates.sort(Filters.eq("forecast_time", 1))
    							)				   
    				   );
    		   obj.put("forecast", temp);
    		   array.add(obj);
    		   
    		}
    		
    	       return array.toJSONString();
    	}

    查询结果:

    [-{
    	"report_time": "20180705000000",
    	-"forecast": [-{
    		"forecast_time": "20180705000000"
    	}, -{
    		"forecast_time": "20180706030000"
    	}, -{
    		"forecast_time": "20180714000000"
    	}, -{
    		"forecast_time": "20180714060000"
    	}]
    }, -{
    	"report_time": "20180704120000",
    	-"forecast": [-{
    		"forecast_time": "20180704120000"
    	}, -{
    		"forecast_time": "20180704150000"
    	}, -{
    		"forecast_time": "20180704180000"
    	}, -{
    		"forecast_time": "20180704210000"
    	}, -{
    		"forecast_time": "20180714120000"
    	}]
    }]

        至此,问题已全部解决。







    展开全文
  • 查询语文成绩大于70,数学成绩小于80分的同学:(多条件查询): select * from exam_result where chinese>70 and math; where 条件1 and 条件2 where 条件1 or 条件2 where 条件1 and (条件2 or 条件3) 查询...
  • 分组去重查询,并执行某一个函数 :select 分组字段,聚合函数 from 表名 where 条件 group by分组字段 select 分组字段,聚合函数 from 表名 where 条件 group by分组字段 having过滤条件 例:select cno, ...
  • 查询 select3.1 全列查询3.2 指定列查询3.3 查询字段为表达式3.3.1 表达式为指定数据3.3.2 表达式包含一个字段3.3.3 表达式包含多个字段3.3.4 为查询结果指定别名3.4 查询结果去重3.5 where 条件3.5.1 英语不及格的...
  • example: select distinct * from table(表名) where (条件) 2.存在部分字段相同的纪录(有主键id即唯一键) 如果是这种情况的话用distinct是过滤不了的,这就要用到主键id的唯一性特点及group by分组 example: s....
  • 多表连接查询distinct去重 //分页及排序 pageInfo.setNumber(pageInfo.getNumber() - 1); Pageable pageable = new PageRequest(pageInfo.getNumber(), pageInfo.getSize(), Sort....//查询条件 Specification<...
  • HQL内连接查询去重

    千次阅读 2017-05-25 09:34:49
    因为查询条件需要对 连接的表中的两个字段 or 条件查询 导致查询出来的记录,有重复 一. 使用 group by 主键(用这种可以 再 SELECT COUNT(*) 进行分页,记录数的统计) @Override public List getOrderList(int...
  • MySQL基于文章目录基础查询查询表中单个字段查询表中多个字段查询表中全部字段查询常量值查询表达式条件查询筛选条件方式简单运算符逻辑运算符模糊查询通配符条件查询示例算术运算符示例逻辑运算符示例模糊查询示例...
  • sql count()加distinct和条件去重统计

    千次阅读 2021-01-13 10:07:55
    表数据: userid userType ------------------------------------------ A 1 B 1 B 1 C 2 需求:查出userType=1和userType=2的用户数,并且直接用字段展示出来,可能还有很多...去重加上条件查询: select
  • MySql实现根据某个条件去重求和

    万次阅读 2018-08-09 14:11:50
    //第一图 直接查询出所有的id SELECT d.id FROM t_device d LEFT JOIN t_device_collect_state a on d.id = a.device_collect_id LEFT JOIN t_group b on d.group_id = b....
  • MYSQL中重复记录的查询去重

    千次阅读 2018-08-22 09:44:19
    在项目开发过程中,由于多次跑测试数据,出现了大量的重复数据的情况,因而需要将重复的数据进行删除,从而避免根据某些条件查询数据时,本应该出现一条,实际 出现多条的情况,导致在mybatis中报错~ 举例说明:...
  • 1、上午主要是做两个老板要的统计,其中要涉及到distinct on按字段去重的用法,我发现mysql居然没有这个语法,mysql按字段去重,可以用group by,但这样就是按照系统某种规则取相同的一条记录,比如说我的需求是按某...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 706
精华内容 282
关键字:

查询条件去重