SQL در مقابل NoSQL در 7 مثال

دیتابیس های رابطه ای یا Relational داده ها را به صورت جدول با ردیف ها و ستون های لیبل دار ذخیره می کنند. اگرچه دیتابیس های Relational معمولاً یک راه حل مناسب برای ذخیره سازی داده ها ارائه می دهند، اما سرعت و مقیاس پذیری در برخی موارد ممکن است مسئله ساز باشد.

SQL (Structured Query Language) توسط اکثر سیستم های مدیریت دیتابیس رابطه ای برای مدیریت دیتابیس هایی که داده ها را به صورت جدول ذخیره می کنند استفاده می شود. NoSQL به طراحی پایگاه داده غیر SQL یا غیر رابطه ای اشاره دارد. که هنوز هم یک روش سازمان یافته برای ذخیره سازی داده ها را ارائه می دهد اما به شکل جدول نیست.

اگر نگرانی در مورد سرعت و مقیاس پذیری را کنار بگذارید، هر دو پایگاه داده SQL و NoSQL روش های متنوع و کارآمدی را برای کوئری داده ها ارائه می دهند. این برای یک پایگاه داده ضروری است زیرا قابلیت دسترسی نیز از اهمیت حیاتی برخوردار است.

در این مقاله، ما 8 مثال را نشان خواهیم داد که نحوه کوئری از پایگاه داده SQL و NoSQL را نشان می دهد. این مثالها شامل چگونگی موارد زیر است:

  • داده ها را بر اساس شرط انتخاب کنید
  • موارد جدید را وارد کنید
  • موارد موجود را به روز کنید
  •  aggregation function ها را اعمال کنید

ما تسک های یکسانی را در هر دو پایگاه داده انجام می دهیم تا بتوانیم تفاوت ها و شباهت ها را ببینیم.

من از MySQL برای SQL و MongoDB برای NoSQL استفاده خواهم کرد. قبل از شروع با مثال ها، بیایید به طور خلاصه نحوه ذخیره سازی داده ها در SQL و NoSQL را توضیح دهیم.

SQL داده ها را به صورت جدول با ردیف ها و ستون های لیبل دار ذخیره می کند. ساختارهای متداول سازگار شده توسط پایگاه های داده NoSQL برای ذخیره داده ها عبارتند از جفت های key-value، ستون عریض ، گراف یا داکیومنت. MongoDB داده ها را به عنوان داکیومنت هاذخیره می کند. یک داکیومنت در MongoDB از جفت های field-value تشکیل شده است. داکیومنت ها در ساختاری به نام "collection" سازمان یافته اند. برای تشبیه، می توانیم داکیومنت ها را به عنوان سطرهای یک جدول و collection ها را به عنوان جداول در نظر بگیریم.

ما یک جدول ساده در MySQL و collection در MongoDB با داده های مشابه ایجاد کرده ایم که شامل ویژگی های برخی اتومبیل ها و قیمت آنها است.

در اینجا داکیومنتی وجود دارد که یک آیتم را در car collection مشخص می کند:

        
{
    "_id" : ObjectId("600c626932e0e6419cee81a7"),
    "year" : "2017",
    "make" : "hyundai",
    "color" : "white",
    "km" : 22000,
    "price" : 32000
}
        
    

در SQL، یک data point (در مورد ما یک ماشین) توسط یک ردیف مشخص می شود.

        
+------+---------+-------+-------+-------+
| year | make    | color | km    | price |
+------+---------+-------+-------+-------+
| 2017 | hyundai | white | 22000 | 32000 |
+------+---------+-------+-------+-------+
        
    

مثال 1

اتومبیل های ساخت Ford را پیدا کنید.

NoSQL (MongoDB):

شرط را به تابع find منتقل می کنیم. "db" به پایگاه داده فعلی اشاره دارد و "car" همان collection یی است که ما از آن سوال (کوئری)می کنیم.

        
> db.car.find( {make: "ford"} ).limit(1).pretty()
{
 "_id" : ObjectId("600c63cf32e0e6419cee81ab"),
 "year" : "2017",
 "make" : "ford",
 "color" : "black",
 "km" : 34000,
 "price" : 28000
}
        
    

