Penugasan PILIH KE Tanpa operasi SQL Dinamis Nilai yang ditampilkan Kondisional: JIKA Kondisional: KASUS Loop Cursors MENAIKKAN Kontrol transaksi

Pernyataan PL/PGSQL yang didukung

Pernyataan PL/PGSQL menambah perintah SQL dengan konstruksi prosedural, termasuk perulangan dan ekspresi bersyarat, untuk mengontrol aliran logis. Sebagian besar perintah SQL dapat digunakan, termasuk bahasa manipulasi data (DHTML) seperti COPY, UNLOAD, dan INSERT, dan bahasa definisi data (DDL) seperti CREATE TABLE. Untuk daftar perintah SQL yang komprehensif, lihatSQLperintah. Selain itu, pernyataan PL/PGSQL berikut didukung oleh Amazon Redshift.

Penugasan

Pernyataan penugasan memberikan nilai ke variabel. Ekspresi harus mengembalikan satu nilai.


identifier := expression;

Menggunakan nonstandar = untuk penugasan, alih-alih:=, juga diterima.

Jika tipe data ekspresi tidak cocok dengan tipe data variabel atau variabel memiliki ukuran atau presisi, nilai hasil secara implisit dikonversi.

Berikut ini menunjukkan contoh.


customer_number := 20;
tip := subtotal * 0.15;

PILIH KE

Pernyataan SELECT INTO memberikan hasil dari beberapa kolom (tetapi hanya satu baris) ke dalam variabel rekaman atau daftar variabel skalar.


SELECT INTO target select_expressions FROM ...;

Dalam sintaks sebelumnya, target dapat berupa variabel rekaman atau daftar variabel sederhana dan bidang catatan yang dipisahkan koma. Daftar select_expressions dan sisa perintah sama seperti di SQL biasa.

Jika daftar variabel digunakan sebagai target, nilai yang dipilih harus sama persis dengan struktur target, atau kesalahan runtime terjadi. Ketika variabel rekaman adalah target, secara otomatis mengkonfigurasi dirinya sendiri ke jenis baris kolom hasil kueri.

Klausa INTO dapat muncul hampir di mana saja dalam pernyataan SELECT. Biasanya muncul tepat setelah klausa SELECT, atau tepat sebelum klausa FROM. Artinya, muncul tepat sebelum atau setelah daftar select_expressions.

Jika query mengembalikan nol baris, nilai NULL ditetapkan ke target. Jika kueri mengembalikan beberapa baris, baris pertama ditetapkan ke target dan sisanya dibuang. Kecuali pernyataan tersebut berisi ORDER BY, baris pertama tidak deterministik.

Untuk menentukan apakah tugas mengembalikan setidaknya satu baris, gunakan variabel FOUND khusus.


SELECT INTO customer_rec * FROM cust WHERE custname = lname;
IF NOT FOUND THEN
  RAISE EXCEPTION 'employee % not found', lname;
END IF;

Untuk menguji apakah hasil record adalah null, Anda dapat menggunakan IS NULL bersyarat. Tidak ada cara untuk menentukan apakah ada baris tambahan yang mungkin telah dibuang. Contoh berikut menangani kasus di mana tidak ada baris yang dikembalikan.


CREATE OR REPLACE PROCEDURE select_into_null(return_webpage OUT varchar(256))
AS $$
DECLARE
  customer_rec RECORD;
BEGIN
  SELECT INTO customer_rec * FROM users WHERE user_id=3;
  IF customer_rec.webpage IS NULL THEN
    -- user entered no webpage, return "http://"
    return_webpage = 'http://';
  END IF;
END;
$$ LANGUAGE plpgsql;

Tanpa operasi

Pernyataan no-op (NULL;) adalah pernyataan placeholder yang tidak melakukan apa-apa. Pernyataan no-op dapat menunjukkan bahwa satu cabang dari rantai IF-THEN-ELSE kosong.


NULL;

SQL Dinamis

Untuk menghasilkan perintah dinamis yang dapat melibatkan tabel yang berbeda atau tipe data yang berbeda setiap kali dijalankan dari prosedur tersimpan PL/PGSQL, gunakan pernyataan tersebut. EXECUTE


EXECUTE command-string [ INTO target ];

