html-flip-book-react 0.0.0-alpha.1

package/example/assets/pages_data/en/content/012-sql-command-categories.md

@@ -0,0 +1,121 @@
+# SQL | DDL, DQL, DML, DCL and TCL Commands
+Structured Query Language(SQL), as we all know, is the database language by which we can perform certain operations on the existing database. Also, we can use this language to create a database. SQL uses specific commands like Create, Drop, Insert, etc., to carry out the required tasks.
+1. **DDL** – Data Definition Language
+2. **DQl** – Data Query Language
+3. **DML** – Data Manipulation Language
+4. **DCL** – Data Control Language
+
+#### Though many resources claim there to be another category of SQL clauses TCL – Transaction Control Language, so we will see in detail about TCL as well.
+![img.png](../assets/sql-command.png)
+
+### DDL (Data Definition Language):
+DDL or Data Definition Language consists of the SQL commands used to define the database schema. It simply deals with descriptions of the database schema and is used to create and modify the structure of database objects in the database. These commands usually are not used by a general user, who should be accessing the database via an application.
+
+#### List of DDL commands:
+- `CREATE`: This command is used to create the database or its objects (like table, index, function, views, store procedure, and triggers).
+```sql
+CREATE TABLE Persons (
+    PersonID int,
+    LastName varchar(255),
+    FirstName varchar(255),
+    Address varchar(255),
+    City varchar(255)
+);
+```
+- `DROP`: This command is used to delete objects from the database.
+
+```sql
+DROP TABLE table_name;
+```
+- `ALTER`: This is used to alter the structure of the database.
+```sql
+ALTER TABLE Persons
+ADD Age int;
+```
+- `TRUNCATE`: This is used to remove all records from a table, including all spaces allocated for the records.
+```sql
+TRUNCATE TABLE Persons;
+```
+- `COMMENT`: This is used to add comments to the data dictionary.
+```sql
+--SELECT * FROM Customers;
+SELECT * FROM Persons;
+```
+-` RENAME`: This is used to rename an object existing in the database.
+```sql
+ALTER TABLE Persons
+RENAME COLUMN Age TO Year;
+```
+
+#### DQL (Data Query Language):
+**DQL** statements are used for performing queries on the data within schema objects. The purpose of the DQL Command is to get some schema relation based on the query passed to it. We can define DQL as follows. It is a component of the SQL statement that allows getting data from the database and imposing order upon it. It includes the SELECT statement. This command allows getting the data out of the database to perform operations with it. When a SELECT is fired against a table(s), the result is compiled into a different temporary table, which is displayed or perhaps received by the program, i.e. a front-end.
+
+#### List of DQL:
+`SELECT`: It is used to retrieve data from the database.
+```sql
+SELECT * FROM table_name;
+```
+```
++--------+--------------+------------+--------+---------+
+| emp_id | emp_name     | hire_date  | salary | dept_id |
++--------+--------------+------------+--------+---------+
+|      1 | Ethan Hunt   | 2001-05-01 |   5000 |       4 |
+|      2 | Tony Montana | 2002-07-15 |   6500 |       1 |
+|      3 | Sarah Connor | 2005-10-18 |   8000 |       5 |
+|      4 | Rick Deckard | 2007-01-03 |   7200 |       3 |
+|      5 | Martin Blank | 2008-06-24 |   5600 |    NULL |
++--------+--------------+------------+--------+---------+
+```
+The SQL commands that deal with the manipulation of data present in the database belong to DML or Data Manipulation Language, including most of the SQL statements. It is the component of the SQL statement that controls access to data and the database. DCL statements are grouped with DML statements.
+
+#### List of DML commands:
+- `INSERT `: It is used to insert data into a table.
+```sql
+INSERT INTO Customers
+  (CustomerName, ContactName, Address, City, PostalCode, Country)
+VALUES
+  ('Cardinal', 'Tom B. Erichsen', 'Skagen 21', 'Stavanger', '4006', 'Norway');
+```
+- `UPDATE`: It is used to update existing data within a table.
+
+```sql
+UPDATE Customers
+SET ContactName='Alfred Schmidt', City='Frankfurt'
+WHERE CustomerID = 1;
+```
+- `DELETE `: It is used to delete records from a database table.
+```sql
+ DELETE FROM Customers WHERE CustomerName='Alfreds Futterkiste';
+```
+- `LOCK`: Table control concurrency.
+```sql
+LOCK TABLES table_name [READ | WRITE]
+--------------------------------------
+UNLOCK TABLES;
+```
+- `CALL`: Call a PL/SQL or JAVA subprogram.
+```sql
+CREATE PROCEDURE procedure_name
+AS sql_statement
+GO;
+```
+#### Execute a Stored Procedure
+```sql
+EXEC procedure_name;
+```
+- `EXPLAIN PLAN`: It describes the access path to data.
+
+#### DCL (Data Control Language):
+DCL includes commands such as GRANT and REVOKE, which mainly deal with the database system's rights, permissions, and other controls.
+
+##### List of  DCL commands:
+- `GRANT`: This command gives users access privileges to the database.
+- `REVOKE`: This command withdraws the user’s access privileges given by using the GRANT command.
+
+Though many resources claim there to be another category of SQL clauses TCL – Transaction Control Language, we will see in detail about TCL. TCL commands deal with the transaction within the database.
+
+##### List of TCL commands:
+- `COMMIT`: Commits a Transaction.
+- `ROLLBACK`: Rollbacks a transaction in case of any error occurs.
+- `SAVEPOINT`:Sets a savepoint within a transaction.
+- `SET TRANSACTION`: Specify characteristics for the transaction.

