Bagaimana cara saya melempar string ke integer dan memiliki 0 jika terjadi kesalahan dalam cetakan dengan PostgreSQL?

Di PostgreSQL saya memiliki tabel dengan kolom varchar. Data seharusnya berupa bilangan bulat dan saya membutuhkannya dalam tipe bilangan bulat dalam kueri. Beberapa nilai adalah string kosong. Pengikut:

SELECT myfield::integer FROM mytable

hasil panen ERROR: invalid input syntax for integer: ""

Bagaimana saya bisa meminta para pemain dan memiliki 0 jika terjadi kesalahan selama para pemain di postgres?

Saya sendiri hanya bergulat dengan masalah yang sama, tetapi tidak ingin overhead fungsi. Saya datang dengan pertanyaan berikut:

SELECT myfield::integer FROM mytable WHERE myfield ~ E'^\\d+$';

Postgres memintas kondisinya, jadi Anda seharusnya tidak mendapatkan non-integer yang mengenai cast :: integer Anda. Itu juga menangani nilai NULL (mereka tidak akan cocok dengan regexp).

Jika Anda ingin nol bukannya tidak memilih, maka pernyataan KASUS akan berfungsi:

SELECT CASE WHEN myfield~E'^\\d+$' THEN myfield::integer ELSE 0 END FROM mytable;

Anda juga dapat membuat fungsi konversi Anda sendiri, di dalamnya Anda dapat menggunakan blok pengecualian:

CREATE OR REPLACE FUNCTION convert_to_integer(v_input text)
RETURNS INTEGER AS $$
DECLARE v_int_value INTEGER DEFAULT NULL;
BEGIN
    BEGIN
        v_int_value := v_input::INTEGER;
    EXCEPTION WHEN OTHERS THEN
        RAISE NOTICE 'Invalid integer value: "%".  Returning NULL.', v_input;
        RETURN NULL;
    END;
RETURN v_int_value;
END;
$$ LANGUAGE plpgsql;

Pengujian:

=# select convert_to_integer('1234');
 convert_to_integer 
--------------------
               1234
(1 row)

=# select convert_to_integer('');
NOTICE:  Invalid integer value: "".  Returning NULL.
 convert_to_integer 
--------------------

(1 row)

=# select convert_to_integer('chicken');
NOTICE:  Invalid integer value: "chicken".  Returning NULL.
 convert_to_integer 
--------------------

(1 row)

Saya mempunyai kebutuhan yang sama dan merasa ini bekerja dengan baik untuk saya (postgres 8.4):

CAST((COALESCE(myfield,'0')) AS INTEGER)

Beberapa kasus uji untuk menunjukkan:

db=> select CAST((COALESCE(NULL,'0')) AS INTEGER);
 int4
------
    0
(1 row)

db=> select CAST((COALESCE('','0')) AS INTEGER);
 int4
------
    0
(1 row)

db=> select CAST((COALESCE('4','0')) AS INTEGER);
 int4
------
    4
(1 row)

db=> select CAST((COALESCE('bad','0')) AS INTEGER);
ERROR:  invalid input syntax for integer: "bad"

Jika Anda perlu menangani kemungkinan bidang memiliki teks non-numerik (seperti "100bad"), Anda dapat menggunakan regexp_replace untuk menghapus karakter non-numerik sebelum pemeran.

CAST(REGEXP_REPLACE(COALESCE(myfield,'0'), '[^0-9]+', '', 'g') AS INTEGER)

Kemudian nilai teks / varchar seperti "b3ad5" juga akan memberikan angka

db=> select CAST(REGEXP_REPLACE(COALESCE('b3ad5','0'), '[^0-9]+', '', 'g') AS INTEGER);
 regexp_replace
----------------
             35
(1 row)

Untuk mengatasi kekhawatiran Chris Cogdon dengan solusi tidak memberikan 0 untuk semua kasus, termasuk kasus seperti "buruk" (tidak ada karakter digit sama sekali), saya membuat pernyataan yang disesuaikan ini:

CAST((COALESCE(NULLIF(REGEXP_REPLACE(myfield, '[^0-9]+', '', 'g'), ''), '0')) AS INTEGER);

Ini berfungsi mirip dengan solusi yang lebih sederhana, kecuali akan memberikan 0 ketika nilai untuk dikonversi adalah karakter non-digit saja, seperti "buruk":

db=> select CAST((COALESCE(NULLIF(REGEXP_REPLACE('no longer bad!', '[^0-9]+', '', 'g'), ''), '0')) AS INTEGER);
     coalesce
----------
        0
(1 row)

Ini mungkin semacam peretasan, tapi itu menyelesaikan pekerjaan dalam kasus kami:

(0 || myfield)::integer

Penjelasan (Diuji pada Postgres 8.4):

Ekspresi yang disebutkan di atas menghasilkan NULLuntuk nilai-nilai NULL di myfielddan 0untuk string kosong (Perilaku tepat ini mungkin cocok atau tidak cocok dengan kasus penggunaan Anda).

SELECT id, (0 || values)::integer from test_table ORDER BY id

Data uji:

CREATE TABLE test_table
(
  id integer NOT NULL,
  description character varying,
  "values" character varying,
  CONSTRAINT id PRIMARY KEY (id)
)

