PostgreSQL Array (Dizi) Tipi: ARRAY[], İndeks ve Dilim, ANY/ALL, unnest, @> ve &&

Dizi sütunu tanımlamak

Belgelere göre yerleşik ya da kullanıcı tanımlı her temel tip, enum, bileşik tip, aralık (range) tipi ve domain için dizi oluşturulabilir. Aşağıdaki tabloda bir makalenin etiketleri text[], okur puanları int[] olarak tutuluyor. Değerleri hem literal hem yapıcı yazımıyla ekledik; bir satırda puan NULL, bir satırda boş dizi:

CREATE TABLE makale (
    id        int PRIMARY KEY,
    baslik    text NOT NULL,
    etiketler text[] NOT NULL DEFAULT '{}',
    puanlar   int[]
);
INSERT INTO makale VALUES
  (1, 'PostgreSQL Kurulumu', '{postgresql,kurulum,linux}', ARRAY[5, 4, 5]),
  (2, 'JSONB Rehberi',       ARRAY['postgresql', 'jsonb'],   '{3,5}'),
  (3, 'Nginx Ayarları',      ARRAY['nginx', 'linux'],        NULL),
  (4, 'Boş Taslak',          '{}',                           '{}');
SELECT id, etiketler, puanlar FROM makale ORDER BY id;

 id |         etiketler          | puanlar 
----+----------------------------+---------
  1 | {postgresql,kurulum,linux} | {5,4,5}
  2 | {postgresql,jsonb}         | {3,5}
  3 | {nginx,linux}              | 
  4 | {}                         | {}
(4 rows)

CREATE TABLE sözdizimi int[3] ya da int[3][3] gibi boyut yazmanıza izin verir, ancak belgeler bunun yalnızca belgeleme amaçlı olduğunu açıkça söyler: ne eleman sayısı ne de boyut sayısı denetlenir. 3x3 olarak tanımlanmış bir sütuna beş elemanlı tek boyutlu bir dizi sorunsuz eklenir:

CREATE TABLE ornek_boyut (kare int[3][3]);
INSERT INTO ornek_boyut VALUES ('{1,2,3,4,5}');
SELECT kare, array_dims(kare) FROM ornek_boyut;

    kare     | array_dims 
-------------+------------
 {1,2,3,4,5} | [1:5]
(1 row)

Eleman sayısına bir sınır gerekiyorsa bunu CHECK (cardinality(sutun) <= 10) gibi bir kısıtla kendiniz koymalısınız; CHECK ve diğer kısıtlar yazısına bakabilirsiniz.

Literal mi ARRAY[] yapıcısı mı?

Literal yazımda ('{...}') değer önce bir metin olarak okunur ve dizi ayrıştırıcısına verilir. Virgül, süslü parantez, boşluk, ters bölü ya da çift tırnak içeren elemanlar, boş metin ve "NULL" kelimesinin kendisi çift tırnakla yazılmalıdır; tırnaksız NULL gerçek bir NULL elemandır. ARRAY[...] yapıcısında ise elemanlar sıradan SQL ifadeleridir, metinler tek tırnakla yazılır. Belgeler de SQL komutlarında yapıcının genellikle daha kolay olduğunu belirtir. İki yazım aynı diziyi üretir:

SELECT '{elma, "armut, kiraz", NULL, "NULL", ""}'::text[] AS literal,
       ARRAY['elma', 'armut, kiraz', NULL, 'NULL', ''] AS yapici;

               literal                |                yapici                
--------------------------------------+--------------------------------------
 {elma,"armut, kiraz",NULL,"NULL",""} | {elma,"armut, kiraz",NULL,"NULL",""}
(1 row)

Çıktı biçimi de aynı kuralı izler: PostgreSQL özel karakter içeren, boş ya da "NULL" yazan elemanları çift tırnakla gösterir. Uygulama tarafında dizi çıktısını kendiniz ayrıştırıyorsanız tırnaklı ve tırnaksız elemanlarla karşılaşmaya hazır olun. Metni diziye bölmek için string_to_array, diziyi metne birleştirmek için array_to_string kullanılır; bu fonksiyonlar string fonksiyonları yazısında da geçiyor.

Eleman ve dilim erişimi

