Converti SQLite in MySQL

Trascina un file di database SQLite (.db, .sqlite, .sqlite3) o il SQL che scrive il .dump di sqlite3, e scarica uno script per MySQL con le stesse tabelle, chiavi, indici e dati. Ogni colonna riceve il tipo in cui stanno i suoi valori, e ogni valore che MySQL non può contenere così com'è è elencato nel report.

Guida alla migrazione da SQLite a MySQL Tipi di dati da SQLite a MySQL

Il tuo file

sqlshop_2024_sqlite.sqlFile di esempio, 3,4 kB

18 righe convertite, nessuna correzione, nessuna rifiutata

TabelleSQLReport

Tabelle in shop_2024_sqlite.sqlDump SQLite · scritto da sqlite3 · utf-8

customers8 righe
7 colonne
id bigint not null
name text not null
email varchar(768) not null
country varchar(768) not null
is_active tinyint(1) not null
signed_up date
created_at datetime not null
orders10 righe
9 colonne
id bigint not null
customer_id bigint not null
status varchar(768) not null
total decimal(10,2) not null
items int not null
ordered_at datetime not null
shipped_at datetime
note text
receipt blob

7 colonne
id	bigint not null
name	text not null
email	varchar(768) not null
country	varchar(768) not null
is_active	tinyint(1) not null
signed_up	date
created_at	datetime not null

9 colonne
id	bigint not null
customer_id	bigint not null
status	varchar(768) not null
total	decimal(10,2) not null
items	int not null
ordered_at	datetime not null
shipped_at	datetime
note	text
receipt	blob

Non convertiti

Vista order_totals
Trigger orders_shipped

Ogni database li scrive nel proprio linguaggio. Riscrivili per MySQL.

-- Written by IntoSQL from a SQLite dump. Load it with: mysql --default-character-set=utf8mb4 <database> < <file>
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
SET UNIQUE_CHECKS = 0;
SET SQL_MODE = 'NO_AUTO_VALUE_ON_ZERO,ALLOW_INVALID_DATES';