-- Insert Test Data
INSERT INTO test_table VALUES (1, 'null', NULL);
INSERT INTO test_table VALUES (2, 'empty string', '');
INSERT INTO test_table VALUES (3, 'one', '1');

Kueri akan menghasilkan hasil berikut:

 ---------------------
 |1|null        |NULL|
 |2|empty string|0   |
 |3|one         |1   |
 ---------------------

Sedangkan pilih saja values::integerakan menghasilkan pesan kesalahan.

Semoga ini membantu.

SELECT CASE WHEN myfield="" THEN 0 ELSE myfield::integer END FROM mytable

Saya belum pernah bekerja dengan PostgreSQL tapi saya memeriksa manual untuk sintaks yang benar dari pernyataan IF dalam permintaan SELECT.

@ Jawaban Matthew bagus. Tetapi bisa lebih sederhana dan lebih cepat. Dan pertanyaannya meminta untuk mengonversi string kosong ( '') menjadi 0, tetapi bukan input "sintaks input tidak valid" atau "di luar kisaran" lainnya:

CREATE OR REPLACE FUNCTION convert_to_int(text)
  RETURNS int AS
$func$
BEGIN
   IF $1 = '' THEN  -- special case for empty string like requested
      RETURN 0;
   ELSE
      RETURN $1::int;
   END IF;

EXCEPTION WHEN OTHERS THEN
   RETURN NULL;  -- NULL for other invalid input

END
$func$  LANGUAGE plpgsql IMMUTABLE;

Ini mengembalikan 0string kosong dan NULLinput tidak valid lainnya.
Itu dapat dengan mudah diadaptasi untuk konversi tipe data apa pun .

Memasuki blok pengecualian jauh lebih mahal. Jika string kosong adalah umum , masuk akal untuk menangkap kasus itu sebelum mengajukan pengecualian.
Jika string kosong sangat jarang, ia membayar untuk memindahkan tes ke klausa pengecualian.

CREATE OR REPLACE FUNCTION parse_int(s TEXT) RETURNS INT AS $$
BEGIN
  RETURN regexp_replace(('0' || s), '[^\d]', '', 'g')::INT;
END;
$$ LANGUAGE plpgsql;

Fungsi ini akan selalu kembali 0jika tidak ada digit dalam string input.

SELECT parse_int('test12_3test');

akan kembali 123

Saya menemukan kode berikut ini mudah dan berfungsi. Jawaban asli ada di sini https://www.postgresql.org/message-id/371F1510.F86C876B@sferacarta.com

prova=> create table test(t text, i integer);
CREATE

prova=> insert into test values('123',123);
INSERT 64579 1

prova=> select cast(i as text),cast(t as int)from test;
text|int4
----+----
123| 123
(1 row)

semoga membantu

SUBSTRING dapat membantu untuk beberapa kasus, Anda dapat membatasi ukuran int.

SELECT CAST(SUBSTRING('X12312333333333', '([\d]{1,9})') AS integer);

Jika data seharusnya berupa bilangan bulat, dan Anda hanya perlu nilai-nilai itu sebagai bilangan bulat, mengapa Anda tidak melakukan yang terbaik dan mengonversi kolom menjadi kolom bilangan bulat?

Kemudian Anda bisa melakukan konversi nilai ilegal ini menjadi nol hanya sekali, pada titik sistem di mana data dimasukkan ke dalam tabel.

Dengan konversi di atas, Anda memaksa Postgres untuk mengonversi nilai-nilai itu lagi dan lagi untuk setiap baris di setiap kueri untuk tabel itu - ini secara serius dapat menurunkan kinerja jika Anda melakukan banyak pertanyaan terhadap kolom ini dalam tabel ini.

Fungsi berikut tidak

• gunakan nilai default ( error_result) untuk hasil yang tidak dapat dicasting misalnya abcatau999999999999999999999999999999999999999999
• terus nullsebagainull
• memangkas ruang dan spasi putih lainnya dalam input
• nilai-nilai yang dicantumkan valid bigintsdibandingkan lower_bounddengan misalnya hanya menegakkan nilai-nilai positif

CREATE OR REPLACE FUNCTION cast_to_bigint(text) 
RETURNS BIGINT AS $$
DECLARE big_int_value BIGINT DEFAULT NULL;
DECLARE error_result  BIGINT DEFAULT -1;
DECLARE lower_bound   BIGINT DEFAULT 0;
BEGIN
    BEGIN
        big_int_value := CASE WHEN $1 IS NOT NULL THEN GREATEST(TRIM($1)::BIGINT, lower_bound) END;
    EXCEPTION WHEN OTHERS THEN
        big_int_value := error_result;
    END;
RETURN big_int_value;
END;

Saya juga memiliki kebutuhan yang sama tetapi bekerja dengan JPA 2.0 dan Hibernate 5.0.2:

SELECT p FROM MatchProfile p WHERE CONCAT(p.id, '') = :keyword

Keajaiban bekerja. Saya pikir itu bekerja dengan LIKE juga.

Ini juga harus melakukan pekerjaan tetapi ini di SQL dan tidak spesifik postgres.

select avg(cast(mynumber as numeric)) from my table