Di baris sebelumnya, command-string adalah ekspresi yang menghasilkan string (dari jenis teks) yang berisi perintah yang akan dijalankan. Nilai command-string ini dikirim ke mesin SQL. Tidak ada substitusi variabel PL/PGSQL yang dilakukan pada string perintah. Nilai-nilai variabel harus dimasukkan dalam string perintah seperti yang dibangun.

catatan

Anda tidak dapat menggunakan pernyataan COMMIT dan ROLLBACK dari dalam SQL dinamis. Untuk informasi tentang menggunakan pernyataan COMMIT dan ROLLBACK dalam prosedur tersimpan, lihat. Mengelola transaksi

Saat bekerja dengan perintah dinamis, Anda sering harus menangani pelolosan tanda kutip tunggal. Sebaiknya lampirkan teks tetap dalam tanda kutip di badan fungsi Anda menggunakan kutipan dolar. Nilai dinamis untuk dimasukkan ke dalam kueri yang dibangun memerlukan penanganan khusus karena mungkin mengandung tanda kutip. Contoh berikut mengasumsikan kutipan dolar untuk fungsi secara keseluruhan, sehingga tanda kutip tidak perlu digandakan.


EXECUTE 'UPDATE tbl SET '
  || quote_ident(colname)
  || ' = '
  || quote_literal(newvalue)
  || ' WHERE key = '
  || quote_literal(keyvalue);

Contoh sebelumnya menunjukkan fungsi quote_ident(text) dan. quote_literal(text) Contoh ini meneruskan variabel yang berisi pengidentifikasi kolom dan tabel ke quote_ident fungsi. Ini juga melewati variabel yang berisi string literal dalam perintah yang dibangun ke quote_literal fungsi. Kedua fungsi mengambil langkah yang tepat untuk mengembalikan teks input yang diapit tanda kutip ganda atau tunggal masing-masing, dengan karakter khusus yang disematkan dengan benar lolos.

Kutipan dolar hanya berguna untuk mengutip teks tetap. Jangan menulis contoh sebelumnya dalam format berikut.


EXECUTE 'UPDATE tbl SET '
  || quote_ident(colname)
  || ' = $$'
  || newvalue
  || '$$ WHERE key = '
  || quote_literal(keyvalue);

Anda tidak melakukan ini karena contoh rusak jika konten newvalue kebetulan berisi $$. Masalah yang sama berlaku untuk pembatas kutipan dolar lainnya yang mungkin Anda pilih. Untuk mengutip teks yang tidak diketahui sebelumnya dengan aman, gunakan quote_literal fungsinya.

Nilai yang ditampilkan

Pernyataan RETURN kembali ke pemanggil dari prosedur yang disimpan.


RETURN;

Bagian berikut menunjukkan satu contoh.


CREATE OR REPLACE PROCEDURE return_example(a int)
AS $$  
BEGIN
  FOR b in 1..10 LOOP
    IF b < a THEN
      RAISE INFO 'b = %', b;
    ELSE
      RETURN;
    END IF;
  END LOOP;
END;
$$ LANGUAGE plpgsql;

Kondisional: JIKA

Pernyataan bersyarat IF dapat mengambil formulir berikut dalam bahasa PL/PGSQL yang digunakan Amazon Redshift:

JIKA... KEMUDIAN


IF boolean-expression THEN
  statements
END IF;

Bagian berikut menunjukkan satu contoh.


IF v_user_id <> 0 THEN
  UPDATE users SET email = v_email WHERE user_id = v_user_id;
END IF;

JIKA... LALU... LAIN


IF boolean-expression THEN
  statements
ELSE
  statements
END IF;

Bagian berikut menunjukkan satu contoh.


IF parentid IS NULL OR parentid = ''
THEN
  return_name = fullname;
  RETURN;
ELSE
  return_name = hp_true_filename(parentid) || '/' || fullname;
  RETURN;
END IF;

JIKA... LALU... ELSIF... LALU... LAIN

Kata kunci ELSIF juga bisa dieja ELSEIF.


IF boolean-expression THEN
  statements
[ ELSIF boolean-expression THEN
  statements
[ ELSIF boolean-expression THEN
  statements
    ...] ]
[ ELSE
  statements ]
END IF;

Bagian berikut menunjukkan satu contoh.


IF number = 0 THEN
  result := 'zero';
ELSIF number > 0 THEN
  result := 'positive';
ELSIF number < 0 THEN
  result := 'negative';
ELSE
  -- the only other possibility is that number is null
  result := 'NULL';
END IF;

Kondisional: KASUS