package/example/assets/pages_data/en/content/013-sub-queries.md

@@ -0,0 +1,112 @@
+# SQL Sub Queries
+
+###  A subquery is a SQL query nested inside a larger query.
+
+- A subquery may occur in
+  - A SELECT clause
+  - A FROM clause
+  - A WHERE clause
+
+- The subquery can be nested inside a SELECT, INSERT, UPDATE, or DELETE statement or inside another subquery.
+- A subquery is usually added within the WHERE Clause of another SQL SELECT statement.
+- The inner query executes first before its parent query so that the results of an inner query can be passed to the outer query.
+
+#### You can use a subquery in a SELECT, INSERT, DELETE, or UPDATE statement to perform the following tasks:
+- Compare an expression to the result of the query.
+- Determine if an expression is included in the results of the query.
+- Check whether the query selects any rows.
+
+**_Subqueries with the `SELECT` Statement_**:
+
+Consider the CUSTOMERS table having the following records
+
+    +----+----------+-----+-----------+----------+
+    | ID | NAME     | AGE | ADDRESS   | SALARY   |
+    +----+----------+-----+-----------+----------+
+    |  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
+    |  2 | Khilan   |  25 | Delhi     |  1500.00 |
+    |  3 | Kaushik  |  23 | Kota      |  2000.00 |
+    |  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+    |  5 | Hardik   |  27 | Bhopal    |  8500.00 |
+    |  6 | Komal    |  22 | MP        |  4500.00 |
+    |  7 | Muffy    |  24 | Indore    | 10000.00 |
+    +----+----------+-----+-----------+----------+
+Now, let us check the following subquery with a SELECT statement.
+
+_**Example**_:
+```sql
+SELECT *
+FROM CUSTOMERS
+WHERE ID IN (
+    SELECT ID
+    FROM CUSTOMERS
+    WHERE SALARY > 4500
+);
+```
+This would produce the following result.
+
+    +----+----------+-----+---------+----------+
+    | ID | NAME     | AGE | ADDRESS | SALARY   |
+    +----+----------+-----+---------+----------+
+    |  4 | Chaitali |  25 | Mumbai  |  6500.00 |
+    |  5 | Hardik   |  27 | Bhopal  |  8500.00 |
+    |  7 | Muffy    |  24 | Indore  | 10000.00 |
+    +----+----------+-----+---------+----------+
+
+
+**_Subqueries with the `UPDATE` Statement_**:
+
+The subquery can be used in conjunction with the UPDATE statement. Either single or multiple columns in a table can be updated when using a subquery with the UPDATE statement.
+
+**_Example_**:
+
+Assuming, we have CUSTOMERS_BKP table available which is backup of CUSTOMERS table. The following example updates SALARY by 0.25 times in the CUSTOMERS table for all the customers whose AGE is greater than or equal to 27.
+```sql
+UPDATE CUSTOMERS
+SET SALARY = SALARY * 0.25
+WHERE AGE IN (
+    SELECT AGE
+    FROM CUSTOMERS_BKP
+    WHERE AGE >= 27
+);
+```
+This would impact two rows and finally CUSTOMERS table would have the following records.
+
+    +----+----------+-----+-----------+----------+
+    | ID | NAME     | AGE | ADDRESS   | SALARY   |
+    +----+----------+-----+-----------+----------+
+    |  1 | Ramesh   |  35 | Ahmedabad |   125.00 |
+    |  2 | Khilan   |  25 | Delhi     |  1500.00 |
+    |  3 | Kaushik  |  23 | Kota      |  2000.00 |
+    |  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+    |  5 | Hardik   |  27 | Bhopal    |  2125.00 |
+    |  6 | Komal    |  22 | MP        |  4500.00 |
+    |  7 | Muffy    |  24 | Indore    | 10000.00 |
+    +----+----------+-----+-----------+----------+
+
+**_Subqueries with the `DELETE` Statement_**:
+
+The subquery can be used in conjunction with the DELETE statement like with any other statements mentioned above.
+
+**_Example_**:
+
+Assuming, we have a CUSTOMERS_BKP table available which is a backup of the CUSTOMERS table. The following example deletes the records from the CUSTOMERS table for all the customers whose AGE is greater than or equal to 27.
+```sql
+DELETE FROM CUSTOMERS
+WHERE AGE IN (
+    SELECT AGE
+    FROM CUSTOMERS_BKP
+    WHERE AGE >= 27
+);
+```
+This would impact two rows and finally the CUSTOMERS table would have the following records.
+
+    +----+----------+-----+---------+----------+
+    | ID | NAME     | AGE | ADDRESS | SALARY   |
+    +----+----------+-----+---------+----------+
+    |  2 | Khilan   |  25 | Delhi   |  1500.00 |
+    |  3 | Kaushik  |  23 | Kota    |  2000.00 |
+    |  4 | Chaitali |  25 | Mumbai  |  6500.00 |
+    |  6 | Komal    |  22 | MP      |  4500.00 |
+    |  7 | Muffy    |  24 | Indore  | 10000.00 |
+    +----+----------+-----+---------+----------+

