PostgreSQL
 sql >> Teknologi Basis Data >  >> RDS >> PostgreSQL

Ikhtisar Kemampuan JSON Dalam PostgreSQL

Apa itu JSON?

JSON adalah singkatan dari "JavaScript Object Notation" yang merupakan jenis format data yang populer digunakan oleh aplikasi web. Ini berarti, data akan dikirimkan antara aplikasi web dan server dalam format seperti itu. JSON diperkenalkan sebagai alternatif format XML. Di "masa lalu yang baik" data yang digunakan untuk dikirim dalam format XML yang merupakan tipe data berbobot berat dibandingkan dengan JSON. Di bawah ini adalah contoh string berformat JSON:

{ "ID":"001","name": "Ven", "Country": "Australia",  "city": "Sydney", "Job Title":"Database Consultant"}

String JSON dapat berisi objek JSON lain di dalam dirinya sendiri seperti yang ditunjukkan di bawah ini:

{ "ID":"001", "name": "Ven", "Job Title":"Database Consultant", "Location":{"Suburb":"Dee Why","city": "Sydney","State":"NSW","Country": "Australia"}}

Aplikasi web dan seluler modern sebagian besar menghasilkan data dalam format JSON, juga disebut sebagai "Bytes JSON" yang diambil oleh server aplikasi dan dikirim ke database. Byte JSON diproses secara bergantian, dipecah menjadi nilai kolom terpisah dan dimasukkan ke dalam tabel RDBMS.
Contoh:

{ "ID":"001","name": "Ven", "Country": "Australia",  "city": "Sydney", "Job Title":"Database Consultant"}

Data JSON di atas diubah menjadi SQL seperti di bawah ini..

Insert into test (id, name, country,city,job_title) values  (001,'Ven','Australia','Sydney','Database Consultant');

Dalam hal menyimpan dan memproses data JSON, ada berbagai database NoSQL yang mendukungnya dan yang paling populer adalah MongoDB. Ketika datang ke database RDBMS, hingga saat ini, string JSON diperlakukan sebagai teks biasa dan tidak ada tipe data yang secara khusus mengenali, menyimpan, atau memproses string format JSON. PostgreSQL, database RDBMS open-source paling populer telah hadir dengan tipe data JSON yang ternyata sangat bermanfaat untuk kinerja, fungsionalitas, dan skalabilitas saat menangani data JSON.

PostgreSQL + JSON

Database PostgreSQL telah menjadi semakin populer sejak tipe data JSON diperkenalkan. Faktanya, PostgreSQL telah mengungguli MongoDB dalam hal pemrosesan data JSON dalam jumlah besar. Aplikasi dapat menyimpan string JSON dalam database PostgreSQL dalam format JSON standar. Pengembang hanya perlu memberi tahu aplikasi untuk mengirim string JSON ke database sebagai tipe data json dan mengambil kembali dalam format JSON. Menyimpan string JSON dalam tipe data JSON memiliki beberapa keuntungan dibandingkan dengan menyimpan yang sama dalam tipe data TEXT. Tipe data JSON hanya dapat menerima string berformat JSON yang valid, jika string tidak dalam format JSON yang benar, kesalahan akan dihasilkan. Tipe data JSON membantu aplikasi melakukan pencarian berbasis indeks dan efisien, yang akan segera kita lihat secara detail.

Tipe data JSON diperkenalkan di PostgreSQL-9.2 posting yang, peningkatan signifikan dibuat. Penambahan utama muncul di PostgreSQL-9.4 dengan penambahan tipe data JSONB. JSONB adalah versi lanjutan dari tipe data JSON yang menyimpan data JSON dalam format biner. Ini adalah peningkatan besar yang membuat perbedaan besar pada cara data JSON dicari dan diproses di PostgreSQL. Mari kita lihat secara mendetail keunggulan tipe data JSON.

Jenis Data JSON dan JSONB

Tipe data JSON menyimpan string berformat json sebagai teks yang tidak terlalu kuat dan tidak mendukung banyak fungsi terkait JSON yang digunakan untuk pencarian. Ini hanya mendukung pengindeksan B-TREE tradisional dan tidak mendukung jenis Indeks lain yang sangat penting untuk operasi pencarian yang lebih cepat dan efisien di seluruh data JSON.

JSONB, versi lanjutan dari tipe data JSON, sangat disarankan untuk menyimpan dan memproses dokumen JSON. Ini mendukung berbagai operator json dan memiliki banyak keunggulan dibandingkan JSON, seperti menyimpan string berformat JSON dalam format biner, dan mendukung fungsi dan pengindeksan JSON, untuk melakukan pencarian yang efisien.

Mari kita lihat perbedaannya.

  JSON JSONB
1 Cukup seperti tipe data TEXT yang hanya menyimpan dokumen JSON yang valid. Menyimpan dokumen JSON dalam format Biner.
2 Menyimpan dokumen JSON apa adanya termasuk spasi. Memotong ruang kosong dan menyimpan dalam format yang kondusif untuk penelusuran yang lebih cepat dan efisien
3 Tidak mendukung Pengindeksan FULL-TEXT-SEARCH Mendukung Pengindeksan PENCARIAN TEKS LENGKAP
4 Tidak mendukung berbagai fungsi dan operator JSON Mendukung semua fungsi dan operator JSON

Contoh untuk #4 Tercantum Di Atas

JSON

Di bawah ini adalah tabel dengan tipe data JSON

dbt3=# \d product
                   Table "dbt3.product"
     Column     |  Type  | Collation | Nullable | Default
----------------+--------+-----------+----------+---------
 item_code      | bigint |           | not null |
 productdetails | json   |           |          |
Indexes:
    "product_pkey" PRIMARY KEY, btree (item_code)

Tidak mendukung operator JSON tradisional (seperti “@>” atau “#>”). Pencarian Teks Lengkap melalui data JSON dilakukan menggunakan “@>” atau “#>” dalam SQL yang tidak didukung oleh tipe data JSON

dbt3=# select * from product where productdetails @> '{"l_shipmode":"AIR"}' and productdetails @> '{"l_quantity":"27"}';
ERROR:  operator does not exist: json @> unknown
LINE 1: select * from product where productdetails @> '{"l_shipmode"...
                                                   ^
HINT:  No operator matches the given name and argument types. You might need to add explicit type casts.
dbt3=#

JSONB

Di bawah ini adalah tabel dengan tipe data JSONB

dbt3=# \d products
                  Table "dbt3.products"
    Column     |  Type  | Collation | Nullable | Default
---------------+--------+-----------+----------+---------
 item_code     | bigint |           | not null |
 order_details | jsonb  |           |          |
Indexes:
    "products_pkey" PRIMARY KEY, btree (item_code)

Mendukung PENCARIAN TEKS LENGKAP melalui data JSON menggunakan operator (seperti “@>”)

dbt3=# select * from products where order_details @> '{"l_shipmode" : "AIR"}' limit 2;
 item_code |                                                                                        order_details
-----------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
         4 | {"l_partkey": 21315, "l_orderkey": 1, "l_quantity": 28, "l_shipdate": "1996-04-21", "l_shipmode": "AIR", "l_commitdate": "1996-03-30", "l_shipinstruct": "NONE", "l_extendedprice": 34616.7}
         8 | {"l_partkey": 42970, "l_orderkey": 3, "l_quantity": 45, "l_shipdate": "1994-02-02", "l_shipmode": "AIR", "l_commitdate": "1994-01-04", "l_shipinstruct": "NONE", "l_extendedprice": 86083.6}
(2 rows)
Unduh Whitepaper Hari Ini Pengelolaan &Otomatisasi PostgreSQL dengan ClusterControlPelajari tentang apa yang perlu Anda ketahui untuk menerapkan, memantau, mengelola, dan menskalakan PostgreSQLUnduh Whitepaper

Cara Membuat Kueri Data JSON

Mari kita lihat beberapa kapabilitas PostgreSQL JSON yang terkait dengan operasi data. Berikut adalah tampilan data JSON dalam sebuah Tabel. Kolom “order_details” bertipe JSONB

dbt3=# select * from product_details ;
 item_code |                                                                                                 order_details
-----------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
         1 | {"l_partkey": 1551894, "l_orderkey": 1, "l_quantity": 17, "l_shipdate": "1996-03-13", "l_shipmode": "TRUCK", "l_commitdate": "1996-02-12", "l_shipinstruct": "DELIVER IN PERSON", "l_extendedprice": 33078.9}
         2 | {"l_partkey": 673091, "l_orderkey": 1, "l_quantity": 36, "l_shipdate": "1996-04-12", "l_shipmode": "MAIL", "l_commitdate": "1996-02-28", "l_shipinstruct": "TAKE BACK RETURN", "l_extendedprice": 38306.2}
         3 | {"l_partkey": 636998, "l_orderkey": 1, "l_quantity": 8, "l_shipdate": "1996-01-29", "l_shipmode": "REG AIR", "l_commitdate": "1996-03-05", "l_shipinstruct": "TAKE BACK RETURN", "l_extendedprice": 15479.7}
         4 | {"l_partkey": 21315, "l_orderkey": 1, "l_quantity": 28, "l_shipdate": "1996-04-21", "l_shipmode": "AIR", "l_commitdate": "1996-03-30", "l_shipinstruct": "NONE", "l_extendedprice": 34616.7}
         5 | {"l_partkey": 240267, "l_orderkey": 1, "l_quantity": 24, "l_shipdate": "1996-03-30", "l_shipmode": "FOB", "l_commitdate": "1996-03-14", "l_shipinstruct": "NONE", "l_extendedprice": 28974}
         6 | {"l_partkey": 156345, "l_orderkey": 1, "l_quantity": 32, "l_shipdate": "1996-01-30", "l_shipmode": "MAIL", "l_commitdate": "1996-02-07", "l_shipinstruct": "DELIVER IN PERSON", "l_extendedprice": 44842.9}
         7 | {"l_partkey": 1061698, "l_orderkey": 2, "l_quantity": 38, "l_shipdate": "1997-01-28", "l_shipmode": "RAIL", "l_commitdate": "1997-01-14", "l_shipinstruct": "TAKE BACK RETURN", "l_extendedprice": 63066.3}
         8 | {"l_partkey": 42970, "l_orderkey": 3, "l_quantity": 45, "l_shipdate": "1994-02-02", "l_shipmode": "AIR", "l_commitdate": "1994-01-04", "l_shipinstruct": "NONE", "l_extendedprice": 86083.6}
         9 | {"l_partkey": 190355, "l_orderkey": 3, "l_quantity": 49, "l_shipdate": "1993-11-09", "l_shipmode": "RAIL", "l_commitdate": "1993-12-20", "l_shipinstruct": "TAKE BACK RETURN", "l_extendedprice": 70822.1}
        10 | {"l_partkey": 1284483, "l_orderkey": 3, "l_quantity": 27, "l_shipdate": "1994-01-16", "l_shipmode": "SHIP", "l_commitdate": "1993-11-22", "l_shipinstruct": "DELIVER IN PERSON", "l_extendedprice": 39620.3}
(10 rows)

Pilih semua kode barang termasuk tanggal pengirimannya

dbt3=# select item_code, order_details->'l_shipdate' as shipment_date from product_details ;

 item_code | shipment_date
-----------+---------------
         1 | "1996-03-13"
         2 | "1996-04-12"
         3 | "1996-01-29"
         4 | "1996-04-21"
         5 | "1996-03-30"
         6 | "1996-01-30"
         7 | "1997-01-28"
         8 | "1994-02-02"
         9 | "1993-11-09"
        10 | "1994-01-16"
(10 rows)

Dapatkan kode_item, jumlah, dan harga semua pesanan yang tiba melalui udara

dbt3=# select item_code, order_details->'l_quantity' as quantity, order_details->'l_extendedprice' as price, order_details->'l_shipmode' as price from product_details where order_details->>'l_shipmode'='AIR';

 item_code | quantity |  price  | price
-----------+----------+---------+-------
         4 | 28       | 34616.7 | "AIR"
         8 | 45       | 86083.6 | "AIR"
(2 rows)

Operator JSON “->” dan “->>” digunakan untuk pemilihan dan perbandingan dalam kueri SQL. Operator “->” mengembalikan bidang Objek JSON sebagai bidang dalam tanda kutip dan operator “->>” mengembalikan bidang objek JSON sebagai TEXT. Dua SQL di atas adalah contoh menampilkan nilai bidang JSON apa adanya. Di bawah ini adalah contoh pengambilan field JSON dalam bentuk TEXT.
Berikut adalah contoh pengambilan field JSON dalam bentuk TEXT

dbt3=# select item_code, order_details->>'l_shipdate' as shipment_date from product_details ;
 item_code | shipment_date
-----------+---------------
         1 | 1996-03-13
         2 | 1996-04-12
         3 | 1996-01-29
         4 | 1996-04-21
         5 | 1996-03-30
         6 | 1996-01-30
         7 | 1997-01-28
         8 | 1994-02-02
         9 | 1993-11-09
        10 | 1994-01-16
(10 rows)

Ada operator lain yang disebut "#>" yang digunakan untuk menanyakan bagian data dari Elemen JSON yang merupakan bagian dari string JSON. Mari kita lihat contohnya.
Berikut adalah data dalam tabel.

dbt3=# select * from test_json ;
  id   |                                                                                                details
-------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 10000 | {"Job": "Database Consultant", "name": "Venkata", "Location": {"city": "Sydney", "State": "NSW", "Suburb": "Dee Why", "Country": "Australia"}}
 20000 | {"Job": "Database Consultant", "name": "Smith", "Location": {"city": "Sydney", "State": "NSW", "Suburb": "Manly", "Country": "Australia"}}
 30000 | {"Job": "Developer", "name": "John", "Location": {"city": "Sydney", "State": "NSW", "Suburb": "Brookvale", "Country": "Australia"}}
 50000 | {"cars": {"Ford": [{"doors": 4, "model": "Taurus"}, {"doors": 4, "model": "Escort"}], "Nissan": [{"doors": 4, "model": "Sentra"}, {"doors": 4, "model": "Maxima"}, {"doors": 2, "model": "Skyline"}]}}
 40000 | {"Job": "Architect", "name": "James", "Location": {"city": "Melbourne", "State": "NSW", "Suburb": "Trugnania", "Country": "Australia"}}

Saya ingin melihat semua detail dengan "State" "NSW" dan "State" adalah kunci objek JSON yang merupakan bagian dari kunci "Location". Di bawah ini adalah cara menanyakan hal yang sama.

dbt3=# select * from test_json where details #> '{Location,State}'='"NSW"';
  id   |                                                                    details
-------+------------------------------------------------------------------------------------------------------------------------------------------------
 10000 | {"Job": "Database Consultant", "name": "Venkata", "Location": {"city": "Sydney", "State": "NSW", "Suburb": "Dee Why", "Country": "Australia"}}
 20000 | {"Job": "Database Consultant", "name": "Smith", "Location": {"city": "Sydney", "State": "NSW", "Suburb": "Manly", "Country": "Australia"}}
 30000 | {"Job": "Developer", "name": "John", "Location": {"city": "Sydney", "State": "NSW", "Suburb": "Brookvale", "Country": "Australia"}}
 30000 | {"Job": "Architect", "name": "James", "Location": {"city": "Melbourne", "State": "NSW", "Suburb": "Trugnania", "Country": "Australia"}}
(4 rows)

Operasi aritmatika dapat dilakukan pada data JSON. Pengecoran tipe diperlukan karena bagian data kolom JSON adalah TEXT.

dbt3=# select item_code, order_details->'l_quantity' as quantity, order_details->'l_extendedprice' as price, order_details->'l_shipmode' as price from product_details where (order_details->'l_quantity')::int > 10;
 item_code | quantity |  price  |  price
-----------+----------+---------+---------
         1 | 17       | 33078.9 | "TRUCK"
         2 | 36       | 38306.2 | "MAIL"
         4 | 28       | 34616.7 | "AIR"
         5 | 24       | 28974   | "FOB"
         6 | 32       | 44842.9 | "MAIL"
         7 | 38       | 63066.3 | "RAIL"
         8 | 45       | 86083.6 | "AIR"
         9 | 49       | 70822.1 | "RAIL"
        10 | 27       | 39620.3 | "SHIP"
(9 rows)

Terlepas dari semua hal di atas, operasi berikut juga dapat dilakukan pada JSON menggunakan SQL termasuk GABUNG

  1. Mengurutkan data menggunakan klausa ORDER BY
  2. Agregasi menggunakan fungsi agregat seperti SUM, AVG, MIN, MAX dll
  3. Kelompokkan data menggunakan klausa GROUP BY

Bagaimana Dengan Performanya?

Data dalam kolom JSON akan berupa teks dan berdasarkan masalah kinerja ukuran data dapat diharapkan. Pencarian melalui data JSON dapat memakan waktu dan daya komputasi yang mengakibatkan respons yang lambat terhadap aplikasi. Sangat penting bagi DBA untuk memastikan SQL yang mengenai kolom JSON merespons dengan cukup cepat dan memberikan kinerja yang baik. Karena ekstraksi data dilakukan melalui SQL, Opsi yang akan dicari DBA adalah kemungkinan Pengindeksan dan ya, tipe Data JSON mendukung opsi Pengindeksan.

Mari kita lihat opsi Pengindeksan yang diberikan JSON.

Pengindeksan JSONB

Tipe data JSONB mendukung Pengindeksan FULL-TEXT-SEARCH. Ini adalah kemampuan JSONB yang paling penting yang akan dinanti-nantikan oleh DBA saat menggunakan tipe data JSONB. Indeks normal pada kunci Objek JSON mungkin tidak membantu saat menggunakan operator khusus JSON dalam kueri penelusuran. Di bawah ini adalah kueri PENELUSURAN TEKS yang berlaku untuk PEMINDAIAN TABLE LENGKAP

dbt3=# explain select * from products where order_details @> '{"l_shipmode" : "AIR"}';
                             QUERY PLAN
--------------------------------------------------------------------
 Seq Scan on products  (cost=0.00..4205822.65 rows=59986 width=252)
   Filter: (order_details @> '{"l_shipmode": "AIR"}'::jsonb)
(2 rows)

JSONB mendukung jenis Indeks FULL-TEXT-SEARCH yang disebut GIN yang membantu kueri seperti di atas.
Sekarang, izinkan saya membuat Indeks GIN dan lihat apakah itu membantu

dbt3=# create index od_gin_idx on products using gin(order_details jsonb_path_ops);
CREATE INDEX

Jika Anda dapat mengamati di bawah, kueri mengambil Indeks GIN

dbt3=# explain select * from products where order_details @> '{"l_shipmode" : "AIR"}';
                                  QUERY PLAN
-------------------------------------------------------------------------------
 Bitmap Heap Scan on products  (cost=576.89..215803.18 rows=59986 width=252)
   Recheck Cond: (order_details @> '{"l_shipmode": "AIR"}'::jsonb)
   ->  Bitmap Index Scan on od_gin_idx  (cost=0.00..561.90 rows=59986 width=0)
         Index Cond: (order_details @> '{"l_shipmode": "AIR"}'::jsonb)

Dan indeks B-TREE sebagai ganti GIN TIDAK akan membantu

dbt3=# create index idx on products((order_details->>'l_shipmode'));
CREATE INDEX

dbt3=# \d products
                  Table "dbt3.products"
    Column     |  Type  | Collation | Nullable | Default
---------------+--------+-----------+----------+---------
 item_code     | bigint |           | not null |
 order_details | jsonb  |           |          |
Indexes:
    "products_pkey" PRIMARY KEY, btree (item_code)
    "idx" btree ((order_details ->> 'l_shipmode'::text))

Anda dapat melihat di bawah, kueri lebih memilih FULL-TABLE-SCAN

dbt3=# explain select * from products where order_details @> '{"l_shipmode" : "AIR"}';
                             QUERY PLAN
--------------------------------------------------------------------
 Seq Scan on products  (cost=0.00..4205822.65 rows=59986 width=252)
   Filter: (order_details @> '{"l_shipmode": "AIR"}'::jsonb)

Apa itu Indeks GIN?

GIN adalah singkatan dari Generalized Inverted Index. Kemampuan inti Indeks GIN adalah untuk mempercepat pencarian teks lengkap. Saat melakukan pencarian berdasarkan Kunci atau elemen tertentu dalam TEXT atau dokumen, Indeks GIN adalah cara yang harus dilakukan. Indeks GIN menyimpan "Kunci" (atau elemen atau nilai) dan pasangan "daftar posisi". Daftar posisi adalah rowID dari kunci. Ini berarti, jika "Kunci" muncul di beberapa tempat dalam dokumen, Indeks GIN menyimpan Kunci hanya sekali bersama dengan posisi kemunculannya yang tidak hanya membuat Indeks GIN tetap kompak dalam ukuran dan juga membantu mempercepat pencarian dalam jumlah besar. jalan. Ini adalah peningkatan di Postgres-9.4.

Tantangan dengan Indeks GIN

Bergantung pada kompleksitas data, mempertahankan Indeks GIN bisa jadi mahal. Pembuatan Indeks GIN menghabiskan waktu dan sumber daya karena Indeks harus menelusuri seluruh dokumen untuk menemukan Kunci dan ID barisnya. Ini bisa menjadi lebih menantang jika indeks GIN membengkak. Selain itu, ukuran indeks GIN bisa sangat besar berdasarkan ukuran dan kompleksitas data.

Pengindeksan JSON

JSON tidak mendukung pencarian teks dan Indeks seperti GIN

dbt3=# create index pd_gin_idx on product using gin(productdetails jsonb_path_ops);
ERROR:  operator class "jsonb_path_ops" does not accept data type json

Pengindeksan Normal seperti B-TREE didukung oleh JSON dan JSONB

Ya, indeks normal seperti Indeks B-TREE didukung oleh tipe data JSON dan JSONB dan tidak kondusif untuk operasi pencarian teks. Setiap kunci objek JSON dapat diindeks satu per satu yang akan sangat membantu HANYA ketika kunci objek yang sama digunakan dalam klausa WHERE.
Biarkan saya membuat Indeks B-TREE di JSONB dan lihat cara kerjanya

dbt3=# create index idx on products((order_details->>'l_shipmode'));
CREATE INDEX

dbt3=# \d products
                  Table "dbt3.products"
    Column     |  Type  | Collation | Nullable | Default
---------------+--------+-----------+----------+---------
 item_code     | bigint |           | not null |
 order_details | jsonb  |           |          |
Indexes:
    "products_pkey" PRIMARY KEY, btree (item_code)
    "idx" btree ((order_details ->> 'l_shipmode'::text))

Kami telah belajar di atas bahwa indeks B-TREE TIDAK berguna untuk mempercepat SQL melakukan PENCARIAN TEKS LENGKAP pada data JSON menggunakan operator (seperti “@>”) , dan Indeks semacam itu HANYA akan membantu mempercepat kueri seperti yang di bawah ini, yang merupakan SQL tipe RDBMS khas (yang bukan permintaan pencarian). Setiap kunci Objek JSON dapat diindeks satu per satu, yang akan membantu mempercepat kueri saat Kunci Objek JSON Terindeks tersebut menggunakan klausa WHERE.
Contoh kueri di bawah ini menggunakan Kunci Objek “l_shipmode” dalam klausa WHERE dan sejak itu diindeks, kueri akan melakukan pemindaian indeks. Jika Anda ingin mencari menggunakan Kunci Objek yang berbeda, kueri akan memilih untuk melakukan FULL-TABLE-SCAN.

dbt3=# explain select * from products where order_details->>'l_shipmode'='AIR';
                                   QUERY PLAN
---------------------------------------------------------------------------------
 Index Scan using idx on products  (cost=0.56..1158369.34 rows=299930 width=252)
   Index Cond: ((order_details ->> 'l_shipmode'::text) = 'AIR'::text)

Sama bekerja dengan tipe data JSON juga

dbt3=# create index idx on products((order_details->>'l_shipmode'));
CREATE INDEX

dbt3=# \d products
                  Table "dbt3.products"
    Column     |  Type  | Collation | Nullable | Default
---------------+--------+-----------+----------+---------
 item_code     | bigint |           | not null |
 order_details | json  |           |          |
Indexes:
    "products_pkey" PRIMARY KEY, btree (item_code)
    "idx" btree ((order_details ->> 'l_shipmode'::text))

Jika Anda bisa mengamati, kuerinya menggunakan Indeks

dbt3=# explain select * from products where order_details->>'l_shipmode'='AIR';
                                   QUERY PLAN
---------------------------------------------------------------------------------
 Index Scan using idx on products  (cost=0.56..1158369.34 rows=299930 width=252)
   Index Cond: ((order_details ->> 'l_shipmode'::text) = 'AIR'::text)

Kesimpulan

Berikut beberapa hal yang perlu diingat saat menggunakan Data JSON PostgreSQL...

  • PostgreSQL adalah salah satu opsi terbaik untuk menyimpan dan memproses Data JSON
  • Dengan semua fitur canggih, PostgreSQL dapat menjadi database dokumen Anda
  • Saya telah melihat arsitektur di mana dua atau lebih penyimpanan data dipilih, dengan campuran database PostgreSQL dan NoSQL seperti database MongoDB atau Couchbase. REST API akan membantu aplikasi mendorong data ke penyimpanan data yang berbeda. Dengan PostgreSQL yang mendukung JSON, kerumitan arsitektur ini dapat dihindari hanya dengan memilih satu penyimpanan data.
  • Data JSON di PostgreSQL dapat dikueri dan diindeks yang menghasilkan kinerja dan skalabilitas yang luar biasa
  • Jenis data JSONB adalah opsi yang paling disukai karena bagus dalam penyimpanan dan kinerja. Sepenuhnya mendukung PENCARIAN TEKS LENGKAP dan Pengindeksan. Memberikan kinerja yang baik
  • Gunakan tipe data JSON hanya jika Anda ingin menyimpan string JSON sebagai JSON dan Anda tidak melakukan banyak pencarian teks yang rumit
  • Keuntungan terbesar memiliki JSON di PostgreSQL adalah pencarian dapat dilakukan menggunakan SQL
  • Kinerja pencarian JSON di PostgreSQL telah setara dengan database NoSQL terbaik seperti MongoDB

  1. Database
    2.   
  2. Mysql
    3.   
  3. Oracle
    4.   
  4. Sqlserver
    5.   
  5. PostgreSQL
    6.   
  6. Access
    7.   
  7. SQLite
    8.   
  8. MariaDB

  1. Bisakah saya menulis fungsi PostgreSQL di Ruby on Rails?

  2. Dapatkan Nama Hari dari Tanggal di PostgreSQL

  3. Catatan berbasis kursor di PostgreSQL

  4. Memasukkan pernyataan siap pakai ke database - PSQL

  5. Postgresql json menyukai kueri