PostgreSQL, MongoDb, Express, React, Structured

PostgreSQL
Akash Pundir
System Programming
School of Computer Science and Engineering

What is a Database?
A database is a structured
collection of data organized for
efficient retrieval, storage, and
manipulation. It serves as a
central repository for storing
and managing information in a
structured manner.

DBMS (Database Management
System)
It is a software system that
facilitates the creation,
organization, manipulation, and
administration of databases. DBMS
serves as an interface between
users or applications and the
database itself, providing a set
of tools and functionalities for
managing data efficiently

PostgresSQL
PostgreSQL (often abbreviated
as Postgres) is a powerful
open-source relational
database management system
(RDBMS).

Relational Database Management
System (RDBMS)
• In the relational model, data is organized into
tables, also known as relations.
• Each table consists of rows (tuples) and
columns (attributes).
• Rows represent individual records or instances,
while columns represent attributes or
properties of those records.

Structured Query Language
• SQL is the standard language for interacting
with RDBMS.
• It provides a set of commands for defining,
querying, manipulating, and managing relational
databases.
• Common SQL commands include SELECT, INSERT,
UPDATE, DELETE, CREATE TABLE, ALTER TABLE, DROP
TABLE, and many others

Navigate to
https://www.postgresql.org/dow
nload/

PostgreSQL, MongoDb, Express, React, Structured

Now, run the installer and
complete setup
• After that open sql shell

Listing Databases
• To list all databases, use the l command:
l

Connecting to a Specific
Database
• To connect to a specific database, use the c
command
c database_name

Let’s try creating a table
CREATE TABLE todos (
id SERIAL PRIMARY KEY,
title TEXT NOT NULL,
completed BOOLEAN NOT NULL
);

Listing Tables
• To list all tables in the current database, use
the dt command
dt

Describing a Table
• To describe the structure of a specific table,
use the d command:
d table_name

Viewing Data
• To view data from a table, use a simple SQL
query
SELECT * FROM table_name;

Now, let’s install POSTMAN
• Postman simplifies the process of testing
APIs by providing a user-friendly
interface for sending HTTP requests and
viewing responses.
• It supports various request types such as
GET, POST, PUT, DELETE, PATCH, etc.,
allowing users to test different API
endpoints and methods.
https://www.postman.com/downloads/

https://www.postman.com/downlo
ads/

Let’s setup a new node project
npm init -y

Install necessary libraries
npm i express pg

Make a new index.js file in
the same folder
const express = require('express');
const { Pool } = require('pg');
const app = express();
const port = 3000;
const pool = new Pool({
user: 'postgres',
host: 'localhost',
database: 'postgres',
password: 'root',
port: 5432,
});
app.use(express.json());

// GET all todos
app.get('/todos', (req, res) => {
pool.query('SELECT * FROM todos', (error, result) =>
{
if (error) {
console.error('Error fetching todos', error);
res.status(500).json({ error: 'Internal server
error' });
} else {
res.json(result.rows);
}
});
});

// POST a new todo
app.post('/todos', (req, res) => {
const { title, completed } = req.body;
pool.query('INSERT INTO todos (title, completed) VALUES ($1, $2)',
[title, completed], (error) => {
if (error) {
console.error('Error creating todo', error);
res.status(500).json({ error: 'Internal server error' });
} else {
res.status(201).json({ message: 'Todo created successfully' });
}
});
});

// PUT update todo
app.put('/todos/:id', (req, res) => {
const { id } = req.params;
pool.query('UPDATE todos SET title = $1, completed = $2 WHERE id = $3', [title,
completed, id], (error) => {
if (error) {
console.error('Error updating todo', error);
} else {
res.json({ message: 'Todo updated successfully' });
}
});
});

Object Relational
Mapping
ORM is a programming technique
that allows developers to work
with relational databases
using object-oriented
programming languages,
enabling them to interact with
database entities as if they
were ordinary objects in their

Sequalize
Sequelize is a popular Object-Relational
Mapping (ORM) library for Node.js, used
with SQL databases such as PostgreSQL,
MySQL, MariaDB, SQLite, and MSSQL

Key Features
• Model Definition: Sequelize allows developers to define
models that map directly to database tables. These
models specify the structure of the data and the
relationships between different tables.
• Querying: Sequelize provides methods for executing SQL
queries against the database, including selecting,
inserting, updating, and deleting records. It supports
various query options and conditions.
• Data Validation: Sequelize includes built-in support
for data validation, allowing developers to define
constraints on the data being saved to the database.
This helps ensure data integrity and consistency.
• Associations: Sequelize enables developers to define
relationships between different models, such as one-to-
one, one-to-many, and many-to-many associations. These

Create a new directory for
your project and navigate into
it via the terminal.
mkdir sequelize-postgres
cd sequelize-postgres

Initialize a new Node.js
project:
npm init -y

Install Express Sequelize,
PostgreSQL, and the pg driver:
npm install express sequelize
pg pg-hstore

• sequelize: This is the main library itself.
Sequelize is an ORM that abstracts away the
intricacies of SQL queries and provides a
simple API for interacting with your database
tables as JavaScript objects.
• pg: This is the PostgreSQL client for Node.js.
Sequelize uses this package to communicate with
PostgreSQL databases.
• pg-hstore: This is a module that Sequelize uses
for managing JSON data in PostgreSQL.

Set up Sequelize:
Create a file named sequelize.js in your
project directory:
const { Sequelize } = require('sequelize');
// Initialize Sequelize with your PostgreSQL database
credentials
const sequelize = new Sequelize('postgres', 'postgres',
'root', {
host: 'localhost',
dialect: 'postgres', // Specify the dialect for PostgreSQL
});
module.exports = sequelize;

Define a model:
Create a folder named models in your project
directory, and within it, create a file named
Todo.js:
const { DataTypes } = require('sequelize');
const sequelize = require('../sequelize');
const Todo = sequelize.define('Todo', {
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true
},
title: {
type: DataTypes.STRING,
allowNull: false
},

completed: {
type: DataTypes.BOOLEAN,
allowNull: false,
defaultValue: false
}
}, {
tableName: 'todos', // Match the table name with your
existing database table
timestamps: false
});
module.exports = Todo;

Create an index.js file in your
project directory to initialize
Sequelize and synchronize the models
with the database:
const express = require('express');
const sequelize = require('./sequelize');
const Todo = require('./models/Todo');
const app = express();
const PORT = 3000;

// Test the database connection
sequelize.authenticate()
.then(() => {
console.log('Connection has been established successfully.');
// Synchronize defined models with the database
return sequelize.sync({ alter: true });
})
.then(() => {
console.log('All models were synchronized successfully.');
})
.catch((error) => {
console.error('Unable to connect to the database:', error);
});
app.use(express.json());

// Define endpoints
app.get('/todos', (req, res) => {
Todo.findAll()
.then((todos) => {
res.json(todos);
})
.catch((error) => {
});
});
app.post('/todos', (req, res) => {
Todo.create({ title, completed })
.then((todo) => {
res.status(201).json(todo);
})
.catch((error) => {
res.status(400).json({ error: 'Bad request' });
});
});
app.listen(PORT, () => {
console.log(`Server is running on port ${PORT}`);
});

PostgreSQL, MongoDb, Express, React, Structured

More Related Content

Similar to PostgreSQL, MongoDb, Express, React, Structured (20)

Recently uploaded (20)

PostgreSQL, MongoDb, Express, React, Structured