Afinitatea tipurilor și typeof() în SQLite

typeof(expresie)  -- 'integer', 'real', 'text', 'blob' sau 'null'

Ce face Afinitatea tipurilor și typeof()

SQLite are cinci clase de stocare pentru valori: NULL, INTEGER, REAL, TEXT și BLOB. Într-un tabel obișnuit (nu STRICT), orice coloană poate ține orice tip de valoare. Tipul declarat al coloanei îi dă doar o afinitate: o preferință aplicată la inserare.

Afinitatea se deduce din numele tipului, cu reguli aplicate în ordine: dacă numele conține INT, afinitatea este INTEGER; dacă conține CHAR, CLOB sau TEXT, este TEXT; dacă conține BLOB sau lipsește, este BLOB (valorile rămân cum sunt); dacă conține REAL, FLOA sau DOUB, este REAL; altfel este NUMERIC.

Conversia are loc doar dacă nu pierde informație: textul '42' intră ca număr 42 într-o coloană INTEGER, dar 'Ana' rămâne text în aceeași coloană. Funcția typeof() îți arată clasa reală a unei valori.

Parametri

Parametru	Descriere
expresie	Orice valoare sau coloană.

Ce returnează

Textul 'integer', 'real', 'text', 'blob' sau 'null'.

Exemple

Exemplul 1: Aceeași valoare, coloane diferite

Inserăm aceleași texte în coloane cu afinități diferite. INTEGER transformă '42' în număr; TEXT face din numărul 42 textul '42'; REAL face din '3' numărul 3.0; NUMERIC face din '7.0' întregul 7; BLOB și coloana fără tip păstrează valoarea exact cum a venit.

CREATE TABLE t (a INTEGER, b TEXT, c REAL, d NUMERIC, e BLOB, f);
INSERT INTO t VALUES ('42', 42, '3', '7.0', '5', '5');
SELECT typeof(a), typeof(b), typeof(c), c, typeof(d), d, typeof(e), typeof(f) FROM t;

Rezultat

╭───────────┬───────────┬───────────┬─────┬───────────┬───┬───────────┬───────────╮
│ typeof(a) │ typeof(b) │ typeof(c) │  c  │ typeof(d) │ d │ typeof(e) │ typeof(f) │
╞═══════════╪═══════════╪═══════════╪═════╪═══════════╪═══╪═══════════╪═══════════╡
│ integer   │ text      │ real      │ 3.0 │ integer   │ 7 │ text      │ text      │
╰───────────┴───────────┴───────────┴─────┴───────────┴───┴───────────┴───────────╯

Exemplul 2: Ce nu poate fi convertit rămâne cum este

'Ana' nu este un număr, deci rămâne text chiar dacă coloana este INTEGER. În coloana TEXT, '0042' își păstrează zerourile de la început.

CREATE TABLE elevi (cod TEXT, varsta INTEGER);
INSERT INTO elevi VALUES ('0042', '17'), ('0043', 'Ana');
SELECT cod, varsta, typeof(varsta) AS tip FROM elevi;

Rezultat

╭──────┬────────┬─────────╮
│ cod  │ varsta │   tip   │
╞══════╪════════╪═════════╡
│ 0042 │     17 │ integer │
│ 0043 │ Ana    │ text    │
╰──────┴────────┴─────────╯

Exemplul 3: Nume de tipuri care păcălesc

FLOATING POINT conține „INT” (în „POINT”), deci are afinitate INTEGER. STRING nu se potrivește cu nicio regulă, deci are afinitate NUMERIC și textul '12' devine număr. Comparațiile între literale nu au afinitate: textul '10' nu este egal cu numărul 10, iar orice număr este „mai mic” decât orice text.

CREATE TABLE u (x FLOATING POINT, y STRING, z DATETIME);
INSERT INTO u VALUES ('3', '12', '2026-10-25');
SELECT typeof(x), typeof(y), typeof(z) FROM u;
SELECT '10' = 10 AS text_egal_numar, 10 < '9' AS numar_mai_mic_ca_text;

Rezultat

╭───────────┬───────────┬───────────╮
│ typeof(x) │ typeof(y) │ typeof(z) │
╞═══════════╪═══════════╪═══════════╡
│ integer   │ integer   │ text      │
╰───────────┴───────────┴───────────╯
╭─────────────────┬───────────────────────╮
│ text_egal_numar │ numar_mai_mic_ca_text │
╞═════════════════╪═══════════════════════╡
│               0 │                     1 │
╰─────────────────┴───────────────────────╯

Greșeli frecvente

• Declari telefon INTEGER sau cod_postal INTEGER. Zerourile de la început se pierd ('0745' devine 745); pentru coduri folosește TEXT.
• Folosești STRING pentru texte. Are afinitate NUMERIC, nu TEXT, deci '007' devine 7. Scrie TEXT.
• Compari o coloană fără tip care conține texte cu un număr (WHERE f = 5). Textul '5' nu este egal cu numărul 5; convertește cu CAST(f AS INTEGER) sau salvează valorile cu tipul potrivit.
• Vrei ca SQLite să refuze tipurile greșite. Afinitatea nu refuză nimic; pentru asta există tabelele STRICT.

Comenzi înrudite

• Tabele STRICT: Un tabel STRICT verifică tipul fiecărei valori la scriere și refuză, cu eroare, valorile care nu se potrivesc cu coloana.
• CREATE TABLE: Creează un tabel nou. În SQLite tipul coloanei este opțional și doar sugerează cum se salvează valorile.
• .import: Încarcă un fișier CSV într-un tabel: îl creează din antetul fișierului sau adaugă rândurile într-un tabel existent.
• PRAGMA table_info: Afișează coloanele unui tabel: poziția, numele, tipul declarat, NOT NULL, valoarea implicită și cheia primară.