C++: تمرين: قاعدة بيانات بسيطة

#include <iostream>
#include <string>
#include <variant>
#include <vector>

// تعريف العمود
struct Column {
	std::string name;
	enum Type { INT, STRING } type;
};

// نوع القيمة (استخدم variant لتخزين أنواع مختلفة)
using Value = std::variant<int, std::string>;

// صف (صف واحد من البيانات)
using Row = std::vector<Value>;

// جدول
class Table {
private:
	std::string name;
	std::vector<Column> columns;
	std::vector<Row> rows;

public:
	Table(const std::string& name, const std::vector<Column>& columns)
	: name(name), columns(columns) {}
	
	// إدراج صف
	void insert(const Row& row) {
		if (row.size() != columns.size()) {
			std::cerr << "Column count mismatch" << std::endl;
			return;
		}
		rows.push_back(row);
	}
	
	// استعلام (مبسط: إرجاع جميع الصفوف)
	std::vector<Row> select() {
		return rows;
	}
	
	// عرض بنية الجدول
	void describe() const {
		std::cout << "Table name: " << name << std::endl;
		std::cout << "Columns: " << std::endl;
		for (const auto& col : columns) {
			std::cout << "  " << col.name << " (";
			if (col.type == Column::INT) {
				std::cout << "INT";
			} else {
				std::cout << "STRING";
			}
			std::cout << ")" << std::endl;
		}
	}
};

Table name:
Columns:
  (
INT
STRING
)

// دالة المسند (لـ WHERE)
using Predicate = std::function<bool(const Row&)>;

// استعلام بشرط
std::vector<Row> selectWhere(Predicate pred) {
	std::vector<Row> result;
	for (const auto& row : rows) {
		if (pred(row)) {
			result.push_back(row);
		}
	}
	return result;
}

// مثال: إيجاد صفوف حيث العمر > 18
auto predicate = [](const Row& row) {
	int age = std::get<int>(row[1]); // افترض أن العمود 2 هو العمر
	return age > 18;
};

auto result = table.selectWhere(predicate);

#include <map>

// فهرس (مبسط: فهرسة أنواع int فقط)
class Index {
private:
	std::map<int, std::vector<int>> index; // القيمة → قائمة أرقام الصفوف

public:
	void build(const std::vector<Row>& rows, int colIndex) {
		index.clear();
		for (int i = 0; i < rows.size(); i++) {
			int key = std::get<int>(rows[i][colIndex]);
			index[key].push_back(i);
		}
	}
	
	std::vector<int> lookup(int key) {
		auto it = index.find(key);
		if (it != index.end()) {
			return it->second;
		}
		return {};
	}
};

#include <stack>

class Transaction {
private:
	std::stack<std::vector<Row>> undoStack;

public:
	// بدء المعاملة (حفظ الحالة الحالية)
	void begin(Table& table) {
		undoStack.push(table.rows);
	}
	
	// تأكيد (تفريغ مكاكب التراجع)
	void commit() {
		while (!undoStack.empty()) {
			undoStack.pop();
		}
	}
	
	// تراجع (استعادة الحالة السابقة)
	void rollback(Table& table) {
		if (!undoStack.empty()) {
			table.rows = undoStack.top();
			undoStack.pop();
		}
	}
};

int main() {
	// إنشاء جدول
	Table t("users", {{"name", Column::STRING}, {"age", Column::INT}});
	
	// إدخال بيانات
	t.insert({"Alice", 25});
	t.insert({"Bob", 30});
	t.insert({"Charlie", 20});
	
	// استعلام الكل
	auto rows = t.select();
	std::cout << "All users:" << std::endl;
	for (const auto& row : rows) {
		std::cout << std::get<std::string>(row[0]) << ", "
			<< std::get<int>(row[1]) << std::endl;
	}
	
	return 0;
}

All users:
, 

#include <iostream>
#include <string>
#include <vector>
#include <variant>

// نوع القيمة (يدعم أنواع بيانات متعددة)
using Value = std::variant<int, std::string, double>;

// صف واحد من البيانات
struct Row {
    int id;
    Value name;
    Value age;
    Value score;

    void display() const {
        std::cout << "ID: " << id << std::endl;
        std::cout << "Name: " << std::get<std::string>(name) << std::endl;
        std::cout << "Age: " << std::get<int>(age) << std::endl;
        std::cout << "Score: " << std::get<double>(score) << std::endl;
    }
};

int main() {
    Row r = {1, std::string("Alice"), 20, 95.5};
    r.display();
    return 0;
}

ID: 
Name: 
Age: 
Score: