SQL-də JSON: SQLite və PostgreSQL

JSON sütununu nə vaxt işlətmək olar, SQLite-da `json_extract`, `->`, `->>`, `json_each` və `json_group_array`, PostgreSQL-də `json` ilə `jsonb` fərqi, operatorlar və GIN indeksləri — və JSON-un sxemi korladığı hallar.

  • İrəli
  • 22 dəq
  • 12 sual
  • 28 dərsdən 21-cisi

Bu dərsdə öyrənəcəksən

  • JSON-u SQLite-da yoxlanılan mətn kimi saxlamaq və json_extract, ->, ->> ilə qiymətləri oxumaq
  • Massivləri json_each ilə sətirlərə açmaq, json_object və json_group_array ilə JSON qurmaq
  • PostgreSQL-də json və jsonb-ni, @>, ? operatorlarını və GIN indeksini izah etmək
  • Hansı məlumatın JSON-da, hansının adi sütunda qalmalı olduğunu seçmək

Mağazada noutbukun yaddaşı, monitorun diaqonalı, qulaqlığın isə simsiz olub-olmaması var. Hər xüsusiyyətə ayrıca sütun açsan, cədvəl yüzlərlə əsasən boş sütuna çevrilər. Üstəlik onlayn xidmətlər məlumatı JSON şəklində göndərir. Ona görə müasir relyasiya bazaları JSON-u «başa düşür»: SQLite-da JSON funksiyaları hazır gəlir, PostgreSQL-də json və jsonb tipləri, MySQL-də JSON tipi var. «Praktikada PostgreSQL və MySQL» dərsində JSON sütununa qısaca baxmışdıq; burada dərinə gedirik — oxumaq, massivləri açmaq, JSON qurmaq, indeksləmək və ən vacibi: JSON-u nə vaxt işlətməmək.

JSON-u saxlamaq: yoxlanılan mətn sütunu

SQLite-da ayrıca JSON tipi yoxdur: sənəd TEXT sütununda saxlanır. Sütuna zibil düşməsin deyə CHECK (json_valid(specs)) yazırıq — json_valid ciddi JSON standartını yoxlayır. Əsas, sabit məlumat (name, price) products-da qalır, dəyişkən xüsusiyyətlər isə ayrıca product_specs cədvəlinə, JSON-a gedir. Sənədin içinə yol (path) ilə müraciət olunur:

JSON yoluTərif