dizi[n] tek bir eleman, dizi[alt:ust] bir dilim (alt dizi) döndürür. Sınırlardan biri yazılmazsa dizinin başı ya da sonu kabul edilir. Sınır dışındaki bir indeks hata değil NULL verir; tamamen sınır dışındaki bir dilim ise NULL yerine boş dizi döndürür (belgeler bu farkın tarihsel nedenlerle böyle olduğunu belirtir). Son elemana ulaşmak için array_upper(dizi, 1) ile üst sınırı alabilirsiniz:

SELECT id, etiketler[1] AS ilk, etiketler[2:3] AS dilim, etiketler[5] AS sinir_disi,
       etiketler[array_upper(etiketler, 1)] AS son
FROM makale ORDER BY id;

 id |    ilk     |      dilim      | sinir_disi |  son  
----+------------+-----------------+------------+-------
  1 | postgresql | {kurulum,linux} |            | linux
  2 | postgresql | {jsonb}         |            | jsonb
  3 | nginx      | {linux}         |            | linux
  4 |            | {}              |            | 
(4 rows)

JSON dizileri sıfırdan, PostgreSQL dizileri birden başlar; ikisini aynı sorguda kullanırken bu fark kolayca hataya yol açar. İsterseniz alt sınırı farklı olan diziler de oluşturabilirsiniz ('[0:2]={a,b,c}'); bu durumda çıktı boyut bilgisini açıkça gösterir ve array_lower 0 döndürür.

Uzunluk: cardinality ve array_length

cardinality(dizi) bütün boyutlardaki toplam eleman sayısını verir ve boş dizi için 0 döndürür. array_length(dizi, boyut) ise belirli bir boyutun uzunluğunu verir, ancak boş dizi için 0 yerine NULL döndürür. WHERE array_length(etiketler, 1) = 0 gibi bir koşul bu yüzden boş dizileri hiçbir zaman bulmaz:

SELECT id, cardinality(etiketler) AS cardinality, array_length(etiketler, 1) AS array_length,
       array_ndims(etiketler) AS ndims, array_dims(etiketler) AS dims
FROM makale ORDER BY id;

 id | cardinality | array_length | ndims | dims  
----+-------------+--------------+-------+-------
  1 |           3 |            3 |     1 | [1:3]
  2 |           2 |            2 |     1 | [1:2]
  3 |           2 |            2 |     1 | [1:2]
  4 |           0 |              |       | 
(4 rows)

Boş dizinin boyut sayısı da NULL çıkıyor; belgeler boş diziyi sıfır boyutlu dizi olarak tanımlar. Boş dizi testi için cardinality(dizi) = 0 ya da dizi = '{}' kullanın. NULL bir dizi ile boş dizi farklı şeylerdir: 3 numaralı satırdaki NULL puan "bilinmiyor", 4 numaralı satırdaki {} "hiç puan yok" anlamına gelir.

Dizide arama: ANY, ALL, @>, &&, <@

Bir değerin dizide geçip geçmediğini sınamanın standart yolu deger = ANY (dizi) ifadesidir (SOME eş anlamlıdır). ALL karşılaştırmanın bütün elemanlar için doğru olmasını ister. Operatör olarak = dışında <, >=, LIKE gibi mantıksal sonuç veren herhangi bir operatör kullanılabilir:

SELECT id, baslik FROM makale WHERE 'linux' = ANY (etiketler) ORDER BY id;

SELECT id, puanlar, 4 = ANY (puanlar) AS herhangi_4, 3 < ALL (puanlar) AS hepsi_3ten_buyuk
FROM makale ORDER BY id;

 id |       baslik        
----+---------------------
  1 | PostgreSQL Kurulumu
  3 | Nginx Ayarları
(2 rows)

 id | puanlar | herhangi_4 | hepsi_3ten_buyuk 
----+---------+------------+------------------
  1 | {5,4,5} | t          | t
  2 | {3,5}   | f          | f
  3 |         |            | 
  4 | {}      | f          | t
(4 rows)

Son satıra dikkat edin: boş dizide ANY yanlış, ALL ise doğru döner. Bu matematiksel olarak tutarlıdır ama "bütün puanlar 3'ten büyük" sorgusunun hiç puanı olmayan makaleyi de getirmesi raporlarda şaşırtıcı olabilir. NULL elemanlar da üç değerli mantığa göre davranır; belgelere göre eşleşme bulunamazsa ve dizide NULL varsa sonuç yanlış değil NULL olur:

SELECT 1 = ANY (ARRAY[2, NULL]) AS any_null, 1 = ANY (ARRAY[1, NULL]) AS any_bulundu,
       1 <> ALL (ARRAY[2, NULL]) AS all_null, 1 = ANY ('{}'::int[]) AS bos_any, 1 = ALL ('{}'::int[]) AS bos_all;

 any_null | any_bulundu | all_null | bos_any | bos_all 
----------+-------------+----------+---------+---------
          | t           |          | f       | t
(1 row)

Bu, NOT IN ile yaşanan bilinen NULL tuzağının dizi karşılığıdır: x <> ALL (dizi) dizide bir NULL varsa hiçbir zaman doğru olmaz.

Birden çok değerle arama için dizi operatörleri daha kısadır. @> soldaki dizinin sağdakinin bütün elemanlarını içerip içermediğini, <@ tersini, && ise en az bir ortak eleman olup olmadığını sınar. Belgelere göre içerme kontrolünde tekrarlar önemsenmez:

SELECT id, baslik FROM makale WHERE etiketler @> ARRAY['postgresql', 'linux'] ORDER BY id;
SELECT id, baslik FROM makale WHERE etiketler && ARRAY['nginx', 'jsonb'] ORDER BY id;
SELECT id, baslik FROM makale WHERE etiketler <@ ARRAY['postgresql', 'jsonb', 'linux', 'kurulum'] ORDER BY id;

 id |       baslik        
----+---------------------
  1 | PostgreSQL Kurulumu
(1 row)

 id |     baslik     
----+----------------
  2 | JSONB Rehberi
  3 | Nginx Ayarları
(2 rows)

 id |       baslik        
----+---------------------
  1 | PostgreSQL Kurulumu
  2 | JSONB Rehberi
  4 | Boş Taslak
(3 rows)

Boş dizi her dizinin alt kümesi sayıldığı için 4 numaralı makale de <@ sonucunda çıktı. Bir değerin konumunu bulmak için array_position, bütün konumları için array_positions kullanılır; ikisi de NULL aramayı destekleyen IS NOT DISTINCT FROM karşılaştırması yapar.

unnest: diziyi satırlara açmak

unnest(dizi) her eleman için bir satır üretir. FROM içinde tabloyla yan yana yazıldığında her satırın kendi dizisi açılır. WITH ORDINALITY eklenirse elemanın sırasını veren ek bir sütun gelir; birden çok dizi verildiğinde ise diziler yan yana açılır ve kısa olanlar NULL ile doldurulur:

SELECT m.id, e.etiket, e.sira
FROM makale m, unnest(m.etiketler) WITH ORDINALITY AS e(etiket, sira)
WHERE m.id = 1;

SELECT * FROM unnest(ARRAY['Ankara', 'İzmir', 'Bursa'], ARRAY[6, 35]) AS t(il, plaka);

 id |   etiket   | sira 
----+------------+------
  1 | postgresql |    1
  1 | kurulum    |    2
  1 | linux      |    3
(3 rows)

   il   | plaka 
--------+-------
 Ankara |     6
 İzmir  |    35
 Bursa  |      
(3 rows)

Açılmış diziler sıradan satırlar olduğu için üzerinde gruplama yapabilirsiniz. Etiket bulutu ya da "bu etiketi taşıyan makaleler" listesi tek sorgudur; ters yönde array_agg satırları yeniden diziye toplar ve kendi içinde ORDER BY kabul eder:

SELECT etiket, count(*) AS makale_sayisi
FROM makale, unnest(etiketler) AS etiket
GROUP BY etiket ORDER BY makale_sayisi DESC, etiket;

SELECT etiket, array_agg(id ORDER BY id) AS makaleler
FROM makale, unnest(etiketler) AS etiket
GROUP BY etiket ORDER BY etiket;

   etiket   | makale_sayisi 
------------+---------------
 linux      |             2
 postgresql |             2
 jsonb      |             1
 kurulum    |             1
 nginx      |             1
(5 rows)

   etiket   | makaleler 
------------+-----------
 jsonb      | {2}
 kurulum    | {1}
 linux      | {1,3}
 nginx      | {3}
 postgresql | {1,2}
(5 rows)

Virgülle yazılan yan yana kullanım iç birleşme gibi davranır ve boş dizili satırları sonuçtan atar. Bütün satırları korumak için LEFT JOIN LATERAL ... ON true yazın; 4 numaralı boş taslak bu sayede NULL etiketle sonuçta kalır:

SELECT m.id, m.baslik, e.etiket
FROM makale m LEFT JOIN LATERAL unnest(m.etiketler) AS e(etiket) ON true
WHERE m.id IN (3, 4) ORDER BY m.id;

 id |     baslik     | etiket 
----+----------------+--------
  3 | Nginx Ayarları | nginx
  3 | Nginx Ayarları | linux
  4 | Boş Taslak     | 
(3 rows)

LATERAL ayrıntısı JOIN türleri ve LATERAL, array_agg ve diğer toplama fonksiyonları GROUP BY ve aggregate fonksiyonlar yazısında. Bir alt sorgunun sonucunu diziye çevirmenin kısa yolu da ARRAY(SELECT ...) yapıcısıdır; örneğin ARRAY(SELECT id FROM makale WHERE etiketler @> '{postgresql}' ORDER BY id) bu tabloda {1,2} döndürdü.

Diziyi güncellemek

Bir diziyi tamamen değiştirebilir, tek bir elemana ya da dilime atama yapabilir, ||, array_append, array_prepend, array_remove ve array_replace ile parça ekleyip çıkarabilirsiniz. Dizinin sonundan uzaktaki bir indekse atama yapmak diziyi büyütür ve aradaki konumları NULL ile doldurur (belgelere göre bu yalnızca tek boyutlu dizilerde geçerlidir):

UPDATE makale SET etiketler = etiketler || 'veritabani'::text WHERE id = 2;
UPDATE makale SET etiketler = array_append(etiketler, 'web') WHERE id = 3;
UPDATE makale SET etiketler = array_remove(etiketler, 'linux') WHERE id = 1;
UPDATE makale SET puanlar[3] = 4 WHERE id = 2;
UPDATE makale SET puanlar[6] = 1 WHERE id = 1;
SELECT id, etiketler, puanlar FROM makale ORDER BY id;

 id |           etiketler           |       puanlar       
----+-------------------------------+---------------------
  1 | {postgresql,kurulum}          | {5,4,5,NULL,NULL,1}
  2 | {postgresql,jsonb,veritabani} | {3,5,4}
  3 | {nginx,linux,web}             | 
  4 | {}                            | {}
(4 rows)

|| operatörünün tuzağı

|| üç ayrı işi üstlenir: dizi ile dizi, eleman ile dizi ve dizi ile eleman birleştirme. Taraflardan biri tipi belirsiz bir sabitse PostgreSQL onu diğer tarafla aynı tipte, yani dizi sayar. Bu yüzden ARRAY[1, 2] || '7' hata verir, ARRAY[1, 2] || NULL ise hiçbir şey eklemez; belgeler bu durumlarda array_append kullanmayı önerir. Yukarıdaki güncellemede 'veritabani'::text dönüşümünü bu yüzden yazdık.

SELECT ARRAY[1, 2] || ARRAY[3, 4] AS dizi_dizi, 0 || ARRAY[1, 2] AS basa, ARRAY[1, 2] || 3 AS sona,
       array_cat(ARRAY[1, 2], ARRAY[3]) AS cat;
SELECT ARRAY[1, 2] || NULL AS null_birlesim, array_append(ARRAY[1, 2], NULL) AS append_null;
SELECT ARRAY[1, 2] || '7';

 dizi_dizi |  basa   |  sona   |   cat   
-----------+---------+---------+---------
 {1,2,3,4} | {0,1,2} | {1,2,3} | {1,2,3}
(1 row)

 null_birlesim | append_null 
---------------+-------------
 {1,2}         | {1,2,NULL}
(1 row)

ERROR:  malformed array literal: "7"
LINE 1: SELECT ARRAY[1, 2] || '7';
                              ^
DETAIL:  Array value must start with "{" or dimension information.

Yardımcı fonksiyonlar ve PostgreSQL 18 yenilikleri

PostgreSQL 18 sürüm notları dizilerle ilgili üç ekleme bildiriyor: dizinin ilk boyutunu sıralayan array_sort(), ilk boyutu ters çeviren array_reverse() ve MIN()/MAX() toplama fonksiyonlarının diziler üzerinde de çalışabilmesi. array_sort isteğe bağlı olarak azalan sıralama ve NULL'ların başa mı sona mı konacağı parametrelerini alır; metin dizileri collation'a göre sıralanır:

SELECT array_sort(ARRAY[3, 1, NULL, 2]) AS artan, array_sort(ARRAY[3, 1, NULL, 2], true) AS azalan,
       array_reverse(ARRAY['a', 'b', 'c']) AS ters,
       array_sort(ARRAY['zeytin', 'çilek', 'armut'] COLLATE "tr-TR-x-icu") AS tr_sirali;
SELECT min(puanlar) AS en_kucuk_dizi, max(puanlar) AS en_buyuk_dizi FROM makale;

    artan     |    azalan    |  ters   |      tr_sirali       
--------------+--------------+---------+----------------------
 {1,2,3,NULL} | {NULL,3,2,1} | {c,b,a} | {armut,çilek,zeytin}
(1 row)

 en_kucuk_dizi |    en_buyuk_dizi    
---------------+---------------------
 {}            | {5,4,5,NULL,NULL,1}
(1 row)

Diziler eleman eleman karşılaştırılır; bu yüzden min boş diziyi, max ise ilk elemanı en büyük olan diziyi seçti. Türkçe sıralama kuralları collation ve Türkçe sıralama yazısında. Diğer sık kullanılanlar:

SELECT array_position(ARRAY['pzt', 'sal', 'çar', 'per'], 'çar') AS konum,
       array_positions(ARRAY[1, 4, 3, 1], 1) AS konumlar,
       array_replace(ARRAY[1, 2, 5, 4], 5, 3) AS degistir,
       array_to_string(ARRAY['a', NULL, 'c'], ',', '-') AS metne,
       string_to_array('a;b;c', ';') AS diziye;

 konum | konumlar | degistir  | metne | diziye  
-------+----------+-----------+-------+---------
     3 | {1,4}    | {1,2,3,4} | a,-,c | {a,b,c}
(1 row)

Çok boyutlu diziler

İç içe ARRAY[[...], [...]] yazımı çok boyutlu dizi üretir. Her alt dizinin aynı uzunlukta olması gerekir; PostgreSQL "düzensiz" dizileri kabul etmez. Elemanlara her boyut için ayrı indeksle, alt matrislere dilimle erişilir; cardinality bütün elemanları sayar:

SELECT ARRAY[[1, 2, 3], [4, 5, 6]] AS matris, (ARRAY[[1, 2, 3], [4, 5, 6]])[2][3] AS eleman,
       (ARRAY[[1, 2, 3], [4, 5, 6]])[1:2][2:3] AS alt_matris, cardinality(ARRAY[[1, 2, 3], [4, 5, 6]]) AS toplam;
SELECT ARRAY[[1, 2], [3]];

      matris       | eleman |  alt_matris   | toplam 
-------------------+--------+---------------+--------
 {{1,2,3},{4,5,6}} |      6 | {{2,3},{5,6}} |      6
(1 row)

ERROR:  multidimensional arrays must have array expressions with matching dimensions

Belgelerin bir uyarısı: bir boyutu dilim olarak yazarsanız bütün boyutlar dilim kabul edilir ve tek sayı yazılmış boyut 1:n anlamına gelir. Karışıklığı önlemek için çok boyutlu dilimlerde her boyutu [1:2][1:1] gibi açıkça yazın. Ayrıca array_append ve array_prepend yalnızca tek boyutlu dizilerde çalışır, çok boyutlu birleştirme için array_cat gerekir.

Dizileri GIN indeksi ile aramak

Dizi sütunlarında @>, <@, && ve = aramaları GIN indeksiyle hızlanabilir; GIN, her eleman için ayrı bir indeks girdisi tutan "ters indeks" yapısıdır. Tabloya 20.000 sentetik satır ekleyip planlara baktık:

INSERT INTO makale SELECT g, 'Yazı ' || g,
  CASE WHEN g % 50 = 0 THEN ARRAY['postgresql', 'performans'] ELSE ARRAY['genel'] END, NULL
FROM generate_series(5, 20000) AS g;
CREATE INDEX makale_etiket_gin ON makale USING GIN (etiketler);
ANALYZE makale;

EXPLAIN (COSTS OFF) SELECT id FROM makale WHERE etiketler @> ARRAY['performans'];
EXPLAIN (COSTS OFF) SELECT id FROM makale WHERE 'performans' = ANY (etiketler);

                        QUERY PLAN                         
