ليه مهندس .NET محتاج يعرف ده؟
انت مش هتكتب storage engine. لكن كل قرار يومي في الـ schema بيتحول لعمليات على القرص: نوع الـ primary key، عدد الـ indexes، حجم الـ rows، الـ updates المتكررة، وطريقة الحذف. الفرق بين جدول بيستحمل 50 ألف insert في الثانية وجدول بيقع عند 2,000 غالبًا قرار من دول — مش الهاردوير.
| العرض اللي هتشوفه | السبب على مستوى التخزين | القسم |
|---|---|---|
| Inserts بتبطأ مع الوقت والـ index بقى fragmented | random GUID key ← page splits في B+tree | B+tree |
| جدول PostgreSQL حجمه 3× البيانات الحقيقية | MVCC dead tuples ← bloat من غير VACUUM كافي | PostgreSQL |
| Commit بطيء على VM رخيص | fsync للـ WAL على قرص latency عالي | WAL |
| Cassandra/time-series DB بتاخد كتابة ضخمة بسهولة بس القراءة متقلبة | LSM: كتابة sequential، قراءة من كذا SSTable | LSM |
| «مسحنا البيانات والمساحة ما رجعتش» | tombstones/dead tuples لحد الـ compaction/VACUUM | Compaction |
الـ page: وحدة كل حاجة
الـ database ما بيقراش «صف»؛ بيقرأ page كاملة (8 KB في SQL Server و PostgreSQL، 4 KB افتراضي في SQLite). كل قراءة/كتابة للقرص وكل حاجة في الـ buffer pool (cache الذاكرة) بالـ pages. عشان كده:
- صف حجمه 4 KB ← صفين في الـ page. صف حجمه 200 byte ← ~40 صف. Scan لمليون صف صغير = 25 ألف page؛ لمليون صف كبير = 500 ألف page. حجم الصف بيأثر مباشرة على سرعة الـ scans والـ cache.
- الـ buffer pool (shared_buffers في PostgreSQL) بيحتفظ بالـ pages الأكتر استخدامًا. Query «سريعة» ممكن تكون سريعة لأنها في الـ cache بس — قيس الـ logical vs physical reads.
- الأعمدة الكبيرة (NVARCHAR(MAX)، JSON، text طويل) بتتخزن off-row/TOAST، وجيبها في
SELECT *= I/O زيادة.
-- SQL Server
SET STATISTICS IO ON;
SELECT TOP (100) * FROM dbo.Orders WHERE CustomerId = 42 ORDER BY OrderDate DESC;
-- Table 'Orders'. Scan count 1, logical reads 4, physical reads 0 ... <- pages touched
-- PostgreSQL
EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM orders WHERE customer_id = 42 ORDER BY order_date DESC LIMIT 100;
-- Buffers: shared hit=4 read=0 <- hit = from cache, read = from disk/OS cacheB+tree: ليه أي صف على بعد 3–4 قراءات
- Fan-out عالي: كل internal page فيها مئات المفاتيح، فالشجرة قصيرة جدًا. المستويين العلويين غالبًا في الذاكرة دايمًا، فالـ seek = قراءة أو اتنين من القرص.
- Leaf pages متربطة ← range scan (
BETWEEN,ORDER BY) = نزول مرة واحدة وبعدين مشي على الأوراق. - Clustered (SQL Server، InnoDB): الأوراق هي الصفوف نفسها مرتبة بالـ clustering key؛ أي nonclustered index بيخزن الـ clustering key كـ pointer. يعني clustering key عريض (GUID 16 byte + أعمدة) بيكبّر كل index.
- Heap + index (PostgreSQL): الصفوف في heap من غير ترتيب، وكل index (حتى الـ primary key) بيشاور على مكان فيزيائي (ctid).
Page splits ومشكلة الـ random GUID
لو الـ key بيزيد دايمًا (identity/sequence)، الإدخال دايمًا في آخر ورقة: الـ page بتتملي وتتفتح واحدة جديدة — كتابة متتالية سعيدة. لو الـ key عشوائي (Guid.NewGuid() v4)، كل insert بيروح لورقة عشوائية: لو مليانة، تتقسم نصين (page split) ← كتابة أكتر، pages نص فاضية، fragmentation، و cache أسوأ لأن الـ inserts بتلمس pages في كل حتة.
// .NET 9+: version 7 GUIDs are time-ordered (Unix ms timestamp in the high bits) -> inserts go to the end in PostgreSQL uuid
var id = Guid.CreateVersion7();
// SQL Server compares uniqueidentifier bytes in a different order than RFC/PostgreSQL,
// so v7 is not automatically "sequential" there. Options: NEWSEQUENTIALID() as a column default,
// EF Core's SequentialGuidValueGenerator (default for Guid keys with the SQL Server provider),
// or an int/bigint identity clustering key with the GUID as a unique nonclustered public id.Fill factor: ممكن تسيب مساحة فاضية في كل page (مثلًا 90%) عشان الـ inserts/updates العشوائية ما تعملش split فورًا — على حساب مساحة وقراءة أكتر. مفيد للـ indexes اللي بتاخد inserts عشوائية بطبيعتها (email مثلًا).
الـ WAL والـ crash recovery
المشكلة: تعديل صف = تعديل page في الذاكرة. لو كل commit استنى يكتب كل الـ pages المتعدلة على القرص (عشوائي ومتفرق)، الـ commits هتبقى بطيئة جدًا. ولو ما كتبش ووقع الكهربا، البيانات ضاعت.
الحل: قبل أي تغيير في الـ data pages على القرص، التغيير بيتسجل في log متسلسل (WAL في PostgreSQL، transaction log في SQL Server). الـ commit = الـ log records بتاعته اتعملها fsync. الـ data pages نفسها بتتكتب بعدين على مهلها (checkpoint / background writer).
- ليه أسرع؟ الكتابة في الـ log متسلسلة (append)، والـ fsync واحد ممكن يغطي commits كتير مع بعض (group commit).
- Checkpoint: بيكتب الـ dirty pages ويحدد نقطة «كل اللي قبلها في الـ data files». الـ recovery بيبدأ من آخر checkpoint بس.
- أثر عملي: transaction واحدة فيها 10,000 insert أسرع بكتير من 10,000 transaction (fsync واحد بدل 10,000) — نفس درس SQLite. و
synchronous_commit = offفي PostgreSQL أو delayed durability في SQL Server بيسرّعوا مقابل احتمال خسارة آخر لحظات قبل crash — قرار بيزنس مش تقني بس. - الـ log هو مصدر الـ replication والـ CDC: Debezium و logical replication بيقروا نفس الـ log ده — وده اللي بيخلي outbox relay بالـ CDC ممكن.
LSM-tree: لما الكتابة هي الأولوية
بدل ما تعدّل pages في مكانها (in-place)، الـ LSM بيعامل التخزين كله كـ append: الكتابات بتروح memtable في الذاكرة (مرتبة) + log للأمان، ولما الـ memtable تتملي بتتكتب مرة واحدة كملف SSTable مرتب ومش بيتغير. مع الوقت ملفات كتير ← compaction بيدمجها في ملفات أكبر ويشيل القديم والمحذوف.
- Updates: مفيش تعديل في مكانه؛ نسخة أحدث بتكتب، والقراءة بتاخد الأحدث. الـ compaction بيشيل القديم.
- Deletes: بتتكتب tombstone (علامة «اتمسح»). المساحة ما بترجعش لحد ما الـ compaction يعدّي على كل الملفات اللي فيها النسخ القديمة — وده سبب مشاكل «حذفنا ملايين الصفوف والقراءة بقت أبطأ» (القراءة بتعدّي على tombstones كتير).
- استراتيجيات الـ compaction: leveled (قراءة أسرع، كتابة إضافية أكتر) مقابل size-tiered (كتابة أرخص، مساحة وقراءة أسوأ). أمثلة: RocksDB، Cassandra، ScyllaDB، وكتير من الـ time-series والـ vector stores.
Bloom filter: «أكيد مش موجود» أو «يمكن موجود»
bit array بحجم m و k hash functions. الإضافة: حط 1 في k مواضع. الفحص: لو أي موضع من الـ k = 0 ← أكيد مش موجود. لو كلهم 1 ← يمكن موجود (false positive ممكن، false negative مستحيل).
public sealed class BloomFilter
{
private readonly BitArray _bits;
private readonly int _k;
public BloomFilter(int expectedItems, double falsePositiveRate)
{
int m = (int)Math.Ceiling(-expectedItems * Math.Log(falsePositiveRate) / (Math.Log(2) * Math.Log(2)));
_k = Math.Max(1, (int)Math.Round((double)m / expectedItems * Math.Log(2)));
_bits = new BitArray(m);
}
private IEnumerable<int> Positions(string key)
{
var h = System.IO.Hashing.XxHash64.HashToUInt64(Encoding.UTF8.GetBytes(key));
uint h1 = (uint)h, h2 = (uint)(h >> 32);
for (int i = 0; i < _k; i++) yield return (int)((h1 + (uint)i * h2) % (uint)_bits.Length); // double hashing
}
public void Add(string key) { foreach (var p in Positions(key)) _bits[p] = true; }
public bool MightContain(string key) => Positions(key).All(p => _bits[p]);
}
// 1M keys at 1% false positives -> ~9.6 bits per key (~1.2 MB) and k = 7 hash functions.| Bits per key | False positive rate تقريبًا |
|---|---|
| 5 | ~9% |
| 10 | ~1% |
| 15 | ~0.1% |
استخدامات خارج الـ DB: «هل الـ username ده متاخد؟» قبل ما تضرب الـ DB، تجنب cache penetration (طلبات على مفاتيح مش موجودة)، dedup للـ URLs في crawler، و PostgreSQL نفسه عنده bloom index extension. الحذف مش مدعوم في الـ Bloom العادي (Counting Bloom أو Cuckoo filter لو محتاجه).
Read و write و space amplification: المثلث
| B+tree (in-place) | LSM (append + compaction) | |
|---|---|---|
| Write amplification | page كاملة لكل تغيير صغير + WAL؛ page splits | كل بايت بيتكتب أكتر من مرة عبر مستويات الـ compaction (ممكن 10×+) لكن sequential |
| Read amplification | منخفض ومتوقع: مسار واحد في الشجرة | أعلى: memtable + كذا SSTable (Bloom filters بتقلله) |
| Space amplification | fragmentation و pages مش مليانة | نسخ قديمة و tombstones لحد الـ compaction |
| Throughput كتابة | جيد؛ بيتأثر بالـ random I/O | عالي جدًا (sequential) |
| Latency قراءة | ثابت | متقلب أثناء compaction |
| أنسب لـ | OLTP عام، قراءات و range queries، transactions | ingestion ضخم: logs، events، metrics، time-series، key-value |
مفيش engine بيكسب في التلاتة. الـ RUM conjecture بيقول: تحسين اتنين من (Read، Update، Memory/space) بيكون على حساب التالت. القرار يبدأ من الـ workload: نسبة القراءة للكتابة، شكل الـ queries، وحجم البيانات.
SQL Server مقابل PostgreSQL مقابل MongoDB على مستوى التخزين
| الجانب | SQL Server | PostgreSQL | MongoDB (WiredTiger) |
|---|---|---|---|
| تنظيم الصفوف | Clustered index (B+tree) غالبًا؛ heap ممكن | Heap دايمًا؛ كل الـ indexes secondary (ctid) | B-tree للـ collection مرتب بـ record id داخلي؛ indexes منفصلة |
| Update | in-place غالبًا (+ log) | نسخة جديدة من الـ tuple (MVCC)؛ القديمة dead لحد VACUUM؛ HOT updates لو مفيش indexed column اتغير | copy-on-write للـ pages في الذاكرة، checkpoints دورية |
| Concurrency | locks + اختياري row versioning في tempdb (RCSI/Snapshot) | MVCC أصلي: القراءة ما بتعملش block للكتابة | MVCC على مستوى الـ document + document-level concurrency |
| Log | transaction log (.ldf)، VLFs | WAL segments | journal (WAL) + checkpoints كل ~60 ثانية |
| Cleanup | ghost cleanup، index rebuild/reorganize | VACUUM / autovacuum (أساسي!)، bloat monitoring | compaction command لاسترجاع المساحة |
| ضغط | row/page compression، columnstore | TOAST compression للقيم الكبيرة | snappy/zstd للـ data و prefix compression للـ indexes افتراضيًا |
نتايج عملية
- PostgreSQL + updates كتير على نفس الصفوف (counters، status): dead tuples بتتراكم؛ راقب
n_dead_tup، اضبط autovacuum للجدول ده، وفكّر في fillfactor أقل عشان HOT updates تشتغل. عدّاد بيتحدث آلاف المرات في الثانية مكانه Redis، مش صف في PostgreSQL. - SQL Server + clustering key: اختار key ضيق ومتزايد وثابت (bigint identity أو sequential GUID) لأنه بيتنسخ في كل index.
- MongoDB documents كبيرة بتكبر: كل update بيكتب نسخة جديدة من الـ document؛ arrays بتكبر للأبد = documents ضخمة وكتابة أكتر. ده سبب قاعدة «ما تعملش unbounded arrays» في MongoDB.
- Long-running transactions في الاتنين بتمنع التنظيف (PostgreSQL ما يقدرش يمسح tuples ممكن الـ transaction القديمة تشوفها؛ SQL Server row versions في tempdb بتكبر).
SELECT relname, n_live_tup, n_dead_tup,
round(100.0 * n_dead_tup / NULLIF(n_live_tup + n_dead_tup, 0), 1) AS dead_pct,
last_autovacuum, last_autoanalyze
FROM pg_stat_user_tables
ORDER BY n_dead_tup DESC
LIMIT 10;الربط بالـ AI: vector indexes كمان storage engines
الـ vector indexes (HNSW، IVF) ليها نفس الأسئلة: الـ HNSW graph في الذاكرة غالبًا (RAM-heavy)، الإضافة رخيصة نسبيًا، الحذف بيعلّم nodes كمحذوفة ومحتاج rebuild/compaction دوري، والـ updates الكتير بتبوّظ جودة الـ graph. وكتير من الـ vector databases بتستخدم تصميم LSM-like (segments بتتكتب وتتدمج). نفس التفكير — كتابة مقابل قراءة مقابل مساحة — بيساعدك تختار بين pgvector وحل مخصص في Production Vector Retrieval.
أخطاء شائعة
- Random GUID v4 كـ clustered key في جدول insert-heavy.
- Indexes كتير «احتياطي» على جدول write-heavy: كل index = كتابة إضافية لكل insert/update.
- تعطيل أو تجاهل autovacuum في PostgreSQL، أو transactions مفتوحة لساعات.
- Delete ضخم مرة واحدة ← log ضخم، locks، وفي LSM tombstones كتير. احذف على دفعات، أو partitions و drop للـ partition.
- الحكم على الأداء من query تانية مرة (cache دافي) من غير ما تبص على physical reads.
- افتراض إن «NoSQL أسرع» من غير ما تفهم الـ engine والـ workload.
اختبر فهمك
ليه الـ commit في database بيعتمد على fsync للـ WAL مش للـ data pages؟
Bloom filter قال «يمكن موجود». إيه المعنى؟
جدول PostgreSQL فيه عمود status بيتحدث 50 مرة لكل صف، وحجمه بيكبر رغم إن عدد الصفوف ثابت. السبب الأرجح؟
تمارين محلولة
1: احسب عمق B+tree لجدول فيه 500 مليون صف، fan-out 400
الحل: 400¹ = 400، 400² = 160,000، 400³ = 64M، 400⁴ = 25.6B. يبقى 4 مستويات (root + 2 internal + leaf). الـ root والمستوى التاني في الذاكرة غالبًا، فالـ seek = 1–2 قراءة قرص. ده ليه الـ index seek «فوري» حتى على جداول ضخمة، والمشكلة دايمًا في عدد الـ seeks (key lookups) مش في عمق الشجرة.
2: نظام بيستقبل 200 ألف event/ثانية للـ telemetry، والقراءة غالبًا آخر ساعة لكل device. أنهي engine؟
الحل: write-heavy، append-only، قراءات range زمنية على أحدث بيانات، وحذف بالـ retention ← LSM/time-series engine (أو columnar time-series) أنسب من B-tree OLTP. صمّم الـ key بـ (device_id, time) عشان القراءة تبقى range scan، والـ retention بـ partitions زمنية تتشال كاملة (بدل tombstones). وخلي بيانات الـ SaaS الأساسية (tenants، billing) في PostgreSQL/SQL Server.
3: insert rate وقع من 20k/s لـ 3k/s بعد ما الجدول عدّى 200M صف، والـ key = Guid.NewGuid()
الحل: الـ index بقى أكبر من الذاكرة، والـ random keys بيلمسوا pages عشوائية مش في الـ cache ← physical reads + page splits. الحل: key متسلسل (identity أو sequential/v7 GUID حسب الـ engine)، وراجع عدد الـ secondary indexes. قِس قبل وبعد بـ page splits/sec (SQL Server) أو buffer reads.
أسئلة إنترفيو
(Mid) إيه الفرق بين B-tree و LSM-tree؟
(Mid) ليه random GUID كـ clustered key مشكلة؟
(Senior) PostgreSQL مقابل SQL Server في update-heavy workload؟
المراجع والقراءة الإضافية
الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)
التوثيق الرسمي — Official documentation
مصادر تعليمية ومتقدمة — Third-party & advanced reading
خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.