SQL Functions, Aggregates and GROUP BYکردارەکانی SQL، کردارەکانی کۆکردنەوە و ⁦GROUP BY⁩

An SQL function does one job and gives back a value — exactly the idea of a function in PHP (what is a function?). MySQL has hundreds of built-in functions. You call one by its name with its arguments in brackets: ROUND(2912.564, 1) gives 2912.6.

کردارێکی SQL یەک کار دەکات و نرخێک دەگەڕێنێتەوە — ڕێک هەمان بیرۆکەی کردار لە PHP (کردار چییە؟). MySQL سەدان کرداری ئامادەی (Built-in function) هەیە. بە ناوەکەی و ئارگیومێنتەکان (Argument) لە ناو کەوانەدا بانگی دەکەیت: ROUND(2912.564, 1) 2912.6 دەدات.

All examples run on the shop database of the previous lesson (our example: a phone and computer shop). When MySQL and SQLite give different answers, both are shown.

هەموو نموونەکان لەسەر بنکەدراوەی (Database) دوکانەکەی وانەی پێشوو جێبەجێ دەکرێن (نموونەکەمان: دوکانێکی مۆبایل و کۆمپیوتەر). هەر کاتێک MySQL و SQLite وەڵامی جیاواز بدەن، هەردووکیان پیشان دەدرێن.

SQL functions come in two kinds, and the difference is about how many rows go in:

کردارەکانی SQL دوو جۆرن و جیاوازییەکەیان لە ژمارەی ئەو تۆمارانەدایە کە دەچنە ناویانەوە:

The two kinds differ in how many rows go in, how many results come out, and where in a query they may stand:

دوو جۆرەکە لەمانەدا جیاوازن: چەند تۆمار دەچێتە ناویان، چەند ئەنجام دەردەچێت و لە کوێی پرسێک دەتوانن بێن:

A negative number of places rounds to the left of the point: -1 to the nearest ten, -2 to the nearest hundred, -3 to the nearest thousand. For exact numbers MySQL rounds a half away from zero: ROUND(18750, -3) is 19000.

ئەگەر ژمارەی شوێنەکان سالب بێت، بۆ لای چەپی خاڵەکە خڕ دەکاتەوە: -1 بۆ نزیکترین دە، -2 بۆ نزیکترین سەد، -3 بۆ نزیکترین هەزار. بۆ ژمارە وردەکان MySQL نیوە بە دوور لە سفر خڕ دەکاتەوە: ROUND(18750, -3) دەبێتە 19000.

Shops in Kurdistan price in whole thousands of dinars. A 10 % price rise, rounded to the nearest thousand:

دوکانەکانی کوردستان بە هەزارانی تەواوی دینار قیمەت دادەنێن. بەرزکردنەوەی قیمەت بە ⁦10 %⁩، خڕکراوە بۆ نزیکترین هەزار:

The same function can change stored data inside UPDATE. Try it on a copy first, so a mistake costs nothing:

هەمان کردار دەتوانێت لە ناو UPDATE دراوەی (Data) هەڵگیراو بگۆڕێت. سەرەتا لەسەر کۆپییەک تاقی بکەرەوە، بۆ ئەوەی هەڵەیەک هیچ زیانێکی نەبێت:

MOD and FLOOR split a price into ten monthly instalments in whole thousands, plus the rest paid at once. A monthly payment is the price divided by 10, cut down to whole thousands — FLOOR(price_iqd / 10000) * 1000 — and what is left is MOD(price_iqd, 10000):

MOD و FLOOR قیمەتێک دابەش دەکەن بۆ دە قیستی مانگانە بە هەزارانی تەواو، لەگەڵ ئەوەی دەمێنێتەوە و یەکجار دەدرێت. قیستی مانگانە قیمەتەکەیە دابەش بە ⁦10⁩، کورتکراوە بۆ هەزارانی تەواو — FLOOR(price_iqd / 10000) * 1000 — و ئەوەی دەمێنێتەوە MOD(price_iqd, 10000)ـە:

A seller's commission (2 % of what they sold, rounded to whole dinars) needs the prices of the sold products, so it is computed after GROUP BY and a join: see GROUP BY over a join.