$ — bütün sənəd, .açar — obyektin sahəsi, [0] — massivin elementi (0-dan sayılır). $.ports[0] — birinci port; SQLite-da $.ports[#-1] — sonuncu element. Yol mövcud deyilsə, nəticə xətasız NULL olur.

SQL
CREATE TABLE product_specs (
  product_id INTEGER PRIMARY KEY REFERENCES products(id),
  specs      TEXT NOT NULL CHECK (json_valid(specs))
);
INSERT INTO product_specs VALUES
  (1, '{"ram_gb": 16, "color": "silver", "ports": ["usb-c", "hdmi"]}'),
  (2, '{"ram_gb": 8, "color": "black", "ports": ["usb-c"]}'),
  (3, '{"color": "black", "wireless": true}'),
  (9, '{"size_in": 27, "ports": ["hdmi", "dp"]}');

SELECT p.name,
       json_extract(s.specs, '$.color') AS color,
       s.specs ->> '$.ram_gb'           AS ram_gb,
       s.specs ->> '$.ports[0]'         AS first_port
FROM product_specs AS s
JOIN products AS p ON p.id = s.product_id
ORDER BY p.id;
Gözlənilən nəticə
name | color | ram_gb | first_port
Laptop | silver | 16 | usb-c
Smartphone | black | 8 | usb-c
Headphones | black | NULL | NULL
Monitor | NULL | NULL | hdmi
Olmayan açar (ram_gb qulaqlıqda) sadəcə NULL verir.
SQL
CREATE TABLE product_specs (
  product_id INTEGER PRIMARY KEY,
  specs      TEXT NOT NULL CHECK (json_valid(specs))
);
INSERT INTO product_specs VALUES (5, '{"color": "blue", "pens": 12,}');
Gözlənilən nəticə
Error: CHECK constraint failed: json_valid(specs)
Sondakı vergül JSON standartına ziddir — CHECK sətri buraxmır.

Davamını oxumaq üçün pulsuz qeydiyyatdan keç

Dərsin qalan bölmələri, test və qeydlər Educora hesabı ilə açılır. Qeydiyyat bir dəqiqə çəkir; irəliləyişin bütün cihazlarında saxlanılır.

Qiymətləri oxumaq: json_extract, -> və ->>

json_extract(sənəd, yol) və sənəd ->> yol adi SQL qiyməti qaytarır: mətn, ədəd və ya NULL. sənəd -> yol isə JSON parçası qaytarır: sətir dırnaqla, massiv mötərizə ilə gəlir. Sadə açar üçün $. yazmamaq olar: specs ->> 'color'.

SQL
SELECT '{"color": "black", "ports": ["usb-c"]}' -> '$.color'  AS one_arrow,
       '{"color": "black", "ports": ["usb-c"]}' ->> '$.color' AS two_arrows,
       '{"color": "black", "ports": ["usb-c"]}' -> 'ports'    AS ports_json,
       typeof('{"ram_gb": 8}' -> '$.ram_gb')  AS type_one,
       typeof('{"ram_gb": 8}' ->> '$.ram_gb') AS type_two;
Gözlənilən nəticə
one_arrow | two_arrows | ports_json | type_one | type_two
"black" | black | ["usb-c"] | text | integer

Nəticəni təxmin et

Məsələ

Bir məhsulun sənədində yaddaş səhvən mətn kimi yazılıb: {"ram_gb": "4"}. WHERE specs ->> 'ram_gb' > 10 bu məhsulu tapacaqmı?

Həllini göstərHəllini gizlət

Həll

1) ->> '4' mətnini qaytarır, çünki JSON-da qiymət dırnaq içindədir.
2) SQLite-da istənilən mətn istənilən ədəddən «böyükdür» (tiplərin sıralanması).
3) Nəticə: bəli, tapacaq — 4 GB-lıq məhsul «10-dan çox» siyahısına düşür. Düzəliş: CAST(specs ->> 'ram_gb' AS INTEGER) > 10 və ya yazarkən tipi CHECK (json_type(specs, '$.ram_gb') = 'integer') ilə yoxlamaq.
SQL
SELECT '{"ram_gb": "4"}' ->> '$.ram_gb' > 10                   AS text_check,
       CAST('{"ram_gb": "4"}' ->> '$.ram_gb' AS INTEGER) > 10 AS number_check,
       '{"ram_gb": 4}' ->> '$.colour'                         AS typo;
Gözlənilən nəticə
text_check | number_check | typo
1 | 0 | NULL
Səhv yazılmış açar (colour) da xəta vermir — sadəcə NULL.

JSON sahəsi ilə tez-tez axtarılırsa, ifadə indeksi yaradılır. Diqqət: SQLite indeksi yalnız sorğudakı ifadə indeksdəkinə hərfbəhərf uyğun gələndə işlədir. json_extract(specs, '$.color') üzrə indeks specs ->> '$.color' = ... sorğusunda istifadə olunmur (yoxlanılıb: SCAN), eyni ifadə ilə isə işləyir:

SQL
CREATE TABLE product_specs (
  product_id INTEGER PRIMARY KEY REFERENCES products(id),
  specs      TEXT NOT NULL CHECK (json_valid(specs))
);
INSERT INTO product_specs VALUES
  (1, '{"ram_gb": 16, "color": "silver", "ports": ["usb-c", "hdmi"]}'),
  (2, '{"ram_gb": 8, "color": "black", "ports": ["usb-c"]}'),
  (3, '{"color": "black", "wireless": true}'),
  (9, '{"size_in": 27, "ports": ["hdmi", "dp"]}');

CREATE INDEX idx_specs_color ON product_specs (specs ->> '$.color');

EXPLAIN QUERY PLAN
SELECT product_id FROM product_specs WHERE specs ->> '$.color' = 'black';
Gözlənilən nəticə
id | parent | notused | detail
3 | 0 | 53 | SEARCH product_specs USING COVERING INDEX idx_specs_color (<expr>=?)

Massivləri açmaq və JSON qurmaq

json_eachTərif

Cədvəl qaytaran funksiya: JSON massivinin (və ya obyektinin) hər elementi üçün bir sətir verir; əsas sütunları key (indeks və ya açar), value (qiymət) və type-dır. FROM hissəsində cədvəl kimi yazılır və əvvəlki cədvəlin sütunlarına müraciət edə bilər.