بیش از یک اتومبیل ساخته شده توسط فورد وجود دارد اما ما از تابع limit برای نمایش فقط یکی استفاده می کنیم.

تابع pretty باعث خوانایی و جذابیت بیشتر خروجی می شود. در اینجا نحوه عملکرد آن بدون تابع pretty نشان داده شده است.

        
> db.car.find( {make: "ford"} ).limit(1)
{ "_id" : ObjectId("600c63cf32e0e6419cee81ab"), "year" : "2017", "make" : "ford", "color" : "black", "km" : 34000, "price" : 28000 }
        
    

SQL (MySQL):

همه ستون ها را انتخاب می کنیم (*) و شرط را در where مشخص می کنیم.

        
mysql> select * from car
    -> where make = "ford"
    -> limit 1;
+------+------+-------+-------+-------+
| year | make | color | km    | price |
+------+------+-------+-------+-------+
| 2017 | ford | black | 34000 | 28000 |
+------+------+-------+-------+-------+
        
    

مثال 2

خودروهای ساخته شده توسط فورد در سال 2019 را پیدا کنید.

NoSQL (MongoDB):

ما می توانیم چندین شرط را با کاما از هم جدا کنیم تا منطق "and" روی شروط را نشان دهیم.

    
> db.car.find( {make: "ford", year: "2019"} ).pretty()
{
 "_id" : ObjectId("600c63cf32e0e6419cee81af"),
 "year" : "2019",
 "make" : "ford",
 "color" : "white",
 "km" : 8000,
 "price" : 42000
}

SQL (MySQL):

شبیه نمونه قبلی است. با استفاده از عملگر and می توان چندین شرط را در  where ترکیب کرد.

        
    mysql> select * from car
    -> where make = "ford" and year = "2019";
    +------+------+-------+------+-------+
    | year | make | color | km | price |
    +------+------+-------+------+-------+
    | 2019 | ford | white | 8000 | 42000 |
    +------+------+-------+------+-------+

مثال 3

خودروهای ساخت فورد یا هیوندای در سال 2017 را پیدا کنید.

NoSQL (MongoDB):

ما ابتدا شرط مربوط به برند را با منطق "or" ترکیب کرده و سپس با استفاده از منطق "and" با سال ترکیب می کنیم. عملگر "$in" می تواند برای منطق "or" استفاده شود.

    
> db.car.find( {make: {$in: ["ford","hyundai"] } , year: "2017"} ).pretty()
{
 "_id" : ObjectId("600c626932e0e6419cee81a7"),
 "year" : "2017",
 "make" : "hyundai",
 "color" : "white",
 "km" : 22000,
 "price" : 32000
}
{
 "_id" : ObjectId("600c63cf32e0e6419cee81ab"),
 "year" : "2017",
 "make" : "ford",
 "color" : "black",
 "km" : 34000,
 "price" : 28000
}

SQL (MySQL):

where عملگر "in" را می پذیرد بنابراین می توانیم شروطی مشابه NoSQL را مشخص کنیم.

        
    mysql> select * from car
    -> where make in ("ford","hyundai") and year = "2017";
    +------+---------+-------+-------+-------+
    | year | make | color | km | price |
    +------+---------+-------+-------+-------+
    | 2017 | hyundai | white | 22000 | 32000 |
    | 2017 | ford | black | 34000 | 28000 |
    +------+---------+-------+-------+-------+

مثال 4

یک آیتم جدید وارد کنید.

NoSQL (MongoDB):

از تابع "insertOne" برای درج یک document واحد در یک collection استفاده می شود. ما باید جفت های field-value داکیومنت جدید را بنویسیم.

    
> db.car.insertOne(
... {year: "2017", make: "bmw", color: "silver", 
...  km: 28000, price: 39000}
... )
{
 "acknowledged" : true,
 "insertedId" : ObjectId("600c6bc79445b834692e3b91")
}

SQL (MySQL):

از تابع "insert into" برای افزودن یک ردیف جدید به جدول استفاده می شود. برخلاف NoSQL، نیازی به نوشتن نام ستون ها نداریم. با این حال، ترتیب مقادیر باید با ترتیب ستون های جدول مطابقت داشته باشد.

    
mysql> insert into car values
    -> ("2017", "bmw", "silver", 28000, 39000);
Query OK, 1 row affected (0.03 sec)