کۆمیسیۆنی فرۆشیارێک (⁦2 %⁩ی ئەوەی فرۆشتوویەتی، خڕکراوە بۆ دیناری تەواو) پێویستی بە قیمەتی کاڵا فرۆشراوەکانە، بۆیە دوای GROUP BY و لێکبەستنێک (Join) دەژمێردرێت: بڕوانە ⁦GROUP BY⁩ لەگەڵ لێکبەستن.

Text functions change, measure and cut strings. Positions in SQL start at 1, not 0.

کردارە دەقییەکان زنجیرەنووسەکان (String) دەگۆڕن، دەپێون و دەبڕن. شوێن لە SQLـدا لە 1ـەوە دەست پێدەکات، نەک 0.

CONCAT builds new text from columns. Careful with NULL: in MySQL one NULL argument makes the whole result NULL.

CONCAT لە ستوونەکان دەقی نوێ دروست دەکات. ئاگاداری NULL بە: لە MySQL یەک ئارگیومێنتی NULL هەموو ئەنجامەکە دەکاتە NULL.

The textbook says LENGTH returns the number of characters. That is only true for English letters. MySQL stores text as UTF-8 (character encoding), where an English letter takes one byte but a Kurdish (Arabic-script) letter takes two (UTF-8: one to four bytes). LENGTH counts bytes; CHAR_LENGTH counts characters:

کتێبەکە دەڵێت LENGTH ژمارەی نووسەکان دەگەڕێنێتەوە. ئەمە تەنها بۆ پیتی ئینگلیزی ڕاستە. MySQL دەق بە ⁦UTF-8⁩ (ئینکۆدینگ (Character encoding)) هەڵدەگرێت کە تێیدا پیتێکی ئینگلیزی یەک بایت دەگرێت، بەڵام پیتێکی کوردی (بە ئەلفوبێی عەرەبی) دوو (⁦UTF-8⁩: یەک تا چوار بایت). LENGTH بایتەکان دەژمێرێت؛ CHAR_LENGTH نووسەکان:

شیلان has five letters, and each is stored in two bytes, so LENGTH says 10. Use CHAR_LENGTH whenever you mean how many letters — for example to check that a name is not longer than its VARCHAR(40) column, because VARCHAR(n) also counts characters.

شیلان پێنج پیتە و هەر پیتێک لە دوو بایتدا هەڵدەگیرێت، بۆیە LENGTH دەڵێت ⁦10⁩. هەر کاتێک مەبەستت چەند پیتـە CHAR_LENGTH بەکار بهێنە — بۆ نموونە بۆ پشکنینی ئەوەی ناوێک لە ستوونی VARCHAR(40)ـەکەی درێژتر نییە، چونکە VARCHAR(n)ـیش نووسەکان دەژمێرێت.

INSTR finds where the @ is; LEFT and SUBSTRING cut before and after it. The user name is everything before the @ (position − 1 characters); the domain starts one position after it:

INSTR شوێنی @ دەدۆزێتەوە؛ LEFT و SUBSTRING پێش و دوای ئەو دەبڕن. ناوی بەکارهێنەر (Username) هەموو ئەوەیە کە پێش @ دێت (شوێن − 1 نووسە)؛ دۆمەین یەک شوێن دوای ئەو دەست پێدەکات:

TRIM can also remove a given text from one end. The textbook removes .com from e-mails; in MySQL that is TRIM(TRAILING '.com' FROM email):

TRIM دەتوانێت دەقێکی دیاریکراویش لە سەرێک لابەرێت. کتێبەکە ⁦.com⁩ لە ئیمەیڵەکان لادەبات؛ لە MySQL ئەوە TRIM(TRAILING '.com' FROM email)ـە:

Text functions also work in WHERE. The textbook's two activities, on our shop: brands that start with S in capitals, and the first ten characters of every long product name.

کردارە دەقییەکان لە WHEREـیش کار دەکەن. دوو چالاکییەکەی کتێبەکە، لەسەر دوکانەکەمان: ئەو براندانەی بە S دەست پێدەکەن بە پیتی گەورە و یەکەم دە نووسەی هەموو ناوێکی درێژی کاڵا.

Date functions read the clock or take a date apart. They return numbers (the year 2026), text (October) or a new date.

کردارەکانی بەروار کاتژمێر دەخوێننەوە یان بەروارێک دەکەنە بەش. ژمارە (ساڵی ⁦2026⁩)، دەق (October) یان بەرواری نوێ دەگەڕێننەوە.

The day, month and year of three sales (the textbook asks the same about the day each employee joined):

