mongodb查询统计

已于 2022-04-25 11:07:25 修改
阅读量2.8k 收藏 2
点赞数
文章标签： java mongodb
于 2022-04-25 11:04:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45232584/article/details/124399959
版权 
 /**
     * 统一查询
     *
     * @param map            前端提交的查询参数
     * @param stockKey       仓库的字段名
     * @param fieldList      查询字段
     * @param countFieldMap  统计字段
     * @param sortMap        排序字段
     * @param collectionName 表名
     * @return
     */
    public Map query(Map map, String stockKey, List<String> fieldList, Map<String, Integer> countFieldMap, Map<String, Integer> sortMap, String collectionName) {
        //默认查询
        QueryUtil queryUtil = defautQuery(map, stockKey);
        //需要查询的字段
        queryUtil.setGroupField(fieldList);
        //默认返回统计字段
        queryUtil.setCountField(countFieldMap);

        //返回统计字段
        queryUtil.setReturnField(fieldList);

        //排序字段
        queryUtil.setSortField(sortMap);

        //查询
        List queryList = queryUtil.queryAssemble();

        List<Map<String, Object>> reList = publicService.aggregateByShell(collectionName, queryList);

        HashMap<String, BigDecimal> countMap = new HashMap<>();
        countFieldMap.forEach((key, Value) -> {
            countMap.put(key + "Total", new BigDecimal(0));
        });
        countMap.remove("countTotal");
        LinkedHashMap<String, Object> reMap = new LinkedHashMap<>();

        if (reList.size() >= 1) {
            Map<String, Object> maps = reList.get(0);


            List<Map> data = (List<Map>) maps.get("data");
            //修正_id
            for (int i = 0; i < data.size(); i++) {
                Map mp = data.get(i);
                String id = String.valueOf(mp.get("id"));
                if (!id.equals("null")) {
                    mp.put(CommonConstants.TABLE_ID, id);
                    data.set(i, mp);
                }
            }
            maps.put("data", data);


            reMap.put("page", maps);

            for (int i = 0; i < data.size(); i++) {
                int j = i;
                countMap.forEach((key, Value) -> {
                    BigDecimal bigDecimal = countMap.get(key);
                    bigDecimal = bigDecimal.add(getBigDecimal(data.get(j).get(key.replaceAll("Total", ""))));
                    countMap.put(key, getBigDecimal(bigDecimal));
                });
            }

        }

        reMap.put("count", countMap);


        return reMap;
    }

查询语句
import com.alibaba.fastjson.JSON;
import com.sckj.basemongodbtool.commonconstants.CommonConstants;
import lombok.Setter;
import org.springframework.stereotype.Component;

import java.util.*;


@Component
public class QueryUtil {
    private static final String GT = "$gt"; //大于
    private static final String GTE = "$gte"; //大于等于
    private static final String LT = "$lt"; //小于
    private static final String LTE = "$lte"; //小于等于
    private static final String NE = "$ne"; //不等于
    private static final String MATCH = "$match"; //匹配关键字
    private static final String GROUP = "$group"; //分组关键字
    private static final String FACET = "$facet"; //部份关键字
    private static final String COUNT = "$count"; //统计加关键字
    private static final String SORT = "$sort"; //统计关键字

    private String gtName = "gt";
    private String gtValue = "gt";

    private String gteName = "gte";
    private String gteValue = "gte";

    private String ltName = "lt";
    private String ltValue = "lt";

    private String lteName = "lte";
    private String lteValue = "lt";

    private String neName = "ne";
    private String neValue = "lt";

    @Setter
    private Integer page = 1;//查询条数
    @Setter
    private Integer pageSize = 10;//跳过条数


    @Setter
    private Map<String, List<String>> matchIn;//查询条件in {查询字段：[字段值]}
    @Setter
    private List<Map<String, Object>> judgeNumber;//判断数字
    @Setter
    private List<String> groupField;//分组字段
    @Setter
    private Map<String, Integer> countField;//统计字段  key为查询字段，value 0 或1  0为字段本身  1为计数
    @Setter
    private List<String> returnField;//返回字段
    @Setter
    private Map<String, Integer> sortField;//排序字段


    /**
     * 组装多条件查询
     *
     * @param matchIn
     * @return
     */
    public LinkedHashMap<String, Object> mapIn(Map<String, List<String>> matchIn) {
        LinkedHashMap<String, Object> reMap = new LinkedHashMap<>();
        matchIn.forEach((key, value) -> {
            reMap.put(key, inFieldToMap(value));
        });
        return reMap;
    }


