Explore topic-wise InterviewSolutions in .

SQL pattern matching provides for pattern search in data if you have no clue as to what that word should be. This kind of SQL query uses wildcards to match a string pattern, rather than writing the exact word. The LIKE operator is used in CONJUNCTION with SQL Wildcards to fetch the required information.

• Using the % wildcard to perform a simple search

The % wildcard matches zero or more characters of any type and can be used to define wildcards both before and after the pattern. Search a student in your database with FIRST name beginning with the letter K:

• Omitting the patterns using the NOT keyword

Use the NOT keyword to select records that don't match the pattern. This query returns all students whose first name does not begin with K.

• Matching a pattern anywhere using the % wildcard twice

Search for a student in the database where he/she has a K in his/her first name.

• Using the _ wildcard to match pattern at a specific position

The _ wildcard matches exactly one character of any type. It can be used in conjunction with % wildcard. This query fetches all students with letter K at the third position in their first name.

• Matching patterns for a specific length

The _ wildcard plays an important role as a LIMITATION when it matches exactly one character. It limits the length and position of the matched results. For example - 

Creating empty TABLES with the same structure can be done smartly by fetching the records of ONE table into a new table using the INTO operator while fixing a WHERE CLAUSE to be false for all records. Hence, SQL prepares the new table with a duplicate structure to accept the fetched records but since no records GET fetched due to the WHERE clause in action, nothing is inserted into the new table.

A stored procedure that calls itself until a BOUNDARY condition is reached, is called a recursive stored procedure. This recursive function helps the programmers to DEPLOY the same set of code several times as and when required. Some SQL programming languages limit the recursion depth to prevent an infinite loop of procedure calls from causing a stack overflow, which slows down the system and may lead to system crashes.

A STORED procedure is a subroutine available to applications that access a relational database management SYSTEM (RDBMS). Such procedures are stored in the database data dictionary. The sole disadvantage of stored procedure is that it can be executed nowhere except in the database and occupies more MEMORY in the database server. It also provides a sense of security and FUNCTIONALITY as users who can't access the data DIRECTLY can be granted access via stored procedures.

Collation refers to a set of rules that determine how data is sorted and compared. Rules defining the correct character SEQUENCE are used to sort the character data. It INCORPORATES OPTIONS for specifying CASE sensitivity, accent marks, kana character types, and character width. Below are the different types of collation sensitivity:

• Case sensitivity: A and a are treated differently.
• Accent sensitivity: a and á are treated differently.
• Kana sensitivity: Japanese kana characters Hiragana and KATAKANA are treated differently.
• Width sensitivity: Same character represented in single-byte (half-width) and double-byte (full-width) are treated differently.

The user-defined functions in SQL are like functions in any other PROGRAMMING language that accept parameters, perform complex calculations, and return a value. They are written to use the logic repetitively WHENEVER required. There are two types of SQL user-defined functions:

• SCALAR Function: As explained earlier, user-defined scalar functions return a single scalar value.
• Table-Valued Functions: User-defined table-valued functions return a table as output.
  • Inline: returns a table data type based on a single SELECT statement.
  • Multi-statement: returns a tabular result-set but, unlike inline, multiple SELECT STATEMENTS can be USED inside the function body.

An AGGREGATE function performs OPERATIONS on a collection of values to return a single scalar value. Aggregate functions are often used with the GROUP BY and HAVING CLAUSES of the SELECT statement. Following are the widely used SQL aggregate functions:

• AVG() - Calculates the mean of a collection of values.
• COUNT() - Counts the total number of records in a specific table or view.
• MIN() - Calculates the minimum of a collection of values.
• MAX() - Calculates the maximum of a collection of values.
• SUM() - Calculates the sum of a collection of values.
• FIRST() - FETCHES the first element in a collection of values.
• LAST() - Fetches the last element in a collection of values.

Note: All aggregate functions described above ignore NULL values except for the COUNT function.

A scalar function returns a single value based on the input value. Following are the widely used SQL scalar functions:

• LEN() - Calculates the total LENGTH of the given field (column).
• UCASE() - Converts a collection of string values to uppercase characters.
• LCASE() - Converts a collection of string values to lowercase characters.
• MID() - Extracts substrings from a collection of string values in a table.
• CONCAT() - Concatenates two or more strings.
• RAND() - Generates a random collection of numbers of a given length.
• ROUND() - Calculates the round-off integer value for a numeric field (or decimal point values).
• NOW() - Returns the current date & time.
• FORMAT() - Sets the format to display a collection of values.