مثال 5

برند "bmw" را با "BMW" آپدیت کنید.

NoSQL (MongoDB):

از تابع update استفاده می شود. ما ابتدا شرطی را نشان می دهیم که داکیومنت ها را آپدیت می کند و سپس مقادیر update شده را به همراه keyword تنظیم شده ارسال می کنیم.

    
> db.car.update(
... { make: "bmw" },
... { $set: { make: "BMW" }},
... { multi: true }
... )
WriteResult({ "nMatched" : 5, "nUpserted" : 0, "nModified" : 5 })


برای update تمام داکیومنت هایی که شرایط ارائه شده را دارند، باید از پارامتر multi استفاده کنیم. در غیر این صورت، فقط یک داکیومنت به روز می شود.

SQL (MySQL):

ما از دستور update به صورت زیر استفاده می کنیم:

        
    mysql> update car
    -> set make = "BMW"
    -> where make = "bmw";
    Query OK, 5 rows affected (0.05 sec)
    Rows matched: 5 Changed: 5 Warnings: 0

مثال 6

هر دو SQL و NoSQL هنگام پرس و جو از یک پایگاه داده از نظر data aggregation بسیار متنوع هستند. به عنوان مثال، ما به راحتی می توانیم قیمت متوسط هر برند را محاسبه کنیم.

NoSQL (MongoDB):

ما از تابع aggregate استفاده می کنیم.

    
> db.car.aggregate([
... { $group: { _id: "$make", avg_price: { $avg: "$price" }}}
... ])
{ "_id" : "hyundai", "avg_price" : 36333.333333333336 }
{ "_id" : "BMW", "avg_price" : 47400 }
{ "_id" : "ford", "avg_price" : 35333.333333333336 }

ما ابتدا داکیومنت ها را بر اساس برند ها با انتخاب "$ make" به عنوان id گروه بندی می کنیم. قسمت بعدی هم تابع aggregation را که "$avg است مشخص می کند و هم فیلدی را که باید aggregate شود.

اگر با Pandas آشنا باشید، syntax کاملاً شبیه تابع groupby است.

SQL (MySQL):

group by برای گروه بندی ردیف ها بر اساس دسته بندی ها در ستون داده شده استفاده می شود. تابع aggregate هنگام انتخاب ستون اعمال می شود.

    
mysql> select make, avg(price)
    -> from car
    -> group by make;
+---------+------------+
| make    | avg(price) |
+---------+------------+
| BMW     | 47400.0000 |
| ford    | 35333.3333 |
| hyundai | 36333.3333 |
+---------+------------+

مثال 7

ما می توانیم شرایط را در تابع aggregate پیاده سازی کنیم. برای هر برند، بیایید میانگین قیمت خودروهای ساخته شده در سال 2019 را محاسبه کنیم.

NoSQL (MongoDB):

ما فقط باید کلمه کلیدی match را اضافه کنیم تا شروط را مشخص کنیم.

    
> db.car.aggregate([
... { $match: { year: "2019" }},
... { $group: { _id: "$make", avg_price: { $avg: "$price" }}}
... ])
{ "_id" : "BMW", "avg_price" : 53000 }
{ "_id" : "ford", "avg_price" : 42000 }
{ "_id" : "hyundai", "avg_price" : 41000 }

SQL (MySQL):
ما از where و group by با توجه به شروط زیراستفاده می کنیم:
mysql> select make, avg(price)
    -> from car
    -> where year = "2019"
    -> group by make;
+---------+------------+
| make    | avg(price) |
+---------+------------+
| BMW     | 53000.0000 |
| ford    | 42000.0000 |
| hyundai | 41000.0000 |
+---------+------------+

نتیجه

ما 7 مثال را نشان داده ایم که عملیات اساسی را برای  پایگاه داده های SQL و NoSQL نشان می دهد.

هر دوی آنها توابع و متدهای بسیار بیشتری را برای ایجاد کوئری پیشرفته تر ارائه می دهند. در نتیجه، از آنها می توان به عنوان ابزار تجزیه و تحلیل و دستکاری داده ها نیز استفاده کرد.

با تشکر از شما برای خواندن این مقاله، لطفا در صورت داشتن هرگونه بازخورد به ما اطلاع دهید.

× در حال پاسخ به: