কোয়েরি বিল্ডার বনাম রॉ SQL বনাম ORM

# ---------- L28-এর মিনি-ORM (পুনরায় সংজ্ঞায়িত) ----------
class QueryManager:
    def __init__(self, model_cls):
        self.model_cls = model_cls

    def filter(self, **criteria):
        return [
            row for row in self.model_cls._table
            if all(row.get(key) == value for key, value in criteria.items())
        ]


class Model:
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        cls._table = []
        cls._next_id = 1
        cls.objects = QueryManager(cls)

    def __init__(self, **fields):
        self.id = fields.pop("id", None)
        for key, value in fields.items():
            setattr(self, key, value)

    def save(self):
        cls = type(self)
        self.id = cls._next_id
        cls._next_id += 1
        cls._table.append(dict(self.__dict__))
        return self


class User(Model):
    pass


people = [("Zafar", 25), ("Aporna", 30), ("Karim", 15), ("Bithi", 22), ("Nadia", 17), ("Rafi", 40)]
for name, age in people:
    User(name=name, age=age).save()


# ---------- ১. ফ্লুয়েন্ট কোয়েরি বিল্ডার ----------
class QueryBuilder:
    def __init__(self, table):
        self.table = table
        self._filters = {}
        self._order_key = None

    def where(self, **criteria):
        self._filters.update(criteria)
        return self          # নিজেকেই রিটার্ন করে -- চেইনিং সম্ভব করে তোলে

    def order_by(self, key):
        self._order_key = key
        return self

    def execute(self):
        result = []
        for row in self.table:
            ok = True
            for key, value in self._filters.items():
                if key.endswith("__gt"):
                    field = key[: -len("__gt")]
                    if not (row.get(field) is not None and row[field] > value):
                        ok = False
                        break
                elif row.get(key) != value:
                    ok = False
                    break
            if ok:
                result.append(row)
        if self._order_key:
            result = sorted(result, key=lambda r: r[self._order_key])
        return result


qb_result = QueryBuilder(User._table).where(age__gt=18).order_by("name").execute()
print("১. কোয়েরি বিল্ডার ফলাফল:")
for row in qb_result:
    print(" ", row["name"], row["age"])


# ---------- ২. লিটারাল SQL -- শুধু একটি স্ট্রিং, এক্সিকিউট করা হয় না ----------
raw_sql = "SELECT * FROM users WHERE age > 18 ORDER BY name ASC;"
print("\n২. লিটারাল SQL (শুধু দেখানো হলো, এক্সিকিউট করা হয়নি):")
print(" ", raw_sql)


# ---------- ৩. মিনি-ORM স্টাইল ----------
# এই সহজ filter() শুধু ইকুয়ালিটি সাপোর্ট করে (L28), তাই বয়সের ">" শর্ত সাধারণ পাইথন দিয়ে প্রয়োগ করা হলো --
# একটি বাস্তব ORM-এ (Django-এর age__gt=18) এই একই কাজ ভেতরে সত্যিকারের SQL দিয়ে হতো
all_users = User.objects.filter()
orm_result = sorted((row for row in all_users if row["age"] > 18), key=lambda r: r["name"])
print("\n৩. মিনি-ORM ফলাফল:")
for row in orm_result:
    print(" ", row["name"], row["age"])


# ---------- অভিন্নতা যাচাই ----------
qb_set = {(r["name"], r["age"]) for r in qb_result}
orm_set = {(r["name"], r["age"]) for r in orm_result}
identical = qb_set == orm_set
print(f"\nকোয়েরি বিল্ডার ও ORM ফলাফল অভিন্ন: {identical}")
assert identical