ڕۆژ، مانگ و ساڵی سێ فرۆشتن (کتێبەکە هەمان پرسیار دەربارەی ئەو ڕۆژە دەکات کە هەر فەرمانبەرێک دەستی بە کار کردووە):

A single-row function can be used inside WHERE. In Kurdistan, Friday is the main day off of the week, so the owner wants to know which sales happened on a Friday:

کرداری تاکڕیز دەتوانرێت لە ناو WHERE بەکار بهێنرێت. لە کوردستان هەینی ڕۆژی سەرەکیی پشووی هەفتەیە، بۆیە خاوەنی دوکانەکە دەیەوێت بزانێت کام فرۆشتن لە ڕۆژی هەینیدا بووە:

The other way round — every sale not on a Friday — is <>; 17 of the 20 sales. The textbook also shows such dates in a long form such as Wednesday, 2 September 2026; DATE_FORMAT does it in one step:

پێچەوانەکەی — هەموو فرۆشتنێک کە لە هەینیدا نەبووە — <>ـە؛ ⁦17⁩ لە ⁦20⁩ فرۆشتنەکە. کتێبەکە ئەم جۆرە بەروارانە بە شێوەیەکی درێژیش پیشان دەدات، وەک ⁦Wednesday, 2 September 2026⁩؛ DATE_FORMAT بە یەک هەنگاو ئەمە دەکات:

Five aggregate functions answer the questions every shop owner asks: how many, how much in total, on average, the least, the most. Without GROUP BY they treat all the rows that pass WHERE as one group.

پێنج کرداری کۆکردنەوە وەڵامی ئەو پرسیارانە دەدەنەوە کە هەموو خاوەن دوکانێک دەیانکات: چەند، کۆی گشتی چەند، بە تێکڕا، کەمترین، زۆرترین. بەبێ GROUP BY هەموو ئەو تۆمارانەی لە WHERE تێدەپەڕن وەک یەک گرووپ دادەنێن.

The total, the average, the cheapest and the dearest of the four phones:

کۆ، تێکڕا، هەرزانترین و گرانترینی چوار مۆبایلەکە:

AVG is the arithmetic mean you know from statistics (the mean of ungrouped data). It divides by the number of values, not rows. The laptops have stocks 4, NULL and 5:

AVG هەمان ناوەندی ژمێرەییە کە لە ئامارەوە دەیناسیت (ناوەندی داتای گرووپنەکراو). دابەشی ژمارەی نرخەکان دەکات، نەک تۆمارەکان. لاپتۆپەکان (Laptop) کۆگایان 4، NULL و 5ـە:

An aggregate can be combined with WHERE, and its column can get an alias. How many Samsung products are there, and what do they cost at least and at most?

کردارێکی کۆکردنەوە دەتوانرێت لەگەڵ WHERE تێکەڵ بکرێت و ستوونەکەی نازناوێک (Alias) وەربگرێت. چەند کاڵای Samsung هەیە و کەمترین و زۆرترین قیمەتیان چەندە؟

MIN and MAX compare any values that can be put in order: numbers by size, text alphabetically (by the collation), dates by time. The first and last product name, and the oldest and newest product:

MIN و MAX هەر نرخێک بەراورد دەکەن کە بتوانرێت ڕیز بکرێت: ژمارە بەپێی قەبارە، دەق بەپێی ئەلفوبێ (بەپێی ڕیزبەندیی پیت)، بەروار بەپێی کات. یەکەم و دوایین ناوی کاڵا و کۆنترین و نوێترین کاڵا:

The same works on the sales: SELECT MIN(sold_on), MAX(sold_on) FROM sales; gives the first and the last day of sales, 2026-09-02 and 2026-10-24.

هەمان شت لەسەر فرۆشتنەکان کار دەکات: SELECT MIN(sold_on), MAX(sold_on) FROM sales; یەکەم و دوایین ڕۆژی فرۆشتن دەدات، 2026-09-02 و 2026-10-24.

DISTINCT inside the brackets counts or adds every different value once. The 20 sales sold 27 items; the different quantities are 1, 2 and 3:

DISTINCT لە ناو کەوانەکاندا هەر نرخێکی جیاواز یەک جار دەژمێرێت یان کۆ دەکاتەوە. ⁦20⁩ فرۆشتنەکە ⁦27⁩ دانەیان فرۆشتووە؛ بڕە جیاوازەکان 1، 2 و 3ـن:

What happens when WHERE matches no row? Nobody paid by cheque:

چی ڕوودەدات کاتێک WHERE هیچ تۆمارێک نادۆزێتەوە؟ کەس بە چەک پارەی نەداوە:

In a report you usually want 0, not NULL. COALESCE gives it:

لە ڕاپۆرتدا زۆرجار 0ت دەوێت، نەک NULL. COALESCE ئەوە دەدات:

What is the most expensive product, and what is it called? A natural first try mixes a plain column with an aggregate:

گرانترین کاڵا کامەیە و ناوی چییە؟ یەکەم هەوڵی سروشتی ستوونێکی ئاسایی لەگەڵ کردارێکی کۆکردنەوە تێکەڵ دەکات:

MAX folds 12 rows into one value, but name still has 12 values. Which one should the single answer row show? Standard SQL says: with an aggregate and no GROUP BY, every other column must be inside an aggregate too. The three databases you may meet react differently:

MAX ⁦12⁩ تۆمار دەپێچێتەوە بۆ یەک نرخ، بەڵام name هێشتا ⁦12⁩ نرخی هەیە. یەک تۆمارەکەی وەڵامەکە کامیان پیشان بدات؟ SQLـی ستاندارد دەڵێت: لەگەڵ کردارێکی کۆکردنەوە و بەبێ GROUP BY، هەموو ستوونێکی تر دەبێت ئەویش لە ناو کردارێکی کۆکردنەوەدا بێت. ئەو سێ بنکەدراوەیەی لەوانەیە بیانبینیت بە شێوەی جیاواز وەڵام دەدەنەوە:

Do not depend on any of these. The portable answer asks two questions, one inside the other: first what is the highest price?, then which product has that price?. The inner SELECT in brackets is a subquery:

پشت بە هیچیان مەبەستە. وەڵامی گشتگیر دوو پرسیار دەکات، یەکێکیان لە ناو ئەوی تردا: یەکەم بەرزترین قیمەت چەندە؟، پاشان کام کاڵا ئەو قیمەتەی هەیە؟. SELECTـی ناوەوە لە ناو کەوانەدا ژێرپرسە (Subquery):

How many products are there in each category? Without grouping you would need one query per category — WHERE category = 'phone', then 'laptop', and so on — and you would first have to know every category. GROUP BY does it in one query:

لە هەر جۆرێکدا چەند کاڵا هەیە؟ بەبێ گرووپکردن بۆ هەر جۆرێک پرسێک پێویست دەبوو — WHERE category = 'phone'، پاشان 'laptop' و هتد — و دەبوو سەرەتا هەموو جۆرەکان بزانیت. GROUP BY بە یەک پرس ئەمە دەکات:

SQL puts the rows with the same category into one group and runs every aggregate once per group: one answer row for each of the four categories.

SQL ئەو تۆمارانەی هەمان categoryـیان هەیە دەخاتە یەک گرووپ و هەموو کردارێکی کۆکردنەوە بۆ هەر گرووپێک یەک جار جێبەجێ دەکات: یەک تۆماری وەڵام بۆ هەر یەک لە چوار جۆرەکە.

The sales of each seller, and the number of sales of each payment type — the textbook's cars sold by each employee and payments per payment mode, on our shop:

فرۆشتنەکانی هەر فرۆشیارێک و ژمارەی فرۆشتنی هەر جۆرێکی پارەدان — ئۆتۆمبێلی فرۆشراو لەلایەن هەر فەرمانبەرێکەوە و پارەدان بەپێی جۆری پارەدانـی کتێبەکە، لەسەر دوکانەکەمان:

NULLs form a group of their own: the power bank with no brand gets its own row (MySQL's manual: two NULL values are regarded as equal in a GROUP BY).

NULLـەکان گرووپێکی تایبەت بە خۆیان پێکدەهێنن: پاوەر بانکە بێ براندەکە تۆمارێکی تایبەت بە خۆی وەردەگرێت (ڕێبەری MySQL: دوو نرخی NULL لە ⁦GROUP BY⁩ـدا وەک یەکسان هەژمار دەکرێن).

You can group by an expression, such as the month of a date. Sales and items per month:

دەتوانیت بەپێی دەربڕینێک (Expression) گرووپ بکەیت، وەک مانگی بەروارێک. فرۆشتن و دانەکان بۆ هەر مانگێک:

Brands and prices are in products, quantities in sales. An INNER JOIN puts each sale next to its product (joins); then GROUP BY works on the joined rows. AS s and AS p are short aliases for the tables:

براند و قیمەت لە productsـدان، بڕەکان لە salesـدا. INNER JOIN هەر فرۆشتنێک لە تەنیشت کاڵاکەی دادەنێت (لێکبەستنەکان)؛ پاشان GROUP BY لەسەر تۆمارە بەستراوەکان کار دەکات. AS s و AS p نازناوی کورتن بۆ خشتەکان:

Each seller earns a 2 % commission on what they sold, rounded to whole dinars — the textbook's commission example, now per seller:

هەر فرۆشیارێک ⁦2 %⁩ی ئەوەی فرۆشتوویەتی وەک کۆمیسیۆن وەردەگرێت، خڕکراوە بۆ دیناری تەواو — نموونەی کۆمیسیۆنی کتێبەکە، ئێستا بۆ هەر فرۆشیارێک:

WHERE filters rows before they are grouped. HAVING clause filters groups after GROUP BY, so it may use aggregates. The textbook's question which payment types were used more than twice? needs HAVING:

WHERE پێش گرووپکردن تۆمارەکان دەپاڵێوێت. بڕگەی HAVING دوای GROUP BY گرووپەکان دەپاڵێوێت، بۆیە دەتوانێت کردارەکانی کۆکردنەوە بەکار بهێنێت. پرسیاری کتێبەکە کام جۆری پارەدان زیاتر لە دوو جار بەکار هاتووە؟ پێویستی بە HAVINGـە:

An aggregate cannot go in WHERE, because when WHERE runs there are no groups yet:

کردارێکی کۆکردنەوە ناتوانێت لە WHEREـدا بێت، چونکە کاتێک WHERE کار دەکات هێشتا هیچ گرووپێک نییە:

A condition on rows and a condition on groups can work together. Cash sales per seller, only for sellers with at least three of them:

مەرجێک لەسەر تۆمارەکان و مەرجێک لەسەر گرووپەکان دەتوانن پێکەوە کار بکەن. فرۆشتنی نەختینە بۆ هەر فرۆشیارێک، تەنها بۆ ئەو فرۆشیارانەی لانیکەم سێیان هەیە:

One more, from a database course's review notes: the average price of every category that has at least three products.

یەکێکی تر، لە تێبینییەکانی پێداچوونەوەی کۆرسێکی بنکەدراوە: تێکڕای قیمەتی هەر جۆرێک کە لانیکەم سێ کاڵای هەیە.

For each category, find the cheapest product that costs at least 20,000 IQD — but only for categories that have at least two such products.

بۆ هەر جۆرێک، هەرزانترین ئەو کاڵایە بدۆزەرەوە کە لانیکەم ⁦20,000⁩ دینارە — بەڵام تەنها بۆ ئەو جۆرانەی لانیکەم دوو کاڵای وایان هەیە.

Add one more wish: … and every product of the category costs at most 1,000,000 IQD. Standard SQL has an aggregate for every row is true, EVERY(price_iqd <= 1000000). MySQL and SQLite do not have it:

داواکارییەکی تر زیاد بکە: … و هەموو کاڵایەکی ئەو جۆرە لە ⁦1,000,000⁩ دینار زیاتر نییە. SQLـی ستاندارد کردارێکی کۆکردنەوەی بۆ هەموو تۆمارێک ڕاستە هەیە، EVERY(price_iqd <= 1000000). MySQL و SQLite ئەوەیان نییە:

Think about it differently: every price is at most 1,000,000 means the largest price is at most 1,000,000. So write MAX(…) <= …:

بە شێوەیەکی تر بیری لێ بکەرەوە: هەموو قیمەتێک لە ⁦1,000,000⁩ زیاتر نییە واتە گەورەترین قیمەت لە ⁦1,000,000⁩ زیاتر نییە. بۆیە بنووسە MAX(…) <= …:

And at least one product costs at most 1,000,000 (standard ANY or SOME) means the smallest price is at most 1,000,000: MIN(…) <= …. Then the phone group stays, thanks to its cheaper phones:

و لانیکەم یەک کاڵا لە ⁦1,000,000⁩ زیاتر نییە (ANY یان SOMEـی ستاندارد) واتە بچووکترین قیمەت لە ⁦1,000,000⁩ زیاتر نییە: MIN(…) <= …. ئەو کاتە گرووپی phone دەمێنێتەوە، بەهۆی مۆبایلە هەرزانترەکانیەوە:

Is every product costs at most 1,000,000 the same as removing the expensive rows first with WHERE? Try it:

ئایا هەموو کاڵایەک لە ⁦1,000,000⁩ زیاتر نییە هەمان لابردنی کاڵا گرانەکانە بە WHERE لە سەرەتادا؟ تاقی بکەرەوە:

No. WHERE throws away the iPhone row before grouping, so the phone group still has three cheaper phones and stays. With MAX(price_iqd) <= 1000000 in HAVING, the whole phone group is judged and dropped. On this data the WHERE version gives the same rows as the some row (MIN) version — but only by chance.

نەخێر. WHERE تۆماری iPhone پێش گرووپکردن فڕێ دەدات، بۆیە گرووپی phone هێشتا سێ مۆبایلی هەرزانتری تێدایە و دەمێنێتەوە. لەگەڵ MAX(price_iqd) <= 1000000 لە HAVING، هەموو گرووپی phone هەڵدەسەنگێنرێت و لادەبرێت. لەسەر ئەم دراوەیە شێوەی WHERE هەمان تۆمارەکانی شێوەی هەندێک تۆمار (MIN) دەدات — بەڵام تەنها بە ڕێکەوت.

Here is the full shape of a SELECT. The parts must be written in this order; the parts in square brackets are optional.

ئەمە شێوەی تەواوی فەرمانی SELECTـە. بەشەکان دەبێت بەم ڕیزبەندییە بنووسرێن؛ ئەو بەشانەی لە ناو کەوانەی چوارگۆشەدان هەڵبژاردەن.

SQL does not read a query in the order it is written. Logically it works through these steps, each one handing a smaller table to the next:

SQL پرسێک بەو ڕیزبەندییە ناخوێنێتەوە کە نووسراوە. بە شێوەی لۆجیکی بەم هەنگاوانەدا دەڕوات و هەر یەکێکیان خشتەیەکی بچووکتر دەداتە هەنگاوی دواتر:

Only SELECT is always needed. The table shows when each of the other parts is used:

تەنها SELECT هەمیشە پێویستە. خشتەکە پیشان دەدات هەر یەک لە بەشەکانی تر کەی بەکار دێت:

This order explains the rules of both SQL lessons: an alias cannot be used in WHERE (it is born at step 5) but can be used in ORDER BY (step 7); an aggregate cannot be used in WHERE (no groups yet) but can in HAVING, SELECT and ORDER BY. The database may use a faster plan inside, but the answer is always the same as if it had followed these steps. The most popular products, sorted by an aggregate alias:

ئەم ڕیزبەندییە یاساکانی هەردوو وانەی SQL ڕوون دەکاتەوە: نازناو لە WHEREـدا بەکار نایەت (لە هەنگاوی 5دا لەدایک دەبێت) بەڵام لە ORDER BYـدا بەکار دێت (هەنگاوی ⁦7⁩)؛ کرداری کۆکردنەوە لە WHEREـدا بەکار نایەت (هێشتا هیچ گرووپێک نییە) بەڵام لە HAVING، SELECT و ORDER BYـدا بەکار دێت. بنکەدراوەکە لەوانەیە لە ناوەوە پلانێکی خێراتر بەکار بهێنێت، بەڵام وەڵامەکە هەمیشە وەک ئەوەیە کە ئەم هەنگاوانەی گرتبێتە بەر. بەناوبانگترین کاڵاکان، ڕیزکراو بەپێی نازناوی کردارێکی کۆکردنەوە:

Grouping is everywhere that data is summarised:

گرووپکردن لە هەموو ئەو شوێنانەدایە کە دراوە کورت دەکرێتەوە:

All tasks use the shop database. They follow the exercise ideas of the course's textbook chapter and lecture slides, moved to our shop.

هەموو ئەرکەکان بنکەدراوەی دوکانەکە بەکار دەهێنن. بیرۆکەی ڕاهێنانەکانی بەشی کتێبەکە و سلایدەکانی وانەی کۆرسەکە دەگرنەبەر کە گوازراونەتەوە بۆ دوکانەکەمان.