The TRUNCATE command is used to delete all the rows from the table and FREE the SPACE containing the table.
The DELETE command DELETES only the rows from the table based on the CONDITION given in the where clause or deletes all the rows from the table if no condition is specified. But it does not free the space containing the table.

If a table is dropped, all things associated with the tables are dropped as well. This INCLUDES - the RELATIONSHIPS defined on the table with other tables, the integrity checks and constraints, ACCESS privileges and other grants that the table has. To create and use the table again in its original form, all these relations, checks, constraints, privileges and relationships need to be REDEFINED. However, if a table is truncated, none of the above problems exist and the table RETAINS its original structure.

DELETE statement is USED to delete rows from a table.

TRUNCATE COMMAND is used to delete all the rows from the table and free the space containing the table.

DROP command is used to remove an object from the database. If you drop a table, all the rows in the table are deleted and the table structure is removed from the database.

Normal Forms are used to eliminate or reduce redundancy in database tables. The different forms are as follows:

• First Normal Form:
  A relation is in first normal form if every attribute in that relation is a single-valued attribute. If a relation contains a composite or multi-valued attribute, it violates the first normal form. Let's consider the following students table. Each student in the table, has a name, his/her address, and the books they issued from the public library -

Students Table

As we can observe, the Books Issued field has more than one value per RECORD, and to convert it into 1NF, this has to be resolved into separate individual records for each book issued. Check the following table in 1NF form -

Students Table (1st Normal Form)

• Second Normal Form:

A relation is in second normal form if it satisfies the conditions for the first normal form and does not contain any partial dependency. A relation in 2NF has no partial dependency, i.e., it has no non-prime attribute that depends on any proper subset of any candidate key of the table. Often, specifying a single column Primary Key is the solution to the problem. Examples -

Example 1 - Consider the above example. As we can observe, the Students Table in the 1NF form has a candidate key in the form of [Student, Address] that can UNIQUELY identify all records in the table. The field Books Issued (non-prime attribute) depends partially on the Student field. Hence, the table is not in 2NF. To convert it into the 2nd Normal Form, we will partition the tables into two while specifying a new Primary Key attribute to identify the individual records in the Students table. The Foreign Key constraint will be set on the other table to ensure referential integrity.

Students Table (2nd Normal Form)

Books Table (2nd Normal Form)

Example 2 - Consider the following dependencies in relation to R(W,X,Y,Z)

Here, WX is the only candidate key and there is no partial dependency, i.e., any proper subset of WX doesn’t determine any non-prime attribute in the relation.

• THIRD Normal Form

A relation is said to be in the third normal form, if it satisfies the conditions for the second normal form and there is no transitive dependency between the non-prime attributes, i.e., all non-prime attributes are determined only by the candidate keys of the relation and not by any other non-prime attribute.

Example 1 - Consider the Students Table in the above example. As we can observe, the Students Table in the 2NF form has a single candidate key Student_ID (primary key) that can uniquely identify all records in the table. The field Salutation (non-prime attribute), however, depends on the Student Field rather than the candidate key. Hence, the table is not in 3NF. To convert it into the 3rd Normal Form, we will once again partition the tables into two while specifying a new Foreign Key constraint to identify the salutations for individual records in the Students table. The Primary Key constraint for the same will be set on the Salutations table to identify each record uniquely.

Students Table (3rd Normal Form)

Books Table (3rd Normal Form)

Salutations Table (3rd Normal Form)

Example 2 - Consider the following dependencies in relation to R(P,Q,R,S,T)

For the above relation to exist in 3NF, all possible candidate keys in the above relation should be {P, RS, QR, T}.

• Boyce-Codd Normal Form

A relation is in Boyce-Codd Normal Form if satisfies the conditions for third normal form and for every functional dependency, Left-Hand-Side is super key. In other words, a relation in BCNF has non-trivial functional dependencies in form X –> Y, such that X is always a super key. For example - In the above example, Student_ID serves as the sole unique identifier for the Students Table and Salutation_ID for the Salutations Table, thus these tables exist in BCNF. The same cannot be said for the Books Table and there can be SEVERAL books with common Book Names and the same Student_ID.

An alias is a feature of SQL that is supported by most, if not all, RDBMSs. It is a temporary name assigned to the table or table column for the purpose of a PARTICULAR SQL query. In addition, aliasing can be EMPLOYED as an obfuscation technique to secure the real names of database fields. A table alias is also called a correlation name.

