4_advanced_queries.js

const { connect, closeConnection } = require('./0_connection');

// Comparison Operators Examples
async function comparisonOperators() {
    const db = await connect();
    try {
        // $eq - Equals
        const exactPrice = await db.collection('products')
            .find({ price: { $eq: 199.99 } })
            .toArray();

        // $gt, $gte - Greater than, Greater than or equal
        const expensiveProducts = await db.collection('products')
            .find({
                price: {
                    $gt: 500,    // price > 500
                    $lte: 2000   // price <= 2000
                }
            })
            .toArray();

        // $in - Match any value in array
        const specificCategories = await db.collection('products')
            .find({
                category: {
                    $in: ["Electronics", "Accessories"]
                }
            })
            .toArray();

        // $ne - Not equal
        const notElectronics = await db.collection('products')
            .find({
                category: { $ne: "Electronics" }
            })
            .toArray();

        console.log('Comparison operator results:', {
            exactPrice,
            expensiveProducts,
            specificCategories,
            notElectronics
        });
    } catch (error) {
        console.error('Error in comparison operators:', error);
    }
}

// Logical Operators Examples
async function logicalOperators() {
    const db = await connect();
    try {
        // $and operator
        const androidPhones = await db.collection('products')
            .find({
                $and: [
                    { category: "Electronics" },
                    { "specifications.os": "Android" },
                    { price: { $lt: 1000 } }
                ]
            })
            .toArray();

        // $or operator
        const dealItems = await db.collection('products')
            .find({
                $or: [
                    { on_sale: true },
                    { clearance: true }
                ]
            })
            .toArray();

        // $nor operator - neither condition is true
        const regularItems = await db.collection('products')
            .find({
                $nor: [
                    { on_sale: true },
                    { clearance: true }
                ]
            })
            .toArray();

        // Complex query combining operators
        const specificProducts = await db.collection('products')
            .find({
                $and: [
                    {
                        $or: [
                            { category: "Electronics" },
                            { category: "Accessories" }
                        ]
                    },
                    {
                        price: { $gt: 100 }
                    },
                    {
                        in_stock: true
                    }
                ]
            })
            .toArray();

        console.log('Logical operator results:', {
            androidPhones,
            dealItems,
            regularItems,
            specificProducts
        });
    } catch (error) {
        console.error('Error in logical operators:', error);
    }
}

// Sorting and Limiting Results
async function sortingAndPagination() {
    const db = await connect();
    try {
        // Basic sorting
        const sortedByPrice = await db.collection('products')
            .find({})
            .sort({ price: -1 })  // -1 for descending, 1 for ascending
            .toArray();

        // Multiple sort conditions
        const complexSort = await db.collection('products')
            .find({})
            .sort({
                category: 1,    // First sort by category (ascending)
                price: -1       // Then by price (descending)
            })
            .toArray();

        // Pagination example
        const pageSize = 10;
        const pageNumber = 1;
        const paginatedResults = await db.collection('products')
            .find({})
            .skip(pageSize * (pageNumber - 1))
            .limit(pageSize)
            .toArray();

        // Combining everything
        const filteredSortedPaginated = await db.collection('products')
            .find({
                price: { $gt: 100 },
                in_stock: true
            })
            .sort({ price: 1 })
            .skip(0)
            .limit(5)
            .toArray();

        console.log('Sorting and pagination results:', {
            sortedByPrice,
            complexSort,
            paginatedResults,
            filteredSortedPaginated
        });
    } catch (error) {
        console.error('Error in sorting and pagination:', error);
    } finally {
        await closeConnection();
    }
}

// Run all examples if this file is run directly
if (require.main === module) {
    async function runAll() {
        await comparisonOperators();
        await logicalOperators();
        await sortingAndPagination();
    }
    runAll();
}

module.exports = {
    comparisonOperators,
    logicalOperators,
    sortingAndPagination
};