Pernyataan bersyarat CASE dapat mengambil formulir berikut dalam bahasa PL/PGSQL yang digunakan Amazon Redshift:

KASUS Sederhana
```
CASE search-expression
WHEN expression [, expression [ ... ]] THEN
  statements
[ WHEN expression [, expression [ ... ]] THEN
  statements
  ... ]
[ ELSE
  statements ]
END CASE;
```
Sebuah pernyataan CASE sederhana memberikan eksekusi bersyarat berdasarkan kesetaraan operan.

Nilai ekspresi pencarian dievaluasi satu kali dan berturut-turut dibandingkan dengan setiap ekspresi dalam klausa WHEN. Jika kecocokan ditemukan, maka pernyataan yang sesuai berjalan, dan kemudian kontrol diteruskan ke pernyataan berikutnya setelah END CASE. Ekspresi WHEN selanjutnya tidak dievaluasi. Jika tidak ada kecocokan yang ditemukan, pernyataan ELSE berjalan. Namun, jika ELSE tidak ada, maka pengecualian CASE_NOT_FOUND dimunculkan.

Bagian berikut menunjukkan satu contoh.
```
CASE x
WHEN 1, 2 THEN
  msg := 'one or two';
ELSE
  msg := 'other value than one or two';
END CASE;                  
```
Dicari KASUS
```
CASE
WHEN boolean-expression THEN
  statements
[ WHEN boolean-expression THEN
  statements
  ... ]
[ ELSE
  statements ]
END CASE;
```
Bentuk CASE yang dicari menyediakan eksekusi bersyarat berdasarkan kebenaran ekspresi Boolean.

Setiap ekspresi boolean klausa WHEN dievaluasi secara bergantian, sampai ditemukan yang menghasilkan true. Kemudian pernyataan yang sesuai berjalan, dan kemudian kontrol lolos ke pernyataan berikutnya setelah END CASE. Ekspresi WHEN selanjutnya tidak dievaluasi. Jika tidak ada hasil yang benar ditemukan, pernyataan ELSE dijalankan. Namun, jika ELSE tidak ada, maka pengecualian CASE_NOT_FOUND dimunculkan.

Bagian berikut menunjukkan satu contoh.
```
CASE
WHEN x BETWEEN 0 AND 10 THEN
  msg := 'value is between zero and ten';
WHEN x BETWEEN 11 AND 20 THEN
  msg := 'value is between eleven and twenty';
END CASE;                                
```

Loop

Pernyataan loop dapat mengambil formulir berikut dalam bahasa PL/PGSQL yang digunakan Amazon Redshift:

Loop sederhana


[<<label>>]
LOOP
  statements
END LOOP [ label ];

Loop sederhana mendefinisikan loop tanpa syarat yang diulang tanpa batas hingga diakhiri oleh pernyataan EXIT atau RETURN. Label opsional dapat digunakan oleh pernyataan EXIT dan CONTINUE dalam loop bersarang untuk menentukan loop mana yang dirujuk oleh pernyataan EXIT dan CONTINUE.

Bagian berikut menunjukkan satu contoh.


CREATE OR REPLACE PROCEDURE simple_loop()
LANGUAGE plpgsql
AS $$
BEGIN
  <<simple_while>>
  LOOP
    RAISE INFO 'I am raised once';  
    EXIT simple_while;
    RAISE INFO 'I am not raised';
  END LOOP;
  RAISE INFO 'I am raised once as well';
END;
$$;

Keluar dari loop
```
EXIT [ label ] [ WHEN expression ];
```
Jika label tidak ada, loop terdalam dihentikan dan pernyataan berikut END LOOP berjalan berikutnya. Jika ada label, itu harus berupa label arus atau tingkat luar loop atau blok bersarang. Kemudian, loop atau blok bernama dihentikan dan kontrol berlanjut dengan pernyataan setelah loop atau blok END yang sesuai.

Jika WHEN ditentukan, loop exit hanya terjadi jika ekspresi benar. Jika tidak, kontrol lolos ke pernyataan setelah EXIT.

Anda dapat menggunakan EXIT dengan semua jenis loop; itu tidak terbatas untuk digunakan dengan loop tanpa syarat.

Ketika digunakan dengan blok BEGIN, EXIT meneruskan kontrol ke pernyataan berikutnya setelah akhir blok. Label harus digunakan untuk tujuan ini. EXIT yang tidak berlabel tidak pernah dianggap cocok dengan blok BEGIN.

