🖍️
Developer Note
  • Welcome
  • Git
    • Eslint & Prettier & Stylelint & Husky
  • Programming Language
    • JavaScript
      • Script Async vs Defer
      • Module
      • Const VS Let VS Var
      • Promise
      • Event Loop
      • Execution Context
      • Hoisting
      • Closure
      • Event Buddling and Capturing
      • Garbage Collection
      • This
      • Routing
      • Debounce and Throttle
      • Web Component
      • Iterator
      • Syntax
      • String
      • Array
      • Object
      • Proxy & Reflect
      • ProtoType
      • Class
      • Immutability
      • Typeof & Instanceof
      • Npm (Node package manager)
    • TypeScript
      • Utility Type
      • Type vs Interface
      • Any vs Unknown vs Never
      • Void and undefined
      • Strict Mode
      • Namespace
      • Enum
      • Module
      • Generic
    • Python
      • Local Development
      • Uv
      • Asyncio & Event loop
      • Context Manager
      • Iterator & Generator
      • Fast API
      • Pydantic & Data Class
    • Java
      • Compilation and Execution
      • Data Type
      • Enumeration
      • Data Structure
      • Try Catch
      • InputStream and OutputStream
      • Concurrent
      • Unicode Block
      • Build Tools
      • Servlet
      • Java 8
  • Coding Pattern
    • MVC vs MVVM
    • OOP vs Functional
    • Error Handling
    • MVC vs Flux
    • Imperative vs Declarative
    • Design Pattern
  • Web Communication
    • REST API
      • Web Hook
      • CORS issue
    • HTTPS
    • GraphQL
      • REST API vs GraphQL
      • Implementation (NodeJS + React)
    • Server-Sent Event
    • Web Socket
    • IP
    • Domain Name System (DNS)
  • Frontend
    • Progressive Web App (PWA)
    • Single Page & Multiple Page Application
    • Search Engine Optimiaztion (SEO)
    • Web bundling & Micro-frontend
      • Webpack
        • Using Webpack to build React Application
        • Using Webpack to build react library
      • Vite
      • Using rollup to build react library
      • Implementing micro frontend
    • Web Security
      • CSRF & Nonce
      • XSS
      • Click hijacking
    • Cypress
    • CSS
      • Core
        • Box Model
        • Inline vs Block
        • Flexbox & Grid
        • Pseudo Class
        • Position
      • Tailwind CSS
        • Shadcn
      • CSS In JS
        • Material UI
    • React
      • Core
        • Component Pattern
        • React Lazy & Suspense
        • React Portal
        • Error Boundary
        • Rendering Methods
        • Environment Variable
        • Conditional CSS
        • Memo
        • Forward Reference
        • High Order Component (HOC) & Custom Hook
        • TypeScript
      • State Management
        • Redux
        • Recoil
        • Zustand
      • Routing
        • React Router Dom
      • Data Fetching
        • Axios & Hook
        • React Query
        • Orval
      • Table
        • React Table
      • Form & Validation
        • React Hook Form
        • Zod
      • NextJS
        • Page Router
        • App Router
      • React Native
    • Angular
    • Svelte
      • Svelte Kit
  • Backend
    • Cache
      • Browser Cache
      • Web Browser Storage
      • Proxy
      • Redis
    • Rate limit
    • Monitoring
      • Logging
      • Distributed Tracing
    • Load Test
    • Encryption
    • Authentication
      • Password Protection
      • Cookie & Session
      • JSON Web Token
      • SSO
        • OAuth 2.0
        • OpenID Connect (OIDC)
        • SAML
    • Payment
      • Pre-built
      • Custom
    • File Handling
      • Upload & Download (Front-end)
      • Stream & Buffer
    • Microservice
      • API Gateway
      • Service Discovery
      • Load Balancer
      • Circuit Breaker
      • Message Broker
      • BulkHead & Zipkin
    • Elastic Search
    • Database
      • SQL
        • Group By vs Distinct
        • Index
        • N + 1 problem
        • Normalization
        • Foreign Key
        • Relationship
        • Union & Join
        • User Defined Type
      • NOSQL (MongoDB)
      • Transaction
      • Sharding
      • Lock (Concurrency Control)
    • NodeJS
      • NodeJS vs Java Spring
      • ExpressJS
      • NestJS
        • Swagger
        • Class Validator & Validation Pipe
        • Passport (Authentication)
      • Path Module
      • Database Connection
        • Integrating with MYSQL
        • Sequalize
        • Integrating with MongoDB
        • Prisma
        • MikroORM
        • Mongoose
      • Streaming
      • Worker Thread
      • Passport JS
      • JSON Web Token
      • Socket IO
      • Bull MQ
      • Pino (Logging)
      • Yeoman
    • Spring
      • Spring MVC
      • Spring REST
      • Spring Actuator
      • Aspect Oriented Programming (AOP)
      • Controller Advice
      • Filter
      • Interceptor
      • Concurrent
      • Spring Security
      • Spring Boot
      • Spring Cloud
        • Resilience 4j
      • Quartz vs Spring Batch
      • JPA and Hibernate
      • HATEOS
      • Swagger
      • Unit Test (Java Spring)
      • Unit Test (Spring boot)
  • DevOp
    • Docker
    • Kubernetes
      • Helm
    • Nginx
    • File System
    • Cloud
      • AWS
        • EC2 (Virtual Machine)
        • Network
        • IAM
          • Role-Service Binding
        • Database
        • Route 53
        • S3
        • Message Queue
        • Application Service
        • Serverless Framework
        • Data Analysis
        • Machine Learning
        • Monitoring
        • Security
      • Azure
        • Identity
        • Compute Resource
        • Networking
        • Storage
        • Monitoring
      • Google Cloud
        • IAM
          • Workload Identity Federation
        • Compute Engine
        • VPC Network
        • Storage
        • Kubernetes Engine
        • App Engine
        • Cloud function
        • Cloud Run
        • Infra as Code
        • Pub/Sub
    • Deployment Strategy
    • Jenkins
    • Examples
      • Deploy NextJS on GCP
      • Deploy Spring on Azure
      • Deploy React on Azure
  • Domain Knowledge
    • Web 3
      • Blockchain
      • Cryptocurrency
    • AI
      • Prompt
      • Chain & Agent
      • LangChain
      • Chunking
      • Search
      • Side Products
Powered by GitBook
On this page
  • Introduction
  • SQL
  • NoSQL
  • Comparison
  • How does the query work
  • Database Connection Pool

Was this helpful?

  1. Backend

Database

PreviousElastic SearchNextSQL

Last updated 9 months ago

Was this helpful?

Introduction

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

SQL

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

  • 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

  • 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

  • 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

  • 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

  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. Reading / writing data over the socket

    3. Closing the connection

    4. 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

Opening a for reading/writing data

TCP socket