如何使用 Node Js 从 mongoose 中的多个集合中搜索或查找数据

Question

我正在构建电影的 MERN 应用程序，我必须在其中实现搜索字段，但我坚持如何通过 MongoDB 中的多个集合运行搜索或查询，并根据 NodeJS 中的搜索获取数据。

控制器/movies.js

        import MoviePost from "../../models/movies/moviesSchema.js";
        import mongoose from 'mongoose'

        export const getAllMov=async(req,res)=>{
            try {
                const data=await MoviePost.find().sort({_id:-1})
                res.status(201).json(data)
            } catch (error) {
                res.status(401).json('error')
            }
        }

        export const getMovById=async(req,res)=>{
            const {id} =req.params
            try {
                const data=await MoviePost.findById(id)
                res.status(201).json(data)
            } catch (error) {
                res.status(401).json('error')
            }
        }

        export const getMov=async(req,res)=>{
            const limit=10
            const page=1
            try {
                const data=await MoviePost.find().sort({_id:-1}).limit(limit * 1).skip((page-1)*limit)
                res.status(201).json(data)
            } catch (error) {
                res.status(401).json('error')
            }
        }

        export const createMov=async(req,res)=>{
            const data=req.body
            const movie=new MoviePost(data)
            try {
                await movie.save()
                res.status(201).json(movie)
            } catch (error) {
                res.status(401).json('error')
            }
        }

        export const updateMov=async(req,res)=>{
            const {id}=req.params
            const updateMovie=req.body
            if(!mongoose.Types.ObjectId.isValid((id))) return res.status(401).json('no data with that id')
            const updatedMovie=await MoviePost.findByIdAndUpdate(id,updateMovie,{new:true})
            res.status(201).json(updatedMovie)
        }

        export const deleteMov=async(req,res)=>{
            const {id}=req.params
            if(!mongoose.Types.ObjectId.isValid((id))) return res.status(401).json('no data with that id')
            await MoviePost.findByIdAndRemove(id)
            res.status(201).json('data Deleted')
        }

        export const getDataBySearch=async(req,res)=>{
            const {searchQuery}=req.query
            try {
                const title=new RegExp(searchQuery,'i')
                const data=await MoviePost.find({title})
                res.status(201).json(data)
            } catch (error) {
                res.status(404).json({message:error.message})
            }
        }

模型中有三个具有相同架构的猫鼬模型，模型在代码中命名：

1. 电影
2. 趋势
3. 网络秀

我将movies.js放在这里同样适用于所有模型

models/movies.js

            import mongoose from 'mongoose'

            const MovieSchema=mongoose.Schema({
                poster:String,
                youtube:String,
                title:String,
                genre:[String],
                director:String,
                duration:String,
                quality:String,
                release:String,
                imdb:String,
                name:String,
                description:String,
                detailtitle:String,
                screenshots:[String],
                createdAt:{
                    type:Date,
                    default:new Date()
                }
            })

            var WebShowPost=mongoose.model('Webshow',MovieSchema)

            export default WebShowPost

至于模型路线都差不多。

routes/movies.js

            import express from 'express'
            const router=express.Router()
            import { createMov, deleteMov, getAllMov, getMov, getMovById, updateMov,getDataBySearch } from '../../controllers/movies/movies.js'

            router.get('/search',getDataBySearch)
            router.get('/',getMov)
            router.get('/all',getAllMov)
            router.get('/:id',getMovById)
            router.post('/',createMov)
            router.patch('/:id',updateMov)
            router.delete('/:id',deleteMov)

            export default router

在主 server.js 中

            import bodyParser from 'body-parser'
            import cors from 'cors'
            import dotenv from 'dotenv'
            import mongoose from 'mongoose'
            import express from 'express'
            import movieRoutes from './routes/routes.js'
            import AdminRoutes from './routes/Admin.js'
            import trendingCardRouter from './routes/movies/Trending.js'
            import movieCardRouter from './routes/movies/movies.js'
            import WebShowRouter from './routes/movies/WebShow.js'

            const app=express()
            dotenv.config({path:'./.env'})

            app.use(bodyParser.json({limit:'4gb',extended:true}))
            app.use(bodyParser.urlencoded({limit:'4gb',extended:true}))
            app.use(cors())

            app.use('/movies',movieRoutes)
            app.use('/admin',AdminRoutes)
            app.use('/trendCard',trendingCardRouter)
            app.use('/movieCard',movieCardRouter)
            app.use('/webshowCard',WebShowRouter)

            app.get('/',(req,res)=>{
                res.send('hello')
            })

            mongoose.connect(process.env.MONGO_URI,{useNewUrlParser:true,useUnifiedTopology:true})
                .then(()=>app.listen('5000',()=> console.log('connected')))
                .catch((err)=>console.log(err))

            mongoose.set('useFindAndModify',false)

还请告诉我如何将数据直接发送回前端

Answer 1

要在数据库中搜索查询，您应该为每个数据库发送查询，我建议使用 Promise.all 以加快搜索速度，例如使用希望在两个集合中搜索 users 和 orders 这样做

Promise.all([
   Users.find(query),
   Orders.find(query)
])
.then(results=>{
    var users =  results[0] //// first call in Promise.all
    var orders = results[1] //// second call in Promise.all
})
.catch(errors=>{
    console.log('errors' : errors)
})

Answer 2

您可以使用Aggregation 管道，在第一阶段您可以使用$unionWith 合并来自不同集合的文档，然后在第二阶段您可以使用$match 在某个字段上进行搜索。

Collection_1.aggregate([
  {
    "$unionWith": {
      "coll": "collection_2"
    }
  },
  {
    "$match": {
      "filed_name": {
        "$regex": "search_query"
      }
    }
  }
])