Bagian berikut menunjukkan satu contoh.
```
CREATE OR REPLACE PROCEDURE simple_loop_when(x int)
LANGUAGE plpgsql
AS $$
DECLARE i INTEGER := 0;
BEGIN
  <<simple_loop_when>>
  LOOP
    RAISE INFO 'i %', i;
    i := i + 1;
    EXIT simple_loop_when WHEN (i >= x);
  END LOOP;
END;
$$;                     
```
Lanjutkan loop
```
CONTINUE [ label ] [ WHEN expression ];
```
Jika label tidak diberikan, eksekusi melompat ke iterasi berikutnya dari loop terdalam. Artinya, semua pernyataan yang tersisa di badan loop dilewati. Kontrol kemudian kembali ke ekspresi kontrol loop (jika ada) untuk menentukan apakah iterasi loop lain diperlukan. Jika label hadir, itu menentukan label loop yang eksekusi dilanjutkan.

Jika WHEN ditentukan, iterasi loop berikutnya dimulai hanya jika ekspresi benar. Jika tidak, kontrol lolos ke pernyataan setelah LANJUTKAN.

Anda dapat menggunakan CONTINUE dengan semua jenis loop; itu tidak terbatas untuk digunakan dengan loop tanpa syarat.
```
CONTINUE mylabel;
```

LINGKARAN SEMENTARA


[<<label>>]
WHILE expression LOOP
  statements
END LOOP [ label ];

Pernyataan WHILE mengulangi urutan pernyataan selama ekspresi boolean mengevaluasi ke true. Ekspresi diperiksa tepat sebelum setiap entri ke badan loop.

Bagian berikut menunjukkan satu contoh.


WHILE amount_owed > 0 AND gift_certificate_balance > 0 LOOP
  -- some computations here
END LOOP;

WHILE NOT done LOOP
  -- some computations here
END LOOP;

UNTUK loop (varian integer)
```
[<<label>>]
FOR name IN [ REVERSE ] expression .. expression LOOP
  statements
END LOOP [ label ];
```
Loop FOR (varian integer) menciptakan loop yang iterasi pada rentang nilai integer. Nama variabel secara otomatis didefinisikan sebagai tipe integer dan hanya ada di dalam loop. Setiap definisi yang ada dari nama variabel diabaikan dalam loop. Dua ekspresi yang memberikan batas bawah dan atas rentang dievaluasi satu kali saat memasuki loop. Jika Anda menentukan REVERSE, maka nilai langkah dikurangi, bukan ditambahkan, setelah setiap iterasi.

Jika batas bawah lebih besar dari batas atas (atau kurang dari, dalam kasus REVERSE), badan loop tidak berjalan. Tidak ada kesalahan yang muncul.

Jika label dilampirkan ke loop FOR, maka Anda dapat mereferensikan variabel loop integer dengan nama yang memenuhi syarat, menggunakan label itu.

Bagian berikut menunjukkan satu contoh.
```
FOR i IN 1..10 LOOP
  -- i will take on the values 1,2,3,4,5,6,7,8,9,10 within the loop
END LOOP;

FOR i IN REVERSE 10..1 LOOP
  -- i will take on the values 10,9,8,7,6,5,4,3,2,1 within the loop
END LOOP;                
```

UNTUK loop (varian set hasil)


[<<label>>]
FOR target IN query LOOP
  statements
END LOOP [ label ];

Targetnya adalah variabel rekaman atau daftar variabel skalar yang dipisahkan koma. Target secara berturut-turut ditetapkan setiap baris yang dihasilkan dari kueri, dan badan loop dijalankan untuk setiap baris.

Loop FOR (varian set hasil) memungkinkan prosedur tersimpan untuk mengulangi hasil kueri dan memanipulasi data yang sesuai.

Bagian berikut menunjukkan satu contoh.


CREATE PROCEDURE cs_refresh_reports() AS $$
DECLARE
  reports RECORD;
BEGIN
  FOR reports IN SELECT * FROM cs_reports ORDER BY sort_key LOOP
    -- Now "reports" has one record from cs_reports
    EXECUTE 'INSERT INTO ' || quote_ident(reports.report_name) || ' ' || reports.report_query;
  END LOOP;
  RETURN;
END;
$$ LANGUAGE plpgsql;

UNTUK loop dengan SQL dinamis


[<<label>>]
FOR record_or_row IN EXECUTE text_expression LOOP 
  statements
