Forem: Rishav Kapil

Hard Delete vs Soft Delete in DBMS.

Rishav Kapil — Tue, 10 Dec 2024 16:32:53 +0000

Hard Delete Vs Soft Delete in DBMS

Rishav Kapil ・ Dec 10

#dbms #programming #database #productivity

Hard Delete Vs Soft Delete in DBMS

Rishav Kapil — Tue, 10 Dec 2024 12:16:01 +0000

When working with databases, we often need to remove records. There are two common approaches for deletion: hard delete and soft delete. Let’s explore these concepts in simple terms with a real-world example.

Hard Delete

A hard delete means permanently removing a record from the database.
Once deleted, the data is gone forever and cannot be retrieved.

Real-World Example:
Imagine you have an email inbox. If you delete an email and then empty your trash folder, that email is permanently removed. You cannot restore it anymore. This is an example of a hard delete.

How It Works in a Database:

When you perform a hard delete, the database removes the record completely:

DELETE FROM Users WHERE id = 101;

This query deletes the user with ID 101 from the Users table, and the data is no longer available.

Soft Delete

A soft delete means marking a record as deleted without actually removing it from the database. This allows you to "restore" the record later if needed.

Real-World Example:

Think about your recycle bin on a computer. When you delete a file, it goes into the recycle bin instead of being permanently erased. You can still recover the file until you permanently delete it from the recycle bin. This is similar to a soft delete.

How It Works in a Database:

Instead of removing the record, we add a flag (usually a column like is_deleted) to mark it as deleted:

UPDATE Users SET is_deleted = 1 WHERE id = 101;

The record is still in the database, but the is_deleted column indicates it should not be shown in normal operations.

To retrieve only active records, you add a condition in your query:

SELECT * FROM Users WHERE is_deleted = 0;

When to Use Hard Delete

When the data is no longer needed.
For sensitive data that must be permanently erased (e.g., user passwords).

When to Use Soft Delete

When you want to maintain a history of data.
For audit logs or when users can undo deletions (e.g., social media posts).

Method Chaining in C++

Rishav Kapil — Mon, 18 Nov 2024 08:41:31 +0000

What is method chaining ?

Method chaining is a programming technique where multiple method calls are executed sequentially on the same object, all in a single statement. Each method in the chain returns the object itself (usually *this), allowing the next method to be called on the same object without needing to reference it again.

How It Works

To enable method chaining:

Methods should return a reference to the object they belong to (typically *this in C++).
Each method can then be called on the returned reference, forming a chain.

Example

Lets take an example of "Rectangle class"..

class Rectangle{
    public:
    int length;
    int width;
    string color;
    Rectangle(int set_length , int set_width , string set_color){
        length = set_length;
        width = set_width;
        color = set_color;
    }

void print()
    {
        cout << "Lenght : "  << length << endl;
        cout << "Width : " << width << endl;
        cout << "Colour : " << color << endl;
    }

Rectangle& setColor(string set_color){
        color = set_color;
        return *this;
    }

Rectangle& setLength(int set_length){
        length = set_length;
        return *this;
    }

};

int main()
{
    Rectangle r1(4,5,"red");
    r1.setColor("orange").setLength(10);
    r1.print();
    return 0;
}

without method chaining we have to repeat the object like

object1.method1();
object1.method2();
object1.method3();

here the object is getting repeated again and again but with the help of method chaining we can resolve this issue

with method chaining
object1.method1().method2().method3()

here when the method1 is executed it will return the object itself which will help in the execution of method2 and so on.

I hope you got my point :)

Understanding Constructors in C++: A Complete Guide for Beginners

Rishav Kapil — Fri, 08 Nov 2024 03:40:41 +0000

Introduction

In C++, constructors are special functions that allow for efficient and controlled initialization of objects. They provide a way to assign initial values when an object is created, making them a crucial part of object-oriented programming.

What is a Constructor in C++?

A constructor is a unique member function automatically called when an object of a class is created. It has the same name as the class and doesn’t return a value. Constructors are essential for setting up initial values or allocating resources at the time of object creation.

Types of Constructors in C++

Default Constructor

A default constructor is one that takes no arguments. If no constructor is defined, C++ automatically provides a default constructor. If we make another constructor then default constructor is automatically removed and if we want to use the functionalities of default constructor then we have to make a new default constructor. Below is the code of default constructor in C++

class Car {
public:
int speed;

// Default constructor
Car() {
    speed = 0;
    std::cout << "Default constructor called, speed set to 0." << std::endl;
}

};

int main() {
Car myCar; // Default constructor called
}

Parameterized Constructor

A parameterized constructor allows passing values to initialize an object. A class can have multiple parameterized constructors but with different parameters and if are passing the same parameters than the order of that parameters should be different. Below is the code of parameterized constructor.

class Car {
public:
int speed;

// Parameterized constructor
Car(int s) {
    speed = s;
    std::cout << "Parameterized constructor called, speed set to " << speed << "." << std::endl;
}

};

int main() {
Car myCar(100); // Parameterized constructor called
}

Copy Constructor

The copy constructor initializes a new object as a copy of an existing object. In this, we pass object as the parameter to the constructor. Below is the code of copy constructor in C++.

class Car {
public:
int speed;

// Copy constructor
Car(const Car &c) {
    speed = c.speed;
    std::cout << "Copy constructor called, speed copied: " << speed << "." << std::endl;
}

};

int main() {
Car myCar(120);
Car anotherCar = myCar; // Copy constructor called
}

Conclusion

Constructors are the backbone of C++ class initialization, providing flexible ways to create and configure objects. By understanding the types of constructors and best practices, you can write more efficient and robust code in C++.