"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; function _createMdxContent(props) { const _components = { code: "code", h3: "h3", li: "li", ol: "ol", p: "p", pre: "pre", strong: "strong", table: "table", tbody: "tbody", td: "td", th: "th", thead: "thead", tr: "tr", ul: "ul", ..._provideComponents(), ...props.components }, {Answer, Assessment, CodeBlock, ComparisonTable, ContentAttribution, DefinitionEntry, DefinitionGroup, English, Explanation, Hinglish, ImportantQA, KeyPoints, MCQ, Practical, Prompt, QAQuestion, Remember, SubTopicHeader, Theory, TopicOverview} = _components; if (!Answer) _missingMdxReference("Answer", true); if (!Assessment) _missingMdxReference("Assessment", true); if (!CodeBlock) _missingMdxReference("CodeBlock", true); if (!ComparisonTable) _missingMdxReference("ComparisonTable", true); if (!ContentAttribution) _missingMdxReference("ContentAttribution", true); if (!DefinitionEntry) _missingMdxReference("DefinitionEntry", true); if (!DefinitionGroup) _missingMdxReference("DefinitionGroup", true); if (!English) _missingMdxReference("English", true); if (!Explanation) _missingMdxReference("Explanation", true); if (!Hinglish) _missingMdxReference("Hinglish", true); if (!ImportantQA) _missingMdxReference("ImportantQA", true); if (!KeyPoints) _missingMdxReference("KeyPoints", true); if (!MCQ) _missingMdxReference("MCQ", true); if (!Practical) _missingMdxReference("Practical", true); if (!Prompt) _missingMdxReference("Prompt", true); if (!QAQuestion) _missingMdxReference("QAQuestion", true); if (!Remember) _missingMdxReference("Remember", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!Theory) _missingMdxReference("Theory", true); if (!TopicOverview) _missingMdxReference("TopicOverview", true); return _jsxs(_Fragment, { children: [_jsxs(Theory, { children: [_jsx(SubTopicHeader, { id: "3.3", title: "Operators: Relational, Arithmetic, Logical, Set Operators" }), _jsx(English, { children: _jsx(TopicOverview, { title: "SQL Operators: The Building Blocks of Queries", topicId: "3.3", readingTime: "10 min read", difficulty: "Easy", children: _jsx(_components.p, { children: "Operators are the fundamental building blocks of every SQL query. They allow you to perform calculations, compare values, filter rows based on conditions, and combine results from multiple queries. SQL provides four major categories of operators: Arithmetic operators for mathematical computations, Relational (comparison) operators for comparing values, Logical operators for combining multiple conditions, and Set operators for combining results of two or more SELECT statements. Mastering these operators is essential for writing effective queries, from simple data retrieval to complex analytical reporting. Understanding when and how to use each operator type helps you write efficient, readable, and correct SQL code." }) }) }), _jsx(Hinglish, { children: _jsx(TopicOverview, { title: "SQL Operators: Queries Ke Building Blocks", topicId: "3.3", readingTime: "10 min read", difficulty: "Easy", children: _jsx(_components.p, { children: "Operators har SQL query ke fundamental building blocks hain. Ye aapko calculations karne, values compare karne, conditions ke basis pe rows filter karne, aur do ya zyada SELECT statements ke results combine karne mein madad karte hain. SQL mein chaar major categories ke operators hain: Arithmetic operators jo mathematical computations ke liye hain, Relational (comparison) operators jo values compare karne ke liye hain, Logical operators jo multiple conditions combine karne ke liye hain, aur Set operators jo do ya zyada SELECT statements ke results combine karne ke liye hain. In operators ko master karna effective queries likhne ke liye zaroori hai — simple data retrieval se lekar complex analytical reporting tak. Kab aur kaunsa operator type use karna hai ye samajhna aapko efficient, readable, aur correct SQL code likhne mein madad karta hai." }) }) }), _jsxs(DefinitionGroup, { children: [_jsx(DefinitionEntry, { term: "Arithmetic Operators", children: _jsx(_components.p, { children: "Arithmetic operators mathematical operations perform karne ke liye use hote hain SQL queries mein. Inmein addition (+), subtraction (-), multiplication (*), division (/), aur modulus (%) shamil hain. Ye operators SELECT statements mein columns ke saath calculations karne ke liye use kiye jaate hain. Example: Salary * 12 se annual salary nikal sakte hain." }) }), _jsx(DefinitionEntry, { term: "Relational Operators", children: _jsx(_components.p, { children: "Relational operators (jise comparison operators bhi kehte hain) do values ke beech comparison karke BOOLEAN result (TRUE ya FALSE) return karte hain. Inmein equal to (=), not equal to (!= ya <>), less than (<), less than or equal to (<=), greater than (>), aur greater than or equal to (>=) shamil hain. Ye operators WHERE clause mein conditions define karne ke liye use hote hain." }) }), _jsx(DefinitionEntry, { term: "Logical Operators", children: _jsx(_components.p, { children: "Logical operators multiple conditions ko combine karke ek single BOOLEAN result produce karte hain. Major logical operators hain: AND (jab dono conditions TRUE hon), OR (jab koi bhi condition TRUE ho), NOT (condition ka opposite). Additional logical operators include IN, BETWEEN, LIKE, aur IS NULL jo specific pattern matching aur range checking ke liye use hote hain." }) }), _jsx(DefinitionEntry, { term: "Set Operators", children: _jsx(_components.p, { children: "Set operators do ya zyada SELECT statements ke results ko combine karte hain. Char major set operators hain: UNION (dono queries ke results combine, duplicates remove), UNION ALL (dono queries ke results combine, duplicates retain), INTERSECT (sirf common rows return), aur MINUS/EXCEPT (pehli query mein jo rows hain lekin doosri mein nahi)." }) }), _jsx(DefinitionEntry, { term: "BETWEEN Operator", children: _jsx(_components.p, { children: "BETWEEN operator ek specified range ke andar values ko match karta hai. Ye inclusive hota hai — dono boundary values include hoti hain. Syntax: column BETWEEN value1 AND value2. Example: Age BETWEEN 18 AND 25 sabhi students select karta hai jinki age 18 se 25 ke beech hai (18 aur 25 dono shamil)." }) }), _jsx(DefinitionEntry, { term: "IN Operator", children: _jsx(_components.p, { children: "IN operator ek column ka value ek specified list of values mein exist karta hai ya nahi check karta hai. Ye multiple OR conditions ka shorthand hai. Example: Branch IN ('CS', 'IT', 'CE') woh sabhi students select karta hai jinka branch CS, IT, ya CE hai." }) }), _jsx(DefinitionEntry, { term: "LIKE Operator", children: _jsx(_components.p, { children: "LIKE operator pattern matching ke liye use hota hai aur do wildcards support karta hai: percent sign (%) jo zero ya zyada characters ko match karta hai, aur underscore (_) jo exactly ek character ko match karta hai. Example: Name LIKE 'R%' sabhi names match karta hai jo R se shuru hote hain, aur Name LIKE '_ahul' wo name match karta hai jismein doosra character 'a' ho." }) }), _jsx(DefinitionEntry, { term: "IS NULL Operator", children: _jsx(_components.p, { children: "IS NULL operator check karta hai ki ek column ki value NULL hai ya nahi. NULL ka matlab hai data exist nahi karta ya unknown hai. IS NOT NULL opposite hai — ye non-NULL values return karta hai. Important: NULL se comparison karne ke liye = operator ka use nahi hota, hamesha IS NULL ya IS NOT NULL use karna chahiye." }) })] }), _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "Arithmetic Operators" }), _jsx(_components.p, { children: "SQL provides five arithmetic operators for performing mathematical calculations directly on column values:" }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Operator" }), _jsx(_components.th, { children: "Description" }), _jsx(_components.th, { children: "Example" }), _jsx(_components.th, { children: "Result" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "+" }), _jsx(_components.td, { children: "Addition" }), _jsx(_components.td, { children: "10 + 5" }), _jsx(_components.td, { children: "15" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "-" }), _jsx(_components.td, { children: "Subtraction" }), _jsx(_components.td, { children: "10 - 5" }), _jsx(_components.td, { children: "5" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "*" }), _jsx(_components.td, { children: "Multiplication" }), _jsx(_components.td, { children: "10 * 5" }), _jsx(_components.td, { children: "50" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "/" }), _jsx(_components.td, { children: "Division" }), _jsx(_components.td, { children: "10 / 5" }), _jsx(_components.td, { children: "2" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "%" }), _jsx(_components.td, { children: "Modulus (Remainder)" }), _jsx(_components.td, { children: "10 % 3" }), _jsx(_components.td, { children: "1" })] })] })] }), _jsx(CodeBlock, { language: "sql", children: `-- Calculate annual salary from monthly salary SELECT Name, Salary, Salary * 12 AS AnnualSalary FROM Employee; -- Find discount price SELECT ProductName, Price, Price * 0.10 AS DiscountAmount, Price - (Price * 0.10) AS FinalPrice FROM Products; -- Modulus to find even-numbered IDs SELECT * FROM Student WHERE StudentID % 2 = 0;` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Operator Precedence (BODMAS rule applies):" }) }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "*" }), ", ", _jsx(_components.code, { children: "/" }), ", ", _jsx(_components.code, { children: "%" }), " (evaluated first)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" }), " (evaluated second)"] }), "\n", _jsxs(_components.li, { children: ["Use parentheses ", _jsx(_components.code, { children: "()" }), " to override precedence"] }), "\n"] }), _jsx(_components.h3, { children: "Relational (Comparison) Operators" }), _jsx(_components.p, { children: "Relational operators compare two values and return TRUE, FALSE, or UNKNOWN (when NULL is involved):" }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Operator" }), _jsx(_components.th, { children: "Description" }), _jsx(_components.th, { children: "Example" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "=" }), _jsx(_components.td, { children: "Equal to" }), _jsx(_components.td, { children: "Age = 20" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "!= or <>" }), _jsx(_components.td, { children: "Not equal to" }), _jsx(_components.td, { children: "Age != 20" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "<" }), _jsx(_components.td, { children: "Less than" }), _jsx(_components.td, { children: "Age < 20" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "<=" }), _jsx(_components.td, { children: "Less than or equal to" }), _jsx(_components.td, { children: "Age <= 20" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: ">" }), _jsx(_components.td, { children: "Greater than" }), _jsx(_components.td, { children: "Age > 20" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: ">=" }), _jsx(_components.td, { children: "Greater than or equal to" }), _jsx(_components.td, { children: "Age >= 20" })] })] })] }), _jsx(CodeBlock, { language: "sql", children: `-- Find students older than 20 SELECT * FROM Student WHERE Age > 20; -- Find CS branch students SELECT * FROM Student WHERE Branch = 'CS'; -- Find students whose name is not Rahul SELECT * FROM Student WHERE Name != 'Rahul';` }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Important NULL Behavior:" }), "\r\nWhen comparing with NULL using any relational operator, the result is UNKNOWN (not TRUE or FALSE). That is why ", _jsx(_components.code, { children: "Age = NULL" }), " does not work — you must use ", _jsx(_components.code, { children: "IS NULL" }), "."] }), _jsx(_components.h3, { children: "Logical Operators" }), _jsx(_components.p, { children: "Logical operators combine multiple conditions into a single result:" }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "AND Operator:" }), "\r\nReturns TRUE only when ", _jsx(_components.strong, { children: "both" }), " conditions are TRUE."] }), _jsx(CodeBlock, { language: "sql", children: `-- Students in CS branch AND older than 20 SELECT * FROM Student WHERE Branch = 'CS' AND Age > 20;` }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "OR Operator:" }), "\r\nReturns TRUE when ", _jsx(_components.strong, { children: "at least one" }), " condition is TRUE."] }), _jsx(CodeBlock, { language: "sql", children: `-- Students in CS OR IT branch SELECT * FROM Student WHERE Branch = 'CS' OR Branch = 'IT';` }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "NOT Operator:" }), "\r\nNegates (reverses) the condition."] }), _jsx(CodeBlock, { language: "sql", children: `-- Students NOT in CS branch SELECT * FROM Student WHERE NOT Branch = 'CS';` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Truth Table for AND and OR:" }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Condition A" }), _jsx(_components.th, { children: "Condition B" }), _jsx(_components.th, { children: "A AND B" }), _jsx(_components.th, { children: "A OR B" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "TRUE" }), _jsx(_components.td, { children: "TRUE" }), _jsx(_components.td, { children: "TRUE" }), _jsx(_components.td, { children: "TRUE" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "TRUE" }), _jsx(_components.td, { children: "FALSE" }), _jsx(_components.td, { children: "FALSE" }), _jsx(_components.td, { children: "TRUE" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "FALSE" }), _jsx(_components.td, { children: "TRUE" }), _jsx(_components.td, { children: "FALSE" }), _jsx(_components.td, { children: "TRUE" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "FALSE" }), _jsx(_components.td, { children: "FALSE" }), _jsx(_components.td, { children: "FALSE" }), _jsx(_components.td, { children: "FALSE" })] })] })] }), _jsx(_components.h3, { children: "Special Logical Operators: BETWEEN, IN, LIKE, IS NULL" }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "BETWEEN — Range Check:" }) }), _jsx(CodeBlock, { language: "sql", children: `-- Students with age between 18 and 25 (inclusive) SELECT * FROM Student WHERE Age BETWEEN 18 AND 25; -- Equivalent to: SELECT * FROM Student WHERE Age >= 18 AND Age <= 25;` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "IN — List Match:" }) }), _jsx(CodeBlock, { language: "sql", children: `-- Students in CS, IT, or CE branch SELECT * FROM Student WHERE Branch IN ('CS', 'IT', 'CE'); -- Equivalent to: SELECT * FROM Student WHERE Branch = 'CS' OR Branch = 'IT' OR Branch = 'CE';` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "LIKE — Pattern Match:" }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Wildcard" }), _jsx(_components.th, { children: "Meaning" }), _jsx(_components.th, { children: "Example" }), _jsx(_components.th, { children: "Matches" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "%" }), _jsx(_components.td, { children: "Zero or more characters" }), _jsx(_components.td, { children: "'R%'" }), _jsx(_components.td, { children: "Rahul, Ravi, Raj" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "_" }), _jsx(_components.td, { children: "Exactly one character" }), _jsx(_components.td, { children: "'_ahul'" }), _jsx(_components.td, { children: "Rahul (not Rshul)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "%com%" }), _jsx(_components.td, { children: "Contains 'com'" }), _jsx(_components.td, { children: "'%com%'" }), _jsx(_components.td, { children: "computer, domain.com" })] })] })] }), _jsx(CodeBlock, { language: "sql", children: `-- Names starting with R SELECT * FROM Student WHERE Name LIKE 'R%'; -- Names ending with 'ul' SELECT * FROM Student WHERE Name LIKE '%ul'; -- Names where second character is 'a' SELECT * FROM Student WHERE Name LIKE '_a%'; -- Names with exactly 5 characters SELECT * FROM Student WHERE Name LIKE '_____';` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "IS NULL — Null Check:" }) }), _jsx(CodeBlock, { language: "sql", children: `-- Find students with no email SELECT * FROM Student WHERE Email IS NULL; -- Find students who have an email SELECT * FROM Student WHERE Email IS NOT NULL;` }), _jsx(_components.h3, { children: "Set Operators" }), _jsx(_components.p, { children: "Set operators combine the results of two or more SELECT statements. Each SELECT must have the same number of columns with compatible data types." }), _jsx(CodeBlock, { language: "sql", children: `-- UNION: Combined results, duplicates removed SELECT Name FROM CS_Students UNION SELECT Name FROM IT_Students; -- UNION ALL: Combined results, duplicates kept SELECT Name FROM CS_Students UNION ALL SELECT Name FROM IT_Students; -- INTERSECT: Only common rows SELECT Name FROM CS_Students INTERSECT SELECT Name FROM IT_Students; -- MINUS: Rows in first query but not in second SELECT Name FROM CS_Students MINUS SELECT Name FROM IT_Students;` })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "Arithmetic Operators" }), _jsx(_components.p, { children: "SQL paanch arithmetic operators deta hai jo seedhe column values pe mathematical calculations perform karne ke liye hain:" }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Operator" }), _jsx(_components.th, { children: "Description" }), _jsx(_components.th, { children: "Example" }), _jsx(_components.th, { children: "Result" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "+" }), _jsx(_components.td, { children: "Addition" }), _jsx(_components.td, { children: "10 + 5" }), _jsx(_components.td, { children: "15" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "-" }), _jsx(_components.td, { children: "Subtraction" }), _jsx(_components.td, { children: "10 - 5" }), _jsx(_components.td, { children: "5" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "*" }), _jsx(_components.td, { children: "Multiplication" }), _jsx(_components.td, { children: "10 * 5" }), _jsx(_components.td, { children: "50" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "/" }), _jsx(_components.td, { children: "Division" }), _jsx(_components.td, { children: "10 / 5" }), _jsx(_components.td, { children: "2" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "%" }), _jsx(_components.td, { children: "Modulus (Remainder)" }), _jsx(_components.td, { children: "10 % 3" }), _jsx(_components.td, { children: "1" })] })] })] }), _jsx(CodeBlock, { language: "sql", children: `-- Monthly salary se annual salary calculate karo SELECT Name, Salary, Salary * 12 AS AnnualSalary FROM Employee; -- Discount price find karo SELECT ProductName, Price, Price * 0.10 AS DiscountAmount, Price - (Price * 0.10) AS FinalPrice FROM Products; -- Modulus use karke even-numbered IDs dhundho SELECT * FROM Student WHERE StudentID % 2 = 0;` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Operator Precedence (BODMAS rule lagta hai):" }) }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "*" }), ", ", _jsx(_components.code, { children: "/" }), ", ", _jsx(_components.code, { children: "%" }), " (pehle evaluate hote hain)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" }), " (baad mein evaluate hote hain)"] }), "\n", _jsxs(_components.li, { children: ["Precedence override karne ke liye parentheses ", _jsx(_components.code, { children: "()" }), " use karo"] }), "\n"] }), _jsx(_components.h3, { children: "Relational (Comparison) Operators" }), _jsx(_components.p, { children: "Relational operators do values compare karte hain aur TRUE, FALSE, ya UNKNOWN return karte hain (jab NULL involved ho):" }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Operator" }), _jsx(_components.th, { children: "Description" }), _jsx(_components.th, { children: "Example" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "=" }), _jsx(_components.td, { children: "Equal to" }), _jsx(_components.td, { children: "Age = 20" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "!= ya <>" }), _jsx(_components.td, { children: "Not equal to" }), _jsx(_components.td, { children: "Age != 20" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "<" }), _jsx(_components.td, { children: "Less than" }), _jsx(_components.td, { children: "Age < 20" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "<=" }), _jsx(_components.td, { children: "Less than or equal to" }), _jsx(_components.td, { children: "Age <= 20" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: ">" }), _jsx(_components.td, { children: "Greater than" }), _jsx(_components.td, { children: "Age > 20" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: ">=" }), _jsx(_components.td, { children: "Greater than or equal to" }), _jsx(_components.td, { children: "Age >= 20" })] })] })] }), _jsx(CodeBlock, { language: "sql", children: `-- 20 se zyada umar ke students dhundho SELECT * FROM Student WHERE Age > 20; -- CS branch ke students dhundho SELECT * FROM Student WHERE Branch = 'CS'; -- Jinka naam Rahul nahi hai SELECT * FROM Student WHERE Name != 'Rahul';` }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "NULL Ka Important Behavior:" }), "\r\nJab bhi kisi bhi relational operator se NULL se compare karte ho toh result UNKNOWN aata hai (TRUE ya FALSE nahi). Isliye ", _jsx(_components.code, { children: "Age = NULL" }), " kaam nahi karta — hamesha ", _jsx(_components.code, { children: "IS NULL" }), " use karna chahiye."] }), _jsx(_components.h3, { children: "Logical Operators" }), _jsx(_components.p, { children: "Logical operators multiple conditions ko combine karke ek single result banate hain:" }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "AND Operator:" }), "\r\nSirf tab TRUE return karta hai jab ", _jsx(_components.strong, { children: "dono" }), " conditions TRUE hon."] }), _jsx(CodeBlock, { language: "sql", children: `-- CS branch KE SAATH 20 se zyada umar ke students SELECT * FROM Student WHERE Branch = 'CS' AND Age > 20;` }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "OR Operator:" }), "\r\nTab TRUE return karta hai jab ", _jsx(_components.strong, { children: "kam se kam ek" }), " condition TRUE ho."] }), _jsx(CodeBlock, { language: "sql", children: `-- CS YA IT branch ke students SELECT * FROM Student WHERE Branch = 'CS' OR Branch = 'IT';` }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "NOT Operator:" }), "\r\nCondition ka opposite (negate) karta hai."] }), _jsx(CodeBlock, { language: "sql", children: `-- CS branch KE ALAWA sabhi students SELECT * FROM Student WHERE NOT Branch = 'CS';` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "AND aur OR ke liye Truth Table:" }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Condition A" }), _jsx(_components.th, { children: "Condition B" }), _jsx(_components.th, { children: "A AND B" }), _jsx(_components.th, { children: "A OR B" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "TRUE" }), _jsx(_components.td, { children: "TRUE" }), _jsx(_components.td, { children: "TRUE" }), _jsx(_components.td, { children: "TRUE" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "TRUE" }), _jsx(_components.td, { children: "FALSE" }), _jsx(_components.td, { children: "FALSE" }), _jsx(_components.td, { children: "TRUE" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "FALSE" }), _jsx(_components.td, { children: "TRUE" }), _jsx(_components.td, { children: "FALSE" }), _jsx(_components.td, { children: "TRUE" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "FALSE" }), _jsx(_components.td, { children: "FALSE" }), _jsx(_components.td, { children: "FALSE" }), _jsx(_components.td, { children: "FALSE" })] })] })] }), _jsx(_components.h3, { children: "Special Logical Operators: BETWEEN, IN, LIKE, IS NULL" }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "BETWEEN — Range Check:" }) }), _jsx(CodeBlock, { language: "sql", children: `-- 18 se 25 ke beech umar ke students (dono inclusive) SELECT * FROM Student WHERE Age BETWEEN 18 AND 25; -- Equivalent: SELECT * FROM Student WHERE Age >= 18 AND Age <= 25;` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "IN — List Match:" }) }), _jsx(CodeBlock, { language: "sql", children: `-- CS, IT, ya CE branch ke students SELECT * FROM Student WHERE Branch IN ('CS', 'IT', 'CE'); -- Equivalent: SELECT * FROM Student WHERE Branch = 'CS' OR Branch = 'IT' OR Branch = 'CE';` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "LIKE — Pattern Match:" }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Wildcard" }), _jsx(_components.th, { children: "Meaning" }), _jsx(_components.th, { children: "Example" }), _jsx(_components.th, { children: "Matches" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "%" }), _jsx(_components.td, { children: "Zero ya zyada characters" }), _jsx(_components.td, { children: "'R%'" }), _jsx(_components.td, { children: "Rahul, Ravi, Raj" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "_" }), _jsx(_components.td, { children: "Exactly ek character" }), _jsx(_components.td, { children: "'_ahul'" }), _jsx(_components.td, { children: "Rahul (Rshul nahi)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "%com%" }), _jsx(_components.td, { children: "'com' contain kare" }), _jsx(_components.td, { children: "'%com%'" }), _jsx(_components.td, { children: "computer, domain.com" })] })] })] }), _jsx(CodeBlock, { language: "sql", children: `-- R se shuru hone wale names SELECT * FROM Student WHERE Name LIKE 'R%'; -- 'ul' se khatam hone wale names SELECT * FROM Student WHERE Name LIKE '%ul'; -- Jismein doosra character 'a' ho SELECT * FROM Student WHERE Name LIKE '_a%'; -- Exactly 5 characters wale names SELECT * FROM Student WHERE Name LIKE '_____';` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "IS NULL — Null Check:" }) }), _jsx(CodeBlock, { language: "sql", children: `-- Jin students ka email nahi hai SELECT * FROM Student WHERE Email IS NULL; -- Jin students ke paas email hai SELECT * FROM Student WHERE Email IS NOT NULL;` }), _jsx(_components.h3, { children: "Set Operators" }), _jsx(_components.p, { children: "Set operators do ya zyada SELECT statements ke results ko combine karte hain. Har SELECT ke paas same number of columns hone chahiye aur compatible data types hone chahiye." }), _jsx(CodeBlock, { language: "sql", children: `-- UNION: Combined results, duplicates hataye jaate hain SELECT Name FROM CS_Students UNION SELECT Name FROM IT_Students; -- UNION ALL: Combined results, duplicates bhi rehte hain SELECT Name FROM CS_Students UNION ALL SELECT Name FROM IT_Students; -- INTERSECT: Sirf common rows aati hain SELECT Name FROM CS_Students INTERSECT SELECT Name FROM IT_Students; -- MINUS: Pehli query mein jo hain lekin doosri mein nahi SELECT Name FROM CS_Students MINUS SELECT Name FROM IT_Students;` })] }), _jsx(ComparisonTable, { title: "Relational vs Logical Operators", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Aspect" }), _jsx(_components.th, { children: "Relational Operators" }), _jsx(_components.th, { children: "Logical Operators" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Purpose" }), _jsx(_components.td, { children: "Do values compare karna" }), _jsx(_components.td, { children: "Multiple conditions combine karna" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Returns" }), _jsx(_components.td, { children: "Boolean (TRUE/FALSE/UNKNOWN)" }), _jsx(_components.td, { children: "Boolean (TRUE/FALSE)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Works on" }), _jsx(_components.td, { children: "Individual values" }), _jsx(_components.td, { children: "Boolean expressions" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Examples" }), _jsx(_components.td, { children: "=, <, >, <=, >=, !=" }), _jsx(_components.td, { children: "AND, OR, NOT" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Used in" }), _jsx(_components.td, { children: "WHERE clause conditions" }), _jsx(_components.td, { children: "WHERE clause mein conditions join karne ke liye" })] })] })] }) }), _jsx(ComparisonTable, { title: "UNION vs UNION ALL vs INTERSECT vs MINUS", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Operator" }), _jsx(_components.th, { children: "Result" }), _jsx(_components.th, { children: "Duplicates" }), _jsx(_components.th, { children: "Order of Queries" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "UNION" }), _jsx(_components.td, { children: "Dono queries ke combined rows" }), _jsx(_components.td, { children: "Remove hoti hain" }), _jsx(_components.td, { children: "Dono SELECT same columns hone chahiye" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "UNION ALL" }), _jsx(_components.td, { children: "Dono queries ke combined rows" }), _jsx(_components.td, { children: "Retain hoti hain" }), _jsx(_components.td, { children: "Faster than UNION kyunki duplicate check nahi hota" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "INTERSECT" }), _jsx(_components.td, { children: "Sirf dono queries mein common rows" }), _jsx(_components.td, { children: "Remove hoti hain" }), _jsx(_components.td, { children: "Dono queries ka schema same hona chahiye" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "MINUS" }), _jsx(_components.td, { children: "Pehli query mein jo rows hain lekin doosri mein nahi" }), _jsx(_components.td, { children: "Remove hoti hain" }), _jsx(_components.td, { children: "Order matter karta hai — MINUS A B ≠ MINUS B A" })] })] })] }) }), _jsx(KeyPoints, { children: _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Arithmetic Operators" }), " (+, -, *, /, %) mathematical calculations ke liye hain — BODMAS precedence follow hota hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Relational Operators" }), " (=, !=, <, >, <=, >=) values compare karke TRUE/FALSE/UNKNOWN return karte hain"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Logical Operators" }), " (AND, OR, NOT) multiple conditions combine karte hain"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "BETWEEN" }), " inclusive range check karta hai — dono boundary values include hoti hain"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "IN" }), " ek column ki value specified list mein check karta hai — multiple OR ka shorthand hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "LIKE" }), " pattern matching ke liye hai — % (zero ya zyada chars) aur _ (exactly ek char) wildcards use hota hai"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "IS NULL" }), " hamesha NULL check karne ke liye use karo — ", _jsx(_components.code, { children: "= NULL" }), " kaam nahi karta"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Set Operators" }), " (UNION, UNION ALL, INTERSECT, MINUS) do SELECT statements ke results combine karte hain"] }), "\n"] }) }), _jsx(Remember, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["NULL se compare karne ke liye hamesha IS NULL ya IS NOT NULL use karo — ", _jsx(_components.code, { children: "= NULL" }), " ya ", _jsx(_components.code, { children: "!= NULL" }), " kaam nahi karta"] }), "\n", _jsxs(_components.li, { children: ["BETWEEN inclusive hota hai — ", _jsx(_components.code, { children: "Age BETWEEN 18 AND 25" }), " mein 18 aur 25 dono shamil hain"] }), "\n", _jsx(_components.li, { children: "LIKE ke wildcard: % = zero ya zyada characters, _ = exactly ek character" }), "\n", _jsx(_components.li, { children: "UNION duplicates remove karta hai, UNION ALL duplicates rakhta hai — UNION ALL faster hai" }), "\n", _jsx(_components.li, { children: "MINUS order matter karta hai: MINUS A B aur MINUS B A alag results dete hain" }), "\n", _jsxs(_components.li, { children: ["Logical operators mein AND ka precedence OR se zyada hota hai — ", _jsx(_components.code, { children: "A OR B AND C" }), " means ", _jsx(_components.code, { children: "A OR (B AND C)" })] }), "\n", _jsx(_components.li, { children: "Arithmetic operators mein BODMAS follow hota hai — parentheses use karo confusion avoid karne ke liye" }), "\n"] }) })] }), _jsxs(_components.p, { children: ["=", _jsx("mark", { children: "SUMMARY_SEPARATOR" }), "="] }), _jsxs(_components.p, { children: ["SQL Operators queries ke building blocks hain. Arithmetic operators (+, -, *, /, %) mathematical calculations ke liye hain. Relational operators (=, !=, <, >) values compare karte hain. Logical operators (AND, OR, NOT) conditions combine karte hain. Special operators jaise BETWEEN (range check), IN (list match), LIKE (pattern match with % and _ wildcards), aur IS NULL (null check) specific use cases ke liye hain. Set operators (UNION, UNION ALL, INTERSECT, MINUS) do ya zyada SELECT statements ke results combine karte hain. NULL se comparison mein hamesha IS NULL use karo, ", _jsx(_components.code, { children: "= NULL" }), " kaam nahi karta. BETWEEN inclusive hota hai, UNION duplicates remove karta hai jabki UNION ALL rakhta hai."] })] }), "\n", _jsx(Practical, { children: _jsxs(ImportantQA, { children: [_jsxs(QAQuestion, { marks: 2, children: [_jsx(Prompt, { children: "Define the four categories of SQL operators and give two examples of each." }), _jsxs(Answer, { children: [_jsx(_components.p, { children: "SQL mein chaar categories ke operators hain:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Arithmetic Operators:" }), " Mathematical calculations ke liye. Examples: + (addition), - (subtraction), * (multiplication), / (division), % (modulus)"] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Relational Operators:" }), " Values compare karne ke liye. Examples: = (equal to), != (not equal to), < (less than), > (greater than)"] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Logical Operators:" }), " Multiple conditions combine karne ke liye. Examples: AND (dono conditions TRUE hon), OR (koi bhi condition TRUE ho)"] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Set Operators:" }), " Do SELECT statements ke results combine karne ke liye. Examples: UNION (results combine, duplicates remove), INTERSECT (sirf common rows)"] }), "\n"] }), "\n"] }), _jsx(Remember, { children: "Arithmetic = math, Relational = compare, Logical = combine conditions, Set = combine queries." })] })] }), _jsxs(QAQuestion, { marks: 4, children: [_jsx(Prompt, { children: "Explain LIKE operator with all wildcards. Write SQL queries to find names starting with R, ending with ul, and having exactly 5 characters." }), _jsxs(Answer, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "LIKE operator" }), " pattern matching ke liye use hota hai aur do wildcards support karta hai:"] }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Wildcard" }), _jsx(_components.th, { children: "Meaning" }), _jsx(_components.th, { children: "Example" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "%" }), _jsx(_components.td, { children: "Zero ya zyada characters match karta hai" }), _jsx(_components.td, { children: "'R%' → Rahul, Ravi, Raj" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "_" }), _jsx(_components.td, { children: "Exactly ek character match karta hai" }), _jsx(_components.td, { children: "'_ahul' → Rahul" })] })] })] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "SQL Queries:" }) }), _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: _jsx(_components.strong, { children: "Names starting with R:" }) }), "\n"] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-sql", children: "SELECT * FROM Student WHERE Name LIKE 'R%';\n" }) }), _jsx(_components.p, { children: "R% ka matlab: R ke baad zero ya zyada koi bhi characters ho sakte hain." }), _jsxs(_components.ol, { start: "2", children: ["\n", _jsx(_components.li, { children: _jsx(_components.strong, { children: "Names ending with ul:" }) }), "\n"] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-sql", children: "SELECT * FROM Student WHERE Name LIKE '%ul';\n" }) }), _jsx(_components.p, { children: "%ul ka matlab: ul se pehle zero ya zyada characters ho sakte hain." }), _jsxs(_components.ol, { start: "3", children: ["\n", _jsx(_components.li, { children: _jsx(_components.strong, { children: "Names with exactly 5 characters:" }) }), "\n"] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-sql", children: "SELECT * FROM Student WHERE Name LIKE '_____';\n" }) }), _jsx(_components.p, { children: "Paanch underscores ka matlab: exactly paanch characters hone chahiye." }), _jsx(Remember, { children: "% = zero ya zyada characters, _ = exactly ek character. Dono ko combine bhi kar sakte hain jaise '%a%' (jismein 'a' kahin bhi ho)." })] })] }), _jsxs(QAQuestion, { marks: 6, children: [_jsx(Prompt, { children: "Explain all four set operators with syntax and examples. Compare UNION and UNION ALL. When would you use INTERSECT and MINUS?" }), _jsxs(Answer, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Set Operators" }), " do ya zyada SELECT statements ke results combine karte hain. Har SELECT ke paas same number of columns aur compatible data types hone chahiye."] }), _jsx(_components.h3, { children: "1. UNION" }), _jsxs(_components.p, { children: ["Dono queries ke results combine karta hai aur ", _jsx(_components.strong, { children: "duplicates remove" }), " karta hai."] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-sql", children: "SELECT Name FROM CS_Students\r\nUNION\r\nSELECT Name FROM IT_Students;\n" }) }), _jsx(_components.p, { children: "Result: Sabhi unique names jo CS ya IT mein hain." }), _jsx(_components.h3, { children: "2. UNION ALL" }), _jsxs(_components.p, { children: ["Dono queries ke results combine karta hai aur ", _jsx(_components.strong, { children: "duplicates retain" }), " karta hai. UNION se faster hai kyunki duplicate check nahi hota."] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-sql", children: "SELECT Name FROM CS_Students\r\nUNION ALL\r\nSELECT Name FROM IT_Students;\n" }) }), _jsx(_components.p, { children: "Result: Saare names including duplicates (jo dono mein hain woh do baar aayenge)." }), _jsx(_components.h3, { children: "3. INTERSECT" }), _jsxs(_components.p, { children: ["Sirf ", _jsx(_components.strong, { children: "dono queries mein common" }), " rows return karta hai."] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-sql", children: "SELECT Name FROM CS_Students\r\nINTERSECT\r\nSELECT Name FROM IT_Students;\n" }) }), _jsx(_components.p, { children: "Result: Sirf woh names jo CS dono mein hain." }), _jsx(_components.h3, { children: "4. MINUS (ya EXCEPT)" }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Pehli query mein jo rows hain lekin doosri mein nahi" }), " woh return karta hai."] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-sql", children: "SELECT Name FROM CS_Students\r\nMINUS\r\nSELECT Name FROM IT_Students;\n" }) }), _jsx(_components.p, { children: "Result: Sirf CS students jo IT mein nahi hain." }), _jsx(_components.h3, { children: "UNION vs UNION ALL — Detailed Comparison" }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Feature" }), _jsx(_components.th, { children: "UNION" }), _jsx(_components.th, { children: "UNION ALL" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Duplicates" }), _jsx(_components.td, { children: "Remove hoti hain" }), _jsx(_components.td, { children: "Retain hoti hain" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Performance" }), _jsx(_components.td, { children: "Slow (duplicate check lagta hai)" }), _jsx(_components.td, { children: "Fast (koi check nahi)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "Use Case" }), _jsx(_components.td, { children: "Unique results chahiye" }), _jsx(_components.td, { children: "Saare rows chahiye including duplicates" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "NULL Handling" }), _jsx(_components.td, { children: "Identical NULLs treat as duplicates" }), _jsx(_components.td, { children: "Har NULL alag treat hota hai" })] })] })] }), _jsx(_components.h3, { children: "Kab INTERSECT use karein?" }), _jsxs(_components.p, { children: ["Jab aapko sirf woh records chahiye jo ", _jsx(_components.strong, { children: "dono tables mein exist" }), " karein. Example: Students jo CS aur IT dono ke courses mein enrolled hain."] }), _jsx(_components.h3, { children: "Kab MINUS use karein?" }), _jsxs(_components.p, { children: ["Jab aapko woh records chahiye jo ", _jsx(_components.strong, { children: "ek table mein hain lekin doosre mein nahi" }), ". Example: Students jo CS mein hain lekin IT mein nahi."] }), _jsx(KeyPoints, { children: _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "Set operators ke liye dono SELECT ke columns same number ke hone chahiye" }), "\n", _jsx(_components.li, { children: "Column names pehle query ke column names use hote hain" }), "\n", _jsx(_components.li, { children: "UNION DISTINCT sirf duplicates remove karta hai, UNION ALL mein duplicates rehte hain" }), "\n", _jsx(_components.li, { children: "MINUS ya EXCEPT ka naam database ke hisaab se alag ho sakta hai (Oracle mein MINUS, SQL Server mein EXCEPT)" }), "\n"] }) })] })] })] }) }), "\n", _jsxs(Assessment, { topicId: "3.3", children: [_jsx(MCQ, { questions: [{ "id": "0dc49f56-5c09-4c13-9baa-2c2cbd492264", "q": "Which operator is used to perform mathematical calculations in SQL?", "options": ["Relational Operator", "Logical Operator", "Arithmetic Operator", "Set Operator"], "answer": 2, "hint": "Arithmetic operators perform mathematical calculations on column values", "explanation": "Arithmetic operators (+, -, *, /, %) are used for mathematical computations in SQL queries, such as calculating annual salary by multiplying monthly salary by 12." }, { "id": "6b77c641-4b58-41c9-b225-d93fb1886f52", "q": "What does the BETWEEN operator return for the condition Age BETWEEN 18 AND 25?", "options": ["Students with age 18, 25, and everything in between", "Students with age strictly between 18 and 25 (excluding 18 and 25)", "Only students with age 18 or 25", "All students except those aged 18 to 25"], "answer": 0, "hint": "BETWEEN is inclusive — it includes both boundary values", "explanation": "The BETWEEN operator includes both the lower and upper boundary values. WHERE Age BETWEEN 18 AND 25 returns students whose age is 18, 25, or anything in between." }, { "id": "1b6fa724-99be-41a5-9650-d5e556683b66", "q": "What is the result of (TRUE AND FALSE)?", "options": ["TRUE", "UNKNOWN", "NULL", "FALSE"], "answer": 3, "hint": "AND returns TRUE only when both conditions are TRUE", "explanation": "The AND operator requires both conditions to be TRUE for the overall result to be TRUE. If either condition is FALSE, the result is FALSE." }, { "id": "68c53580-62f5-42ae-a0a1-05f2726008ec", "q": "What is the difference between UNION and UNION ALL?", "options": ["UNION is faster than UNION ALL", "UNION removes duplicates, UNION ALL retains them", "UNION ALL removes duplicates, UNION retains them", "Both produce identical results"], "answer": 1, "hint": "UNION ALL retains duplicates while UNION removes them", "explanation": "UNION removes duplicate rows from the combined result, while UNION ALL keeps all rows including duplicates. UNION ALL is faster because it does not need to check for duplicates." }, { "id": "628b6269-8e73-46cc-aa6f-ceddecda2b9a", "q": "Which of the following is the correct way to check for NULL values in SQL?", "options": ["WHERE Age = NULL", "WHERE Age != NULL", "WHERE Age IS NULL", "WHERE Age == NULL"], "answer": 2, "hint": "NULL cannot be compared using = or != operators", "explanation": "In SQL, NULL represents unknown or missing data. Comparing NULL with any value using = or != returns UNKNOWN. You must use IS NULL or IS NOT NULL to check for NULL values." }, { "id": "34f2d4d9-ca94-4d3e-a5cc-a6816276a23e", "q": "In a LIKE pattern, what does the % wildcard match?", "options": ["Zero or more characters", "Exactly one character", "Exactly two characters", "No characters at all"], "answer": 0, "hint": "The % wildcard matches zero or more characters", "explanation": "In the LIKE operator, % matches zero or more characters of any type. So LIKE 'R%' matches any string starting with R regardless of what follows." }, { "id": "eff9ae4a-7d0e-4284-8197-b0a2b5c91628", "q": "What does the MINUS set operator return?", "options": ["Rows common to both queries", "All rows from both queries including duplicates", "Rows from the second query not in the first", "Rows from the first query not in the second"], "answer": 3, "hint": "MINUS returns rows from the first query that are not in the second", "explanation": "MINUS (or EXCEPT in some databases) returns rows that exist in the first SELECT statement but not in the second. The order of queries matters — MINUS A B is different from MINUS B A." }, { "id": "9e2ae82f-ba62-451c-9825-c1ecc424258f", "q": "Which operator is a shorthand for multiple OR conditions on the same column?", "options": ["BETWEEN", "IN", "LIKE", "EXISTS"], "answer": 1, "hint": "IN operator is a shorthand for multiple OR conditions", "explanation": "The IN operator allows you to specify multiple values in a WHERE clause. WHERE Branch IN ('CS', 'IT') is equivalent to WHERE Branch = 'CS' OR Branch = 'IT'." }, { "id": "a6caef07-d297-4f60-a117-48084bb85f39", "q": "What does the LIKE pattern '_a%' match?", "options": ["Strings starting with 'a'", "Strings ending with 'a'", "Strings where the second character is 'a'", "Strings containing exactly one 'a'"], "answer": 2, "hint": "_ wildcard matches exactly one character", "explanation": "The underscore (_) wildcard in LIKE matches exactly one character. LIKE '_a%' means the second character must be a, followed by any number of characters." }, { "id": "8463523e-527c-4a59-a236-433bbf9a9fb6", "q": "Which set operator returns only rows that are common to both SELECT statements?", "options": ["INTERSECT", "UNION", "UNION ALL", "MINUS"], "answer": 0, "hint": "INTERSECT returns only rows common to both queries", "explanation": "The INTERSECT operator returns only those rows that appear in both SELECT statements. It effectively finds the intersection (common elements) of two result sets." }], topicId: "3.3" }), _jsx(ContentAttribution, { sourceTitle: "Curriculum Reference", sourceUrl: "https://learningway.in", professor: "Faculty Review Team", model: "Curriculum AI", seoTitle: "Operators", seoDesc: "Master Operators with comprehensive notes, real-world examples, and practice quiz on LearningWay.", seoKeywords: "operators, operators notes, operators examples, diploma engineering notes, practice quiz, learningway" })] })] }); } function MDXContent(props = {}) { const {wrapper: MDXLayout} = { ..._provideComponents(), ...props.components }; return MDXLayout ? _jsx(MDXLayout, { ...props, children: _jsx(_createMdxContent, { ...props }) }) : _createMdxContent(props); } return { default: MDXContent }; function _missingMdxReference(id, component) { throw new Error("Expected " + (component ? "component" : "object") + " `" + id + "` to be defined: you likely forgot to import, pass, or provide it."); }