1. Volatile Storage VS Persistent Storage

• Volatile Storage:
  • Uses DRAM (Dynamic Random-Access Memory)
  • Ideal for Quick Data Access
  • Data is LOST without the power
• Persistent Storage:
  • Data is permanently saved on disk
  • It ensures Atomicity, Consistency, Isolation, Durability properties:
    • Atomicity: Transactions are “all or nothing” (no partial changes)
    • Consistency: The database remains valid after transactions
    • Isolation: Transactions don’t interfere with each other
    • Durability: Once a transaction is committed, it’s saved even during crashes

2. File I/O in C++

• This code demonstrates how to read data from a file, insert it into a database (BuzzDB), and run a query on it

int main() {
		BuzzDB db; // our custom database
		// Import data from “output.txt” file
		std::ifstream inputFile("output.txt");
		
		// Variables to store data from the file
		int field1, field2;
		
		// Read pairs of integers from the file and insert them into BuzzDB
		while (inputFile >> field1 >> field2) {
				// insert each pair into the database
				db.insert(field1, field2);
		}
		
		// Perform aggregation query on the imported data
		db.selectGroupBySum();
}

• The program reads integers from a file named output.txt.
• Each pair of integers is inserted into the database.
• The selectGroupBySum method is called, which groups the data and calculates the sum for each group.

3. Tuple Class

A tuple represents one record (or row) in the database. For example:

• A tuple could store a key-value pair, like:
  • Key: 101, Value: 200.

class Tuple {
public:
		// Identifier field (like a unique ID)
		int key;
		// Actual data field (value associated with the key)
		int value;
};

4. Field Class

• A field is an individual piece of data in the tuple. For instance, in a tuple {101, 200}, the key (101) and value (200) are fields.

• Field Class: Type

• Enums: Defines, Constants

  enum FieldType {INT, FLOAT}; // Field types supported: ints and floats
  class Field {
  		public:
  		FieldType type; // type of field (int or float)
  		union {
  				int i; // integer value
  				float f; // float value
  		} data; // actual data
  };
  

5. Constructor Overloading in Field

• Constructor overloading allows us to create a Field with different data types.