The EXISTS function argument is an inner query. It returns true if the query returns one or more rows, and returns false if the query returns zero rows.
The PIVOT relational operator can be used to modify a table-valued expression in another table. The PIVOT operator expands a table-valued expression, transforming the unique values of one column of the expression into multiple output columns, and optionally concatenates the remaining duplicate column values and displays them in the output.
DATETIME is intended to store an integer: YYYYMMDDHHMMSS. And this time does not depend on the time zone configured on the server. Stores: 8 bytes
TIMESTAMP stores a value equal to the number of seconds that have passed since midnight on January 1, 1970 GMT. When received from the database, it is displayed taking into account the time zone. Stores: 4 bytes.
As operands of addition and subtraction operations, any valid expression of any data type of the numeric category is allowed, except for the bit data type.
A stored procedure is a compiled set of SQL statements that is part of the database and stored on the server. There is a lot in common between Stored Procedures and ordinary programming language procedures: they can have input parameters and output results, they can perform various numerical calculations, as well as perform standard database operations. As with procedures in other programming languages, they can have loops and branches.
The ranking functions return a ranking value for each row in a partition. Depending on the function used, the values of some strings may be the same. The ranking functions are non-deterministic.
Transact-SQL contains the following ranking functions:
RANK
NTILE
DENSE_RANK
ROW_NUMBER
Syntax:
SELECT column_name
RANK() OVER (
PARTITION BY expression
ORDER BY expression [ASC|DESC])
AS 'my_rank' FROM table_name;
In this syntax,
The OVER clause sets the partitioning and ordering of a result before the associated window function is applied.
The PARTITION BY clause divides the output produces by the FROM clause into the partition. Then the function is applied to each partition and re-initialized when the division border crosses partitions. If we have not defined this clause, the function will treat all rows as a single partition.
The ORDER BY is a required clause that determines the order of the rows in a descending or ascending manner based on one or more column names before the function is applied.
Example:
SELECT first_name, last_name, city,
RANK () OVER (ORDER BY city) AS Rank_No
FROM rank_demo;
Yes, it can. If this column is not constrained not null, example: when building a file system tree table, where the foreign key column is a link to the same table, to a tuple with information about the parent directory, then for the root directory of the file system in the parent column directory will be null.
ACID - atomicity, consistency, isolation, durability.
The atomicity property guarantees the indivisibility of a set of statements that modify data in the database and are part of a transaction. This means that either all data changes in the transaction are performed, or in case of any error, all changes already made are canceled.
Consistency ensures that the transaction does not allow the database to contain inconsistent data. In other words, data transformation within a single transaction moves the database from one consistent state to another consistent state.
The isolation property separates all concurrently executing transactions. In other words, no active transaction can see data changes made in a concurrent but not completed transaction. This means that some transactions can be rolled back to provide isolation.
Durability - after its completion, the transaction is stored in the system, which nothing can return to its original (before the start of the transaction) state, i.e. the transaction is committed, meaning that its effect is permanent even if the system fails.
SELECT DISTINCT columnsName FROM tableName;
where: columnsName - one or more real names of columns separated by commas; tableName is the name of the table from which these columns are selected.
If more than one column is included in the SELECT DISTINCT clause, then the uniqueness of any row will be determined by the uniqueness of the corresponding combination of all column values included in the clause on that same row among similar combinations matching other rows.
Although null values are never equal to each other (because they are considered unknown), the DISTINCT clause, on the contrary, considers them duplicates. Therefore, the SELECT DISTINCT command will return only one null value, no matter how many null values it encounters.
A full scan is performed by a multi-block read. Scanning by index - single-block. Also, when accessing by index, the index itself is scanned first, and then blocks are read from the table.
The number of blocks that must be read from the table depends on the clustering factor.
If the total cost of all required single-block reads is greater than the cost of a full scan by multi-block reads, then a full scan is more profitable and is chosen by the optimizer. Thus, a full scan is chosen when the overgrowth predicate selectivity and/or data clustering is weak, or in the case of very small tables.
An aggregate function is a function that returns a single value based on multiple records.
Here is a list of some SQL aggregate functions:
COUNT(*) - Returns the number of rows in the record source
COUNT - Returns the number of values in the specified column
SUM - Returns the sum of the values in the specified column
AVG - Returns the average value in the specified column
MIN - Returns the minimum value in the specified column
MAX - Returns the maximum value in the specified column
Definition of the third normal form of a database.
Any field of any record stores only one value. (1NF) For example, if a field contains a comma-separated list of identifiers, then this is a violation of this definition.
The 1NF condition is met and any non-key field is completely dependent on the key (2NF). For example, we have a record with fields (Identifier, CD Name, Group Name), where the key is the "Identifier" field. At the same time, it is obvious that the "Group Name" field depends not only on the "Identifier" but also on the "CD-Disk Name" field. Therefore, such a database is not in second normal form.
The 2NF condition is met and there are no non-key fields dependent on the value of other non-key fields. For example, we store the region code and its name in the record. It is clear that the name of the region depends on the code, and vice versa, so such a database will not be in the third normal form.
Denormalization is the process of deliberately making a database appear in a way that does not conform to the rules of normalization. This is sometimes necessary to improve performance and data retrieval speed by increasing data redundancy.
If an application needs to frequently perform selects that take too long (for example, joining data from many tables), then denormalization should be considered.
A possible solution is the following: put the results of the sample in a separate table. This will speed up queries, but it also means that this new table needs constant maintenance. Before proceeding with denormalization, you need to make sure that the expected results justify the costs that you have to face.
A trigger is a SQL procedure that fires on some event (INSERT, DELETE or UPDATE). Triggers are stored and managed by the DBMS. Triggers are used to maintain the referential integrity of data in the same manner by responding to data change events. The trigger cannot be called or executed manually, the DBMS automatically calls it after modifying the data in the corresponding table. This is where it differs from stored procedures, which must be executed manually by calling CALL. A trigger can also call other procedures.
A trigger can also contain INSERT, DELETE, and UPDATE calls within itself, thus calling another trigger. Such triggers are called nested.
In computer science, a database cursor is a mechanism that enables traversal over the records in a database. Cursors facilitate subsequent processing in conjunction with the traversal, such as retrieval, addition and removal of database records. The database cursor characteristic of traversal makes cursors akin to the programming language concept of iterator.
Cursors are used by database programmers to process individual rows returned by database system queries. Cursors enable manipulation of whole result sets at once. In this scenario, a cursor enables the sequential processing of rows in a result set.
In SQL procedures, a cursor makes it possible to define a result set (a set of data rows) and perform complex logic on a row by row basis. By using the same mechanics, a SQL procedure can also define a result set and return it directly to the caller of the SQL procedure or to a client application.
A cursor can be viewed as a pointer to one row in a set of rows. The cursor can only reference one row at a time, but can move to other rows of the result set as needed.
A cursor is a database object that allows applications to work with records "one at a time", rather than many at once, as it is done in regular SQL commands.
The procedure for working with a cursor is as follows:
Some of them:
The MERGE operation has officially appeared in the ANSI SQL:2008 standard.
It allows you to insert or modify table records at the same time according to the criteria. When the criterion is met, the rows are changed, otherwise they are inserted. It can be replaced by sequential calls to INSERT and UPDATE. In some databases, a similar operation is called UPSERT.
WHERE is a limiting expression. It is executed before the result of the operation is received.
HAVING is a filter expression. It is applied to the result of the operation and is executed after this result is received, unlike where.
WHERE clauses are used with SELECT, UPDATE, DELETE statements, while HAVING clauses are used only with SELECT and GROUP BY clause.
That is, it is impossible to use WHERE in queries with aggregate functions, and HAVING was introduced for this.
Data integrity is an important property of SQL. When used correctly, it ensures the correctness and validity of the stored data at any given time. Also, they can be used to detect errors in applications that are difficult to find in other ways. Data integrity is maintained through constraints.
There are 4 main restrictions in ANSI SQL: PRIMARY KEY, CHECK, UNIQUE and FOREIGN KEY. They are not required for the table.
PRIMARY KEY - a set of fields (1 or more) whose values form a unique combination and are used to uniquely identify a record in a table. Only one such constraint can be created for a table. This constraint is used to ensure the integrity of the entity described by the table.
CHECK is used to restrict the set of values that can be placed in a given column. This constraint is used to ensure the integrity of the subject area that the tables in the database describe.
A UNIQUE constraint ensures that there are no duplicates in a column or set of columns. The difference between PRIMARY KEY and UNIQUE is described in primary and unique keys, in the question below.
A FOREIGN KEY constraint protects against actions that can break relationships between tables. FOREIGN KEY in one table points to PRIMARY KEY in another. Therefore, this restriction is intended to ensure that there are no FOREIGN KEY entries that do not match the PRIMARY KEY entries. Thus, FOREIGN KEY maintains the referential integrity of the data.
The primary and unique constraints are designed to ensure that the values of the column on which they are defined are unique. But by default, the primary constraint creates a clustered index on the column, while the unique constraint creates a non-clustered one. Another difference is that primary does not allow NULL entries, while unique only allows one NULL entry.
Non-clustered indexes are created by the DBMS by default. The data is physically random, but logically ordered according to the index. This type of index is suitable for tables where values change frequently.
With clustered indexing, the data is physically ordered, which greatly increases the speed of data retrieval (but only in the case of sequential data access). Only one clustered index can be created per table.