package/example/assets/pages_data/en/content/014-unions.md

@@ -0,0 +1,124 @@
+# SQL - UNIONS CLAUSE
+
+The SQL UNION clause/operator is used to combine the results of two or more SELECT statements without returning any duplicate rows.
+
+- While using this UNION clause, each SELECT statement must have:
+
+  - The same number of columns selected
+  - The same number of column expressions
+  - The same data type and
+  - Have them in the same order
+
+But they need not have to be in the same length.
+
+_Example_
+
+Consider the following two tables.
+
+Table 1 − customers table is as follows:
+
+    +----+----------+-----+-----------+----------+
+    | id | name     | age | address   | salary   |
+    +----+----------+-----+-----------+----------+
+    |  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+    |  2 | Khilan   |  25 | Delhi     |  1500.00 |
+    |  3 | kaushik  |  23 | Kota      |  2000.00 |
+    |  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+    |  5 | Hardik   |  27 | Bhopal    |  8500.00 |
+    |  6 | Komal    |  22 | MP        |  4500.00 |
+    |  7 | Muffy    |  24 | Indore    | 10000.00 |
+    +----+----------+-----+-----------+----------+
+
+Table 2 − orders table is as follows:
+
+    +-----+---------------------+-------------+--------+
+    | oid | date                | customer_id | amount |
+    +-----+---------------------+-------------+--------+
+    | 102 | 2009-10-08 00:00:00 |           3 |   3000 |
+    | 100 | 2009-10-08 00:00:00 |           3 |   1500 |
+    | 101 | 2009-11-20 00:00:00 |           2 |   1560 |
+    | 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+    +-----+---------------------+-------------+--------+
+
+Now, let us join these two tables in our SELECT statement as follows:
+
+```sql
+SELECT id, name, amount, date
+   FROM customer
+   LEFT JOIN orders
+   ON customers.id = orders.customer_id
+UNION
+   SELECT id, name, amount, date
+   FROM customer
+   RIGHT JOIN orders
+   ON customers.id = orders.customer_id
+```
+
+This would produce the following result:
+
+### The UNION ALL Clause
+The UNION ALL operator is used to combine the results of two SELECT statements including duplicate rows.
+
+The same rules that apply to the UNION clause will apply to the UNION ALL operator.
+
+_Example_ -
+Consider the following two tables:
+
+* Table 1 − customers table is as follows:
+
+      +----+----------+-----+-----------+----------+
+      | id | name     | age | address   | salary   |
+      +----+----------+-----+-----------+----------+
+      |  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+      |  2 | Khilan   |  25 | Delhi     |  1500.00 |
+      |  3 | kaushik  |  23 | Kota      |  2000.00 |
+      |  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+      |  5 | Hardik   |  27 | Bhopal    |  8500.00 |
+      |  6 | Komal    |  22 | MP        |  4500.00 |
+      |  7 | Muffy    |  24 | Indore    | 10000.00 |
+      +----+----------+-----+-----------+----------+
+
+* Table 2 − orders table is as follows:
+
+      +-----+---------------------+-------------+--------+
+      | oid | date                | customer_id | amount |
+      +-----+---------------------+-------------+--------+
+      | 102 | 2009-10-08 00:00:00 |           3 |   3000 |
+      | 100 | 2009-10-08 00:00:00 |           3 |   1500 |
+      | 101 | 2009-11-20 00:00:00 |           2 |   1560 |
+      | 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+      +-----+---------------------+-------------+--------+
+
+Now, let us join these two tables in our SELECT statement as follows :
+```sql
+SELECT id, name, amount, date
+   FROM customers
+   LEFT JOIN orders
+   ON customers.id = order.customer_id
+UNION ALL
+   SELECT id, name, amount, date
+   FROM customers
+   RIGHT JOIN orders
+   ON customers.id = orders.customer_id;
+```
+
+This would produce the following result:
+
+    +------+----------+--------+---------------------+
+    | id   | name     | amount | date                |
+    +------+----------+--------+---------------------+
+    |    1 | Ramesh   |   NULL | NULL                |
+    |    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
+    |    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
+    |    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
+    |    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
+    |    5 | Hardik   |   NULL | NULL                |
+    |    6 | Komal    |   NULL | NULL                |
+    |    7 | Muffy    |   NULL | NULL                |
+    |    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
+    |    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
+    |    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
+    |    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
+    +------+----------+--------+---------------------+
+
+Note : **There are two other clauses (i.e., operators), which are like the UNION clause.**