END LOOP;

Sebuah FOR loop dengan SQL dinamis memungkinkan prosedur tersimpan untuk iterasi melalui hasil query dinamis dan memanipulasi data yang sesuai.

Bagian berikut menunjukkan satu contoh.


CREATE OR REPLACE PROCEDURE for_loop_dynamic_sql(x int)
LANGUAGE plpgsql
AS $$
DECLARE
  rec RECORD;
  query text;
BEGIN
  query := 'SELECT * FROM tbl_dynamic_sql LIMIT ' || x;
  FOR rec IN EXECUTE query
  LOOP
    RAISE INFO 'a %', rec.a;
  END LOOP;
END;
$$;

Cursors

Daripada menjalankan seluruh kueri sekaligus, Anda dapat mengatur kursor. Kursor merangkum kueri dan membaca hasil kueri beberapa baris sekaligus. Salah satu alasan untuk melakukan ini adalah untuk menghindari overrun memori ketika hasilnya berisi sejumlah besar baris. Alasan lain adalah mengembalikan referensi ke kursor yang telah dibuat oleh prosedur tersimpan, yang memungkinkan pemanggil membaca baris. Pendekatan ini menyediakan cara yang efisien untuk mengembalikan set baris besar dari prosedur yang disimpan.

Untuk menggunakan kursor dalam prosedur tersimpan NONATOMIC, tempatkan kursor loop antara MULAI TRANSAKSI... COMMIT.

Untuk mengatur kursor, pertama Anda mendeklarasikan variabel kursor. Semua akses ke kursor di PL/PGSQL melewati variabel kursor, yang selalu dari tipe data khusus. refcursor Tipe refcursor data hanya memegang referensi ke kursor.

Anda dapat membuat variabel kursor dengan mendeklarasikannya sebagai variabel tipe. refcursor Atau, Anda dapat menggunakan sintaks deklarasi kursor berikut.


name CURSOR [ ( arguments ) ] FOR query ;

Dalam hal sebelumnya, argumen (jika ditentukan) adalah daftar dipisahkan koma dari pasangan tipe data nama yang masing-masing mendefinisikan nama yang akan diganti dengan nilai parameter dalam kueri. Nilai aktual untuk menggantikan nama-nama ini ditentukan kemudian, ketika kursor dibuka.

Berikut ini menunjukkan contoh.


DECLARE
  curs1 refcursor;
  curs2 CURSOR FOR SELECT * FROM tenk1;
  curs3 CURSOR (key integer) IS SELECT * FROM tenk1 WHERE unique1 = key;

Ketiga variabel ini memiliki tipe datarefcursor, tetapi yang pertama dapat digunakan dengan kueri apa pun. Sebaliknya, yang kedua memiliki kueri yang ditentukan sepenuhnya yang sudah terikat padanya, dan yang terakhir memiliki kueri berparameter yang terikat padanya. keyNilai digantikan oleh nilai parameter integer ketika kursor dibuka. Variabel curs1 dikatakan tidak terikat karena tidak terikat pada kueri tertentu.

Sebelum Anda dapat menggunakan kursor untuk mengambil baris, itu harus dibuka. PL/PGSQL memiliki tiga bentuk pernyataan OPEN, di mana dua menggunakan variabel kursor tak terikat dan yang ketiga menggunakan variabel kursor terikat:

Buka untuk pilih: Variabel kursor dibuka dan diberikan kueri yang ditentukan untuk dijalankan. Kursor belum bisa dibuka. Juga, itu pasti telah dideklarasikan sebagai kursor tidak terikat (yaitu, sebagai refcursor variabel sederhana). Kueri SELECT diperlakukan dengan cara yang sama seperti pernyataan SELECT lainnya di PL/PGSQL.
```
OPEN cursor_name FOR SELECT ...;                     
```
Bagian berikut menunjukkan satu contoh.
```
OPEN curs1 FOR SELECT * FROM foo WHERE key = mykey;    
```
Buka untuk dieksekusi: Variabel kursor dibuka dan diberikan kueri yang ditentukan untuk dijalankan. Kursor belum bisa dibuka. Juga, itu pasti telah dideklarasikan sebagai kursor tidak terikat (yaitu, sebagai refcursor variabel sederhana). Query ditentukan sebagai ekspresi string dengan cara yang sama seperti pada perintah EXECUTE. Pendekatan ini memberikan fleksibilitas sehingga kueri dapat bervariasi dari satu run ke yang berikutnya.
```
OPEN cursor_name FOR EXECUTE query_string;
```
Bagian berikut menunjukkan satu contoh.
```
OPEN curs1 FOR EXECUTE 'SELECT * FROM ' || quote_ident($1);
```
Buka kursor terikat: Bentuk OPEN ini digunakan untuk membuka variabel kursor yang kuerinya terikat padanya ketika dideklarasikan. Kursor belum bisa dibuka. Daftar ekspresi nilai argumen aktual harus muncul jika dan hanya jika kursor dideklarasikan untuk mengambil argumen. Nilai-nilai ini diganti dalam kueri.
```
OPEN bound_cursor_name [ ( argument_values ) ];
```
Bagian berikut menunjukkan satu contoh.
```
OPEN curs2;
OPEN curs3(42);
```

