{"id":1483,"date":"2023-12-12T13:45:57","date_gmt":"2023-12-12T13:45:57","guid":{"rendered":"https:\/\/www.kaashivinfotech.com\/blog\/?p=1483"},"modified":"2026-06-06T12:31:44","modified_gmt":"2026-06-06T12:31:44","slug":"basic-sql-interview-questions","status":"publish","type":"post","link":"https:\/\/www.kaashivinfotech.com\/blog\/basic-sql-interview-questions\/","title":{"rendered":"Basic SQL Interview Questions & Answers [Updated]"},"content":{"rendered":"

If you’re preparing for your next tech interview, mastering the basic SQL interview questions<\/strong><\/a>\u00a0is crucial.<\/p>\n

SQL, or Structured Query Language, is a powerful and standardized programming language designed for managing and manipulating relational databases. It serves as a means to interact with databases, enabling users to create, retrieve, update, and delete data. SQL is widely used in various industries for tasks ranging from simple data queries to complex database management and administration.<\/p>\n

Databases, organized in a tabular format, store information that can be easily accessed and managed using SQL. SQL provides a set of commands that allow users to interact with the database, making it a fundamental skill for anyone working with data or involved in software development.<\/p>\n

These questions cover some fundamental aspects of SQL and are commonly asked in interviews to assess a candidate’s understanding of database management and SQL syntax.<\/p>\n

Basic SQL interview questions and answers<\/h1>\n
\"basic
50+ Basic SQL Questions and Answers<\/figcaption><\/figure>\n

What is SQL?<\/strong><\/h3>\n

SQL (Structured Query Language) is a standard language used to access and manipulate relational databases. It allows users to perform tasks like retrieving, inserting, updating, and deleting data.<\/p>\n

What are the different types of SQL commands?<\/strong><\/h3>\n
    \n
  • SQL commands are categorized as:<\/li>\n
  • DDL (Data Definition Language): CREATE, ALTER, DROP<\/li>\n
  • DML (Data Manipulation Language): SELECT, INSERT, UPDATE, DELETE<\/li>\n
  • DCL (Data Control Language): GRANT, REVOKE<\/li>\n
  • TCL (Transaction Control Language): COMMIT, ROLLBACK, SAVEPOINT<\/li>\n<\/ul>\n

    What is a primary key in SQL?<\/strong><\/h3>\n

    A primary key uniquely identifies each row in a table. It must contain unique values and cannot have NULLs. Each table can have only one primary key.<\/p>\n

    What is a foreign key?<\/strong><\/h3>\n

    A foreign key is a field in one table that refers to the primary key in another. It establishes a link between the two tables and maintains referential integrity.<\/p>\n

    What is the difference between WHERE and HAVING clause?<\/strong><\/h3>\n
      \n
    • WHERE filters rows before aggregation.<\/li>\n
    • HAVING filters groups after aggregation.<\/li>\n<\/ul>\n
      SELECT department, COUNT(*) FROM employees GROUP BY department HAVING COUNT(*) > 5;<\/code><\/pre> 
       <\/div> <\/div>\n
      What are joins in SQL? Name the types.<\/strong><\/h3>\n
      Joins combine rows from two or more tables. Types include:<\/p>\n
        \n
      • INNER JOIN<\/li>\n
      • LEFT JOIN<\/li>\n
      • RIGHT JOIN<\/li>\n
      • FULL OUTER JOIN<\/li>\n
      • CROSS JOIN<\/li>\n
      • SELF JOIN<\/li>\n<\/ul>\n
        What is an INNER JOIN?<\/strong><\/h3>\n
        It returns only the matching rows from both tables.<\/p>\n
         
        SELECT e.name, d.dept_name FROM employees e INNER JOIN departments d ON e.dept_id = d.id;<\/code><\/pre> 
         <\/div> <\/div>\n
        What is normalization?<\/strong><\/h3>\n
          \n
        • Normalization is the process of organizing data to minimize redundancy and dependency. Common normal forms include 1NF, 2NF, 3NF, and BCNF.<\/li>\n<\/ul>\n
          Goals of Normalization:<\/strong><\/p>\n
            \n
          • \n
            Eliminate redundant (duplicate) data.<\/p>\n<\/li>\n
          • \n
            Ensure data dependencies make sense.<\/p>\n<\/li>\n
          • \n
            Simplify data maintenance and updates.<\/p>\n<\/li>\n<\/ul>\n
            What is denormalization?<\/strong><\/h3>\n
            Denormalization<\/strong> is the process of introducing redundancy into a database<\/strong> by combining tables<\/strong> or adding duplicated data<\/strong>, which was originally removed during normalization<\/strong>. It is typically done to improve read performance<\/strong> and speed up complex queries<\/strong>, especially in relational databases<\/strong> used for analytics or reporting.<\/p>\n
            What is a constraint?<\/strong><\/h3>\n
            Constraints enforce rules on data columns. Types include:<\/p>\n
              \n
            • NOT NULL<\/li>\n
            • UNIQUE<\/li>\n
            • CHECK<\/li>\n
            • DEFAULT<\/li>\n
            • PRIMARY KEY<\/li>\n
            • FOREIGN KEY<\/li>\n<\/ul>\n
              Difference between DELETE, TRUNCATE, and DROP?<\/strong><\/h3>\n\n\n\n\n\n\n\n
              Command<\/th>\nDeletes Data<\/th>\nCan Rollback<\/th>\nDeletes Table Structure<\/th>\n<\/tr>\n<\/thead>\n
              DELETE<\/td>\nYes (specific rows)<\/td>\nYes<\/td>\nNo<\/td>\n<\/tr>\n
              TRUNCATE<\/td>\nYes (all rows)<\/td>\nNo<\/td>\nNo<\/td>\n<\/tr>\n
              DROP<\/td>\nYes (entire table)<\/td>\nNo<\/td>\nYes<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
              What is a View in SQL?<\/strong><\/h3>\n
              A View<\/strong> in SQL is a virtual table<\/strong> based on the result of a predefined SQL query<\/strong>. It does not store data physically<\/strong>, but instead presents data from one or more underlying tables in a customized format. Think of a view as a saved SQL SELECT statement<\/strong> that you can treat like a table.<\/p>\n
              How to fetch the second highest salary?<\/strong><\/h3>\n
               
              SELECT MAX(salary) FROM employees WHERE salary < (SELECT MAX(salary) FROM employees);<\/code><\/pre> 
               <\/div> <\/div>\n
              What is an Index in SQL?<\/h3>\n
              An Index in SQL<\/strong> is a database object<\/strong> that helps speed up the retrieval of rows<\/strong> from a table. Think of it like an index in a book<\/strong> \u2013 instead of reading the whole book to find a topic, you go straight to the indexed page.<\/p>\n
              SQL Syntax to Create an Index:<\/p>\n
               
              CREATE INDEX idx_customer_nameON Customers (CustomerName);CREATE CLUSTERED INDEX idx_customer_idON Customers (CustomerID);<\/code><\/pre> 
               <\/div> <\/div>\n
              What is a subquery?<\/strong><\/h3>\n
              A subquery<\/strong> (also known as a nested query<\/strong> or inner query<\/strong>) is a SQL query embedded inside another query. It is used to perform operations that depend on the results of another query.<\/p>\n
              Types of Subqueries:<\/strong><\/p>\n
                \n
              • \n
                Single-row subquery<\/strong> \u2013 returns one row<\/p>\n<\/li>\n
              • \n
                Multi-row subquery<\/strong> \u2013 returns multiple rows<\/p>\n<\/li>\n
              • \n
                Correlated subquery<\/strong> \u2013 uses values from the outer query<\/p>\n<\/li>\n
              • \n
                Nested subquery<\/strong> \u2013 subqueries within subqueries<\/p>\n<\/li>\n<\/ul>\n
                Difference between CHAR and VARCHAR?<\/strong><\/h3>\n
                The difference between CHAR<\/code> and VARCHAR<\/code><\/strong> in SQL lies mainly in how they store data and handle storage space<\/p>\n\n\n\n\n\n\n\n\n\n
                Feature<\/th>\nCHAR<\/code><\/th>\nVARCHAR<\/code><\/th>\n<\/tr>\n<\/thead>\n
                Length Type<\/td>\nFixed<\/td>\nVariable<\/td>\n<\/tr>\n
                Padding<\/td>\nPadded with spaces<\/td>\nNo padding<\/td>\n<\/tr>\n
                Storage Efficiency<\/td>\nLess efficient for short values<\/td>\nMore efficient for varying lengths<\/td>\n<\/tr>\n
                Performance<\/td>\nSlightly faster for fixed-size data<\/td>\nMay be slower due to size calculation<\/td>\n<\/tr>\n
                Use Case<\/td>\nIDs, codes, fixed-length values<\/td>\nNames, emails, descriptions<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                How to find duplicates?<\/strong><\/h3>\n
                To find duplicates in SQL<\/strong>, you typically use the GROUP BY<\/code> clause along with the HAVING<\/code> clause to identify rows that occur more than once based on specific column(s).<\/p>\n
                 
                SELECT column_name, COUNT(*) FROM table_name GROUP BY column_name HAVING COUNT(*) > 1;<\/code><\/pre> 
                 <\/div> <\/div>\n
                What is a Trigger?<\/strong><\/h3>\n
                A Trigger<\/strong> in SQL (Structured Query Language) is a special kind of stored procedure<\/strong> that automatically executes (or “fires”)<\/strong> in response to certain events on a particular table or view.<\/p>\n
                \ud83d\udd39 Common Events that Trigger a Trigger:<\/h4>\n
                  \n
                • \n
                  INSERT<\/code> \u2014 when a new row is added.<\/p>\n<\/li>\n
                • \n
                  UPDATE<\/code> \u2014 when a row is modified.<\/p>\n<\/li>\n
                • \n
                  DELETE<\/code> \u2014 when a row is removed.<\/p>\n<\/li>\n<\/ul>\n
                  What are aggregate functions?<\/h3>\n
                  Aggregate functions<\/strong> are special functions in SQL (Structured Query Language) used to perform a calculation on a set of values<\/strong> and return a single summarizing result<\/strong>. They are commonly used with the GROUP BY<\/code> clause to group rows that have the same values in specified columns.<\/p>\n
                  Common Aggregate Functions in SQL:<\/strong><\/p>\n
                  \n
                  \n\n\n\n\n\n\n\n\n\n
                  Function<\/th>\nDescription<\/th>\n<\/tr>\n<\/thead>\n
                  COUNT()<\/code><\/td>\nCounts the number of rows or non-NULL values<\/td>\n<\/tr>\n
                  SUM()<\/code><\/td>\nReturns the total sum of a numeric column<\/td>\n<\/tr>\n
                  AVG()<\/code><\/td>\nReturns the average value of a numeric column<\/td>\n<\/tr>\n
                  MIN()<\/code><\/td>\nReturns the smallest value in a column<\/td>\n<\/tr>\n
                  MAX()<\/code><\/td>\nReturns the largest value in a column<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n
                  What is the default order of sorting in SQL?<\/h3>\n
                  In SQL<\/strong>, the default order of sorting<\/strong> when using the ORDER BY<\/code> clause is:<\/p>\n
                  Ascending (ASC) order.<\/strong><\/p>\n
                  This means:<\/p>\n
                    \n
                  • \n
                    Numbers are sorted from smallest to largest<\/strong> (e.g., 1, 2, 3\u2026)<\/p>\n<\/li>\n
                  • \n
                    Text values (strings) are sorted in alphabetical order<\/strong> (A \u2192 Z)<\/p>\n<\/li>\n
                  • \n
                    Dates are sorted from earliest to latest<\/strong><\/p>\n<\/li>\n<\/ul>\n
                    If you want descending order:<\/strong><\/p>\n
                    Use DESC<\/code> explicitly<\/p>\n
                    What is GROUP BY?<\/h3>\n
                    The GROUP BY<\/code> clause in SQL is used to group rows that have the same values in specified columns into summary rows, like “total sales per customer”<\/strong> or “number of students per department.”<\/strong> It is typically used with aggregate functions<\/strong> such as:<\/p>\n
                      \n
                    • \n
                      COUNT()<\/code> \u2013 to count items<\/p>\n<\/li>\n
                    • \n
                      SUM()<\/code> \u2013 to add values<\/p>\n<\/li>\n
                    • \n
                      AVG()<\/code> \u2013 to find the average<\/p>\n<\/li>\n
                    • \n
                      MAX()<\/code> \u2013 to find the maximum<\/p>\n<\/li>\n
                    • \n
                      MIN()<\/code> \u2013 to find the minimum<\/p>\n<\/li>\n<\/ul>\n
                      Difference between IS NULL<\/code> and = NULL<\/code>?<\/h3>\n
                      The difference between IS NULL<\/code> and = NULL<\/code> in SQL is very important<\/strong>, and misunderstanding it can lead to incorrect query results.<\/p>\n
                      IS NULL<\/p>\n
                        \n
                      • \n
                        Correct way<\/strong> to check if a value is NULL<\/code>.<\/p>\n<\/li>\n
                      • \n
                        Used to test whether a column or expression contains a NULL<\/code> value.<\/p>\n<\/li>\n<\/ul>\n
                        =NULL<\/p>\n
                          \n
                        • \n
                          Incorrect and invalid<\/strong> usage.<\/p>\n<\/li>\n
                        • \n
                          In SQL, NULL<\/code> means “unknown”, and comparisons with NULL<\/code> using =<\/code> will always return false<\/strong> or unknown<\/strong>, not the desired result.<\/p>\n<\/li>\n<\/ul>\n
                          What is a Stored Procedure?<\/h3>\n
                          A Stored Procedure<\/strong> is a precompiled collection of one or more SQL statements that are stored in the database and can be executed as a single unit. It allows you to encapsulate repetitive or complex SQL operations, making your code more reusable, organized, and efficient.<\/p>\n
                          Key Features of Stored Procedures:<\/strong><\/p>\n
                            \n
                          • \n
                            Reusable<\/strong>: Once created, it can be called multiple times.<\/p>\n<\/li>\n
                          • \n
                            Precompiled<\/strong>: Executed faster as it is compiled and stored in advance.<\/p>\n<\/li>\n
                          • \n
                            Parameter Support<\/strong>: Can accept input, output, or both types of parameters.<\/p>\n<\/li>\n
                          • \n
                            Improves Security<\/strong>: Reduces SQL injection by avoiding dynamic queries.<\/p>\n<\/li>\n
                          • \n
                            Encapsulation<\/strong>: Hides the implementation details and promotes modular design.<\/p>\n<\/li>\n<\/ul>\n
                            What are wildcards?<\/strong><\/h3>\n
                            Wildcards<\/strong> are special symbols used in search operations or pattern matching to represent one or more characters. They allow users to perform flexible and dynamic searches, especially when the exact term is not known or when searching for variations of a term.<\/p>\n
                            Common Wildcards:<\/strong><\/p>\n
                            1. Asterisk (*)<\/strong><\/h4>\n
                              \n
                            • \n
                              Represents:<\/strong> Zero or more characters.<\/p>\n<\/li>\n
                            • \n
                              Example:<\/strong><\/p>\n
                                \n
                              • \n
                                doc*<\/code> matches doc<\/code>, document<\/code>, doctor<\/code>, etc.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
                                2. Question Mark (?)<\/strong><\/h4>\n
                                  \n
                                • \n
                                  Represents:<\/strong> A single character.<\/p>\n<\/li>\n
                                • \n
                                  Example:<\/strong><\/p>\n
                                    \n
                                  • \n
                                    te?t<\/code> matches text<\/code>, test<\/code>, tent<\/code>, but not teest<\/code>.<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
                                    3. Character Sets (used in RegEx)<\/strong><\/h4>\n
                                      \n
                                    • \n
                                      [abc]<\/strong> matches any one of the characters a, b, or c.<\/p>\n<\/li>\n
                                    • \n
                                      [a-z]<\/strong> matches any lowercase letter from a to z.<\/p>\n<\/li>\n<\/ul>\n
                                      4. Negation (used in RegEx)<\/strong><\/h4>\n
                                        \n
                                      • \n
                                        [^abc]<\/strong> matches any character except a, b, or c.<\/p>\n<\/li>\n<\/ul>\n
                                        What is a transaction?<\/h3>\n
                                        A transaction<\/strong> in the context of databases (especially relational databases like MySQL, SQL Server, Oracle, etc.) is a sequence of one or more SQL operations<\/strong> executed as a single logical unit of work<\/strong>.<\/p>\n
                                        A transaction ensures that either all operations<\/strong> within it are executed successfully (committed)<\/strong> or none are applied (rolled back)<\/strong>, maintaining data integrity<\/strong> and consistency<\/strong>.<\/p>\n
                                        What are ACID properties?<\/h3>\n
                                        Atomicity<\/strong><\/p>\n
                                          \n
                                        • \n
                                          Definition:<\/strong> A transaction must be treated as a single, indivisible unit. Either all operations<\/strong> within the transaction are executed successfully, or none are<\/strong>.<\/p>\n<\/li>\n
                                        • \n
                                          Example:<\/strong> If a bank transfer involves debiting one account and crediting another, both operations must succeed; if one fails, both must be rolled back.<\/p>\n<\/li>\n<\/ul>\n
                                          Consistency<\/strong><\/p>\n
                                            \n
                                          • \n
                                            Definition:<\/strong> A transaction must take the database from one valid state to another<\/strong>, maintaining the integrity of the database.<\/p>\n<\/li>\n
                                          • \n
                                            Example:<\/strong> If there’s a rule that an account balance can’t go below zero, a transaction that violates this rule will not be committed.<\/p>\n<\/li>\n<\/ul>\n
                                            Isolation<\/strong><\/p>\n
                                              \n
                                            • \n
                                              Definition:<\/strong> Transactions must execute independently of one another. Intermediate states<\/strong> of a transaction should not be visible to others.<\/p>\n<\/li>\n
                                            • \n
                                              Example:<\/strong> If two users transfer money at the same time, each transaction should execute as if it’s the only one<\/strong> happening.<\/p>\n<\/li>\n<\/ul>\n
                                              Durability<\/strong><\/p>\n
                                                \n
                                              • \n
                                                Definition:<\/strong> Once a transaction is committed, its changes are permanent<\/strong>, even in the case of system crashes.<\/p>\n<\/li>\n
                                              • \n
                                                Example:<\/strong> After transferring money and getting a success message, even a power outage won\u2019t undo the transfer.<\/p>\n<\/li>\n<\/ul>\n
                                                What is the IN clause?<\/h3>\n
                                                \n
                                                \n
                                                The IN<\/code> clause in SQL is used to filter the result set<\/strong> by checking if a column’s value matches any value<\/strong> in a specified list. It simplifies multiple OR<\/code> conditions and improves query readability.<\/p>\n
                                                Syntax:<\/p>\n
                                                 
                                                SELECT column1, column2FROM table_nameWHERE column_name IN (value1, value2, value3, ...);<\/code><\/pre> 
                                                 <\/div> <\/div>\n<\/div>\n<\/div>\n
                                                What is the difference between UNION and UNION ALL?<\/h3>\n
                                                The difference between UNION<\/code> and UNION ALL<\/code><\/strong> in SQL lies in how they handle duplicate rows<\/strong> when combining the results of two or more SELECT<\/code> queries:<\/p>\n
                                                Union<\/strong><\/p>\n
                                                  \n
                                                • \n
                                                  Removes duplicate rows<\/strong> from the result set.<\/p>\n<\/li>\n
                                                • \n
                                                  Performs an implicit DISTINCT<\/strong>, so only unique rows are returned.<\/p>\n<\/li>\n
                                                • \n
                                                  Slightly slower<\/strong> due to the extra step of removing duplicates.<\/p>\n<\/li>\n<\/ul>\n
                                                  Union All<\/strong><\/p>\n
                                                    \n
                                                  • \n
                                                    Keeps all rows<\/strong>, including duplicates<\/strong>.<\/p>\n<\/li>\n
                                                  • \n
                                                    Does not remove<\/strong> repeated values.<\/p>\n<\/li>\n
                                                  • \n
                                                    Faster<\/strong> because it skips the duplicate-checking step.<\/p>\n<\/li>\n<\/ul>\n
                                                    What is a temporary table?<\/h3>\n
                                                    A temporary table<\/strong> is a special type of table in a database that is created and used temporarily during a session or transaction. It stores intermediate results or temporary data that doesn’t need to be kept permanently in the database.<\/p>\n
                                                    Key Features of Temporary Tables:<\/strong><\/p>\n
                                                      \n
                                                    1. \n
                                                      Short-lived<\/strong>: Exists only for the duration of a session or until it\u2019s manually dropped.<\/p>\n<\/li>\n
                                                    2. \n
                                                      Session-specific<\/strong>: Usually only accessible to the session that created it.<\/p>\n<\/li>\n
                                                    3. \n
                                                      Stored in TempDB<\/strong> (in SQL Server): The data is physically stored in a special system database.<\/p>\n<\/li>\n
                                                    4. \n
                                                      Use Cases<\/strong>:<\/p>\n
                                                        \n
                                                      • \n
                                                        Storing intermediate results during complex queries<\/p>\n<\/li>\n
                                                      • \n
                                                        Simplifying joins and data processing<\/p>\n<\/li>\n
                                                      • \n
                                                        Improving performance for batch processing<\/p>\n<\/li>\n<\/ul>\n<\/li>\n<\/ol>\n
                                                        Types of Temporary Tables in SQL:<\/strong><\/p>\n
                                                          \n
                                                        • Local Temporary Table<\/li>\n
                                                        • Global Temporary Table<\/li>\n<\/ul>\n
                                                          Difference between EXISTS and IN?<\/h3>\n
                                                          The difference between EXISTS<\/code> and IN<\/code><\/strong> in SQL lies in how they work internally and their performance characteristics. Both are used to filter data based on subqueries<\/strong>, but they behave differently.<\/p>\n\n\n\n\n\n\n\n
                                                          Feature<\/th>\nIN<\/code><\/th>\nEXISTS<\/code><\/th>\n<\/tr>\n<\/thead>\n
                                                          Compares<\/td>\nValues returned by subquery<\/td>\nExistence of rows<\/td>\n<\/tr>\n
                                                          Evaluation<\/td>\nFetches all values and compares<\/td>\nStops at first match (faster in some cases)<\/td>\n<\/tr>\n
                                                          Null Handling<\/td>\nCan behave unexpectedly with NULLs<\/td>\nIgnores NULLs and returns correctly<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                                            \n
                                                          • \n
                                                            Use IN<\/code><\/strong> for comparing values directly from a list or a small subquery.<\/p>\n<\/li>\n
                                                          • \n
                                                            Use EXISTS<\/code><\/strong> when you’re testing for row existence<\/strong> and especially when dealing with correlated subqueries<\/strong> or large tables<\/strong>.<\/p>\n<\/li>\n<\/ul>\n
                                                            How to use CASE?<\/h3>\n
                                                            In SQL<\/strong>, the CASE<\/code> statement is used to apply conditional logic<\/strong> within queries \u2014 similar to if-else<\/code> logic in programming.<\/p>\n
                                                            Basic Syntax of CASE (Simple CASE)<\/p>\n
                                                             
                                                            SELECT column1,       CASE column2           WHEN 'value1' THEN 'Result1'           WHEN 'value2' THEN 'Result2'           ELSE 'DefaultResult'       END AS alias_nameFROM table_name;<\/code><\/pre> 
                                                             <\/div> <\/div>\n
                                                            <\/div>\n
                                                            What is a correlated subquery?<\/h3>\n
                                                            A correlated subquery<\/strong> is a subquery that depends on the outer query for its values<\/strong>. It is evaluated once for each row<\/strong> processed by the outer query.<\/p>\n
                                                            Key Characteristics:<\/strong><\/p>\n
                                                              \n
                                                            • \n
                                                              It references columns from the outer query<\/strong>.<\/p>\n<\/li>\n
                                                            • \n
                                                              It is executed repeatedly<\/strong>, once for each row in the outer query.<\/p>\n<\/li>\n
                                                            • \n
                                                              Cannot be executed independently of the outer query.<\/p>\n<\/li>\n<\/ul>\n
                                                              What is an alias?<\/h3>\n
                                                              In SQL<\/strong>, an alias<\/strong> is a temporary name that you assign to a table<\/strong> or a column<\/strong> to make your queries easier to read or more concise.<\/p>\n
                                                                \n
                                                              • \n
                                                                Aliases are temporary<\/strong> and only exist for the duration of the query.<\/p>\n<\/li>\n
                                                              • \n
                                                                The AS<\/code> keyword is optional<\/strong>; you can write SELECT first_name Name<\/code> instead of AS Name<\/code>, but using AS<\/code> improves readability.<\/p>\n<\/li>\n
                                                              • \n
                                                                Useful in complex queries<\/strong> for better understanding and maintenance.<\/p>\n<\/li>\n<\/ul>\n
                                                                \n
                                                                \n
                                                                Column Alias<\/strong><\/p>\n
                                                                  \n
                                                                • Used to rename a column<\/strong> in the result set.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n
                                                                  Table Alias<\/strong><\/p>\n
                                                                    \n
                                                                  • Used to give a temporary name<\/strong> to a table, often used in JOINs<\/strong> to simplify references.<\/li>\n<\/ul>\n
                                                                    What is DISTINCT?<\/h3>\n
                                                                    \n
                                                                    The DISTINCT<\/code> keyword in SQL is used to remove duplicate values<\/strong> from the result set of a query. It ensures that the output contains only unique (non-repeated)<\/strong> rows for the specified column(s).<\/div>\n
                                                                    \n
                                                                      \n
                                                                    • \n
                                                                      Removing duplicate entries from search results.<\/p>\n<\/li>\n
                                                                    • \n
                                                                      Summarizing unique categories or regions.<\/p>\n<\/li>\n
                                                                    • \n
                                                                      Cleaning data before processing or reporting.<\/p>\n<\/li>\n<\/ul>\n<\/div>\n<\/div>\n
                                                                      What is a schema?<\/h3>\n
                                                                      A schema<\/strong> is like a map<\/strong> or layout<\/strong> for a database. It tells the database what kind of data can be stored, how the data is structured, and how different pieces of data relate to each other.<\/p>\n
                                                                      Key Components of a Schema:<\/strong><\/p>\n
                                                                      A database schema typically includes:<\/p>\n