{"id":1615,"date":"2023-12-13T06:14:22","date_gmt":"2023-12-13T06:14:22","guid":{"rendered":"https:\/\/www.kaashivinfotech.com\/blog\/?p=1615"},"modified":"2026-06-06T12:26:24","modified_gmt":"2026-06-06T12:26:24","slug":"experience-sql-interview-questions","status":"publish","type":"post","link":"https:\/\/www.kaashivinfotech.com\/blog\/experience-sql-interview-questions\/","title":{"rendered":"Experience SQL Interview Questions & Answers"},"content":{"rendered":"\t\t
\n\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

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>

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>

These questions cover some advanced\u00a0 aspects of SQL concepts.it is used to crack the sql interviews<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t

\n\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

Experienced SQL Interview Questions<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t

\n\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t1. Fetch in Employee-table Date-of-Joing before the jan-01-2015 employee details ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t

This query will fetch the details of employees who joined before January 1st, 2015 from the “Employee-table”:<\/p>

SELECT * FROM Employee-table WHERE Date-of-Joining < '2015-01-01';<\/code><\/pre> 
 <\/div> <\/div>
\u00a0<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t2. Explain the SQL Query for orderby ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
The\u00a0ORDER BY<\/strong>\u00a0clause in SQL is used to sort the results of a query in ascending or descending order based on one or more columns. The basic syntax for an\u00a0ORDER BY<\/strong>\u00a0clause is:<\/p>
 
SELECT column1, column2, ...FROM table_nameORDER BY column1 [ASC|DESC], column2 [ASC|DESC], ...;<\/code><\/pre> 
 <\/div> <\/div>
  1.  SELECT :<\/strong><\/li><\/ol>
    • specifies the columns to be returned in the result set.<\/li><\/ul>
      1.  FROM :<\/strong><\/li><\/ol>
        • specifies the table to be queried.<\/li><\/ul>
          1.  ORDER BY :<\/strong><\/li><\/ol>
            • sorts the results based on one or more columns. The ASC keyword is used to sort the results in ascending order (which is the default), and the DESC keyword is used to sort the results in descending order.<\/li><\/ul>
              For example, to sort the results of a query on the\u00a0employees<\/strong>\u00a0table by last name in ascending order and first name in descending order:<\/p>
               
              SELECT last_name, first_nameFROM employeesORDER BY last_name ASC, first_name DESC;<\/code><\/pre> 
               <\/div> <\/div><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
              \n\t\t\t\t\t
              \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t3. What is subqueries ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
              • Subqueries in SQL are queries nested within another query. They are used to return data that will be used in the main query as a condition to further restrict the data to be retrieved. Subqueries can be used in various parts of a SQL statement, such as the SELECT clause, FROM clause, WHERE clause, and HAVING clause.<\/li><\/ul>
                 
                SELECT column_name(s)FROM table_nameWHERE column_name operator (SELECT column_name FROM table_name WHERE condition);<\/code><\/pre> 
                 <\/div> <\/div><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                \n\t\t\t\t\t
                \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t4. Explain the Grant ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                The\u00a0GRANT<\/strong>\u00a0statement in SQL is used to grant privileges (e.g. SELECT, INSERT, UPDATE, DELETE, EXECUTE) to a user or role on a specific database object (e.g. table, view, stored procedure, etc.). The basic syntax for the\u00a0GRANT<\/strong>\u00a0statement is:<\/p>
                 
                GRANT privilege [, privilege] ... ON object_type object_name TO user [WITH GRANT OPTION];<\/code><\/pre> 
                 <\/div> <\/div>
                1.  privilege :<\/strong><\/li><\/ol>
                  • specifies the privilege(s) to be granted.<\/li><\/ul>
                    1.  object_type :<\/strong><\/li><\/ol>
                      • specifies the type of object being granted access to (e.g. TABLE, VIEW, PROCEDURE, etc.).<\/li><\/ul>
                        1.  object_name :<\/strong><\/li><\/ol>
                          • specifies the name of the object being granted access to.<\/li><\/ul>
                            1.  user :<\/strong><\/li><\/ol>
                              • specifies the name of the user or role to be granted access.<\/li><\/ul>
                                1.  WITH GRANT OPTION :<\/strong><\/li><\/ol>
                                  • allows the recipient of the grant to pass on the privilege to other users.<\/li><\/ul>
                                    For example, to grant the SELECT privilege on a table named\u00a0employees<\/strong>\u00a0to a user named\u00a0jane<\/strong>:<\/p>
                                     
                                    GRANT SELECT ON employees TO jane;<\/code><\/pre> 
                                     <\/div> <\/div>
                                    Note that the exact syntax and available privileges may vary depending on the specific database management system being used (e.g. MySQL, Microsoft SQL Server, Oracle, etc.).<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                    \n\t\t\t\t\t
                                    \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t5. Explain the Revocke ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                    The\u00a0REVOKE<\/strong>\u00a0statement in SQL is used to revoke privileges that have been granted to a user or role on a specific database object (e.g. table, view, stored procedure, etc.). The basic syntax for the\u00a0REVOKE<\/strong>\u00a0statement is:<\/p>
                                     
                                    REVOKE privilege [, privilege] ... ON object_type object_name FROM user;<\/code><\/pre> 
                                     <\/div> <\/div>
                                    1.  privilege :<\/strong><\/li><\/ol>
                                      • specifies the privilege(s) to be revoked.<\/li><\/ul>
                                        1.  object_type :<\/strong><\/li><\/ol>
                                          • specifies the type of object being revoked access from (e.g. TABLE, VIEW, PROCEDURE, etc.).<\/li><\/ul>
                                            1.  object_name :<\/strong><\/li><\/ol>
                                              • specifies the name of the object being revoked access from.<\/li><\/ul>
                                                1.  user :<\/strong><\/li><\/ol>
                                                  • specifies the name of the user or role to have access revoked.<\/li><\/ul>
                                                    For example, to revoke the SELECT privilege on a table named\u00a0employees<\/strong>\u00a0from a user named\u00a0jane<\/strong>:<\/p>
                                                     
                                                    REVOKE SELECT ON employees FROM jane;<\/code><\/pre> 
                                                     <\/div> <\/div>
                                                    Note that the exact syntax may vary depending on the specific database management system being used (e.g. MySQL, Microsoft SQL Server, Oracle, etc.).<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                    \n\t\t\t\t\t
                                                    \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t6. Explain the self join ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                    • A self join is a type of join operation in SQL where a table is joined with itself. In other words, it’s a way of combining data from a single table based on a relationship between two columns in that same table.<\/li><\/ul>
                                                      • To perform a self join, you need to use an alias to differentiate between the two instances of the same table. The syntax for a self join is as follows:<\/li><\/ul>
                                                         
                                                        SELECT t1.column_name, t2.column_nameFROM table_name t1JOIN table_name t2 ON t1.column_name = t2.column_name<\/code><\/pre> 
                                                         <\/div> <\/div>
                                                        • In this example, table_name is the name of the table being joined, and column_name is the column being used to join the table to itself.<\/li><\/ul>
                                                          • For instance, consider a table named employees with columns employee_id, employee_name, and manager_id. In this table, the manager_id column contains the ID of the employee’s manager. You can use a self join to find the names of all employees and their corresponding managers:<\/li><\/ul>
                                                             
                                                            SELECT e.employee_name, m.employee_name AS manager_nameFROM employees eJOIN employees m ON e.manager_id = m.employee_id;<\/code><\/pre> 
                                                             <\/div> <\/div>
                                                            • In this query, the employees table is joined to itself based on the relationship between the manager_id and employee_id columns. The e and m aliases are used to differentiate between the two instances of the employees table. The result is a list of employee names and their corresponding manager names.<\/li><\/ul>


                                                              <\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                              \n\t\t\t\t\t
                                                              \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t7. Explain the cross join ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                              A cross join (also known as a cartesian product) in SQL is a join operation in which every row from the first table is paired with every row from the second table. The result of a cross join is a table that has a number of rows equal to the number of rows in the first table multiplied by the number of rows in the second table.<\/p>
                                                              The basic syntax for a cross join is:<\/p>
                                                               
                                                              SELECT column1, column2, ...FROM table1CROSS JOIN table2;<\/code><\/pre> 
                                                               <\/div> <\/div>
                                                              1.  SELECT :<\/strong><\/li><\/ol>
                                                                • specifies the columns to be returned in the result set.<\/li><\/ul>
                                                                  1.  FROM :<\/strong><\/li><\/ol>
                                                                    • specifies the first table to be queried.<\/li><\/ul>
                                                                      1.  CROSS JOIN :<\/strong><\/li><\/ol>
                                                                        • specifies the type of join to be performed.<\/li><\/ul>
                                                                          For example, to find all possible combinations of colors and sizes for a product:<\/p>
                                                                           
                                                                          SELECT colors.color_name, sizes.size_nameFROM colorsCROSS JOIN sizes;<\/code><\/pre> 
                                                                           <\/div> <\/div>
                                                                          Note that cross joins are often used in combination with the\u00a0WHERE<\/strong>\u00a0clause to filter the results to only include meaningful combinations of rows.<\/p>


                                                                          <\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                          \n\t\t\t\t\t
                                                                          \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t8. Explain the unique key ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                          In SQL, a unique key is a constraint that ensures that the values in a specific column or set of columns of a table are unique and non-duplicate. A unique key can be defined at the time the table is created, or it can be added later using an\u00a0ALTER TABLE<\/strong>\u00a0statement.<\/p>
                                                                          The basic syntax for defining a unique key constraint during table creation is:<\/p>
                                                                           
                                                                          CREATE TABLE table_name (   column1 data_type constraint_name UNIQUE,   column2 data_type,   ...);<\/code><\/pre> 
                                                                           <\/div> <\/div>
                                                                          1.  CREATE TABLE :<\/strong><\/li><\/ol>
                                                                            • specifies that a new table is being created.<\/li><\/ul>
                                                                              1.  table_name :<\/strong><\/li><\/ol>
                                                                                • specifies the name of the new table.<\/li><\/ul>
                                                                                  1.  column1 :<\/strong><\/li><\/ol>
                                                                                    • specifies the name of the first column in the table.<\/li><\/ul>
                                                                                      1.  data_type :<\/strong><\/li><\/ol>
                                                                                        • specifies the data type of the column.<\/li><\/ul>
                                                                                          1.  constraint_name :<\/strong><\/li><\/ol>
                                                                                            • specifies the name of the constraint being defined.<\/li><\/ul>
                                                                                              1.  UNIQUE :<\/strong><\/li><\/ol>
                                                                                                • specifies that the values in the column must be unique.<\/li><\/ul>
                                                                                                  For example, to create a table named\u00a0employees<\/strong>\u00a0with a unique key constraint on the\u00a0employee_id<\/strong>\u00a0column:<\/p>
                                                                                                   
                                                                                                  CREATE TABLE employees (   employee_id INT PRIMARY KEY,   last_name VARCHAR(30),   first_name VARCHAR(30),   ...);<\/code><\/pre> 
                                                                                                   <\/div> <\/div>
                                                                                                  Note that in this example, the unique key constraint is also defined as the primary key of the table. In SQL, a primary key is a special type of unique key that is used to uniquely identify each row in the table.<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                  \n\t\t\t\t\t
                                                                                                  \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t9. Normalization types and explain each 1,2,3,4 ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                  Normalization is the process of organizing data in a database to minimize redundancy and improve data integrity. There are several normalization levels, each with its own set of rules. The most commonly used normalization levels are 1st, 2nd, 3rd, and 4th normal forms.<\/p>
                                                                                                  1.  First Normal Form (1NF):<\/strong><\/li><\/ol>
                                                                                                    • Each table has a primary key.<\/li>
                                                                                                    • Each column has a unique name.<\/li>
                                                                                                    • Each column has a single value, and values in a column are of the same type.<\/li>
                                                                                                    • Columns are atomic, meaning that a column value cannot be further decomposed.<\/li><\/ul>
                                                                                                      1.  Second Normal Form (2NF):<\/strong><\/li><\/ol>
                                                                                                        • Meets all the requirements of 1NF.<\/li>
                                                                                                        • Each non-key column is functionally dependent on the primary key.<\/li>
                                                                                                        • This means that each non-key column is dependent on the entire primary key and not just a part of it.<\/li><\/ul>
                                                                                                          1.  Third Normal Form (3NF) :<\/strong><\/li><\/ol>
                                                                                                            • Meets all the requirements of 2NF.<\/li>
                                                                                                            • There are no transitive functional dependencies between non-key columns.<\/li>
                                                                                                            • Transitive functional dependencies occur when a column depends on another column, which depends on a third column.<\/li><\/ul>
                                                                                                              1.  Fourth Normal Form (4NF):<\/strong><\/li><\/ol>
                                                                                                                • Meets all the requirements of 3NF.<\/li>
                                                                                                                • There are no multi-valued dependencies.<\/li>
                                                                                                                • Multi-valued dependencies occur when a column depends on another column, but not on the primary key.<\/li><\/ul>
                                                                                                                  These normalization rules help to ensure that data is stored in an organized, consistent, and efficient manner. The goal of normalization is to minimize data redundancy and eliminate the potential for inconsistent data. It is important to note that normalization is not always necessary or appropriate for all database designs, and sometimes a trade-off must be made between data normalization and performance.<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                  \n\t\t\t\t\t
                                                                                                                  \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t10. Explain the Stored procedure syntax ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                  The syntax for creating a stored procedure in SQL can vary between different SQL implementations, such as MySQL, Oracle, Microsoft SQL Server, and others. However, the basic structure is as follows:<\/p>
                                                                                                                   
                                                                                                                  CREATE PROCEDURE procedure_name (    [IN | OUT | INOUT] parameter1 data_type,    [IN | OUT | INOUT] parameter2 data_type,    ...)BEGIN    -- Declare variables here, if needed        -- Execute SQL statements here        -- Return values, if neededEND;<\/code><\/pre> 
                                                                                                                   <\/div> <\/div>
                                                                                                                  1.  CREATE PROCEDURE :<\/strong><\/li><\/ol>
                                                                                                                    • Specifies that you want to create a stored procedure.<\/li><\/ul>
                                                                                                                      1.  procedure_name :<\/strong><\/li><\/ol>
                                                                                                                        • Specifies the name of the stored procedure.<\/li><\/ul>
                                                                                                                          1.  [IN | OUT | INOUT] :<\/strong><\/li><\/ol>
                                                                                                                            • Specifies the type of parameter.\u00a0IN<\/strong>\u00a0parameters are used to pass values into the stored procedure.\u00a0OUT<\/strong>\u00a0parameters are used to return values from the stored procedure.\u00a0INOUT<\/strong>\u00a0parameters are used to pass values into the stored procedure and to return values.<\/li><\/ul>
                                                                                                                              1.  parameter1, parameter2, … :<\/strong><\/li><\/ol>
                                                                                                                                • Specifies the parameters to pass into the stored procedure.<\/li><\/ul>
                                                                                                                                  1.  data_type :<\/strong><\/li><\/ol>
                                                                                                                                    • Specifies the data type of the parameter.<\/li><\/ul>
                                                                                                                                      1.  BEGIN :<\/strong><\/li><\/ol>
                                                                                                                                        • Specifies the start of the stored procedure’s code.<\/li><\/ul>
                                                                                                                                          1.  END :<\/strong><\/li><\/ol>
                                                                                                                                            • Specifies the end of the stored procedure’s code.<\/li><\/ul>
                                                                                                                                              Here is an example that creates a stored procedure that returns the number of employees in the\u00a0employees<\/strong>\u00a0table:<\/p>
                                                                                                                                               
                                                                                                                                              CREATE PROCEDURE count_employees()BEGIN    SELECT COUNT(*) AS count    FROM employees;END;<\/code><\/pre> 
                                                                                                                                               <\/div> <\/div>
                                                                                                                                              In this example, the stored procedure is named\u00a0count_employees<\/strong>\u00a0and takes no parameters. The stored procedure uses the SELECT statement to count the number of rows in the\u00a0employees<\/strong>\u00a0table and returns the result with the AS keyword.<\/p>
                                                                                                                                              Note that the specific syntax for creating stored procedures can vary between different SQL implementations, such as MySQL, Oracle, Microsoft SQL Server, and others.<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                              \n\t\t\t\t\t
                                                                                                                                              \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t11. Explain the CONSTRAINTS ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                              Constraints in SQL are rules that enforce data integrity and consistency within a database. There are several types of constraints in SQL:<\/p>
                                                                                                                                              1.  NOT NULL constraint :<\/strong><\/li><\/ol>
                                                                                                                                                • Ensures that a column cannot contain a null value.<\/li><\/ul>
                                                                                                                                                  1.  UNIQUE constraint :<\/strong><\/li><\/ol>
                                                                                                                                                    • Ensures that all values in a column are unique and no duplicate values are allowed.<\/li><\/ul>
                                                                                                                                                      1.  PRIMARY KEY constraint :<\/strong><\/li><\/ol>
                                                                                                                                                        • A combination of a\u00a0NOT NULL<\/strong>\u00a0and\u00a0UNIQUE<\/strong>\u00a0constraint, ensuring that each row in a table has a unique and non-null value.<\/li><\/ul>
                                                                                                                                                          1.  FOREIGN KEY constraint :<\/strong><\/li><\/ol>
                                                                                                                                                            • Refers to the primary key of another table, ensuring that the values in a column match the values in the referenced table.<\/li><\/ul>
                                                                                                                                                              1.  CHECK constraint :<\/strong><\/li><\/ol>
                                                                                                                                                                • Limits the values that can be entered into a column based on a specified condition.<\/li><\/ul>
                                                                                                                                                                  1.  DEFAULT constraint :<\/strong><\/li><\/ol>
                                                                                                                                                                    • Sets a default value for a column if no value is specified when inserting a new row.<\/li><\/ul>
                                                                                                                                                                      The syntax for adding constraints to a table depends on the SQL implementation you are using. Here is an example for adding a\u00a0NOT NULL<\/strong>\u00a0constraint to the\u00a0first_name<\/strong>\u00a0column of the\u00a0employees<\/strong>\u00a0table in SQL:<\/p>
                                                                                                                                                                       
                                                                                                                                                                      ALTER TABLE employeesADD CONSTRAINT first_name_nn NOT NULL (first_name);<\/code><\/pre> 
                                                                                                                                                                       <\/div> <\/div>
                                                                                                                                                                      This example adds a\u00a0NOT NULL<\/strong>\u00a0constraint to the\u00a0first_name<\/strong>\u00a0column and specifies the constraint name as\u00a0first_name_nn<\/strong>.<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                      \n\t\t\t\t\t
                                                                                                                                                                      \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t12. Explain the Check constraints ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                      CHECK<\/strong>\u00a0constraints in SQL are used to limit the values that can be inserted into a column based on a specified condition. The constraint defines a logical expression that must evaluate to\u00a0TRUE<\/strong>\u00a0for a new record to be inserted into the table.<\/p>
                                                                                                                                                                      Here’s the basic syntax for adding a\u00a0CHECK<\/strong>\u00a0constraint to a column in SQL:<\/p>
                                                                                                                                                                       
                                                                                                                                                                      ALTER TABLE table_nameADD CONSTRAINT constraint_name CHECK (condition);<\/code><\/pre> 
                                                                                                                                                                       <\/div> <\/div>
                                                                                                                                                                      1.  ALTER TABLE :<\/strong><\/li><\/ol>
                                                                                                                                                                        • Changes the structure of an existing table.<\/li><\/ul>
                                                                                                                                                                          1.  table_name :<\/strong><\/li><\/ol>
                                                                                                                                                                            • The name of the table to which you want to add the constraint.<\/li><\/ul>
                                                                                                                                                                              1.  ADD CONSTRAINT :<\/strong><\/li><\/ol>
                                                                                                                                                                                • Adds a constraint to the table.<\/li><\/ul>
                                                                                                                                                                                  1.  constraint_name :<\/strong><\/li><\/ol>
                                                                                                                                                                                    • A name you assign to the constraint.<\/li><\/ul>
                                                                                                                                                                                      1.  CHECK :<\/strong><\/li><\/ol>
                                                                                                                                                                                        • Specifies that you are adding a CHECK constraint.<\/li><\/ul>
                                                                                                                                                                                          1.  condition :<\/strong><\/li><\/ol>
                                                                                                                                                                                            • A logical expression that must evaluate to TRUE for a new record to be inserted into the table.<\/li><\/ul>
                                                                                                                                                                                              Here’s an example that adds a\u00a0CHECK<\/strong>\u00a0constraint to the\u00a0age<\/strong>\u00a0column of the\u00a0employees<\/strong>\u00a0table to ensure that the age is between 18 and 65:<\/p>
                                                                                                                                                                                               
                                                                                                                                                                                              ALTER TABLE employeesADD CONSTRAINT age_ck CHECK (age >= 18 AND age <= 65);<\/code><\/pre> 
                                                                                                                                                                                               <\/div> <\/div>
                                                                                                                                                                                              In this example, a\u00a0CHECK<\/strong>\u00a0constraint is added to the\u00a0age<\/strong>\u00a0column of the\u00a0employees<\/strong>\u00a0table. The constraint checks that the value of the\u00a0age<\/strong>\u00a0column is greater than or equal to 18 and less than or equal to 65 for each new record. If a record is inserted with an\u00a0age<\/strong>\u00a0value outside of this range, the insert operation will fail and an error message will be returned.<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                              \n\t\t\t\t\t
                                                                                                                                                                                              \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t13. What is Hash ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                              A hash in SQL is a mathematical function that transforms data of arbitrary length into a fixed length representation, called a hash value or digest. It’s often used in database management systems for indexing, searching and comparison purposes, as hash values are quicker to compare than the original data.<\/p>
                                                                                                                                                                                              There are several types of hash functions used in SQL:<\/p>
                                                                                                                                                                                              • 1. MD5 – 128-bit hash value<\/li>
                                                                                                                                                                                              • 2. SHA-1 – 160-bit hash value<\/li>
                                                                                                                                                                                              • 3. SHA-2 (224, 256, 384 or 512 bit)<\/li>
                                                                                                                                                                                              • 4. SHA-3 (224, 256, 384 or 512 bit)<\/li><\/ul>
                                                                                                                                                                                                Hash values are usually generated for passwords for security purposes, as storing the actual password in a database is not recommended for security reasons. Instead, a hash of the password is stored, and when a user logs in, the system hashes the entered password and compares it to the stored hash.<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                \n\t\t\t\t\t
                                                                                                                                                                                                \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t14. Explain the Indexing ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                Indexing in SQL is a technique used to speed up the retrieval of data from a database. An index is a data structure that provides a mapping between values in a specific column (or columns) of a table and their location on disk. This enables the database management system to quickly find and retrieve the rows that match a specific search criteria, without having to scan the entire table.<\/p>
                                                                                                                                                                                                Here are some benefits of using indexing in SQL:<\/p>
                                                                                                                                                                                                1.  Faster query performance :<\/strong><\/li><\/ol>
                                                                                                                                                                                                  • Indexes speed up the process of searching for data, which can significantly improve the performance of SELECT, UPDATE and DELETE statements.<\/li><\/ul>
                                                                                                                                                                                                    1.  Improved query optimization :<\/strong><\/li><\/ol>
                                                                                                                                                                                                      • The database management system can use indexes to optimize the execution plan for complex queries.<\/li><\/ul>
                                                                                                                                                                                                        1.  Better scalability :<\/strong><\/li><\/ol>
                                                                                                                                                                                                          • Indexes can help to reduce the load on the database, making it more scalable as the size of the data grows.<\/li><\/ul>
                                                                                                                                                                                                            To create an index in SQL, you can use the CREATE INDEX statement, specifying the table name, the name of the index, and the columns that you want to index:<\/p>
                                                                                                                                                                                                             
                                                                                                                                                                                                            CREATE INDEX index_nameON table_name (column1, column2, ...);<\/code><\/pre> 
                                                                                                                                                                                                             <\/div> <\/div>
                                                                                                                                                                                                            \u00a0<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                            \n\t\t\t\t\t
                                                                                                                                                                                                            \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t15. Difference between clustered and non clustered index ?   <\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                            In SQL, a clustered index and a non-clustered index are two types of indexes that you can create on a table to speed up data retrieval operations.<\/p>
                                                                                                                                                                                                            1.  Clustered Index :<\/strong><\/li><\/ol>
                                                                                                                                                                                                              • A clustered index determines the physical order of data in a table. In other words, the data in the table is stored on disk in the same order as the clustered index. There can be only one clustered index per table, as the data can only be physically ordered in one way. Clustered indexes are often used on columns that have a high cardinality, meaning that the values in the column are unique and evenly distributed.<\/li><\/ul>
                                                                                                                                                                                                                1.  Non-Clustered Index :<\/strong><\/li><\/ol>
                                                                                                                                                                                                                  • A non-clustered index does not affect the physical order of data in the table. Instead, it provides a mapping between the values in a specific column and the location of the corresponding data on disk. Non-clustered indexes are stored separately from the data in the table, and can be used to speed up the execution of SELECT, UPDATE and DELETE statements that involve the indexed columns. You can create multiple non-clustered indexes on a single table.<\/li><\/ul>
                                                                                                                                                                                                                    frequently used in search conditions, is unique, and has a high cardinality. You should consider creating a non-clustered index on a column that is frequently used in search conditions, but is not unique, or has a low cardinality.<\/p>
                                                                                                                                                                                                                    It is important to note that while indexes can significantly improve the performance of data retrieval, they can also have a negative impact on the performance of data modification operations, such as INSERT, UPDATE and DELETE, as the indexes have to be updated every time the data in the indexed columns is changed. Therefore, it is important to carefully consider the columns that you want to index, and to regularly evaluate and adjust your indexing strategy as your data and workload evolves.<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                                    \n\t\t\t\t\t
                                                                                                                                                                                                                    \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t16. Explain the Sql injection ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                                    SQL injection is a type of security vulnerability that occurs in database-driven web applications. It allows attackers to inject malicious code into SQL statements that are executed by the database management system. The malicious code can be used to steal sensitive information, modify or delete data, or gain unauthorized access to the system.<\/p>
                                                                                                                                                                                                                    SQL injection attacks take advantage of insecure coding practices that allow user input to be directly included in SQL statements without proper validation or escaping.<\/p>
                                                                                                                                                                                                                     
                                                                                                                                                                                                                    SELECT * FROM users WHERE id = '' OR 1=1 --'<\/code><\/pre> 
                                                                                                                                                                                                                     <\/div> <\/div>
                                                                                                                                                                                                                    This SQL statement will always return all rows from the users table, bypassing the intended restriction on the id column.<\/p>
                                                                                                                                                                                                                    To prevent SQL injection, it is important to follow secure coding practices, such as:<\/p>
                                                                                                                                                                                                                    • Using parameterized queries (also known as prepared statements) that separate the SQL statement from the data that is passed to it.<\/li>
                                                                                                                                                                                                                    • Validating and escaping user input to ensure that it does not contain any malicious code.<\/li>
                                                                                                                                                                                                                    • Using stored procedures and views, which can enforce a more secure and consistent coding style.<\/li>
                                                                                                                                                                                                                    • Keeping the database and web application software up-to-date with the latest security patches.<\/li><\/ul>
                                                                                                                                                                                                                      By following these best practices, you can reduce the risk of SQL injection and ensure the security of your database-driven web applications.<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                                      \n\t\t\t\t\t
                                                                                                                                                                                                                      \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t 17. Can we do union with 3 columns in one table and 4 columns in another table ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                                      • No, in SQL, the number of columns in each SELECT statement in a UNION operation must be the same. In other words, you cannot perform a UNION operation between a table with 3 columns and another table with 4 columns.<\/li>
                                                                                                                                                                                                                      • To perform a UNION operation, you need to make sure that each SELECT statement in the UNION operation has the same number of columns, with the same data types, in the same order.<\/li>
                                                                                                                                                                                                                      • For example, if you have two tables,\u00a0table1<\/strong>\u00a0with 3 columns and\u00a0table2<\/strong>\u00a0with 4 columns, you can perform a UNION operation by adding a constant value or a NULL value to the SELECT statement from\u00a0table2<\/strong>\u00a0to match the number of columns in\u00a0table1:<\/strong><\/li><\/ul>
                                                                                                                                                                                                                         
                                                                                                                                                                                                                        SELECT column1, column2, column3 FROM table1UNIONSELECT column1, column2, column3, NULL as column4 FROM table2;<\/code><\/pre> 
                                                                                                                                                                                                                         <\/div> <\/div>
                                                                                                                                                                                                                        • This will return a result set that has the same number of columns as the SELECT statement from\u00a0table1<\/strong>, with the additional column in\u00a0table2<\/strong>\u00a0being filled with NULL values.<\/li><\/ul>


                                                                                                                                                                                                                          <\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                                          \n\t\t\t\t\t
                                                                                                                                                                                                                          \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t18. Difference between DBMS and RDBMS ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                                          DBMS (Database Management System) and RDBMS (Relational Database Management System) are both types of database management systems, but they have some differences:<\/p>
                                                                                                                                                                                                                          1.  Structure :<\/strong><\/li><\/ol>
                                                                                                                                                                                                                            • ?A DBMS can have any type of data structure, including hierarchical, network, and object-oriented, while an RDBMS is specifically designed to use a relational data structure, where data is organized into tables with rows and columns.<\/li><\/ul>
                                                                                                                                                                                                                              1.  Relationships :<\/strong><\/li><\/ol>
                                                                                                                                                                                                                                • ?An RDBMS can define and enforce relationships between tables using keys, such as primary and foreign keys, while a DBMS may not have this capability.<\/li><\/ul>
                                                                                                                                                                                                                                  1.  Query Language :<\/strong><\/li><\/ol>
                                                                                                                                                                                                                                    • ?An RDBMS uses SQL (Structured Query Language) as its primary query language, while a DBMS may use a different query language.<\/li><\/ul>
                                                                                                                                                                                                                                      1.  Data Integrity :<\/strong><\/li><\/ol>
                                                                                                                                                                                                                                        • ?An RDBMS provides features for enforcing data integrity, such as constraints, triggers, and stored procedures, while a DBMS may not have these features.<\/li><\/ul>
                                                                                                                                                                                                                                          1.  Scalability :<\/strong><\/li><\/ol>
                                                                                                                                                                                                                                            • RDBMSs are typically more scalable than other types of DBMSs, as they can handle larger amounts of data and support multiple users with concurrent access.<\/li><\/ul>
                                                                                                                                                                                                                                              In summary, an RDBMS is a type of DBMS that uses a relational data structure, supports SQL, and provides features for enforcing data integrity and scalability.<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                                                              \n\t\t\t\t\t
                                                                                                                                                                                                                                              \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t19. Query for Top 5 salary from employee table ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                                                              To retrieve the top 5 salaries from an employee table in SQL, you can use the following query:<\/p>
                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                              SELECT TOP 5 salaryFROM employeeORDER BY salary DESC;<\/code><\/pre> 
                                                                                                                                                                                                                                               <\/div> <\/div>
                                                                                                                                                                                                                                              • This query uses the\u00a0TOP<\/strong>\u00a0clause to limit the number of rows returned to 5. The\u00a0ORDER BY<\/strong>\u00a0clause sorts the rows in descending order based on the\u00a0salary<\/strong>\u00a0column, so that the highest salaries are returned first. The\u00a0DESC<\/strong>\u00a0keyword specifies a descending sort order.<\/li><\/ul>


                                                                                                                                                                                                                                                <\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                                                                \n\t\t\t\t\t
                                                                                                                                                                                                                                                \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t20. Query for Second highest salary ?   <\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                                                                To retrieve the second highest salary in SQL, you can use the following query:<\/p>
                                                                                                                                                                                                                                                 
                                                                                                                                                                                                                                                SELECT MAX(salary)FROM employeeWHERE salary NOT IN (SELECT MAX(salary) FROM employee);<\/code><\/pre> 
                                                                                                                                                                                                                                                 <\/div> <\/div>
                                                                                                                                                                                                                                                • This query uses the\u00a0MAX<\/strong>\u00a0function to find the highest salary in the\u00a0employee<\/strong>\u00a0table, and then uses a subquery to exclude that salary from the result set. The subquery finds the highest salary in the\u00a0employee<\/strong>\u00a0table, and the outer query returns the maximum salary that is not equal to the highest salary. This gives you the second highest salary.<\/li><\/ul><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                                                                  \n\t\t\t\t\t
                                                                                                                                                                                                                                                  \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t21. Create Store Procedure for employee table ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                                                                  To create a stored procedure in SQL for an\u00a0employee<\/strong>\u00a0table, you can use the following syntax:<\/p>
                                                                                                                                                                                                                                                   
                                                                                                                                                                                                                                                  CREATE PROCEDURE get_employee_info (@employee_id INT)ASBEGIN    SELECT *    FROM employee    WHERE employee_id = @employee_id;END;<\/code><\/pre> 
                                                                                                                                                                                                                                                   <\/div> <\/div>
                                                                                                                                                                                                                                                  This stored procedure takes a single input parameter,\u00a0@employee_id<\/strong>, and returns all columns from the\u00a0employee<\/strong>\u00a0table for the specified employee ID. To execute the stored procedure, you can use the following syntax:<\/p>
                                                                                                                                                                                                                                                   
                                                                                                                                                                                                                                                  EXEC get_employee_info @employee_id = 123;<\/code><\/pre> 
                                                                                                                                                                                                                                                   <\/div> <\/div>
                                                                                                                                                                                                                                                  Replace\u00a0123<\/strong>\u00a0with the actual employee ID you want to retrieve. This will execute the stored procedure and return the results.<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                                                                  \n\t\t\t\t\t
                                                                                                                                                                                                                                                  \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t22. Explain the Group by syntax ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                                                                  The\u00a0GROUP BY<\/strong>\u00a0clause in SQL is used to group rows that have the same values in specified columns into summary rows, like “find the number of customers in each city”.<\/p>
                                                                                                                                                                                                                                                   
                                                                                                                                                                                                                                                  SELECT column1, aggregate_function(column2)FROM table_nameGROUP BY column1;<\/code><\/pre> 
                                                                                                                                                                                                                                                   <\/div> <\/div>
                                                                                                                                                                                                                                                  • column1, column2, …<\/strong>\u00a0are the columns that you want to retrieve from the\u00a0table_name.<\/strong><\/li>
                                                                                                                                                                                                                                                  • table_name<\/strong>\u00a0is the name of the table that you want to retrieve data from.<\/li>
                                                                                                                                                                                                                                                  • ORDER BY column1 [ASC|DESC]<\/strong>\u00a0sorts the result set in ascending order (ASC<\/strong>) or descending order (DESC<\/strong>) based on the values in\u00a0column1.<\/strong><\/li>
                                                                                                                                                                                                                                                  • column2 [ASC|DESC]<\/strong>\u00a0sorts the result set based on the values in\u00a0column2<\/strong>, either in ascending order (ASC<\/strong>) or descending order (DESC<\/strong>), if the values in\u00a0column1<\/strong>\u00a0are the same.<\/li><\/ul>
                                                                                                                                                                                                                                                    Here is an example of using the\u00a0ORDER BY<\/strong>\u00a0clause to sort the\u00a0employees<\/strong>\u00a0in the employee table by their salaries in descending order:<\/p>
                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                    SELECT first_name, last_name, salaryFROM employeeORDER BY salary DESC;<\/code><\/pre> 
                                                                                                                                                                                                                                                     <\/div> <\/div>
                                                                                                                                                                                                                                                    This query selects the\u00a0first_name, last_name,<\/strong>\u00a0and\u00a0salary<\/strong>\u00a0columns from the\u00a0employee<\/strong>\u00a0table, and sorts the results by the\u00a0salary<\/strong>\u00a0column in descending order. The\u00a0DESC<\/strong>\u00a0keyword specifies a descending sort order. The query returns the employees sorted by their salaries, with the highest salaries first.<\/p>
                                                                                                                                                                                                                                                    Here is the syntax for using the\u00a0GROUP BY<\/strong>\u00a0clause in SQL:<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                                                                    \n\t\t\t\t\t
                                                                                                                                                                                                                                                    \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t23. CRUD operations with stored procedure ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                                                                    1.  Create :<\/strong><\/li><\/ol>
                                                                                                                                                                                                                                                      • To create a new record in a table, you can use the following stored procedure:<\/li><\/ul>
                                                                                                                                                                                                                                                         
                                                                                                                                                                                                                                                        CREATE PROCEDURE sp_insert_employee (@first_name VARCHAR(50), @last_name VARCHAR(50), @salary INT)ASBEGIN  INSERT INTO employee (first_name, last_name, salary)  VALUES (@first_name, @last_name, @salary)END;<\/code><\/pre> 
                                                                                                                                                                                                                                                         <\/div> <\/div>
                                                                                                                                                                                                                                                        1.  Read :<\/strong><\/li><\/ol>
                                                                                                                                                                                                                                                          • To read data from a table, you can use the following stored procedure:<\/li><\/ul>
                                                                                                                                                                                                                                                             
                                                                                                                                                                                                                                                            CREATE PROCEDURE sp_select_employee (@id INT = NULL)ASBEGIN  SELECT *  FROM employee  WHERE (@id IS NULL OR id = @id)END;<\/code><\/pre> 
                                                                                                                                                                                                                                                             <\/div> <\/div>
                                                                                                                                                                                                                                                            1.  Update :<\/strong><\/li><\/ol>
                                                                                                                                                                                                                                                              • To update an existing record in a table, you can use the following stored procedure:<\/li><\/ul>
                                                                                                                                                                                                                                                                 
                                                                                                                                                                                                                                                                CREATE PROCEDURE sp_update_employee (@id INT, @first_name VARCHAR(50), @last_name VARCHAR(50), @salary INT)ASBEGIN  UPDATE employee  SET first_name = @first_name,      last_name = @last_name,      salary = @salary  WHERE id = @idEND;<\/code><\/pre> 
                                                                                                                                                                                                                                                                 <\/div> <\/div>
                                                                                                                                                                                                                                                                1.  Delete :<\/strong><\/li><\/ol>
                                                                                                                                                                                                                                                                  • To delete an existing record in a table, you can use the following stored procedure:<\/li><\/ul>
                                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                    CREATE PROCEDURE sp_delete_employee (@id INT)ASBEGIN  DELETE FROM employee  WHERE id = @idEND;<\/code><\/pre> 
                                                                                                                                                                                                                                                                     <\/div> <\/div>
                                                                                                                                                                                                                                                                    These stored procedures can be executed by calling them and passing in the necessary parameters. For example:<\/p>
                                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                    EXEC sp_insert_employee 'John', 'Doe', 50000;EXEC sp_select_employee 1;EXEC sp_update_employee 1, 'Jane', 'Doe', 60000;EXEC sp_delete_employee 1;<\/code><\/pre> 
                                                                                                                                                                                                                                                                     <\/div> <\/div><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                                                                                    \n\t\t\t\t\t
                                                                                                                                                                                                                                                                    \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t24. Explain the db first approach ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                                                                                    • The “database-first” approach is a software development process where the database design is created before the development of the application. In this approach, the database design is created using a database management system (DBMS) such as SQL Server, Oracle, or MySQL. The database design typically includes tables, columns, relationships, constraints, and other database objects.<\/li>
                                                                                                                                                                                                                                                                    • Once the database design is complete, the application can be developed to interact with the database. This may involve creating entities, data access layers, and other components to interact with the database. The application is then typically tested against the database to ensure that it works as expected.<\/li>
                                                                                                                                                                                                                                                                    • The database-first approach can be useful in situations where the data structure is well-understood and well-defined, and the database is a critical component of the application. This approach can also be useful in situations where the database design is complex, and it is necessary to have a detailed understanding of the data structure before developing the application.<\/li>
                                                                                                                                                                                                                                                                    • However, the database-first approach can also have some drawbacks. For example, it can be difficult to make changes to the database design once the application has been developed, and the application may become tightly coupled to the database, making it difficult to change the database or use a different database management system in the future.<\/li><\/ul><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                                                                                      \n\t\t\t\t\t
                                                                                                                                                                                                                                                                      \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t25. Swap two numbres ?   <\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                                                                                      • While it’s not very common to swap two numbers in SQL (as SQL is mainly used for database queries and updates), it is possible to do so using SQL variables and mathematical operations. Here’s an example of swapping two numbers using SQL:<\/li><\/ul>
                                                                                                                                                                                                                                                                        • Suppose we have two variables, @num1 and @num2, that contain the values we want to swap. We can swap these values by using a third variable, @temp, to temporarily hold one of the values during the swap.<\/li><\/ul>
                                                                                                                                                                                                                                                                          The SQL code to swap @num1 and @num2 would look like this:<\/p>
                                                                                                                                                                                                                                                                           
                                                                                                                                                                                                                                                                          DECLARE @num1 INT, @num2 INT, @temp INT;SET @num1 = 10;SET @num2 = 20;-- print the original valuesPRINT 'Before Swap:'PRINT 'num1 = ' + CAST(@num1 AS VARCHAR) + ', num2 = ' + CAST(@num2 AS VARCHAR)-- swap the valuesSET @temp = @num1;SET @num1 = @num2;SET @num2 = @temp;-- print the swapped valuesPRINT 'After Swap:'PRINT 'num1 = ' + CAST(@num1 AS VARCHAR) + ', num2 = ' + CAST(@num2 AS VARCHAR)<\/code><\/pre> 
                                                                                                                                                                                                                                                                           <\/div> <\/div>
                                                                                                                                                                                                                                                                           
                                                                                                                                                                                                                                                                          EXEC sp_insert_employee 'John', 'Doe', 50000;EXEC sp_select_employee 1;EXEC sp_update_employee 1, 'Jane', 'Doe', 60000;EXEC sp_delete_employee 1;<\/code><\/pre> 
                                                                                                                                                                                                                                                                           <\/div> <\/div>
                                                                                                                                                                                                                                                                          • In this code, we first declare the variables @num1, @num2, and @temp as integers, and then assign the initial values 10 and 20 to @num1 and @num2, respectively.<\/li>
                                                                                                                                                                                                                                                                          • We then use the PRINT statement to display the original values of @num1 and @num2.<\/li>
                                                                                                                                                                                                                                                                          • Next, we swap the values of @num1 and @num2 by first assigning the value of @num1 to @temp, and then assigning the value of @num2 to @num1 and the value of @temp (which contains the original value of @num1) to @num2.<\/li>
                                                                                                                                                                                                                                                                          • Finally, we use the PRINT statement again to display the swapped values of @num1 and @num2.<\/li><\/ul>
                                                                                                                                                                                                                                                                            When we run this code, the output would look like this:<\/p>
                                                                                                                                                                                                                                                                             
                                                                                                                                                                                                                                                                            Before Swap:num1 = 10, num2 = 20After Swap:num1 = 20, num2 = 10<\/code><\/pre> 
                                                                                                                                                                                                                                                                             <\/div> <\/div>
                                                                                                                                                                                                                                                                            • As you can see, the values of @num1 and @num2 have been successfully swapped using SQL.<\/li><\/ul><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                                                                                              \n\t\t\t\t\t
                                                                                                                                                                                                                                                                              \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t26. Explain the Composite key ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                                                                                              • A composite key in SQL is a combination of two or more columns that together form a primary key for a table. A primary key is a unique identifier for each row in a table, and composite keys allow multiple columns to be used as the unique identifier.<\/li><\/ul>
                                                                                                                                                                                                                                                                                Here is an example of how to create a composite key in SQL:<\/p>
                                                                                                                                                                                                                                                                                 
                                                                                                                                                                                                                                                                                CREATE TABLE Employee (  EmployeeID INT NOT NULL,  DepartmentID INT NOT NULL,  Name VARCHAR(50) NOT NULL,  Salary DECIMAL(10, 2) NOT NULL,  PRIMARY KEY (EmployeeID, DepartmentID));<\/code><\/pre> 
                                                                                                                                                                                                                                                                                 <\/div> <\/div>
                                                                                                                                                                                                                                                                                • In this example, the\u00a0EmployeeID<\/strong>\u00a0and\u00a0DepartmentID<\/strong>\u00a0columns together form the composite primary key for the\u00a0Employee<\/strong>\u00a0table. This means that no two rows in the table can have the same values for both\u00a0EmployeeID<\/strong>\u00a0and\u00a0DepartmentID.<\/strong><\/li>
                                                                                                                                                                                                                                                                                • Composite keys are useful in situations where a single column is not sufficient to uniquely identify a row. For example, in a company with multiple departments, it is possible for two employees to have the same employee ID. By using a composite key that includes both the employee ID and the department ID, each row in the table can be uniquely identified.<\/li><\/ul><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                                                                                                  \n\t\t\t\t\t
                                                                                                                                                                                                                                                                                  \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t27. What is transaction ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                                                                                                  A transaction in SQL refers to a sequence of database operations that are executed as a single unit of work. In other words, a transaction is a way of grouping multiple SQL statements into a single, atomic operation.<\/p>
                                                                                                                                                                                                                                                                                  A transaction has the following properties:<\/p>
                                                                                                                                                                                                                                                                                  1.  Atomicity :<\/strong><\/li><\/ol>
                                                                                                                                                                                                                                                                                    • A transaction is treated as a single, indivisible unit of work. If any part of the transaction fails, the entire transaction is rolled back, and the database is returned to its original state.<\/li><\/ul>
                                                                                                                                                                                                                                                                                      1.  Consistency :<\/strong><\/li><\/ol>
                                                                                                                                                                                                                                                                                        • A transaction ensures that the database remains in a consistent state. If the transaction is completed successfully, the data in the database is guaranteed to be in a valid state.<\/li><\/ul>
                                                                                                                                                                                                                                                                                          1.  Isolation :<\/strong><\/li><\/ol>
                                                                                                                                                                                                                                                                                            • Each transaction is isolated from other transactions. This means that one transaction cannot interfere with another transaction that is running simultaneously.<\/li><\/ul>
                                                                                                                                                                                                                                                                                              1.  Durability :<\/strong><\/li><\/ol>
                                                                                                                                                                                                                                                                                                • A transaction is durable, meaning that its effects are permanent, even if the database or the system crashes.<\/li><\/ul>
                                                                                                                                                                                                                                                                                                  Transactions are useful for ensuring the integrity and consistency of the data in a database. They are used to ensure that multiple operations are performed together, as a single, indivisible unit of work, and to ensure that the database remains in a consistent state, even in the face of errors or system failures.<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                                                                                                                  \n\t\t\t\t\t
                                                                                                                                                                                                                                                                                                  \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t28. How to access the database in JSON format ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                                                                                                                  In SQL, you can use the\u00a0FOR JSON<\/strong>\u00a0clause to return the result of a query in JSON format. Here is an example of how to use this clause in SQL Server:<\/p>
                                                                                                                                                                                                                                                                                                   
                                                                                                                                                                                                                                                                                                  SELECT * FROM Employee-tableFOR JSON PATH<\/code><\/pre> 
                                                                                                                                                                                                                                                                                                   <\/div> <\/div>
                                                                                                                                                                                                                                                                                                  • This will return the entire\u00a0Employee-table<\/strong>\u00a0as a single JSON object, where each row in the table is represented as a JSON object within an array. The PATH option is used to return the JSON objects as a nested structure, which allows you to access properties of nested objects.<\/li><\/ul>
                                                                                                                                                                                                                                                                                                    If you want to return the result of a query as a flat JSON object, you can use the FOR\u00a0JSON AUTO<\/strong>\u00a0clause instead:<\/p>
                                                                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                                                    SELECT * FROM Employee-tableFOR JSON AUTO<\/code><\/pre> 
                                                                                                                                                                                                                                                                                                     <\/div> <\/div>
                                                                                                                                                                                                                                                                                                    This will return the result of the query as a single flat JSON object, where the columns of each row are represented as properties of the JSON object.<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t
                                                                                                                                                                                                                                                                                                    \n\t\t\t\t\t
                                                                                                                                                                                                                                                                                                    \n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t<\/path><\/svg><\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/span>\n\t\t\t\t\t\t\t\t\t\t\t\t29. Get the output from employee-table count of employee date of joning in a every months ?<\/a>\n\t\t\t\t\t<\/div>\n\t\t\t\t\t
                                                                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                                                    example:Month    count of employejan                  5feb                 10march            1<\/code><\/pre> 
                                                                                                                                                                                                                                                                                                     <\/div> <\/div>
                                                                                                                                                                                                                                                                                                    To get the output from the employee table that shows the count of employees who joined in each month, you can use the following SQL query:<\/p>
                                                                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                                                    SELECT   DATE_FORMAT(date_of_joining, '%M') AS Month,   COUNT(*) AS count_of_employee FROM employee_table GROUP BY MonthORDER BY Month;<\/code><\/pre> 
                                                                                                                                                                                                                                                                                                     <\/div> <\/div>
                                                                                                                                                                                                                                                                                                    Explanation:<\/p>
                                                                                                                                                                                                                                                                                                    • The\u00a0DATE_FORMAT<\/strong>\u00a0function is used to format the\u00a0date_of_joining<\/strong>\u00a0column into a month name.<\/li>
                                                                                                                                                                                                                                                                                                    • The\u00a0GROUP BY<\/strong>\u00a0clause groups the rows by the month name and the\u00a0COUNT(*)<\/strong>\u00a0function counts the number of employees in each group.<\/li>
                                                                                                                                                                                                                                                                                                    • The\u00a0ORDER BY<\/strong>\u00a0clause sorts the result set by the month name in ascending order.<\/li><\/ul>
                                                                                                                                                                                                                                                                                                      This query will give you a result set that shows the count of employees who joined in each month, as in the example you provided.<\/p>
                                                                                                                                                                                                                                                                                                      \u00a0<\/p><\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t","protected":false},"excerpt":{"rendered":"
                                                                                                                                                                                                                                                                                                      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 […]<\/p>\n","protected":false},"author":2,"featured_media":25773,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[724],"tags":[742,749,757,740,741,751,748,745,747,743,755,756,753],"class_list":["post-1615","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-interview-questions","tag-interview-questions-sql","tag-sql-interview","tag-sql-interview-question","tag-sql-interview-questions","tag-sql-interview-questions-and-answers","tag-sql-interview-questions-and-answers-for-experienced","tag-sql-interview-questions-and-answers-for-freshers","tag-sql-interview-questions-for-beginners","tag-sql-interview-questions-for-experienced","tag-sql-interview-questions-for-freshers","tag-sql-queries-interview-questions-and-answers","tag-sql-server-interview-questions-and-answers","tag-top-sql-interview-questions"],"_links":{"self":[{"href":"https:\/\/www.kaashivinfotech.com\/blog\/wp-json\/wp\/v2\/posts\/1615","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.kaashivinfotech.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.kaashivinfotech.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.kaashivinfotech.com\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.kaashivinfotech.com\/blog\/wp-json\/wp\/v2\/comments?post=1615"}],"version-history":[{"count":0,"href":"https:\/\/www.kaashivinfotech.com\/blog\/wp-json\/wp\/v2\/posts\/1615\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.kaashivinfotech.com\/blog\/wp-json\/wp\/v2\/media\/25773"}],"wp:attachment":[{"href":"https:\/\/www.kaashivinfotech.com\/blog\/wp-json\/wp\/v2\/media?parent=1615"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.kaashivinfotech.com\/blog\/wp-json\/wp\/v2\/categories?post=1615"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.kaashivinfotech.com\/blog\/wp-json\/wp\/v2\/tags?post=1615"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}