SQL
CREATE TABLE product_specs (
  product_id INTEGER PRIMARY KEY REFERENCES products(id),
  specs      TEXT NOT NULL CHECK (json_valid(specs))
);
INSERT INTO product_specs VALUES
  (1, '{"ram_gb": 16, "color": "silver", "ports": ["usb-c", "hdmi"]}'),
  (2, '{"ram_gb": 8, "color": "black", "ports": ["usb-c"]}'),
  (3, '{"color": "black", "wireless": true}'),
  (9, '{"size_in": 27, "ports": ["hdmi", "dp"]}');

SELECT p.name, j.key AS idx, j.value AS port
FROM product_specs AS s
JOIN products AS p ON p.id = s.product_id,
     json_each(s.specs, '$.ports') AS j
ORDER BY p.id, j.key;
Gözlənilən nəticə
name | idx | port
Laptop | 0 | usb-c
Laptop | 1 | hdmi
Smartphone | 0 | usb-c
Monitor | 0 | hdmi
Monitor | 1 | dp
Portu olmayan qulaqlıq heç bir sətir vermir — json_each daxili birləşmə kimi davranır.

Massiv sətirlərə açılandan sonra adi SQL işləyir: qruplaşdırma, birləşmə, süzgəc. Hansı port neçə məhsulda var?

SQL
CREATE TABLE product_specs (
  product_id INTEGER PRIMARY KEY REFERENCES products(id),
  specs      TEXT NOT NULL CHECK (json_valid(specs))
);
INSERT INTO product_specs VALUES
  (1, '{"ram_gb": 16, "color": "silver", "ports": ["usb-c", "hdmi"]}'),
  (2, '{"ram_gb": 8, "color": "black", "ports": ["usb-c"]}'),
  (3, '{"color": "black", "wireless": true}'),
  (9, '{"size_in": 27, "ports": ["hdmi", "dp"]}');

SELECT j.value AS port, COUNT(*) AS products
FROM product_specs AS s, json_each(s.specs, '$.ports') AS j
GROUP BY j.value
ORDER BY products DESC, port;
Gözlənilən nəticə
port | products
hdmi | 2
usb-c | 2
dp | 1

Əks istiqamət — cədvəldən JSON — API cavabları üçün lazımdır. json_object(açar, qiymət, ...) bir obyekt, aqreqat funksiya json_group_array(x) qrupun bütün qiymətlərindən massiv qurur (SQLite 3.44-dən onun içində ORDER BY yazmaq olar), json_group_object(açar, qiymət) isə obyekt. Azərbaycanlı müştərilərin sifarişləri, hər müştəriyə bir JSON:

SQL
SELECT c.name,
       json_object('orders', COUNT(*),
                   'products', json_group_array(p.name ORDER BY o.order_date))
         AS summary
FROM orders AS o
JOIN customers AS c ON c.id = o.customer_id
JOIN products  AS p ON p.id = o.product_id
WHERE c.country = 'Azerbaijan'
GROUP BY c.id
ORDER BY c.id;
Gözlənilən nəticə
name | summary
Anar Mustafayev | {"orders":3,"products":["Laptop","Headphones","Notebook"]}
Lalə Əhmədova | {"orders":2,"products":["Notebook","Headphones"]}
Zəhra Hüseynli | {"orders":2,"products":["Smartphone","Water bottle"]}