CREATE TABLE `customers` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `name` text NOT NULL,
  `email` varchar(768) NOT NULL,
  `country` varchar(768) NOT NULL DEFAULT 'US',
  `is_active` tinyint(1) NOT NULL DEFAULT 1,
  `signed_up` date,
  `created_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  UNIQUE KEY `email` (`email`),
  CONSTRAINT `check1` CHECK (char_length(`country`) = 2)
) AUTO_INCREMENT=9 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

CREATE TABLE `orders` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `customer_id` bigint NOT NULL,
  `status` varchar(768) NOT NULL DEFAULT 'pending',
  `total` decimal(10,2) NOT NULL,
  `items` int NOT NULL DEFAULT 1,
  `ordered_at` datetime NOT NULL,
  `shipped_at` datetime,
  `note` text,
  `receipt` blob,
  PRIMARY KEY (`id`),
  KEY `idx_orders_customer` (`customer_id`),
  KEY `idx_orders_status_date` (`status`,`ordered_at`),
  CONSTRAINT `check1` CHECK (`status` IN ('pending', 'paid', 'shipped', 'cancelled')),
  FOREIGN KEY (`customer_id`) REFERENCES `customers` (`id`) ON DELETE CASCADE
) AUTO_INCREMENT=11 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

INSERT INTO `customers` (`id`,`name`,`email`,`country`,`is_active`,`signed_up`,`created_at`) VALUES (1,'Ana Martínez','ana@example.com','MX',1,'2023-01-15','2023-01-15 10:24:00');
INSERT INTO `customers` (`id`,`name`,`email`,`country`,`is_active`,`signed_up`,`created_at`) VALUES (2,'Zoë Müller','zoe@example.de','DE',1,'2023-02-03','2023-02-03 08:11:42');
INSERT INTO `customers` (`id`,`name`,`email`,`country`,`is_active`,`signed_up`,`created_at`) VALUES (3,'José Peña','jose@example.es','ES',0,'2023-03-21','2023-03-21 19:05:17');
INSERT INTO `customers` (`id`,`name`,`email`,`country`,`is_active`,`signed_up`,`created_at`) VALUES (4,'李雷','lilei@example.cn','CN',1,'2023-05-09','2023-05-09 02:40:00');
INSERT INTO `customers` (`id`,`name`,`email`,`country`,`is_active`,`signed_up`,`created_at`) VALUES (5,'Noah O\'Brien','noah@example.ie','IE',1,NULL,'2023-06-30 14:00:00');
INSERT INTO `customers` (`id`,`name`,`email`,`country`,`is_active`,`signed_up`,`created_at`) VALUES (6,'Amélie Laurent','amelie@example.fr','FR',1,'2024-01-02','2024-01-02 09:30:00');
INSERT INTO `customers` (`id`,`name`,`email`,`country`,`is_active`,`signed_up`,`created_at`) VALUES (7,'Ravi Patel','ravi@example.in','IN',0,'2024-02-29','2024-02-29 23:59:59');
INSERT INTO `customers` (`id`,`name`,`email`,`country`,`is_active`,`signed_up`,`created_at`) VALUES (8,'Sofia Rossi 🌻','sofia@example.it','IT',1,'2024-04-12','2024-04-12 12:12:12');
INSERT INTO `orders` (`id`,`customer_id`,`status`,`total`,`items`,`ordered_at`,`shipped_at`,`note`,`receipt`) VALUES (1,1,'shipped',129.9,3,'2024-03-01 10:00:00','2024-03-02 16:30:00',NULL,NULL);
INSERT INTO `orders` (`id`,`customer_id`,`status`,`total`,`items`,`ordered_at`,`shipped_at`,`note`,`receipt`) VALUES (2,2,'paid',54,1,'2024-03-02 11:15:00',NULL,'Gift wrap 🎁',NULL);
INSERT INTO `orders` (`id`,`customer_id`,`status`,`total`,`items`,`ordered_at`,`shipped_at`,`note`,`receipt`) VALUES (3,1,'cancelled',12.5,1,'2024-03-03 09:45:00',NULL,'Customer changed their mind',NULL);
INSERT INTO `orders` (`id`,`customer_id`,`status`,`total`,`items`,`ordered_at`,`shipped_at`,`note`,`receipt`) VALUES (4,4,'shipped',980,12,'2024-03-05 02:10:00','2024-03-07 08:00:00','请小心轻放',X'25504446');
INSERT INTO `orders` (`id`,`customer_id`,`status`,`total`,`items`,`ordered_at`,`shipped_at`,`note`,`receipt`) VALUES (5,5,'pending',45.75,2,'2024-03-08 17:20:00',NULL,'Leave at the door;\nring twice',NULL);
INSERT INTO `orders` (`id`,`customer_id`,`status`,`total`,`items`,`ordered_at`,`shipped_at`,`note`,`receipt`) VALUES (6,6,'shipped',310.4,5,'2024-03-10 13:00:00','2024-03-11 09:00:00','Fragile: "glass"',NULL);
INSERT INTO `orders` (`id`,`customer_id`,`status`,`total`,`items`,`ordered_at`,`shipped_at`,`note`,`receipt`) VALUES (7,8,'paid',76.2,2,'2024-03-11 18:45:00',NULL,NULL,NULL);
INSERT INTO `orders` (`id`,`customer_id`,`status`,`total`,`items`,`ordered_at`,`shipped_at`,`note`,`receipt`) VALUES (8,2,'paid',19.99,1,'2024-03-12 08:00:00',NULL,'Paid at the counter',NULL);
INSERT INTO `orders` (`id`,`customer_id`,`status`,`total`,`items`,`ordered_at`,`shipped_at`,`note`,`receipt`) VALUES (9,3,'shipped',64,2,'2024-03-14 15:30:00',NULL,'Shipping date never recorded',NULL);
INSERT INTO `orders` (`id`,`customer_id`,`status`,`total`,`items`,`ordered_at`,`shipped_at`,`note`,`receipt`) VALUES (10,7,'paid',1499,1,'2024-03-15 21:05:00',NULL,'C:\\Users\\ravi\\invoice.pdf',NULL);

SET UNIQUE_CHECKS = 1;
SET FOREIGN_KEY_CHECKS = 1;

Correzioni

Non c'era niente da correggere.

Da controllare

1 colonna di testo confronta ignorando maiuscole e minuscole nell'origine; MySQL confronta in modo esatto, quindi chiavi univoche e ricerche possono comportarsi diversamente. Usa una collation o un tipo di colonna che ignora maiuscole e minuscole nelle colonne che ne hanno bisogno.
2 viste, trigger, routine o eventi non sono convertiti; il report li elenca uno per uno. Ricreali a mano in MySQL.

Il tuo file viene convertito su questo computer e non viene mai caricato.

Altri esempi:

Cosa cambia da SQLite a MySQL

Ogni riga è una regola che il convertitore applica, con la riga del report che scrive quando la regola cambia qualcosa nei tuoi dati.

declared types (any text: VARCHAR(255), DATETIME, BOOLEAN, JSON or none)
il tipo in cui stanno tutti i valori della colonna
SQLite accetta qualsiasi valore in qualsiasi colonna, quindi il tipo dichiarato è un'indicazione: ogni colonna riceve il tipo in cui stanno tutti i suoi valori, e una colonna con valori misti ne mantiene il testo.
BOOLEAN, BOOL
tinyint(1)
Quando ogni valore è 0 o 1; una colonna che contiene anche altri valori li mantiene come numeri o testo.
TEXT, VARCHAR(n), CHAR(n), CLOB
varchar(n) fino a 1024 caratteri, tipi text oltre
SQLite non applica mai una lunghezza; una lunghezza dichiarata vale solo quando ogni valore ci sta. Il testo in una chiave, o con un valore predefinito, è varchar(768) quando i valori ci stanno, che MySQL 5.7 può indicizzare e a cui può dare un valore predefinito.
DECIMAL(p,s), NUMERIC
il tipo esatto quando ogni valore ci sta, altrimenti un double
SQLite li salva come interi o double; una precisione dichiarata vale solo quando i valori ci stanno.
BLOB, and columns holding bytes
tipi blob
I byte restano byte; testo e numeri nella stessa colonna vengono mantenuti come i loro byte.
DATE, DATETIME, TIMESTAMP holding ISO 8601 text
date, datetime(p)
Quando ogni valore è una data o una data con ora; i numeri epoch e l'altro testo mantengono i loro valori così come sono.
JSON holding JSON text
json
Quando ogni valore è un oggetto o un array JSON.
Infinity in REAL columns
NULL
I double di MySQL non hanno l'infinito, quindi quei valori diventano NULL e il report li conta.
Riga del report: invalid_value_null
INTEGER PRIMARY KEY, AUTOINCREMENT
AUTO_INCREMENT, che riparte dopo l'id più alto o dal valore di sqlite_sequence
Solo una colonna dichiarata esattamente INTEGER PRIMARY KEY è il rowid; ogni riga mantiene il suo id, e il contatore parte dopo l'id più alto mai assegnato.
COLLATE NOCASE
confronto esatto (utf8mb4_bin)
Le tabelle usano utf8mb4_bin così il testo si confronta in modo esatto, come quello di SQLite di default; le colonne NOCASE smettono di ignorare le maiuscole.
Riga del report: case_insensitive_collation
generated columns
colonne generate, STORED o VIRTUAL come nella sorgente
MySQL le calcola allo stesso modo.
generated columns with functions IntoSQL doesn't write, and the || operator
una colonna semplice
Una formula che non si può scrivere lascia una colonna semplice e una riga nel report; il dump non ha valori per le colonne generate.
Riga del report: generated_not_translated
defaults with functions IntoSQL doesn't write (strftime, randomblob)
nessun valore predefinito
Un valore predefinito che non si può scrivere viene omesso e segnalato; CURRENT_TIMESTAMP e datetime('now') vengono scritti.
Riga del report: default_not_translated
CHECK constraints
tradotti
MySQL 5.7 li mantiene senza verificarli; gli altri li verificano mentre si carica ogni riga.
CHECK constraints with functions IntoSQL doesn't write
non creato
Un vincolo CHECK che non si può scrivere viene omesso e segnalato.
Riga del report: check_skipped
partial and expression indexes
non creato
IntoSQL scrive indici su colonne intere; ricrea gli altri dopo il caricamento.
Riga del report: index_skipped
foreign keys (unenforced unless PRAGMA foreign_keys=ON)
chiavi esterne, caricate con FOREIGN_KEY_CHECKS=0
SQLite verifica le chiavi esterne solo quando glielo si chiede, quindi le righe senza padre sono comuni: si caricano, e la chiave resta non controllata con un avviso invece di fermare il caricamento.
foreign keys to tables the dump doesn't create
non creato
Una chiave non può riferirsi a una tabella che non c'è.
Riga del report: foreign_key_skipped
primary keys holding NULL, and NOT NULL columns with values that become NULL
NOT NULL rimosso
SQLite permette a una chiave primaria diversa dal rowid di contenere NULL; la colonna non può essere NOT NULL nella destinazione, altrimenti il caricamento si fermerebbe.
Riga del report: not_null_relaxed
views, triggers and virtual tables (FTS, R*Tree)
elencati nel report
Il loro codice è scritto nel linguaggio di SQLite, e le tabelle virtuali richiedono i moduli di SQLite; sono elencati perché tu li ricrei. Le loro tabelle interne non vengono copiate.
Riga del report: not_converted_objects
dumps without CREATE TABLE (--data-only)
tipi ricavati dai valori
Un dump di soli dati contiene solo righe, quindi i tipi vengono ricavati dai valori e le colonne sono numerate.
Riga del report: no_schema
expressions in INSERT values other than the text functions dumps write
NULL
unistr(), replace(), char() e || vengono valutati come li scrive la shell; le altre espressioni non si possono valutare senza un database.
Riga del report: expression_value
NUL characters in text
mantenuto
La shell sqlite3 e Python tagliano il testo a un carattere NUL quando lo esportano, quindi nel dump c'è solo ciò che lo precede.
text that isn't valid UTF-8
i byte errati come carattere di sostituzione
I dump scrivono quel testo come byte grezzi; lo script è UTF-8.
Riga del report: invalid_utf8_replaced
text decoded twice (Ã±)
copiato così com'è
Il dump contiene esattamente questi caratteri, quindi vengono copiati; il report li segnala.
Riga del report: mojibake_suspected

In SQLite	In MySQL	Riga del report
declared types (any text: VARCHAR(255), DATETIME, BOOLEAN, JSON or none)	il tipo in cui stanno tutti i valori della colonnaSQLite accetta qualsiasi valore in qualsiasi colonna, quindi il tipo dichiarato è un'indicazione: ogni colonna riceve il tipo in cui stanno tutti i suoi valori, e una colonna con valori misti ne mantiene il testo.
BOOLEAN, BOOL	tinyint(1)Quando ogni valore è 0 o 1; una colonna che contiene anche altri valori li mantiene come numeri o testo.
TEXT, VARCHAR(n), CHAR(n), CLOB	varchar(n) fino a 1024 caratteri, tipi text oltreSQLite non applica mai una lunghezza; una lunghezza dichiarata vale solo quando ogni valore ci sta. Il testo in una chiave, o con un valore predefinito, è varchar(768) quando i valori ci stanno, che MySQL 5.7 può indicizzare e a cui può dare un valore predefinito.
DECIMAL(p,s), NUMERIC	il tipo esatto quando ogni valore ci sta, altrimenti un doubleSQLite li salva come interi o double; una precisione dichiarata vale solo quando i valori ci stanno.
BLOB, and columns holding bytes	tipi blobI byte restano byte; testo e numeri nella stessa colonna vengono mantenuti come i loro byte.
DATE, DATETIME, TIMESTAMP holding ISO 8601 text	date, datetime(p)Quando ogni valore è una data o una data con ora; i numeri epoch e l'altro testo mantengono i loro valori così come sono.
JSON holding JSON text	jsonQuando ogni valore è un oggetto o un array JSON.
Infinity in REAL columns	NULLI double di MySQL non hanno l'infinito, quindi quei valori diventano NULL e il report li conta.	invalid_value_null
INTEGER PRIMARY KEY, AUTOINCREMENT	AUTO_INCREMENT, che riparte dopo l'id più alto o dal valore di sqlite_sequenceSolo una colonna dichiarata esattamente INTEGER PRIMARY KEY è il rowid; ogni riga mantiene il suo id, e il contatore parte dopo l'id più alto mai assegnato.
COLLATE NOCASE	confronto esatto (utf8mb4_bin)Le tabelle usano utf8mb4_bin così il testo si confronta in modo esatto, come quello di SQLite di default; le colonne NOCASE smettono di ignorare le maiuscole.	case_insensitive_collation
generated columns	colonne generate, STORED o VIRTUAL come nella sorgenteMySQL le calcola allo stesso modo.
generated columns with functions IntoSQL doesn't write, and the \|\| operator	una colonna sempliceUna formula che non si può scrivere lascia una colonna semplice e una riga nel report; il dump non ha valori per le colonne generate.	generated_not_translated
defaults with functions IntoSQL doesn't write (strftime, randomblob)	nessun valore predefinitoUn valore predefinito che non si può scrivere viene omesso e segnalato; CURRENT_TIMESTAMP e datetime('now') vengono scritti.	default_not_translated
CHECK constraints	tradottiMySQL 5.7 li mantiene senza verificarli; gli altri li verificano mentre si carica ogni riga.
CHECK constraints with functions IntoSQL doesn't write	non creatoUn vincolo CHECK che non si può scrivere viene omesso e segnalato.	check_skipped
partial and expression indexes	non creatoIntoSQL scrive indici su colonne intere; ricrea gli altri dopo il caricamento.	index_skipped
foreign keys (unenforced unless PRAGMA foreign_keys=ON)	chiavi esterne, caricate con FOREIGN_KEY_CHECKS=0SQLite verifica le chiavi esterne solo quando glielo si chiede, quindi le righe senza padre sono comuni: si caricano, e la chiave resta non controllata con un avviso invece di fermare il caricamento.
foreign keys to tables the dump doesn't create	non creatoUna chiave non può riferirsi a una tabella che non c'è.	foreign_key_skipped
primary keys holding NULL, and NOT NULL columns with values that become NULL	NOT NULL rimossoSQLite permette a una chiave primaria diversa dal rowid di contenere NULL; la colonna non può essere NOT NULL nella destinazione, altrimenti il caricamento si fermerebbe.	not_null_relaxed
views, triggers and virtual tables (FTS, R*Tree)	elencati nel reportIl loro codice è scritto nel linguaggio di SQLite, e le tabelle virtuali richiedono i moduli di SQLite; sono elencati perché tu li ricrei. Le loro tabelle interne non vengono copiate.	not_converted_objects
dumps without CREATE TABLE (--data-only)	tipi ricavati dai valoriUn dump di soli dati contiene solo righe, quindi i tipi vengono ricavati dai valori e le colonne sono numerate.	no_schema
expressions in INSERT values other than the text functions dumps write	NULLunistr(), replace(), char() e \|\| vengono valutati come li scrive la shell; le altre espressioni non si possono valutare senza un database.	expression_value
NUL characters in text	mantenutoLa shell sqlite3 e Python tagliano il testo a un carattere NUL quando lo esportano, quindi nel dump c'è solo ciò che lo precede.
text that isn't valid UTF-8	i byte errati come carattere di sostituzioneI dump scrivono quel testo come byte grezzi; lo script è UTF-8.	invalid_utf8_replaced
text decoded twice (Ã±)	copiato così com'èIl dump contiene esattamente questi caratteri, quindi vengono copiati; il report li segnala.	mojibake_suspected

Carica lo script in MySQL

Lo script crea le tabelle, copia le righe, poi aggiunge chiavi, indici e chiavi esterne, così si carica in fretta e si ferma al primo errore.

$mysql --default-character-set=utf8mb4 mydb < sqlite.mysql.sql

Le chiavi esterne vengono create come le dichiara il dump, con FOREIGN_KEY_CHECKS=0 mentre le righe si caricano, così una riga che punta a una riga mancante non ferma il caricamento.

Per un dump grande, esegui il client sulla stessa macchina del server, e aumenta max_allowed_packet se una singola riga è molto grande.

IntoSQL Pro carica il file direttamente in MySQL dall'app desktop o dalla riga di comando, senza scrivere uno script.

Fai il dump di SQLite per il miglior risultato

Il convertitore legge ciò che il dump contiene. Con queste opzioni il dump conserva più dei tuoi dati:

Il file del database si converte così com'è, letto pagina per pagina nel browser. Chiudi prima l'app che ci scrive, così nessuna modifica resta indietro nel suo file -wal.
sqlite3 app.db .dump > app.sql scrive lo stesso database come SQL, che si converte anch'esso, come .sql o .sql.gz.
DB Browser for SQLite scrive quel SQL con File, Export, Database to SQL file, e così fa iterdump() di Python.

Cosa non viene convertito

Viste e trigger sono scritti nel linguaggio di SQLite. Sono elencati per nome nel report, mai rimossi in silenzio, così puoi riscriverli per MySQL. Anche le tabelle virtuali, come FTS5 e R*Tree, sono elencate, e le loro tabelle interne vengono escluse.

Domande sulla conversione da SQLite a MySQL

Non trovi la risposta? Scrivici dalla pagina dei contatti e ti risponde una persona. Pagina dei contatti

Il mio dump viene caricato?

No. Il convertitore funziona nel tuo browser e legge il dump dal tuo disco a pezzi, quindi non lascia mai il tuo computer. Anche l'app desktop e la riga di comando convertono sul tuo computer.

Quanto può essere grande il dump?

Il convertitore non tiene mai l'intero dump in memoria: legge il file due volte, per intervalli, e scrive lo script man mano. I dump di più gigabyte si convertono nel browser, nell'app desktop e con la riga di comando.

Posso convertire direttamente il file .db?

Sì. Trascina il file .db, .sqlite o .sqlite3: viene letto nel browser e mai caricato. Il testo con caratteri NUL e ogni cifra di un double arrivano come sono salvati, cosa che un .dump può troncare.

Da quali versioni di SQLite può provenire il dump?

File di database da SQLite 3.0 in poi, in UTF-8 o UTF-16, e dump del .dump della shell sqlite3 o di iterdump() di Python. Ogni file e dump di test viene da sqlite3 dalla 3.31 alla 3.54, tabelle STRICT e WITHOUT ROWID incluse, ed è confrontato con la sorgente cella per cella.

Come vengono decisi i tipi di colonna se SQLite non li applica?

Il tipo dichiarato è un'indicazione e decidono i valori: una colonna diventa un tipo integer, decimal, double, date, datetime, tinyint(1), blob o text quando ogni valore ci sta. Il testo in una chiave o con un valore predefinito è varchar(768), così MySQL 5.7 può indicizzarlo.

INTEGER PRIMARY KEY e AUTOINCREMENT vengono mantenuti?

Sì. Una INTEGER PRIMARY KEY diventa AUTO_INCREMENT, ogni riga mantiene il suo id, e l'id successivo riparte dopo il più alto, o dopo il valore di sqlite_sequence con AUTOINCREMENT.

E viste e trigger?

Sono elencati per nome nel report e non vengono convertiti, perché ogni database li scrive nel proprio linguaggio.

Su quali versioni di MySQL si carica lo script?

MySQL 5.7 e successive. Ogni dump di test si carica su 5.7 e 9, fermandosi al primo errore se qualcosa va storto.