{
  "assessmentTests": {
    "sql_test": {
      "name": "آزمون SQL",
      "desc": "30 سوال سناریویی در مورد فیلترینگ، JOIN‌ها، تجمیع (aggregation)، subqueries و window functions — بفهمید مهارت‌های SQL شما با آنچه یک فرصت شغلی منظور دارد چقدر مطابقت دارد.",
      "recommendation": "پروفایل مهارت‌های SQL شما",
      "results": {
        "beginner": {
          "name": "مبتدی",
          "desc": "می‌توانید یک دستور SELECT درست بنویسید و روی چند شرط فیلتر کنید، اما سؤالاتی که از دست رفته‌اند بیشتر دور NULL handling و مکانیک JOIN‌ها متمرکز هستند — نه نحو. مقایسه یک ستون با NULL با =، اینکه LEFT JOIN واقعاً چه نگاه می‌دارد، حدود BETWEEN چگونه کار می‌کند. هیچ‌کدام این موارد درباره بدبود برای پایگاه‌های داده نیستند؛ این قوانین خاصی هستند که افرادی که SQL را از طریق تجربه و خطا آموخته‌اند را سردرگم می‌کند. در کار اهمیت دارند زیرا هر یک جایی است که کوئری تعداد ردیف نادرست را برمی‌گرداند.",
          "recommendation": "با سه چیز شروع کنید، به ترتیب: چرا WHERE col = NULL هرگز چیزی تطابق نمی‌دهد (و IS NULL ضروری است)، چگونه INNER JOIN ردیف‌های بدون تطابق را می‌اندازد در حالی که LEFT JOIN آن‌ها را نگاه می‌دارد، و دقیق‌ترین حدود BETWEEN. آموزش SQL و مستندات PostgreSQL هر دو این سه‌تایی را با مثال‌های قابل اجرا پوشش می‌دهند."
        },
        "intermediate": {
          "name": "متوسط",
          "desc": "آپ روزمره گزارش‌های کوئری را راحت‌انه کار می‌کنید — JOIN‌ها، GROUP BY، فیلترینگ ساده — و از کار داشبورد یا تجزیه‌های ad-hoc کند نمی‌شوید. شکاف بین اینجا و Advanced بیشتر درباره آن است که وقتی بند‌ها با یکدیگر تعامل دارند چه اتفاق می‌افتد: یک بند WHERE در جدول joined آرام‌آرام یک LEFT JOIN را به INNER JOIN تبدیل می‌کند، یک join که قبل از اعمال aggregate تعداد ردیف‌ها را منتشر می‌کند، یک NOT IN که آرام‌آرام چیزی برنمی‌گرداند زیرا یک NULL به subquery سر زده است. این نوع bugs هستند که یک نگاه سریع را پاس می‌کنند و فقط زمانی ظاهر می‌شوند که کسی کل را با یک گزارش متفاوت مقایسه کند.",
          "recommendation": "روی نحوه تعامل بند‌ها تمرکز کنید نه آنکه هر یک به تنهایی چه کاری انجام دهد: WHERE فیلترینگ یک LEFT JOIN ستون‌های سمت راست، ضرب ردیف از JOIN‌های one-to-many قبل از aggregate، و چرا NOT IN در حضور NULL‌ها شکست می‌خورد (EXISTS معمولاً اینطور نیست). سپس HAVING در برابر WHERE، زیرا این تقسیم افرادی را گیج می‌کند که قبلاً هر دو بند را می‌شناسند."
        },
        "advanced": {
          "name": "پیشرفته",
          "desc": "این سطحی است که بیشتر فرصت‌های شغلی منظور دارند \"SQL قوی\". یک کوئری multi-join را می‌خوانید و قبل از اجرا تعداد ردیف‌های آن را پیش‌بینی می‌کنید، می‌دانید چرا یک مجموعه نتایج تغییر کرد نه تنها اینکه تغییر کرد، و برای CTE یا window function جای یک nested subquery انتخاب می‌کنید. آنچه این band را از top جدا می‌کند سمت defensive کار است: دانستن کدام ranking function را وقتی ties مسئله است استفاده کنید، چه چیزی transaction جدا می‌کند از concurrent session، و وقتی یک ON DELETE rule گمشده است در سطح پایگاه‌های داده واقعاً چه اتفاقی می‌افتد.",
          "recommendation": "به سمتی بروید که داده‌های دیگران را محافظت می‌کند: تفاوت بین RANK، DENSE_RANK و ROW_NUMBER در ties، آنچه COMMIT واقعاً مرئی می‌سازد و برای کی، و رفتار foreign key در DELETE. The Index newsletter یا SQL for Devs deep dives را برای window functions و transaction isolation به‌عنوان قدم بعدی برای هر دو استفاده کنید."
        },
        "expert": {
          "name": "متخصص",
          "desc": "شما در هر بخش بالاترین نمره را گرفتید — filtering و NULL semantics، joins و set operations، aggregation و subqueries، و window functions، CTEs و constraints. عملاً، این یعنی می‌توانید یک کوئری گزارش multi-join یک نفر دیگری را تحویل بگیرید و توضیح دهید چرا تعداد ردیف‌های آن را برمی‌گرداند، نه فقط آنچه نحو می‌گوید باید برگردانی شود، که مهارت سخت‌تر و ارزشمندتر است. در این سطح زبان کوئری به ندرت عامل محدود کننده است؛ محدودیت معمولاً طراحی schema یا اندازه داده زیرینش است.",
          "recommendation": "بازگشت‌ها اکنون در execution plans و design هستند: EXPLAIN output را قبل از فرض اینکه کوئری آهسته است بخوانید، استراتژی indexing به‌عنوان trade-off در برابر write cost نه یک win رایگان، و تصمیمات normalization که موقع رشد schema پابرجا می‌مانند. اگر برای یک نقش غربالگری می‌شوید، یک bug کوئری را مثل join fan-out یا NOT IN/NULL trap که در production پیدا کردید توصیف کنید نه نام‌برداری ویژگی‌های SQL — دلیل را نشان می‌دهد، نه تنها واژگان."
        }
      },
      "questions": [
        {
          "question": "یک جدول دارای یک ستون nullable به نام age است. شما SELECT * FROM users WHERE age = NULL را اجرا می‌کنید. این کوئری چند ردیف برمی‌گرداند، حتی اگر چندین ردیف age به NULL تنظیم شده باشند؟",
          "options": [
            {
              "icon": "",
              "label": "هر ردیفی که age برابر NULL است، زیرا = با NULL مثل هر مقدار دیگری تطابق می‌دهد"
            },
            {
              "icon": "",
              "label": "صفر — مقایسه هر چیزی با NULL با = UNKNOWN را تولید می‌کند، هرگز TRUE نیست، بنابراین ردیفی تطابق نمی‌خورد؛ IS NULL ضروری است"
            },
            {
              "icon": "",
              "label": "یک syntax error — NULL نمی‌تواند در سمت راست = ظاهر شود"
            },
            {
              "icon": "",
              "label": "هر ردیفی در جدول، زیرا مقایسه‌های NULL به طور پیش‌فرض به TRUE تنظیم می‌شوند"
            }
          ]
        },
        {
          "question": "شما SELECT DISTINCT department, role FROM employees را اجرا می‌کنید. DISTINCT دوبلیکات کدام موارد را حذف می‌کند؟",
          "options": [
            {
              "icon": "",
              "label": "ترکیب department و role با هم — یک ردیف فقط اگر هر دو ستون دقیقاً با ردیف دیگری تطابق داشته باشند حذف می‌شود"
            },
            {
              "icon": "",
              "label": "تنها مقادیر دوبلیکه department، هر role را نگاه می‌دارد"
            },
            {
              "icon": "",
              "label": "تنها مقادیر دوبلیکه role، هر department را نگاه می‌دارد"
            },
            {
              "icon": "",
              "label": "چیزی نیست — DISTINCT تنها با یک ستون کار می‌کند"
            }
          ]
        },
        {
          "question": "نام ستونی با WHERE name LIKE 'A_' فیلتر شده است. کدام یک از این مقادیر تطابق دارد: 'A'، 'Al'، 'Ana'، 'Ally'؟",
          "options": [
            {
              "icon": "",
              "label": "'A' — underscore اختیاری است و صفر یا بیشتر کاراکتر را تطابق می‌دهد"
            },
            {
              "icon": "",
              "label": "'Al' — underscore دقیقاً یک کاراکتر را تطابق می‌دهد، بنابراین LIKE 'A_' هر رشته دو کاراکتری که با A شروع شود تطابق می‌دهد"
            },
            {
              "icon": "",
              "label": "'Ana' و 'Ally' — underscore هر تعداد کاراکتر trailing را تطابق می‌دهد"
            },
            {
              "icon": "",
              "label": "هر چهار مقدار تطابق دارد، زیرا LIKE از طول غافل است"
            }
          ]
        },
        {
          "question": "یک ستون price با WHERE price BETWEEN 10 AND 20 فیلتر می‌شود. آیا ردیف‌هایی با price دقیقاً 10 یا دقیقاً 20 شامل می‌شوند؟",
          "options": [
            {
              "icon": "",
              "label": "خیر — BETWEEN هر دو endpoint را حذف می‌کند"
            },
            {
              "icon": "",
              "label": "بلی — BETWEEN در هر دو انتها inclusive است، معادل price >= 10 AND price <= 20"
            },
            {
              "icon": "",
              "label": "تنها price = 10 شامل می‌شود؛ bound بالا exclusive است"
            },
            {
              "icon": "",
              "label": "تنها price = 20 شامل می‌شود؛ bound پایین exclusive است"
            }
          ]
        },
        {
          "question": "جدول orders دارای 10 ردیف است، و 3 آنها دارای NULL shipped_date هستند. SELECT COUNT(*) FROM orders چه برمی‌گرداند، و SELECT COUNT(shipped_date) FROM orders چه برمی‌گرداند؟",
          "options": [
            {
              "icon": "",
              "label": "10، سپس 10 — COUNT همیشه ردیف‌ها را صرف‌نظر از NULL‌ها می‌شمارد"
            },
            {
              "icon": "",
              "label": "7، سپس 7 — هر دو فرم ردیف‌های NULL را رد می‌کنند"
            },
            {
              "icon": "",
              "label": "10، سپس 7 — COUNT(*) هر ردیفی را می‌شمارد، COUNT(column) تنها ردیف‌هایی که آن ستون NULL نیست را می‌شمارد"
            },
            {
              "icon": "",
              "label": "10، سپس 3 — COUNT(column) فقط مقادیر NULL را می‌شمارد"
            }
          ]
        },
        {
          "question": "شما SELECT name, salary FROM employees ORDER BY 2 DESC را اجرا می‌کنید. 2 به چه اشاره می‌کند؟",
          "options": [
            {
              "icon": "",
              "label": "یک syntax error — ORDER BY فقط نام‌های ستون را قبول می‌کند، نه اعداد"
            },
            {
              "icon": "",
              "label": "ردیف دوم نتیجه"
            },
            {
              "icon": "",
              "label": "یک مقدار literal از 2، به‌عنوان tiebreaker استفاده می‌شود"
            },
            {
              "icon": "",
              "label": "ستون دوم در SELECT list، salary — ORDER BY یک شماره موضع ستون را به‌عنوان shorthand قبول می‌کند"
            }
          ]
        },
        {
          "question": "در SQL استاندارد، 'Ana' || ' ' || 'Lee' چه ارزیابی می‌کند؟",
          "options": [
            {
              "icon": "",
              "label": "یک syntax error — SQL هیچ operator concatenation ندارد"
            },
            {
              "icon": "",
              "label": "3 — || به‌عنوان یک boolean OR درمان می‌شود و یک count برمی‌گرداند"
            },
            {
              "icon": "",
              "label": "'AnaLee' — || فاصله‌ها را حفظ نکردن concat می‌کند"
            },
            {
              "icon": "",
              "label": "'Ana Lee' — || standard SQL string concatenation operator است"
            }
          ]
        },
        {
          "question": "کدام یک از این‌ها دقیقاً معادل WHERE status IN ('open', 'pending', 'review') است؟",
          "options": [
            {
              "icon": "",
              "label": "WHERE status = 'open' AND status = 'pending' AND status = 'review'"
            },
            {
              "icon": "",
              "label": "WHERE status != 'open' OR status != 'pending' OR status != 'review'"
            },
            {
              "icon": "",
              "label": "WHERE status = 'open' OR status = 'pending' OR status = 'review'"
            },
            {
              "icon": "",
              "label": "WHERE status LIKE 'open,pending,review'"
            }
          ]
        },
        {
          "question": "customers دارای 100 ردیف است؛ 20 آنها هرگز یک order نگذاشته‌اند. شما SELECT c.id FROM customers c INNER JOIN orders o ON c.id = o.customer_id را اجرا می‌کنید. آیا 20 customer بدون orders در نتیجه ظاهر می‌شوند؟",
          "options": [
            {
              "icon": "",
              "label": "بلی، یک بار هر یک، با o.id نشان‌داده‌شده به‌عنوان NULL"
            },
            {
              "icon": "",
              "label": "بلی، اما فقط اگر آن‌ها نیز در WHERE clause ظاهر شوند"
            },
            {
              "icon": "",
              "label": "خیر — INNER JOIN فقط ردیف‌هایی را برمی‌گرداند که در هر دو جدول تطابق دارند، بنابراین customers بدون orders کاملاً حذف می‌شوند"
            },
            {
              "icon": "",
              "label": "بلی، اما یک بار برای هر ستون در orders تکرار می‌شود"
            }
          ]
        },
        {
          "question": "شما می‌خواهید هر customer چه یا نه دارای orders، بنابراین شما SELECT c.id, o.total FROM customers c LEFT JOIN orders o ON c.id = o.customer_id WHERE o.total > 100 را می‌نویسید. آیا این هنوز customers بدون orders را برمی‌گرداند؟",
          "options": [
            {
              "icon": "",
              "label": "خیر — فیلترینگ بر روی o.total در WHERE clause ردیف‌های NULL را که LEFT JOIN برای customers بدون تطابق تولید کرد رد می‌کند، بنابراین مثل INNER JOIN رفتار می‌کند"
            },
            {
              "icon": "",
              "label": "بلی — LEFT JOIN همیشه هر ردیفی را از customers نگاه می‌دارد صرف‌نظر از آنچه بعد می‌آید"
            },
            {
              "icon": "",
              "label": "بلی، با o.total نشان‌داده‌شده 0 برای customers بدون orders"
            },
            {
              "icon": "",
              "label": "خیر — LEFT JOIN آرام‌آرام خودش را به RIGHT JOIN تبدیل می‌کند وقتی WHERE clause اضافه شود"
            }
          ]
        },
        {
          "question": "جدول employees دارای یک id column و یک manager_id column است که به row دیگری id اشاره می‌کند. برای درج هر employee کنار نام manager آن‌ها، شما جدول را به خودش JOIN می‌کنید: SELECT e.name, m.name FROM employees e JOIN employees m ON e.manager_id = m.id. این pattern چه نام دارد؟",
          "options": [
            {
              "icon": "",
              "label": "یک cross join — هر employee با هر manager تطابق داده می‌شود"
            },
            {
              "icon": "",
              "label": "یک recursive join — تمام زنجیر management را می‌گذارد"
            },
            {
              "icon": "",
              "label": "یک self-join — جدول یکسان به خودش JOIN می‌شود با استفاده از دو alias متفاوت"
            },
            {
              "icon": "",
              "label": "این SQL غلط است — یک جدول نمی‌تواند به خودش JOIN شود"
            }
          ]
        },
        {
          "question": "دو کوئری SELECT با ستون‌های یکسان با UNION ترکیب می‌شوند. اگر هر دو کوئری یک ردیف یکسان برگردانند، چند نسخه از آن ردیف در نتیجه نهایی ظاهر می‌شود؟",
          "options": [
            {
              "icon": "",
              "label": "یک — UNION دوبلیکات ردیف‌ها را در نتیجه ترکیب‌شده حذف می‌کند؛ UNION ALL هر دو نسخه را نگاه می‌دارد"
            },
            {
              "icon": "",
              "label": "دو — UNION هر ردیفی از هر دو کوئری را نگاه می‌دارد"
            },
            {
              "icon": "",
              "label": "صفر — UNION هر ردیفی که در هر دو کوئری ظاهر شود حذف می‌کند"
            },
            {
              "icon": "",
              "label": "بستگی به دارد کدام کوئری ردیف را اول درج کرد"
            }
          ]
        },
        {
          "question": "جدول sizes 3 ردیف و colors 4 ردیف دارد. SELECT * FROM sizes CROSS JOIN colors چند ردیف برمی‌گرداند؟",
          "options": [
            {
              "icon": "",
              "label": "7 — CROSS JOIN تعداد ردیف‌ها را جمع می‌کند"
            },
            {
              "icon": "",
              "label": "12 — یک CROSS JOIN هر ترکیب ممکنی از ردیف‌های هر دو جدول را برمی‌گرداند (3 x 4)"
            },
            {
              "icon": "",
              "label": "3 — CROSS JOIN یک ردیف برای هر ردیفی در جدول اول برمی‌گرداند"
            },
            {
              "icon": "",
              "label": "0 — CROSS JOIN یک ON condition نیاز دارد یا چیزی برنمی‌گرداند"
            }
          ]
        },
        {
          "question": "orders دارای 1 ردیف برای order #100، و order_items دارای 3 ردیف برای order #100 (یک برای هر line item) است. شما SELECT o.id, o.total FROM orders o JOIN order_items i ON o.id = i.order_id WHERE o.id = 100 را اجرا می‌کنید. برای order #100 چند ردیف برمی‌آید؟",
          "options": [
            {
              "icon": "",
              "label": "3 — join یک ردیف output برای هر matching order_items ردیف تولید می‌کند، بنابراین ردیف یک‌تای order #100 یک بار برای هر line item تکرار می‌شود"
            },
            {
              "icon": "",
              "label": "1 — orders فقط یک ردیف برای order #100 دارد، بنابراین join نمی‌تواند بیشتر تولید کند"
            },
            {
              "icon": "",
              "label": "4 — یک ردیف برای order به اضافه یک برای هر line item"
            },
            {
              "icon": "",
              "label": "0 — پیوست دادن جدول یک‌ردیفی به جدول سه‌ردیفی بر روی یک non-unique key ناموفق است"
            }
          ]
        },
        {
          "question": "SELECT c.name, o.id FROM customers c RIGHT JOIN orders o ON c.id = o.customer_id ردیف‌های یکسانی را برمی‌گرداند که کدام یک از این‌ها؟",
          "options": [
            {
              "icon": "",
              "label": "SELECT c.name, o.id FROM customers c INNER JOIN orders o ON c.id = o.customer_id"
            },
            {
              "icon": "",
              "label": "SELECT c.name, o.id FROM orders o LEFT JOIN customers c ON c.id = o.customer_id — تعویض ترتیب جدول و استفاده LEFT JOIN به جای RIGHT JOIN معادل است"
            },
            {
              "icon": "",
              "label": "SELECT c.name, o.id FROM customers c LEFT JOIN orders o ON c.id = o.customer_id"
            },
            {
              "icon": "",
              "label": "SELECT c.name, o.id FROM orders o CROSS JOIN customers c"
            }
          ]
        },
        {
          "question": "در SQL استاندارد، شما SELECT department, name, AVG(salary) FROM employees GROUP BY department را اجرا می‌کنید. آیا این یک کوئری معتبر است؟",
          "options": [
            {
              "icon": "",
              "label": "بلی — GROUP BY فقط نیاز به شامل department کند زیرا اول درج شده است"
            },
            {
              "icon": "",
              "label": "خیر — name انتخاب شده است اما نه aggregated نه درج GROUP BY، و SQL استاندارد نیاز دارد هر ستون non-aggregated انتخاب‌شده در GROUP BY clause ظاهر شود"
            },
            {
              "icon": "",
              "label": "بلی — SQL خودکار یک name دل‌خواه برای هر department انتخاب می‌کند"
            },
            {
              "icon": "",
              "label": "خیر — AVG() نمی‌تواند با GROUP BY در کوئری یکسان ترکیب شود"
            }
          ]
        },
        {
          "question": "شما می‌خواهید departments که average salary آن‌ها بیش از 80000 است. کدام clause بر روی مقدار aggregated مثل AVG(salary) بعد از grouping فیلتر می‌کند — WHERE یا HAVING؟",
          "options": [
            {
              "icon": "",
              "label": "WHERE — HAVING فقط با UNION queries استفاده می‌شود"
            },
            {
              "icon": "",
              "label": "هر یک از آن‌ها یکسان با aggregate functions کار می‌کند"
            },
            {
              "icon": "",
              "label": "هیچ یک — aggregate filtering یک subquery نیاز دارد"
            },
            {
              "icon": "",
              "label": "HAVING — WHERE ردیف‌های individual را قبل از grouping فیلتر می‌کند، HAVING groups را بعد از aggregation فیلتر می‌کند"
            }
          ]
        },
        {
          "question": "شما SELECT salary * 1.1 AS new_salary FROM employees WHERE new_salary > 50000 را می‌نویسید. آیا این اجرا می‌شود؟",
          "options": [
            {
              "icon": "",
              "label": "بلی — aliases تعریف‌شده در SELECT همیشه برای WHERE در کوئری یکسان دسترسی‌پذیر هستند"
            },
            {
              "icon": "",
              "label": "بلی، اما فقط برای numeric aliases"
            },
            {
              "icon": "",
              "label": "خیر — AS در یک کوئری WHERE-filtered مجاز نیست"
            },
            {
              "icon": "",
              "label": "خیر — WHERE قبل از SELECT alias جدید را تخصیص دهد ارزیابی می‌شود، بنابراین alias هنوز در آن نقطه اجرا موجود نیست"
            }
          ]
        },
        {
          "question": "SELECT name FROM employees e WHERE salary > (SELECT AVG(salary) FROM employees WHERE department = e.department). چرا این یک correlated subquery نام‌برده می‌شود؟",
          "options": [
            {
              "icon": "",
              "label": "زیرا از JOIN به جای WHERE clause استفاده می‌کند"
            },
            {
              "icon": "",
              "label": "inner subquery e.department را از outer query ارجاع‌دهی می‌کند، بنابراین باید برای هر ردیفی که outer query در نظر می‌گیرد re-evaluated شود"
            },
            {
              "icon": "",
              "label": "زیرا بیش از یک ستون برمی‌گرداند"
            },
            {
              "icon": "",
              "label": "زیرا دقیقاً یک بار قبل از outer query شروع اجرا می‌شود"
            }
          ]
        },
        {
          "question": "یک subquery SELECT manager_id FROM employees برخی NULL values را بر روی id‌های واقعی برمی‌گرداند. شما SELECT name FROM employees WHERE id NOT IN (SELECT manager_id FROM employees) را اجرا می‌کنید. چه اتفاق می‌افتد؟",
          "options": [
            {
              "icon": "",
              "label": "هر employee که manager نیست برمی‌گرداند، NULL‌ها را نادیده می‌گیرد"
            },
            {
              "icon": "",
              "label": "صفر ردیف برمی‌گرداند — یک NULL در NOT IN list هر مقایسه را UNKNOWN می‌کند، بنابراین ردیفی نمی‌تواند شرط را برآورده کند"
            },
            {
              "icon": "",
              "label": "یک error برمی‌گرداند زیرا NOT IN نمی‌تواند با subqueries استفاده شود"
            },
            {
              "icon": "",
              "label": "هر employee را برمی‌گرداند، زیرا NULL به‌عنوان wildcard درمان می‌شود"
            }
          ]
        },
        {
          "question": "SELECT name FROM customers c WHERE EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.id). این چه برمی‌گرداند؟",
          "options": [
            {
              "icon": "",
              "label": "هر customer که حداقل یک ردیفی در orders دارد — EXISTS فقط بررسی می‌کند آیا subquery هر ردیفی برمی‌گرداند، نه مقادیری که شامل دارند"
            },
            {
              "icon": "",
              "label": "هر customer، زیرا SELECT 1 همیشه true برمی‌گرداند"
            },
            {
              "icon": "",
              "label": "یک error، زیرا subquery یک عدد برای column name می‌گذارد"
            },
            {
              "icon": "",
              "label": "فقط customers با دقیقاً یک order"
            }
          ]
        },
        {
          "question": "شما SELECT name, (SELECT order_id FROM orders WHERE customer_id = c.id) AS last_order FROM customers c را می‌نویسید، و یک customer معیّن 3 ردیف در orders دارد. وقتی این کوئری اجرا می‌شود چه اتفاق می‌افتد؟",
          "options": [
            {
              "icon": "",
              "label": "اولین order_id تطابق‌دهنده را برمی‌گرداند و ساکت دو تای دیگر را نادیده می‌گیرد"
            },
            {
              "icon": "",
              "label": "یک comma-separated list از هر سه order_ids برمی‌گرداند"
            },
            {
              "icon": "",
              "label": "3 ردیف برای آن customer برمی‌گرداند، یک برای هر order"
            },
            {
              "icon": "",
              "label": "یک error در runtime برمی‌گرداند — یک scalar subquery در SELECT list باید حداکثر یک ردیف برگرداند، و این یک سه‌تایی برمی‌گرداند"
            }
          ]
        },
        {
          "question": "چهار ردیف برای بالاترین score تطابق دارند. RANK() ORDER BY score DESC استفاده می‌کند، هر چهار rank 1 دریافت می‌کنند. ردیف بعدی رو به پایین چه rank دریافت می‌کند؟",
          "options": [
            {
              "icon": "",
              "label": "5 — RANK() یک gap برابر تعداد tied rows قبل از ادامه می‌گذارد"
            },
            {
              "icon": "",
              "label": "2 — RANK() همیشه دقیقاً یک بعد از هر tie افزایش می‌یابد"
            },
            {
              "icon": "",
              "label": "1 — هر ردیف بعدی نیز rank 1 دریافت می‌کند"
            },
            {
              "icon": "",
              "label": "4 — RANK() شمارش را از تعداد ties دوباره شروع می‌کند"
            }
          ]
        },
        {
          "question": "چهار ردیف برای بالاترین score تطابق دارند. DENSE_RANK() ORDER BY score DESC استفاده می‌کند، هر چهار rank 1 دریافت می‌کنند. ردیف بعدی رو به پایین چه rank دریافت می‌کند؟",
          "options": [
            {
              "icon": "",
              "label": "5 — DENSE_RANK() دقیقاً مثل RANK() رفتار می‌کند"
            },
            {
              "icon": "",
              "label": "1 — DENSE_RANK() rank یکسانی به هر ردیف باقی‌مانده تخصیص می‌دهد"
            },
            {
              "icon": "",
              "label": "2 — DENSE_RANK() هرگز gaps نمی‌گذارد، بنابراین مقدار distinct بعدی همیشه rank consecutive بعدی دریافت می‌کند"
            },
            {
              "icon": "",
              "label": "3 — DENSE_RANK() یک rank برای هر tie group رد می‌کند"
            }
          ]
        },
        {
          "question": "SUM(amount) OVER (PARTITION BY region ORDER BY amount) به یک کوئری اضافه می‌شود. اینجا PARTITION BY region چه می‌کند؟",
          "options": [
            {
              "icon": "",
              "label": "running sum را برای هر region جدا دوباره شروع می‌کند، به جای تجمیع در سراسر مجموعه نتایج"
            },
            {
              "icon": "",
              "label": "نتایج را به یک region فیلتر می‌کند"
            },
            {
              "icon": "",
              "label": "ردیف‌ها را جمع‌بندی و فروپاش می‌کند یک per region، مثل GROUP BY"
            },
            {
              "icon": "",
              "label": "regions را به‌ترتیب الفبایی قبل از summing ترتیب می‌دهد"
            }
          ]
        },
        {
          "question": "ROW_NUMBER() OVER (ORDER BY score DESC) به پنج ردیف اعمال می‌شود، دو آن‌ها دقیقاً در score تطابق دارند. آیا دو ردیف هرگز همان row number دریافت می‌کنند؟",
          "options": [
            {
              "icon": "",
              "label": "بلی — tied rows همیشه row number یکسانی را می‌دهند"
            },
            {
              "icon": "",
              "label": "فقط اگر PARTITION BY نیز استفاده شود"
            },
            {
              "icon": "",
              "label": "آن بستگی به دارد tie در اول یا آخر موضعیت شود"
            },
            {
              "icon": "",
              "label": "خیر — ROW_NUMBER() همیشه یک عدد صحیح منحصرفرد و strictly increasing به هر ردیف تخصیص می‌دهد، حتی وقتی مقادیر تطابق دارند"
            }
          ]
        },
        {
          "question": "WITH high_earners AS (SELECT * FROM employees WHERE salary > 100000) SELECT department, COUNT(*) FROM high_earners GROUP BY department. high_earners چیست؟",
          "options": [
            {
              "icon": "",
              "label": "یک common table expression (CTE) — یک مجموعه نتایج named، temporary که بقیه کوئری می‌تواند آن را مثل یک جدول ارجاع دهی کند"
            },
            {
              "icon": "",
              "label": "یک جدول دائمی ایجاد‌شده در پایگاه‌های داده"
            },
            {
              "icon": "",
              "label": "یک view که بعد از اتمام کوئری بر جای می‌ماند"
            },
            {
              "icon": "",
              "label": "یک stored procedure که باید به‌طور جداگانه فراخوانی شود"
            }
          ]
        },
        {
          "question": "یک ستون PRIMARY KEY اعلام می‌شود. آیا می‌توانید یک ردیف INSERT کنید جایی که آن ستون NULL است؟",
          "options": [
            {
              "icon": "",
              "label": "بلی — PRIMARY KEY فقط uniqueness را اجرا می‌کند، نه NULL-ness"
            },
            {
              "icon": "",
              "label": "بلی، اما فقط یک NULL ردیف مجاز است، مثل UNIQUE constraint"
            },
            {
              "icon": "",
              "label": "خیر — یک ستون PRIMARY KEY به‌صورت implicit NOT NULL است، بنابراین NULL insertion در آن رد می‌شود"
            },
            {
              "icon": "",
              "label": "آن بستگی به دارد ستون نیز یک default value داشته باشد"
            }
          ]
        },
        {
          "question": "یک transaction باز درون، شما یک UPDATE اجرا می‌کنید اما هنوز COMMIT را اجرا نکردید. از یک second، separate connection به پایگاه‌های داده، آیا آن update مرئی است؟",
          "options": [
            {
              "icon": "",
              "label": "بلی — تمام connections هر write را فوری می‌بینند"
            },
            {
              "icon": "",
              "label": "بلی، اما فقط اگر second connection نیز یک transaction باز کند"
            },
            {
              "icon": "",
              "label": "آن فقط بستگی دارد کدام جدول update شد"
            },
            {
              "icon": "",
              "label": "خیر — یک uncommitted change فقط درون transaction که آن را ساخته است مرئی است، تا COMMIT آن را durable و مرئی برای دیگران کند"
            }
          ]
        },
        {
          "question": "products.category_id یک FOREIGN KEY constraint دارد که به categories.id ارجاع می‌دهد. شما یک ردیف از categories که هنوز products pointing به آن دارد DELETE را سعی می‌کنید، بدون ON DELETE rule تعیین‌شده. چه اتفاق می‌افتد؟",
          "options": [
            {
              "icon": "",
              "label": "ردیف category DELETE می‌شود و matching products.category_id values خودکار به NULL تنظیم می‌شود"
            },
            {
              "icon": "",
              "label": "ردیف category DELETE می‌شود و هر product که به آن ارجاع‌دهی می‌کند DELETE می‌شود"
            },
            {
              "icon": "",
              "label": "DELETE رد می‌شود — default foreign key behavior DELETE یک referenced row را بند‌دارند‌دهی می‌کند در حالی‌که dependent rows هنوز به آن اشاره می‌کنند"
            },
            {
              "icon": "",
              "label": "DELETE موفق می‌شود ساکت، products' category_id را pointing در یک category که دیگر وجود ندارد می‌گذارد"
            }
          ]
        }
      ],
      "optionOrderVersion": "e0466e547cfd8a45"
    }
  }
}