    /**
     * 组装语句
     *
     * @return
     */
    public List queryAssemble() {
        //查询条件
        List<String> queryList = new ArrayList<>();
        LinkedHashMap<String, Object> queryMap = new LinkedHashMap<>();
        LinkedHashMap<String, Object> matchMap = new LinkedHashMap<>();

        if (matchIn.size() != 0) {
            matchMap = mapIn(matchIn);

        }
        if (judgeNumber != null && !judgeNumber.equals("null") && judgeNumber.size() != 0) {
            for (int i = 0; i < judgeNumber.size(); i++) {
                matchMap.putAll(judgeNumber.get(i));
            }
        }

        if (matchMap.size() != 0) {
            //拼接
            queryMap.put(MATCH, matchMap);
            String match = JSON.toJSONString(queryMap);
            System.out.println(match);
            queryList.add(match);
        }


        //查询字段
        LinkedHashMap<String, Object> groupMap = new LinkedHashMap<>();
        LinkedHashMap<String, Object> groupMapAll = new LinkedHashMap<>();
        //返回查询字段
        LinkedHashMap reMap = returnFieldToMap(returnField);

        //需要查询的字段
        if (groupField.size() != 0) {
            groupMap.put(CommonConstants.TABLE_ID, queryFieldToMap(groupField));
        }

        //需要统计的字段
        if (countField.size() != 0) {
            countField.forEach((key, Value) -> {
                groupMap.put(key, countFieldToMap(key, Value));
                reMap.put(key, 1);
            });
        }
        groupMapAll.put(GROUP, groupMap);
        String group = JSON.toJSONString(groupMapAll);
        System.out.println(group);
        queryList.add(group);


        //返回统计字段
        reMap.put(CommonConstants.TABLE_ID, 0);
        HashMap<Object, Object> projectMap = new HashMap<>();
        projectMap.put("$project", reMap);
        String project = JSON.toJSONString(projectMap);
        System.out.println(project);
        queryList.add(project);

        //排序字段
        LinkedHashMap<Object, Object> sortMap = new LinkedHashMap<>();
        sortField.forEach((key, Value) -> {
            sortMap.put(SORT, sortFieldToMap(key, Value));
        });
        String sort = JSON.toJSONString(sortMap);
        System.out.println(sort);
        queryList.add(sort);

        //分页查询
        LinkedHashMap<String, Object> facetMap = new LinkedHashMap<>();
        LinkedHashMap<String, Object> pageMap = new LinkedHashMap<>();
        ArrayList<Map> totalList = new ArrayList<>();
        LinkedHashMap<String, Object> totalMap = new LinkedHashMap<>();
        //统计字段
        totalMap.put(COUNT, "total");
        totalList.add(totalMap);
        pageMap.put("total", totalList);
        //分页字段
        ArrayList<Map> dataList = new ArrayList<>();
        LinkedHashMap<String, Object> skipMap = new LinkedHashMap<>();
        skipMap.put("$skip", (page - 1) * pageSize);//跳过数量
        dataList.add(skipMap);

        LinkedHashMap<String, Object> limitMap = new LinkedHashMap<>();
        limitMap.put("$limit", pageSize);//查询数量
        dataList.add(limitMap);

        pageMap.put("data", dataList);
        facetMap.put(FACET, pageMap);

        String page = JSON.toJSONString(facetMap);
        System.out.println(page);
        queryList.add(page);


        return queryList;
    }


    /**
     * 数组字段
     *
     * @param list
     * @return
     */
    public static LinkedHashMap inFieldToMap(List<String> list) {
        LinkedHashMap<String, Object> reMap = new LinkedHashMap<>();
        reMap.put("$in", list);
        return reMap;

    }

    /**
     * 查询字段
     *
     * @param list
     * @return
     */
    public static LinkedHashMap queryFieldToMap(List<String> list) {
        LinkedHashMap<Object, Object> map = new LinkedHashMap<>();
        list.forEach(str -> {
            if (str.equals("_id")){
                map.put("id", "$" + str);
            }else {
                map.put(str, "$" + str);
            }

        });
        return map;
    }

    /**
     * 统计字段
     *
     * @param str
     * @return
     */
    public static LinkedHashMap countFieldToMap(String str, int i) {
        LinkedHashMap<Object, Object> map = new LinkedHashMap<>();
        if (i == 0) {
            map.put("$sum", "$" + str);
        }
        if (i == 1) {
            map.put("$sum", 1);
        }


        return map;
    }