-----------------------------------------------------------
 Bitmap Heap Scan on makale
   Recheck Cond: (etiketler @> '{performans}'::text[])
   ->  Bitmap Index Scan on makale_etiket_gin
         Index Cond: (etiketler @> '{performans}'::text[])
(4 rows)

                    QUERY PLAN                    
--------------------------------------------------
 Seq Scan on makale
   Filter: ('performans'::text = ANY (etiketler))
(2 rows)

Aynı soruyu soran iki sorgudan yalnızca @> ile yazılanı indeksi kullandı. deger = ANY (sutun) biçimi GIN operatör sınıfının desteklediği operatörlerden biri olmadığı için sıralı taramaya düştü. Dizi sütununda arama yapıyorsanız sorguyu sutun @> ARRAY[deger] biçiminde yazın. Plan okumayı EXPLAIN ANALYZE ile plan okuma, indeks türlerini PostgreSQL indeks türleri yazısında bulabilirsiniz.

Dizi mi ayrı tablo mu?

Belgeler dizilerin küme olmadığını hatırlatır ve dizide belirli elemanları sık sık aramanın bir tasarım sorununa işaret edebileceğini söyler: her eleman için bir satır tutan ayrı bir tablo aramayı kolaylaştırır ve çok sayıda elemanda daha iyi ölçeklenir. Pratik bir kural olarak, eleman sayısı küçükse, elemanlar her zaman birlikte okunup yazılıyorsa ve elemanlara başka tablolardan referans verilmesi gerekmiyorsa dizi uygundur. Elemanların kendi öznitelikleri varsa, bütünlük kısıtları gerekiyorsa ya da tek tek güncelleniyorlarsa ayrı tablo ve yabancı anahtar daha doğrudur. Yarı yapılandırılmış ve iç içe veri için JSONB başka bir seçenektir.

Sık yapılan hatalar

• İndekslerin 0'dan başladığını varsaymak; PostgreSQL dizileri 1'den başlar.
• Boş dizi kontrolünde array_length(d, 1) = 0 yazmak; boş dizi için sonuç NULL'dır. cardinality(d) = 0 kullanın.
• NULL dizi ile boş diziyi aynı saymak.
• Dizide NULL eleman varken x <> ALL (dizi) sonucuna güvenmek.
• dizi || 'metin' yazıp tipsiz sabitin dizi sanılmasıyla hata almak; array_append ya da açık tip dönüşümü kullanın.
• GIN indeksi varken sorguyu = ANY ile yazıp indeksi devre dışı bırakmak.
• int[3] tanımının eleman sayısını sınırladığını düşünmek.

Sık Sorulan Sorular

PostgreSQL'de bir değerin dizide olup olmadığını nasıl kontrol ederim?

WHERE 'linux' = ANY (etiketler) ya da WHERE etiketler @> ARRAY['linux']. Sütunda GIN indeksi varsa ikinci biçim indeksi kullanabilir.

Bir diziye eleman nasıl eklenir?

UPDATE tablo SET sutun = array_append(sutun, 'yeni'). Başa eklemek için array_prepend, başka bir diziyi eklemek için array_cat ya da iki dizi arasında ||. Aynı elemanın tekrar eklenmesini önlemek için koşula NOT (sutun @> ARRAY['yeni']) ekleyebilirsiniz.

Diziyi virgüllü metne nasıl çeviririm?

array_to_string(dizi, ', '). Üçüncü argüman NULL elemanların yerine yazılacak metni belirler; verilmezse NULL elemanlar atlanır.

Dizideki tekrar eden elemanları nasıl kaldırırım?

Diziyi açıp tekrarsız olarak yeniden toplayabilirsiniz: ARRAY(SELECT DISTINCT e FROM unnest(dizi) AS e ORDER BY e). Sıralama gerekmiyorsa ORDER BY yazmayabilirsiniz, ama o durumda sonuç sırası garanti edilmez.

Marka adları sahiplerine aittir. Bu yazı bağımsız bir teknik rehberdir; adı geçen kuruluşlarla bayilik veya ortaklık ilişkisi bulunduğu anlamına gelmez.

İlgili içerikler: PostgreSQL öğrenme rehberi · JSONB kullanımı · GROUP BY ve aggregate · JOIN ve LATERAL · indeks türleri · string fonksiyonları · veri tipleri