An alias is represented explicitly by the AS keyword but in some cases, the same can be performed without it as well. Nevertheless, using the AS keyword is ALWAYS a good practice.

• One-to-One - This can be defined as the RELATIONSHIP between two tables where each record in one table is ASSOCIATED with the MAXIMUM of one record in the other table.
• One-to-Many & Many-to-One - This is the most commonly used relationship where a record in a table is associated with multiple records in the other table.
• Many-to-Many - This is used in cases when multiple instances on both sides are needed for defining a relationship.
• Self-Referencing Relationships - This is used when a table NEEDS to define a relationship with itself.

ENTITY: An entity can be a real-world object, EITHER tangible or intangible, that can be easily identifiable. For example, in a college DATABASE, students, professors, WORKERS, departments, and PROJECTS can be referred to as entities. Each entity has some associated properties that provide it an identity.

Relationships: Relations or links between entities that have something to do with each other. For example - The employee's table in a company's database can be associated with the salary table in the same database.

A DATABASE CURSOR is a control structure that allows for the traversal of records in a database. Cursors, in addition, facilitates processing after traversal, such as retrieval, addition, and deletion of database records. They can be viewed as a pointer to ONE row in a set of rows.

Working with SQL Cursor:

1. DECLARE a cursor after any variable declaration. The cursor declaration must always be associated with a SELECT Statement.
2. Open cursor to initialize the RESULT set. The OPEN statement must be called before fetching rows from the result set.
3. FETCH statement to retrieve and move to the next row in the result set.
4. Call the CLOSE statement to deactivate the cursor.
5. Finally use the DEALLOCATE statement to delete the cursor definition and release the associated resources.

The UNION operator combines and returns the result-set RETRIEVED by two or more SELECT statements.
The MINUS operator in SQL is used to remove duplicates from the result-set obtained by the second SELECT query from the result-set obtained by the first SELECT query and then RETURN the filtered RESULTS from the first.
The INTERSECT clause in SQL combines the result-set fetched by the two SELECT statements where records from ONE match the other and then returns this intersection of result-sets.

Certain conditions need to be met before executing either of the above statements in SQL -

• Each SELECT statement within the clause must have the same number of columns
• The columns must also have similar data types
• The columns in each SELECT statement should necessarily have the same order

Some common SQL clauses used in conjuction with a SELECT query are as follows:

• WHERE clause in SQL is used to filter RECORDS that are NECESSARY, based on specific conditions.
• ORDER BY clause in SQL is used to sort the records based on some field(s) in ascending (ASC) or descending order (DESC).

• GROUP BY clause in SQL is used to group records with identical data and can be used in conjunction with some aggregation FUNCTIONS to produce summarized results from the database.
• HAVING clause in SQL is used to filter records in COMBINATION with the GROUP BY clause. It is different from WHERE, since the WHERE clause cannot filter aggregated records.

SELECT OPERATOR in SQL is USED to select data from a database. The data RETURNED is STORED in a RESULT table, called the result-set.

A subquery is a query WITHIN another query, also known as a nested query or inner query. It is used to RESTRICT or enhance the data to be queried by the main query, thus restricting or enhancing the output of the main query respectively. For example, here we fetch the contact information for students who have enrolled for the maths SUBJECT:

There are two types of subquery - Correlated and Non-Correlated.

• A correlated subquery cannot be considered as an independent query, but it can refer to the column in a table listed in the FROM of the main query.
• A non-correlated subquery can be considered as an independent query and the output of the subquery is substituted in the main query.

A query is a request for DATA or information from a database table or combination of tables. A database query can be either a select query or an ACTION query.

Data INTEGRITY is the assurance of accuracy and consistency of data over its entire life-cycle and is a critical ASPECT of the design, implementation, and usage of any SYSTEM which stores, PROCESSES, or retrieves data. It also defines integrity constraints to enforce business rules on the data when it is entered into an APPLICATION or a database.

As EXPLAINED above, the differences can be BROKEN down into three small factors -

• Clustered index MODIFIES the way records are stored in a database based on the indexed column. A non-clustered index creates a separate entity within the table which references the ORIGINAL table.
• Clustered index is used for easy and speedy retrieval of data from the database, whereas, fetching records from the non-clustered index is relatively slower.
• In SQL, a table can have a single clustered index whereas it can have multiple non-clustered indexes.