Setelah kursor dibuka, Anda dapat bekerja dengannya dengan menggunakan pernyataan yang dijelaskan berikut. Pernyataan ini tidak harus terjadi dalam prosedur tersimpan yang sama yang membuka kursor. Anda dapat mengembalikan refcursor nilai dari prosedur yang disimpan dan membiarkan pemanggil beroperasi pada kursor. Semua portal ditutup secara implisit pada akhir transaksi. Dengan demikian, Anda dapat menggunakan refcursor nilai untuk mereferensikan kursor terbuka hanya sampai akhir transaksi.

FETCH mengambil baris berikutnya dari kursor ke target. Target ini dapat berupa variabel baris, variabel rekaman, atau daftar variabel sederhana yang dipisahkan koma, seperti halnya SELECT INTO. Seperti halnya SELECT INTO, Anda dapat memeriksa variabel khusus FOUND untuk melihat apakah baris diperoleh.
```
FETCH cursor INTO target;
```
Bagian berikut menunjukkan satu contoh.
```
FETCH curs1 INTO rowvar;
```
CLOSE menutup portal yang mendasari kursor terbuka. Anda dapat menggunakan pernyataan ini untuk melepaskan sumber daya lebih awal dari akhir transaksi. Anda juga dapat menggunakan pernyataan ini untuk membebaskan variabel kursor untuk dibuka lagi.
```
CLOSE cursor;
```
Bagian berikut menunjukkan satu contoh.
```
CLOSE curs1;
```

MENAIKKAN

Gunakan RAISE level pernyataan untuk melaporkan pesan dan memunculkan kesalahan.


RAISE level 'format' [, variable [, ...]];

Level yang mungkin adalah NOTICE, INFO, LOG, WARNING, dan EXCEPTION. EXCEPTION menimbulkan kesalahan, yang biasanya membatalkan transaksi saat ini. Level lain hanya menghasilkan pesan dari tingkat prioritas yang berbeda.

Di dalam format string,% digantikan oleh representasi string argumen opsional berikutnya. Tulis%% untuk memancarkan% literal. Saat ini, argumen opsional harus variabel sederhana, bukan ekspresi, dan formatnya harus berupa string literal sederhana.

Dalam contoh berikut, nilai v_job_id menggantikan% dalam string.


RAISE NOTICE 'Calling cs_create_job(%)', v_job_id;

Gunakan RAISE pernyataan untuk melempar kembali pengecualian yang ditangkap oleh blok penanganan pengecualian. Pernyataan ini hanya valid di blok penanganan pengecualian dari prosedur tersimpan mode NONATOMIC.


RAISE;

Kontrol transaksi

Anda dapat bekerja dengan pernyataan kontrol transaksi dalam bahasa PL/PGSQL yang digunakan Amazon Redshift. Untuk informasi tentang menggunakan pernyataan COMMIT, ROLLBACK, dan TRUNCATE dalam prosedur tersimpan, lihat. Mengelola transaksi

Dalam prosedur tersimpan mode NONATOMIC, gunakan START TRANSACTION untuk memulai blok transaksi.


START TRANSACTION;

catatan

Pernyataan PL/PGSQL MULAI TRANSAKSI berbeda dari perintah SQL MULAI TRANSAKSI dengan cara berikut:

Dalam prosedur tersimpan, MULAI TRANSAKSI tidak identik dengan BEGIN.
Pernyataan PL/PGSQL tidak mendukung tingkat isolasi opsional dan kata kunci izin akses.

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Struktur PL/PGSQL

Membuat tampilan terwujud