    /**
     * 返回字段处理
     *
     * @param list
     * @return
     */
    public static LinkedHashMap returnFieldToMap(List<String> list) {
        LinkedHashMap<Object, Object> reMap = new LinkedHashMap<>();
        list.forEach(str -> {
            if (str.equals("_id")){
                reMap.put("id", "$_id.id" );
            }else {
                reMap.put(str, "$_id." + str);
            }

        });

        return reMap;
    }


    /**
     * 排序字段处理
     *
     * @param str
     * @param i
     * @return
     */
    public static LinkedHashMap sortFieldToMap(String str, int i) {
        LinkedHashMap<Object, Object> reMap = new LinkedHashMap<>();
        reMap.put(str, i);
        return reMap;
    }


}


		对时间数字的处理
import lombok.Setter;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

@Setter
@Component
public class NumberUtil {
    String column = null;

    String gtValue = null;


    String gteValue = null;


    String ltValue = null;


    String lteValue = null;


    String neValue = null;

    private static final String GT = "$gt"; //大于
    private static final String GTE = "$gte"; //大于等于
    private static final String LT = "$lt"; //小于
    private static final String LTE = "$lte"; //小于等于
    private static final String NE = "$ne"; //不等于


    public Map<String, Object> getNumber() {
        HashMap<String, Object> reMap = new HashMap<>();
        HashMap<String, Object> oMap = new HashMap<>();
        if (column != null) {
            if ( gtValue != null) {
                oMap.put(GT, gtValue);
            }
            if ( gteValue != null) {
                oMap.put(GTE, gteValue);
            }
            if ( ltValue != null) {
                oMap.put(LT, ltValue);
            }

            if ( lteValue != null) {
                oMap.put(LTE, lteValue);
            }
            if ( neValue != null) {
                oMap.put(NE, neValue);
            }
            reMap.put(column, oMap);
        }
        return reMap;
    }


}

查询条件组装

import dcocd.custom.slsyxt.Util.DateUtil;
import lombok.Data;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Component
@Data
public class SalesEntity {
    public static final String STOCK = "stock";//门店
    public static String PLATFORM = "platform";//站
    public static String PARAGRAPH = "area";//区域
    public static String WIRE = "wire";//线
    public static String START_TIME = "startTime";//开始时间
    public static String END_TIME = "endTime";//结束时间
    public static String TYPE = "type";//类型
    public static String OTHER = "other";//其他


    public Integer page = 1;//查询条数
    public Integer pageSize = 20;//跳过条数

    public List stock = new ArrayList();
    public List wire = new ArrayList();
    public String startTime;
    public String endTime;
    public String type;
    public Map<String, List<String>> other;


    public static SalesEntity getQuery(Map maps) {
        SalesEntity salesEntity = new SalesEntity();
        if (maps == null || maps.get("paraList") == null) {
            return salesEntity;
        }
        //适配查询参数
        HashMap<Object, Object> map = new HashMap<>();
        map.put("page", maps.get("page"));
        map.put("pageSize", maps.get("pageSize"));
        List<Map> paraList = (List<Map>) maps.get("paraList");
        if (paraList != null) {
            paraList.forEach((tmap) -> {
                tmap.forEach((key, Value) -> {
                    map.put(tmap.get("column"), tmap.get("value"));
                });
            });
        }


        if (map == null || map.size() == 0) {
            return salesEntity;
        }

        if (map.get(TYPE) != null) {
            salesEntity.type = map.get(TYPE).toString();
        }

        if (map.get(OTHER) != null) {
            salesEntity.other = (Map) map.get(OTHER);
        }

        if ((List) map.get(STOCK) != null) {
            salesEntity.stock = (List) map.get(STOCK);//门店
        }

        if ((List) map.get(WIRE) != null) {
            salesEntity.wire = (List) map.get(WIRE);//线
        }

        Object st = map.get(START_TIME);
        if (st != null) {
            salesEntity.startTime = DateUtil.localToUtc(String.valueOf(st));//开始时间
        }
        Object et = map.get(END_TIME);
        if (et != null) {
            salesEntity.endTime = DateUtil.localToUtc(String.valueOf(et));//结束时间
        }
        Object page = map.get("page");
        Object pageSize = map.get("pageSize");
        if (page != null && pageSize != null) {
            salesEntity.page = Integer.parseInt(page.toString());
            salesEntity.pageSize = Integer.parseInt(pageSize.toString());
        }


        return salesEntity;
    }


}