package/example/assets/pages_data/en/content/015-Keys-in-a-Relational Database.md

@@ -0,0 +1,51 @@
+# Relational Keys- Keys in a Relational Database
+
+A database must be able to inhibit inconsistency occurring due to incorrect data. It must have certain identified attributes in relations to uniquely distinguish the tuples. No two tuples in a relation should have same value for all attributes since it will lead to duplicity of data. duplicity of data leads to inconsistency . Relational database systems have the concept of Relational Keys to distinguish between different records.
+
+## Types of Relational Keys
+### *Super Keys*
+
+A relation’s tuples can be uniquely identified by various combinations of attributes. Super Keys is defined as a set of one attribute or combinations of two or more attributes that help in distinguishing between tuples in a relation.
+
+For example, the Customer ID attribute of the relation Customer is unique for all customers. The Customer ID can be used to identify each customer tuple in the relation. Customer ID is a Super Key for relation Customer.
+
+Customer Name attribute of Customer cannot be considered as Super Key because many customers for the organization can have same name. However when combined with Customer ID it becomes a Super Key {CustomerID, CustomerName}. It means that Super Key can have additional attributes.  Consider any key K which is identified as a super key. Any superset of key K is also a super key. For example the possible Super Keys for Customer Relation are
+
+- [ CustomerID, CustomerName, Customer Address ]
+- [ CustomerID, CustomerName, Customer Contact Number ]
+- [ CustomerID, Customer Contact Number ]
+
+### *Candidate Keys*
+
+If we take a key from the set of super keys for which we don’t have any  proper subset defined as a superkey, it is called a candidate key. In other words the minimal attribute super keys are termed as candidate keys.
+
+If we can identify some distinct sets of attributes which identify the tuples uniquely they fall in the category of candidate keys. For example the possible Candidate Keys for Customer Relation are
+
+- [ CustomerID ]
+- [ CustomerName, Customer Address ]
+- [ CustomerName, Customer Contact Number ]
+- [ Customer Address, Customer Contact Number ]
+
+### *Primary Key*
+
+Out of all possible candidate keys only one is chosen by the database designer as the key to identify the records in a relation in a database. This selected candidate key is called the Primary Key. It is the property of the relation and not of tuples. The primary key attribute(s) does not allow any duplicate values. It also inhibits leaving the primary key attribute without any value (NOT NULL).
+
+**A relation can have only one primary key.**
+
+In the Customer Database example {Customer ID} is the attribute taken as the primary key of customer relation. While picking up a candidate key as primary key the designer should ensure that it is an attribute or group of attributes that do not change or may change extremely rarely.
+
+### *Alternate Keys*
+
+After selecting one key among candidate keys as primary key, the rest of candidate keys are called the alternate keys. In the customer Database these candidate keys are the alternate keys.
+
+- [ CustomerName, Customer Address ]
+- [ CustomerName, Customer Contact Number ]
+- [ Customer Address, Customer Contact Number ]
+
+### *Foreign Key*
+
+A foreign key is used to reference values from one relation into another relation. This is possible when the attribute or combination of attributes is primary key in the referenced relation. The relation in which the primary key of a relation is referenced is called the referencing table. The foreign key constraint implements the referential integrity in a database. The referencing relation attribute can have only those values which exist in the primary key attribute(s) of the referenced relation
+
+**A relation can have multiple foreign key**
+
+For example in the customer database the orders' relation (referencing relation) has the structure (Order ID, Customer ID, Order Date, Order Status, Total Billing Amount). The attribute Customer ID is the foreign key referencing Customer ID from customer relation (referenced relation). It means that orders can be placed only for the customers whose customer details are already available in the customer relation.