Sənədi dəyişmək üçün dörd funksiya var: json_set (varsa əvəz edir, yoxdursa əlavə edir), json_insert (yalnız əlavə edir), json_replace (yalnız əvəz edir) və json_remove. $.ports[#] yolu massivin sonuna element əlavə edir. Funksiya yeni sənəd qaytarır, ona görə UPDATE ... SET specs = json_set(specs, ...) yazılır:

SQL
CREATE TABLE product_specs (
  product_id INTEGER PRIMARY KEY REFERENCES products(id),
  specs      TEXT NOT NULL CHECK (json_valid(specs))
);
INSERT INTO product_specs VALUES
  (1, '{"ram_gb": 16, "color": "silver", "ports": ["usb-c", "hdmi"]}'),
  (2, '{"ram_gb": 8, "color": "black", "ports": ["usb-c"]}'),
  (3, '{"color": "black", "wireless": true}'),
  (9, '{"size_in": 27, "ports": ["hdmi", "dp"]}');

UPDATE product_specs
SET specs = json_set(specs, '$.ram_gb', 32, '$.ports[#]', 'sd-card')
WHERE product_id = 1;
UPDATE product_specs
SET specs = json_remove(specs, '$.color')
WHERE product_id = 2;

SELECT product_id, specs FROM product_specs WHERE product_id <= 2 ORDER BY product_id;
Gözlənilən nəticə
product_id | specs
1 | {"ram_gb":32,"color":"silver","ports":["usb-c","hdmi","sd-card"]}
2 | {"ram_gb":8,"ports":["usb-c"]}

PostgreSQL: json və jsonb, operatorlar, GIN

PostgreSQL-də iki tip var. json mətni olduğu kimi saxlayır — boşluqlar, açarların sırası və təkrar açarlar daxil — və hər müraciətdə yenidən təhlil edir. jsonb yazılarkən ikili formaya çevrilir: təkrar açarlardan sonuncusu qalır, açarlar yenidən düzülür, oxumaq sürətlidir, indeks və «ehtiva edir» operatorları dəstəklənir. Qayda sadədir: demək olar həmişə jsonb; json yalnız mətni dəqiq olduğu kimi saxlamaq lazım olanda. Bu bölmənin kodu PGlite-də (PostgreSQL 18) yoxlanılıb.

SQL
SELECT '{"b": 1,  "a": 2, "a": 3}'::json  AS as_json,
       '{"b": 1,  "a": 2, "a": 3}'::jsonb AS as_jsonb;

Gözlənilən nəticə

          as_json          |     as_jsonb
---------------------------+------------------
 {"b": 1,  "a": 2, "a": 3} | {"a": 3, "b": 1}
(1 row)
OperatorMənasıNümunə
-> / ->>açar və ya indeks üzrə: JSON / mətnspecs ->> 'color'
#> / #>>yol massivi üzrə: JSON / mətnspecs #>> '{ports,0}'
@>sol tərəf sağ tərəfi ehtiva edirspecs @> '{"color": "black"}'
?belə açar (və ya massivdə belə sətir) varspecs ? 'wireless'
|| / -birləşdirmək / açarı silməkspecs - 'color'
SQL
CREATE TABLE product_specs (product_id int PRIMARY KEY, specs jsonb NOT NULL);
INSERT INTO product_specs VALUES
  (1, '{"ram_gb": 16, "color": "silver", "ports": ["usb-c", "hdmi"]}'),
  (2, '{"ram_gb": 8, "color": "black", "ports": ["usb-c"]}'),
  (3, '{"color": "black", "wireless": true}'),
  (9, '{"size_in": 27, "ports": ["hdmi", "dp"]}');
CREATE INDEX idx_specs ON product_specs USING GIN (specs);

SELECT product_id,
       specs -> 'ports'              AS ports,
       specs #>> '{ports,0}'         AS first_port,
       (specs ->> 'ram_gb')::int * 2 AS double_ram
FROM product_specs
WHERE specs @> '{"color": "black"}'
ORDER BY product_id;

SELECT product_id FROM product_specs
WHERE specs -> 'ports' ? 'hdmi'
ORDER BY product_id;

Gözlənilən nəticə

 product_id |   ports   | first_port | double_ram
------------+-----------+------------+------------
          2 | ["usb-c"] | usb-c      |         16
          3 |           |            |
(2 rows)

 product_id
------------
          1
          9
(2 rows)
->> mətn qaytarır, ona görə hesablamadan əvvəl ::int ilə çevrilir.

GIN (Generalized Inverted Index) sənədin içindəki bütün açar və qiymətlərin «tərs indeksi»dir — kitabın sonundakı mövzu göstəricisi kimi. Susmaya görə operator sinfi (jsonb_ops) @>, ?, ?|, ?& sorğularını sürətləndirir; jsonb_path_ops daha kiçik və sürətlidir, amma yalnız @>-ni (və jsonpath operatorlarını) dəstəkləyir. specs ->> 'color' = 'black' üçün GIN kömək etmir — orada adi B-tree ifadə indeksi lazımdır: CREATE INDEX ON product_specs ((specs ->> 'color')). Cədvəl kiçik olduğu üçün planlayıcını SET enable_seqscan = off ilə indeksə «məcbur» edirik:

SQL
SET enable_seqscan = off;

EXPLAIN (COSTS OFF)
SELECT product_id FROM product_specs WHERE specs @> '{"color": "black"}';

EXPLAIN (COSTS OFF)
SELECT product_id FROM product_specs WHERE specs ->> 'color' = 'black';

Gözlənilən nəticə

                         QUERY PLAN
------------------------------------------------------------
 Bitmap Heap Scan on product_specs
   Recheck Cond: (specs @> '{"color": "black"}'::jsonb)
   ->  Bitmap Index Scan on idx_specs
         Index Cond: (specs @> '{"color": "black"}'::jsonb)
(4 rows)

                      QUERY PLAN
-------------------------------------------------------
 Seq Scan on product_specs
   Disabled: true
   Filter: ((specs ->> 'color'::text) = 'black'::text)
(3 rows)
@> GIN indeksindən keçir, ->> = isə yenə ardıcıl oxunur (Disabled: true — planlayıcının başqa yolu yoxdur).
TapşırıqSQLitePostgreSQL (jsonb)MySQL 8
Qiymət oxumaqd ->> '$.a'd ->> 'a'd ->> '$.a'
Massivi sətirlərə açmaqjson_eachjsonb_array_elementsJSON_TABLE
Qrupdan massivjson_group_arrayjsonb_aggJSON_ARRAYAGG
Obyekt qurmaqjson_objectjsonb_build_objectJSON_OBJECT
Sahəni dəyişməkjson_setjsonb_setJSON_SET
İndeksifadə indeksiGIN və ya ifadə indeksigenerasiya olunan sütun üzrə indeks

JSON nə vaxt pis fikirdir və harada yerindədir

  • Sahə hər sətirdə var (qiymət, müştəri, tarix) — bu, adi sütundur.
  • Sahə başqa cədvələ istinad edir — JSON-un içində xarici açar və JOIN üçün indeks olmur; id massivləri əvəzinə əlaqə cədvəli qur.
  • NOT NULL, CHECK, UNIQUE lazımdır — JSON-un içində tiplər və qaydalar özbaşına yoxlanılmır.
  • Böyük sənəddə tez-tez bir sahə dəyişir — hər dəfə bütün sənəd yenidən yazılır.

Bəzi JSON sahəsi «populyarlaşıbsa», onu generasiya olunan sütuna çıxarmaq olar: dəyər JSON-dan avtomatik hesablanır, amma adi sütun kimi indekslənir və sorğularda sadə görünür. SQLite ALTER TABLE ilə yalnız VIRTUAL (saxlanmayan) belə sütun əlavə etməyə icazə verir:

SQL
CREATE TABLE product_specs (
  product_id INTEGER PRIMARY KEY REFERENCES products(id),
  specs      TEXT NOT NULL CHECK (json_valid(specs))
);
INSERT INTO product_specs VALUES
  (1, '{"ram_gb": 16, "color": "silver", "ports": ["usb-c", "hdmi"]}'),
  (2, '{"ram_gb": 8, "color": "black", "ports": ["usb-c"]}'),
  (3, '{"color": "black", "wireless": true}'),
  (9, '{"size_in": 27, "ports": ["hdmi", "dp"]}');

ALTER TABLE product_specs
  ADD COLUMN color TEXT GENERATED ALWAYS AS (specs ->> '$.color') VIRTUAL;
CREATE INDEX idx_specs_color ON product_specs (color);

SELECT product_id, color FROM product_specs WHERE color = 'black' ORDER BY product_id;
Gözlənilən nəticə
product_id | color
2 | black
3 | black

Mini layihə: API-dən sifarişlərin idxalı. JSON-un ən sağlam yeri sistemin sərhədidir: xidmət JSON göndərir, biz isə onu dərhal adi cədvəllərə çeviririk.

  1. Xam JSON-u saxla

    Gələn sorğunun gövdəsi json_valid yoxlaması olan api_orders cədvəlinə yazılır — problem olsa, orijinal əlində qalır.

  2. Massivi aç

    json_each(a.body, '$.items') hər mal üçün bir sətir verir.

  3. Relyasiya cədvəlinə yaz

    INSERT INTO orders ... SELECT — ->> qiymətləri adi sütunlara düşür.

  4. Adi SQL ilə yoxla

    JOIN ilə müştəri və məhsul adları, məbləğlər.

SQL
CREATE TABLE api_orders (id INTEGER PRIMARY KEY, body TEXT CHECK (json_valid(body)));
INSERT INTO api_orders (body) VALUES
  ('{"customer_id": 4, "date": "2025-08-01",
     "items": [{"product_id": 3, "qty": 2}, {"product_id": 5, "qty": 3}]}'),
  ('{"customer_id": 7, "date": "2025-08-02",
     "items": [{"product_id": 10, "qty": 1}]}');

INSERT INTO orders (customer_id, product_id, quantity, order_date)
SELECT a.body ->> '$.customer_id', i.value ->> '$.product_id',
       i.value ->> '$.qty',        a.body ->> '$.date'
FROM api_orders AS a, json_each(a.body, '$.items') AS i;

SELECT o.id, c.name AS customer, p.name AS product, o.quantity,
       ROUND(o.quantity * p.price, 2) AS amount
FROM orders AS o
JOIN customers AS c ON c.id = o.customer_id
JOIN products  AS p ON p.id = o.product_id
WHERE o.id > 12
ORDER BY o.id;
Gözlənilən nəticə
id | customer | product | quantity | amount
13 | Olga Ivanova | Headphones | 2 | 241
14 | Olga Ivanova | Pen set | 3 | 23.7
15 | Mehmet Kaya | Chess set | 1 | 42
İki JSON sənədi üç adi sifariş sətrinə çevrildi.

Diqqət et: JSON yalnız sistemin sərhədində yaşadı — idxaldan sonra məlumat yenə relyasiyadır, xarici açarlar, indekslər və adi GROUP BY işləyir. Bu, JSON-un SQL-də ən sağlam istifadəsidir.

Tapşırıq

Başlanğıc koddakı product_specs cədvəlindən ports massivi olan hər məhsulun adını və port sayını (ports, json_array_length ilə) göstər. Port sayına görə azalan, sonra ada görə sırala.

Tapşırıq · SQL
CREATE TABLE product_specs (
  product_id INTEGER PRIMARY KEY REFERENCES products(id),
  specs      TEXT NOT NULL CHECK (json_valid(specs))
);
INSERT INTO product_specs VALUES
  (1, '{"ram_gb": 16, "color": "silver", "ports": ["usb-c", "hdmi"]}'),
  (2, '{"ram_gb": 8, "color": "black", "ports": ["usb-c"]}'),
  (3, '{"color": "black", "wireless": true}'),
  (9, '{"size_in": 27, "ports": ["hdmi", "dp"]}');

SELECT p.name
FROM product_specs AS s
JOIN products AS p ON p.id = s.product_id;
Gözlənilən nəticə
name | ports
Laptop | 2
Monitor | 2
Smartphone | 1

Tapşırıq

API üçün kateqoriyalar siyahısı qur: hər kateqoriya üçün məhsulların sayı (products) və adlarının əlifba sırası ilə JSON massivi (names). Kateqoriyaya görə sırala.

Tapşırıq · SQL
SELECT category, COUNT(*) AS products
FROM products
GROUP BY category
ORDER BY category;
Gözlənilən nəticə
category | products | names
Accessories | 2 | ["Backpack","Water bottle"]
Electronics | 4 | ["Headphones","Laptop","Monitor","Smartphone"]
Games | 1 | ["Chess set"]
Home | 1 | ["Desk lamp"]
Stationery | 2 | ["Notebook","Pen set"]

Yadda saxla

  • SQLite JSON-u TEXT (və ya jsonb() ilə BLOB) kimi saxlayır; CHECK (json_valid(...)) zibili buraxmır.
  • -> JSON parçası, ->> və json_extract adi SQL qiyməti qaytarır; olmayan yol NULL verir.
  • json_each massivi sətirlərə açır; json_object, json_group_array cədvəldən JSON qurur.
  • PostgreSQL-də demək olar həmişə jsonb: @> və ? GIN indeksi ilə sürətlənir, ->> = üçün ifadə indeksi lazımdır.
  • Sabit, əlaqəli, yoxlanılmalı sahələr sütunlarda qalır; JSON — həqiqətən dəyişkən atributlar və sistemin sərhədi üçün.
Dərsdə səhv və ya qeyri-dəqiqlik gördün?

Özünü yoxla

12 sual. Hər düzgün cavab XP qazandırır.

Sual 1 / 12

Sual 1 / 12. '{"color": "red"}' -> '$.color' SQLite-da nə qaytarır?