/**
     * 默认查询
     *
     * @param map
     * @return
     */
    public QueryUtil defautQuery(Map map, String name) {

        QueryUtil queryUtil = new QueryUtil();
        //获取查询条件
        SalesEntity query = salesEntity.getQuery(map);
        List stock = query.getStock();
        List wire = query.getWire();
        String startTime = query.getStartTime();
        String endTime = query.getEndTime();
        String type = query.getType();

        Map<String, List<String>> other = query.getOther();

        //获取登录人
        String deptCode = userUtil.getUserInfo().getDeptCode();
        Map<String, Object> shops = getShops(deptCode);

        List<String> shopList = (List<String>) shops.get("data");

        //true
        HashMap<String, List<String>> match = new HashMap<>();

        //判断
        if (!StringUtils.isEmpty(stock) && stock.size() != 0 && !stock.equals("null")) {
            match.put(name, stock);

        } else if (!StringUtils.isEmpty(shopList) && shopList.size() != 0 && !shopList.equals("null")) {
            match.put(name, shopList);

        }
        //判断
        if (!StringUtils.isEmpty(wire) && wire.size() != 0 && !wire.equals("null")) {
            match.put("wire", wire);
        }
        //判断
        if (!StringUtils.isEmpty(type) && type.length() != 0 && !type.equals("null")) {
            ArrayList<String> strings = new ArrayList<>();
            strings.add(type);
            match.put("type", strings);
        }

        //判断其他
        if (!StringUtils.isEmpty(other) && other.size() != 0 && !other.equals("null")) {
            other.forEach((key, value) -> {
                match.put("key", value);
            });

        }


        queryUtil.setMatchIn(match);

        //判断时间
        NumberUtil numberUtil = new NumberUtil();
        if (!StringUtils.isEmpty(startTime) && startTime != null && !startTime.equals("null")) {
            numberUtil.setColumn("ctime");
            numberUtil.setGteValue(startTime);
        }
        if (!StringUtils.isEmpty(endTime) && endTime != null && !endTime.equals("null")) {
            numberUtil.setColumn("ctime");
            numberUtil.setLteValue(endTime);
        }
        if (!StringUtils.isEmpty(numberUtil) && numberUtil != null && !numberUtil.equals("null")) {
            Map<String, Object> number = numberUtil.getNumber();
            if (number.size() != 0) {
                ArrayList<Map<String, Object>> list = new ArrayList<>();
                list.add(number);
                queryUtil.setJudgeNumber(list);
            }

        }
        //分页
        queryUtil.setPage(query.getPage());
        queryUtil.setPageSize(query.getPageSize());

        return queryUtil;
    }

数字转换
 public static BigDecimal getBigDecimal(Object value) {
        BigDecimal ret = null;
        if (value != null) {
            if (value instanceof BigDecimal) {
                ret = (BigDecimal) value;
            } else if (value instanceof String) {
                ret = new BigDecimal((String) value);
            } else if (value instanceof BigInteger) {
                ret = new BigDecimal((BigInteger) value);
            } else if (value instanceof Number) {
                ret = new BigDecimal(((Number) value).doubleValue());
            } else {
                throw new ClassCastException("Not possible to coerce [" + value + "] from class " + value.getClass() + " into a BigDecimal.");
            }
        }
        return ret;
    }

  //保留2位小数
    public BigDecimal getBigDecimal(BigDecimal dou) {

        BigDecimal bigDecimal = new BigDecimal(dou.toString());
        BigDecimal moneys = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP);
        return moneys;
    }

语句查询aggregateByShell
 public List<Map<String, Object>> aggregateByShell(String key, List<String> queryList) {
        List<BasicDBObject> bsonList = new ArrayList();

        for(int r = 0; r < queryList.size(); ++r) {
            BasicDBObject bson = BasicDBObject.parse((String)queryList.get(r));
            bsonList.add(bson);
        }

        MongoCollection<Document> collection = ((MongoTemplate)MongoAop.threadLocal.get()).getCollection(key);
        MongoCursor<Document> cursor = collection.aggregate(bsonList).iterator();

        ArrayList result;
        Document list;
        for(result = new ArrayList(); cursor.hasNext(); result.add(list)) {
            list = (Document)cursor.next();
            if (list.get("_id") != null) {
                list.put("_id", list.get("_id").toString());
            }
        }

        return result;
    }
午后的阳光下
关注
mongodb查询速度慢是什么原因？
weixin_34168880的博客
12-22 937
mongodb查询速度慢是什么原因？ 通过mongodb客户端samus代码研究解决问题 最近有项目需要用到mongodb，于是在网上下载了mongodb的源码，根据示例写了测试代码，但发现一个非常奇怪的问题：插入记录的速度比获取数据的速度还要快，而且最重要的问题是获取数据的速度无法让人接受。 测试场景：主文档存储人员基本信息，子...
MongoDB 统计查询的实现
Vega
10-31 3992
问题：要对每天的数据进行统计产生一个统计报表 这里提到了一些统计框架的介绍，我将对这些做些测试，是否满足需求！ 结果第一条记录的测试就是失败的： distinct
MongoDB数据库统计信息和分析
互联网知识分享
08-23 1027
的统计信息和分析功能对于监控数据库的性能和查询优化非常重要。通过获取数据库和集合的统计信息，我们可以了解数据库的容量和索引使用情况。使用查询分析器和索引分析器，我们可以分析查询语句的性能和索引使用情况，以优化查询性能和索引性能。以上代码展示了如何获取数据库和集合的统计信息，并使用查询分析器和索引分析器来优化查询性能和索引性能。中，我们可以使用统计信息和分析功能来获取有关数据库性能和查询优化的有用信息。查询分析器可以帮助我们分析查询语句的性能和索引使用情况。索引分析器可以帮助我们分析索引的使用情况和性能。
mongodb查看表条数
最新发布
weixin_42492215的博客
07-14 220
MongoDB查看表条数 介绍 在使用 MongoDB 数据库时，有时候我们需要查看某个集合（表）中的文档（数据）条数。这对于监控数据库的大小、优化查询性能等方面都是非常重要的。本文将介绍如何在 MongoDB 中查看表的条数，以及一些注意事项。 查看表条数方法 在 MongoDB 中，要查看表的条数，可以使用 count...
【mongoDB】文档的查询
m0_67930426的博客
01-27 857
跳过第1个文档，按照年龄进行降序排序，并且限制返回的文档数量为3个。先进行排序，再跳过第一个文档，再返回限制的文档数量。跳过第2个文档，按照年龄升序进行排序。例如统计年龄大于等于30的用户数量。统计集合中符合条件的所有记录数。例如，统计每个年龄段的用户数量。例如限制返回文档的数量为4个。查找年龄大于等于28的用户。查找年龄小于等于28的用户。查找年龄不等于28的用户。例如查找名字含有五的用户。例如按照年龄进行升序排序。查找年龄大于28岁的用户。查找年龄小于30的用户。查找年龄等于20的用户。
MongoDB:04---MongoDB统计查询、分页查询、排序查询、比较查询、条件查询
芒种、的博客
04-11 1367
一、文档的查询 1. 统计查询 统计查询使用count()方法，语法如下： db.collection.count(query, options) 参数 类型 说明 query document 查询选择条件 options documnet 可选。用于计数的额外选项 例如： 查询所有记录数 db.collection.count() 例如：按条件统计记录数，统计userid为1003的记录条数 db.collection.count({userid:"1003"}) 提
MongoDB 之聚合函数查询统计
热门推荐
m0_56494324的博客
03-10 1万+
第一关：第1关：聚合管道操作符将文档定制格式输出（一） (命令行) mongo use test1 db.educoder.insert([{ _id:1, course:'Python表达式问题求解实训', author:'李暾', tags:['Python基础','求解'], learning_num:1882 }, { _id:2, course:'Java语言之基本语法', author:
MongoDB查询练习题及答案
07-29
MongoDB 是一种流行的 NoSQL 数据库，以文档型数据存储为主，支持丰富的查询表达能力。在本题中，我们将探讨 MongoDB 的查询操作，基于提供的 `user1` 和 `user2` 文档进行练习。 首先，让我们熟悉一下 `db.users....
MongoDB 查询分析
12-16
explain 操作提供了查询信息，使用索引及查询统计等。有利于我们对索引的优化。 接下来我们在 users 集合中创建 gender 和 user_name 的索引： >db.users.ensureIndex({gender:1,user_name:1}) 现在在查询语句中...
MONGODB查询：使用MONGODB的电影数据库
02-13
MongoDB的聚合框架允许对数据进行更复杂的处理，如统计分析和数据转换。在电影数据库中，你可以计算平均评分或按类型分组： ```javascript db.movies.aggregate([ { $group: { _id: "$genre", avgRating: { $avg: ...
MongoDB复杂分组聚合查询_mongodb分组查询
m0_v648374的博客
04-27 1325
MongoDB 的聚合框架就是将文档输入处理管道，在管道内完成对文档的操作，最终将文档转换为聚合结果，MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理，管道操作是可以重复的。$project可以从文档中选择想要的字段，和不想要的字段（指定的字段可以是来自输入文档或新计算字段的现有字段），也可以通过管道表达式进行一些复杂的操作，例如数学操作，日期操作，字符串操作，逻辑操作。返回包含输入到stage的文档的计数，理解为返回与表或视图的find()查询匹配的文档的计数。
MongoDB 聚合统计
yoyocn的专栏
11-03 2660
MongoDB 中聚合统计SQL
MongoDB系列之数量统计、排序、分页
jxinlina的博客
01-24 886
前段时间项目中用到了MongoDB，上一篇文章介绍了MongoDB的详细查询，今天来介绍一下MongoDB的数量统计、排序和分页。
mongodb的简单操作以及统计查询详细使用步骤
qq_29751083的博客
12-06 4529
1.首先pom文件引入mongodb的依赖 <!--引入mongodb--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> 2.application.properties配置mon..
MongoDB----数据查询 聚合操作
m0_53095312的博客
01-10 1713
where: 使⽤$where后⾯写⼀个函数， 返回满⾜条件的数据// 查询年龄⼤于30的学⽣。
mongodb统计查询相关及csharp方面的应用收集
胡杰的专栏
02-12 2064
mongodb统计查询相关及csharp方面的应用收集 Example 1: Aggregation Framework Basic usage var coll = localDb.GetCollection("examples"); var match = new BsonDocument                  {                      {     
mongoDb按条件统计
qq_21246715的博客
03-04 3679
MongoDatabase db = MongoManager.getMongoDatabase(); MongoCollection&lt;Document&gt; mongoCollection = db.getCollection("db"); BasicDBObject querylocation = new BasicDBObject(); querylocation.put("dat...
分布式数据库NoSQL(四)——MongoDB 之聚合函数查询统计
m0_64139004的博客
09-29 1万+
MongoDB 中聚合( aggregate )主要用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果，通常由聚合管道操作符和聚合表达式组合，完成数据处理。功能有点类似 Sql 语句中的 sum()、agv() 等。
Mongodb 查询所有表的数据量
牛肉胡辣汤
05-18 1621
是MongoDB数据库中的一个方法，用于获取当前数据库中的所有集合（表）的名称列表。请记住，在实际使用时，要将命令和代码中的数据库名和表名替换为实际的名称。当我们使用MongoDB作为数据库时，有时候需要了解数据库中每个表的数据量，以便进行性能调优或者统计分析。可以用于查看当前数据库中的所有集合的名称。并不是一个数据库方法，而是在当前数据库对象上调用的方法。因此，使用时无需指定具体的集合，直接在数据库对象上调用即可。然后，我们连接到数据库、选择要查询的数据库，定义要查询的集合，使用。替换为实际的数据库名。
mongodb 条件查询 分组统计
06-13
好的，MongoDB的条件查询和分组统计可以通过聚合管道实现。以下是一个示例聚合管道，其中包含了条件查询和分组统计操作： ``` db.collection.aggregate([ { $match: { <条件查询表达式> } }, { $group: { _id: <分组表达式>, <统计表达式> } } ]) ``` 其中，`$match` 表达式用于筛选符合条件的文档，可以使用各种查询操作符进行条件查询。例如，如果要查询 `field1` 字段等于 `value1` 的文档，可以使用以下表达式进行查询： ``` { $match: { field1: "value1" } } ``` `$group` 表达式用于分组统计操作，其中 `_id` 表达式用于指定分组的字段，可以是任意字段或字段组合。统计表达式可以是各种聚合操作符，例如 `$sum`、`$avg`、`$max`、`$min` 等。例如，如果要按 `field1` 分组，并统计每组中 `field2` 的平均值，可以使用以下表达式进行查询： ``` { $group: { _id: "$field1", avgField2: { $avg: "$field2" } } } ``` 请根据实际需要修改表达式中的字段名和查询条件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值