package/example/assets/pages_data/en/content/016-Logical-operator-keywords.md

@@ -0,0 +1,17 @@
+# Logical Operator Keywords
+
+Here are the most important Logical Operators summarized in a table.
+
+Logical Operators can be used for conditions as they show a result in form of a `boolean` (True/False) or Unknown.
+So, e.g. if an exact value is `True` for a value, a Logical Operator can proof that it's True.
+
+| Logical Operator | Explanation |
+|------------------|-------------|
+| ALL      | If all comparisons are True: return True |
+| ANY      |   If any comparison is True: return True    |
+| AND |   If both expressions are True: return True   |
+| EXISTS | If a subquery contains rows: return True |
+| IN | If compared value is equal to at least one value: return True |
+| BETWEEN | If there are values in given range: return True |
+| NOT | Reverses the value of any boolean |
+| OR | If either expression is True: return True |

package/example/assets/pages_data/en/content/017-having-clause_aggregate-functions.md

@@ -0,0 +1,184 @@
+# `HAVING` Clause
+
+Unlike where clause which imposes conditions on columns `Having` clause enables you to specify conditions that filter which group results appear in the results.
+
+## Syntax
+
+```sql
+SELECT column_name(s)
+FROM table_name
+WHERE condition
+GROUP BY column_name(s)
+HAVING condition
+ORDER BY column_name(s);
+```
+
+## Description
+
+- Used with `aggregate functions`
+- Must follow `GROUP BY` clause in the query
+
+## Aggregate Functions
+ - SQL aggregation is the task of collecting a set of values to return a single value.
+ - An aggregate function is a function where the values of multiple rows are grouped together as input on certain criteria to form a single value of more significant meaning.
+
+## Aggregate Functions Examples
+
+Suppose this are the table given to us
+
+|Students | table||
+|--------|-----------|--------|
+| rollno | name      | class |
+|      1 | Sanskriti | TE    |
+|      1 | Shree     | BE    |
+|      2 | Harry     | TE    |
+|      3 | John      | TE    |
+|      3 | Shivani   | TE    |
+
+
+|purchase | table||
+|------------|-------|---------------|
+| item       | price | customer_name |
+| Pen          |    10 | Sanskriti     |
+| Bag          |  1000 | Sanskriti     |
+| Vegetables   |   500 | Sanskriti     |
+| Shoes        |  5000 | Sanskriti     |
+| Water Bottle |   800 | XYZ           |
+| Mouse        |   120 | ABC           |
+| Sun Glasses  |  1350 | ABC           |
+
+
+### AVG function
+
+  Calculates `average` of the given column of values
+
+```sql
+SELECT AVG(price) AS Avg_Purchase, customer_name
+FROM purchase
+GROUP BY customer_name;
+```
+
+| Avg_Purchase | customer_name |
+|--------------|---------------|
+|    1627.5000 | Sanskriti     |
+
+### SUM function
+
+   Calculates `sum` of values of given column.
+
+```sql
+SELECT SUM(price) AS Total_Bill, customer_name
+FROM purchase
+GROUP BY customer_name;
+```
+
+| Total_Bill | customer_name |
+|------------|---------------|
+|       6510 | Sanskriti     |
+
+### COUNT function
+
+  Gives `count` of entries/ values in given column.
+
+```sql
+SELECT COUNT(item) AS Total_Items, customer_name
+FROM purchase
+GROUP BY customer_name;
+```
+
+| Total_Items | customer_name |
+|-------------|---------------|
+|           4 | Sanskriti     |
+
+### MAX function
+
+  Return `maximum` value from the number of values in the column.
+
+```sql
+SELECT MAX(price) AS Highest_Purchase, customer_name
+FROM purchase
+GROUP BY customer_name;
+```
+
+| Highest_Purchase | customer_name |
+|-----------------|---------------|
+|             5000 | Sanskriti     |
+
+### MIN function
+
+   Return `minimum` value from the number of values in the column.
+
+```sql
+SELECT MIN(price) AS Lowest_Purchase, customer_name
+FROM purchase
+GROUP BY customer_name;
+```
+| Lowest_Purchase | customer_name |
+|-----------------|---------------|
+|              10 | Sanskriti     |
+
+
+## Having clause Examples
+
+### Example 1
+
+```sql
+SELECT COUNT(class) AS strength, class
+FROM Students
+GROUP BY class
+HAVING COUNT(class) > 2;
+```
+
+Above query gives number of students in a class `having` number of students > 2
+
+| strength | class |
+|----------|-------|
+|        4 | TE  |
+
+### Example 2
+
+```sql
+SELECT customer_name, MIN(price) AS MIN_PURCHASE
+FROM purchase
+GROUP BY customer_name
+HAVING MIN(price) > 10;
+```
+Above query finds `minimum` price which is > 10
+
+| customer_name | MIN_PURCHASE |
+|---------------|------------|
+| XYZ           |        800 |
+| ABC           |        120 |
+
+### Example 3
+
+```sql
+SELECT customer_name, AVG(price) AS Average_Purchase
+FROM purchase
+GROUP BY customer_name
+HAVING AVG(price) > 550
+ORDER BY customer_name DESC;
+```
+Above query calculates `average` of price and prints customer name and average price which is greater than 550 with descending `order` of customer names.
+
+| customer_name | Average_Purchase |
+|---------------|------------------|
+| XYZ           |         800.0000 |
+| Sanskriti     |        1627.5000 |
+| ABC           |         735.0000 |
+
+### Example 4
+
+```sql
+SELECT customer_name, SUM(price) AS Total_Purchase
+FROM purchase
+WHERE customer_name
+LIKE "S%"
+GROUP BY customer_name
+HAVING SUM(price) > 1000;
+```
+Calculates `SUM` of price and returns customer name and sum > 1000.
+
+| customer_name | Total_Purchase |
+|---------------|----------------|
+| Sanskriti     |           6510 |