A database index is a data structure that provides a quick lookup of data in a column or columns of a table. It enhances the speed of operations accessing data from a database table at the cost of additional writes and memory to MAINTAIN the index data structure.

There are different types of indexes that can be created for different purposes:

• Unique and Non-Unique Index:

Unique indexes are indexes that help maintain data integrity by ensuring that no two rows of data in a table have identical key values. Once a unique index has been defined for a table, uniqueness is enforced whenever keys are ADDED or changed within the index.

Non-unique indexes, on the other hand, are not used to enforce CONSTRAINTS on the tables with which they are associated. Instead, non-unique indexes are used solely to improve query performance by maintaining a sorted order of data values that are used frequently.

• Clustered and Non-Clustered Index:

Clustered indexes are indexes whose order of the rows in the database corresponds to the order of the rows in the index. This is why only one clustered index can EXIST in a given table, whereas, multiple non-clustered indexes can exist in the table.

The only difference between clustered and non-clustered indexes is that the database manager attempts to keep the data in the database in the same order as the corresponding keys appear in the clustered index.

Clustering indexes can improve the performance of most query operations because they provide a linear-access path to data stored in the database.

CROSS join can be defined as a cartesian product of the two tables INCLUDED in the join. The table after join contains the same number of rows as in the cross-product of the number of rows in the two tables. If a WHERE clause is used in cross join then the query will work like an INNER JOIN.

A self JOIN is a case of REGULAR join where a table is joined to itself BASED on some RELATION between its own column(s). Self-join uses the INNER JOIN or LEFT JOIN clause and a table alias is used to assign different names to the table within the query.

The SQL Join clause is used to combine RECORDS (rows) from two or more tables in a SQL database based on a related column between the two.

There are four different TYPES of JOINs in SQL:

• (INNER) JOIN: Retrieves records that have matching values in both tables involved in the join. This is the WIDELY used join for queries.

• LEFT (OUTER) JOIN: Retrieves all the records/rows from the left and the matched records/rows from the right table.

• RIGHT (OUTER) JOIN: Retrieves all the records/rows from the right and the matched records/rows from the left table.

• FULL (OUTER) JOIN: Retrieves all the records where there is a match in either the left or right table.

A FOREIGN KEY comprises of single or collection of fields in a table that essentially refers to the PRIMARY KEY in another table. Foreign key CONSTRAINT ensures referential INTEGRITY in the relation between two tables.
The table with the foreign key constraint is labeled as the child table, and the table CONTAINING the candidate key is labeled as the referenced or parent table.

A UNIQUE CONSTRAINT ensures that all values in a column are different. This provides uniqueness for the column(s) and helps identify each row uniquely. Unlike primary key, there can be multiple unique constraints defined PER table. The code syntax for UNIQUE is quite SIMILAR to that of PRIMARY KEY and can be used interchangeably.

The PRIMARY KEY constraint uniquely identifies each row in a table. It must contain UNIQUE values and has an implicit NOT NULL constraint.
A table in SQL is strictly restricted to have one and only one primary key, which is comprised of single or MULTIPLE fields (columns).

A table is an organized COLLECTION of data stored in the form of ROWS and COLUMNS. Columns can be categorized as vertical and rows as horizontal. The columns in a table are CALLED fields while the rows can be referred to as RECORDS.

SQL is a standard language for retrieving and manipulating STRUCTURED DATABASES. On the contrary, MySQL is a relational database MANAGEMENT system, like SQL Server, Oracle or IBM DB2, that is used to manage SQL databases.

SQL STANDS for Structured Query Language. It is the STANDARD language for relational database management systems. It is especially useful in handling ORGANIZED data comprised of entities (variables) and RELATIONS between different entities of the data.

RDBMS stands for Relational Database Management System. The key difference here, compared to DBMS, is that RDBMS STORES data in the form of a collection of tables, and relations can be defined between the common fields of these tables. Most modern database management SYSTEMS like MySQL, MICROSOFT SQL Server, ORACLE, IBM DB2, and Amazon Redshift are based on RDBMS.

DBMS stands for DATABASE Management System. DBMS is a system software responsible for the creation, RETRIEVAL, updation, and management of the database. It ensures that our data is consistent, organized, and is easily accessible by SERVING as an interface between the database and its end-users or APPLICATION software.

A DATABASE is an organized collection of data, stored and retrieved digitally from a remote or local computer system. Databases can be vast and COMPLEX, and such databases are developed using fixed DESIGN and modeling APPROACHES.