Berikut cara cepat untuk menambahkan tanda kurung di sekitar angka negatif di SQL Server saat menggunakan FORMAT() fungsi.
Tujuannya di sini adalah tanda kurung hanya ditambahkan ke negatif nilai-nilai. Tidak ada tanda kurung yang ditambahkan ke nilai positif atau nol. Selain itu, tanda kurung menggantikan tanda minus apa pun yang seharusnya ditampilkan (dengan kata lain, tidak ada tanda minus yang ditampilkan saat tanda kurung digunakan).
Meskipun pemformatan sering kali paling baik diserahkan ke lapisan presentasi, mungkin ada kasus yang menentukan solusi T-SQL di SQL Server. Dalam kasus seperti itu, semoga artikel ini membantu.
Contoh 1 – Tanda Kurung Otomatis
Seperti disebutkan, solusi dalam artikel ini menggunakan FORMAT() fungsi. Fungsi ini memformat nilai numerik (atau tanggal/waktu), lalu mengembalikan representasi string yang diformat dari nilai tersebut.
Saat memanggil fungsi ini, Anda meneruskan nilai yang akan diformat, dan string format yang menentukan bagaimana itu akan diformat. Anda juga dapat memberikan argumen ketiga untuk menentukan lokal/budaya yang akan digunakan untuk output.
Ke mana saya akan pergi dengan ini, apakah ada beberapa kasus di mana FORMAT() akan secara otomatis mengapit nilai negatif dengan tanda kurung, tergantung pada format string dan budaya yang digunakan.
Berikut adalah contoh pemformatan angka sebagai mata uang menggunakan dua argumen "budaya" yang berbeda:
SELECT FORMAT(-1.23, 'C', 'en-us') 'en-us', FORMAT(-1.23, 'C', 'en-gb') 'en-gb';
Hasil:
+---------+---------+ | en-us | en-gb | |---------+---------| | ($1.23) | -£1.23 | +---------+---------+
Dalam hal ini, kombinasi format string dan budaya yang menentukan apakah nilai negatif dikelilingi oleh tanda kurung atau tidak.
C adalah penentu format numerik standar, yang memformat angka sebagai mata uang. Ketika penentu format ini digunakan, output yang tepat ditentukan oleh budaya. Ini karena budaya yang berbeda menggunakan konvensi yang berbeda untuk menampilkan jumlah mata uang. Budaya akan menentukan simbol mata uang yang sebenarnya akan digunakan, penempatannya, serta bagaimana nilai negatif ditampilkan.
Jika Anda tidak menentukan budaya, bahasa sesi saat ini akan digunakan. Ini biasanya bahasa default untuk pengguna, tetapi juga dapat diubah dengan SET LANGUAGE pernyataan.
Contoh 2 – Pemformatan Bersyarat
Jika string format standar tidak memberikan hasil yang Anda butuhkan, Anda harus menggunakan string format numerik kustom sebagai gantinya.
Berikut ini contoh penggunaan string format numerik khusus untuk menyertakan hasil dalam tanda kurung:
SELECT FORMAT(-123, '0; (0)') Result;
Hasil:
+----------+ | Result | |----------| | (123) | +----------+
Untuk mencapai hasil yang kita inginkan, string format menggunakan pemisah bagian untuk menyediakan pemformatan bersyarat.
Pemformatan bersyarat adalah tempat Anda menentukan format yang berbeda, bergantung pada kondisi tertentu. Saat menggunakan FORMAT() fungsi, Anda dapat menggunakan pemformatan bersyarat untuk menerapkan pemformatan berbeda ke angka, bergantung pada apakah angka itu positif, negatif, atau nol.
Dalam konteks ini, pemformatan bersyarat dimungkinkan oleh titik koma (; ). Ini disebut sebagai "pemisah bagian". Dalam hal ini, saya hanya menggunakan satu titik koma, karena saya hanya ingin dua bagian (untuk membedakan antara negatif dan non-negatif).
Jika hanya dua bagian yang disertakan, bagian pertama berlaku untuk nilai positif dan nol. Bagian kedua berlaku untuk nilai negatif. Anda juga dapat menambahkan titik koma lain untuk menentukan format lain hanya untuk nol (lebih lanjut tentang itu di bawah).
Contoh 3 – Dibandingkan dengan Positif dan Nol
Ini contoh lain, kali ini saya sertakan nilai positif dan nol (hanya untuk menunjukkan poin lebih jelas).
SELECT FORMAT(-123, '0; (0)') Negative, FORMAT(123, '0; (0)') Positive, FORMAT(0, '0; (0)') Zero;
Hasil:
+------------+------------+--------+ | Negative | Positive | Zero | |------------+------------+--------| | (123) | 123 | 0 | +------------+------------+--------+
Contoh 4 – Pemformatan Alternatif
Anda tidak terbatas hanya pada tanda kurung. Anda bisa menggunakan kurung kurawal misalnya, atau tanda kurung siku, atau apa pun yang Anda suka.
SELECT
FORMAT(-123, '0; {0}') R1,
FORMAT(-123, '0; [0]') R2,
FORMAT(-123, '0; WARNING! NEGATIVE VALUE!!!') R3;
Hasil:
+--------+--------+-----------------------------+
| R1 | R2 | R3 |
|--------+--------+-----------------------------|
| {123} | [123] | WARNING! NEGATIVE VALUE!!! |
+--------+--------+-----------------------------+
Contoh 5 – Tiga Kondisi
Seperti yang disebutkan, Anda juga dapat menambahkan kondisi ketiga untuk memberikan pemformatan terpisah untuk nol. Berikut ini contoh singkatnya:
SELECT FORMAT(-123, '0; (0); 0 (Zero)') R1, FORMAT(123, '0; (0); 0 (Zero)') R2, FORMAT(0, '0; (0); 0 (Zero)') R3;
Hasil:
+--------+------+-----------+ | R1 | R2 | R3 | |--------+------+-----------| | (123) | 123 | 0 (Zero) | +--------+------+-----------+
Contoh 6 – Dimana Tanda Minusnya?
Anda mungkin telah memperhatikan bahwa tanda minus bahkan tidak muncul pada nilai negatif. Ini karena pemisah bagian mengabaikan pemformatan yang sudah ada sebelumnya pada suatu nilai (termasuk tanda minus apa pun). Ini berarti, jika Anda menggunakan pemformatan bersyarat, dan Anda benar-benar menginginkan tanda minus pada nilai negatif, Anda harus menambahkannya dalam string format Anda:
SELECT FORMAT(-123, '0; 0 (Negative); 0 (Zero)') 'Without Minus Sign', FORMAT(-123, '0; -0 (Negative); 0 (Zero)') 'With Minus Sign';
Hasil:
+----------------------+-------------------+ | Without Minus Sign | With Minus Sign | |----------------------+-------------------| | 123 (Negative) | -123 (Negative) | +----------------------+-------------------+
Namun, ada beberapa kasus di mana tanda minus tetap utuh (setidaknya di sistem saya):
SELECT FORMAT(123, '0;; 0 (Zero)') Positive, FORMAT(-123, '0;; 0 (Zero)') Negative;
Hasil:
+------------+------------+ | Positive | Negative | |------------+------------| | 123 | -123 | +------------+------------+
Dalam contoh ini, nilai negatif dan positif memiliki bagian yang sama. Ini karena saya menambahkan pemisah bagian untuk nilai negatif tetapi membiarkannya kosong. Dalam hal ini, format string di bagian pertama berlaku untuk dan . positif nilai-nilai negatif.
Seperti disebutkan, dalam kasus ini, tanda minus tetap utuh untuk nilai negatif.
