# Database

## Introduction

![](https://1374779285-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MFW3x2aqEO8GF2kr3VU%2Fuploads%2FjALPPJLtVliV4jzPxRxE%2Fscreenshot-www.udemy.com-2022.11.08-01_27_10.png?alt=media\&token=4ee9e438-0990-413f-93ca-08dec36e6f81)

* It is divided into 2 types, sql and no sql

## SQL

![](https://1374779285-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MFW3x2aqEO8GF2kr3VU%2Fuploads%2FWCafUbAnLYcyGd5V9aO9%2Fscreenshot-www.udemy.com-2022.11.08-01_29_28.png?alt=media\&token=6c7635be-63d2-457e-86f3-8372129f3bd3)

* There is database containing tables which contains numbers of row of record

![](https://1374779285-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MFW3x2aqEO8GF2kr3VU%2Fuploads%2FC3SDJ8YA91y7korhpJGn%2Fscreenshot-www.udemy.com-2022.11.08-01_30_58.png?alt=media\&token=c96e0d4f-6816-4868-9eb4-49edee18cf73)

* It contains data schema, all the data in the table must fit the type
* It is a data relations (foreign key and primary key)

## NoSQL

![](https://1374779285-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MFW3x2aqEO8GF2kr3VU%2Fuploads%2FdklHn8Cw3hCcvVeGlLEh%2Fscreenshot-www.udemy.com-2022.11.08-01_33_07.png?alt=media\&token=ac616744-b8ad-4065-b4cd-a20aa910c041)

* There is a database containing different collections that contains numbers of document
* It is used to store data in json format, so as to increase the flexibility of data format

![](https://1374779285-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MFW3x2aqEO8GF2kr3VU%2Fuploads%2FYHXkURjwa5gpFUld8CPA%2Fscreenshot-www.udemy.com-2022.11.08-01_35_43.png?alt=media\&token=65f5b986-1b1a-4203-8609-c8870d6cfcd8)

![](https://1374779285-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MFW3x2aqEO8GF2kr3VU%2Fuploads%2FBt6cHN5aRIJThjuRiWz0%2Fscreenshot-www.udemy.com-2022.11.09-15_02_24.png?alt=media\&token=6293dac0-cdf2-4365-89b1-7a84bb5e5547)

* The data will be duplicated, as there is no linkage between documents
* The important data from other collections can be included into nested document, so that no need to look into other documents, to make fetching data faster and more efficient, but you will need to update the related documents manually
* For the case that update frequently, it is recommended to store references into documents, and find the related information from other collections , and merge together

## Comparison

![](https://1374779285-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MFW3x2aqEO8GF2kr3VU%2Fuploads%2FQofc9c6uMigPOw8017f7%2Fscreenshot-www.udemy.com-2022.11.08-01_37_42.png?alt=media\&token=0a8948c5-372b-42ef-a8d7-cf8ba575e9dc)

* SQL: used to for table that type is really important but not change and access data frequently, e.g : user data
* NoSQL: used for collection that type is not really important but access and change frequently, as its speed is faster than due to no relation between collections, data are usually put together rather than join with different tables. Furthermore, the NOSQL database server can be divided into several partitions, find the value by key-value matching in order to faciltate the horizontal scaling

## How does the query work

<figure><img src="https://1374779285-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MFW3x2aqEO8GF2kr3VU%2Fuploads%2F2eKflVgW1VDWaOoBNcFM%2Fimage.png?alt=media&#x26;token=dc64bcd4-50e0-4d81-bd8a-3fedf53718ff" alt=""><figcaption></figcaption></figure>

1. A SQL statement starts in a client program and gets sent over the network to the database server.
2. When the database server receives the SQL statement, the relational engine starts processing it. First the command parser checks that the statement is valid. Then it converts the statement into a query tree, which is an internal data structure.
3. The query optimizer looks at the query tree and figures out the most efficient way to execute the SQL statement, creating an execution plan.
4. The execution plan gets passed to the query executor, which uses it to coordinate retrieving or changing the data as directed by the SQL statement. The executor interacts with the storage engine to access the data.
5. The storage engine uses access methods, which are protocols for reading and writing data in the most efficient way for different operations.
6. For reading data, the buffer manager checks if the required data is cached in memory and fetches it from disk if needed. This speeds up subsequent access.
7. For writing data with inserts or updates, the transaction manager makes sure the changes happen atomically and maintain the database's integrity.
8. At the same time, the lock manager applies locks so multiple transactions can happen simultaneously without conflict. This maintains isolation and consistency.

Working together, these components process SQL statements reliably and efficiently in a database management system.

## Database Connection Pool

#### Why need connection pool?

*   Here is the sequence of steps involved in a typical database connection life cycle

    1. Opening a connection to the database using the database driver
    2. Opening a [TCP socket](https://en.wikipedia.org/wiki/Network_socket) for reading/writing data
    3. Reading / writing data over the socket
    4. Closing the connection
    5. Closing the socket


* For simple database operations, these steps are not expensive, but as an application scales up, the performance of the application will suffer as each connection is created and destroyed. One pattern for improving performance is a connection pool, a group of already configured and established network connections between the client and database that can be reused for data operations within an application.

#### Sizing

* If we make the pool too small (i.e. choose too few connections), we’ll introduce latency, as operations have to wait for an available connection to open up before they can execute.
* If we choose too many connections, that can also create latency for reasons that relate to how each processor core in a server typically executes threads
* It is important to decide the max pool size and the minimum idle pool size based on :
* Our application and how it interacts with the database
* How often it interacts with the database (i.e. scale)
* Our database technology of choice
* The hardware specs of our database servers
* Network latency
