¿Alguien sabe una forma fácil y rápida de migrar una base de datos SQLite3 a MySQL?

Aquí hay una lista de convertidores (no actualizada desde 2011):

• https://www2.sqlite.org/cvstrac/wiki?p=ConverterTools (o una instantánea en archive.org )

es decir, podrías hacer esto:

1. Cargue datos de la base de datos de origen utilizando la clase ORM.
2. Almacene datos en la memoria o serialice en el disco.
3. Almacene datos en la base de datos de destino utilizando la clase ORM.

Todo el mundo parece comenzar con unos pocos greps y expresiones perl y de alguna manera obtienes algo que funciona para tu conjunto de datos en particular, pero no tienes idea si se importaron los datos correctamente o no. Me sorprende mucho que nadie haya construido una biblioteca sólida que pueda convertir entre los dos.

Aquí una lista de TODAS las diferencias en sintaxis SQL que conozco entre los dos formatos de archivo: Las líneas que comienzan con:

• COMIENZA LA TRANSACCIÓN
• COMETER
• sqlite_sequence
• CREAR ÍNDICE ÚNICO

no se usan en MySQL

• Usos de SQLlite CREATE TABLE/INSERT INTO "table_name"y usos de MySQLCREATE TABLE/INSERT INTO table_name
• MySQL no usa comillas dentro de la definición del esquema
• MySQL usa comillas simples para cadenas dentro de las INSERT INTOcláusulas
• SQLlite y MySQL tienen diferentes formas de escapar de cadenas dentro de INSERT INTOcláusulas
• SQLlite usa 't'y 'f'para booleanos, MySQL usa 1y 0(una expresión regular simple para esto puede fallar cuando tiene una cadena como: 'Sí, no' dentro de su INSERT INTO)
• Usos de SQLLite AUTOINCREMENT, usos de MySQLAUTO_INCREMENT

Aquí hay un script perl pirateado muy básico que funciona para mi conjunto de datos y comprueba muchas más de estas condiciones que otros scripts perl que encontré en la web. Nu garantiza que funcionará para sus datos, pero puede modificarlos y publicarlos aquí.

#! /usr/bin/perl

while ($line = <>){
    if (($line !~  /BEGIN TRANSACTION/) && ($line !~ /COMMIT/) && ($line !~ /sqlite_sequence/) && ($line !~ /CREATE UNIQUE INDEX/)){

        if ($line =~ /CREATE TABLE \"([a-z_]*)\"(.*)/i){
            $name = $1;
            $sub = $2;
            $sub =~ s/\"//g;
            $line = "DROP TABLE IF EXISTS $name;\nCREATE TABLE IF NOT EXISTS $name$sub\n";
        }
        elsif ($line =~ /INSERT INTO \"([a-z_]*)\"(.*)/i){
            $line = "INSERT INTO $1$2\n";
            $line =~ s/\"/\\\"/g;
            $line =~ s/\"/\'/g;
        }else{
            $line =~ s/\'\'/\\\'/g;
        }
        $line =~ s/([^\\'])\'t\'(.)/$1THIS_IS_TRUE$2/g;
        $line =~ s/THIS_IS_TRUE/1/g;
        $line =~ s/([^\\'])\'f\'(.)/$1THIS_IS_FALSE$2/g;
        $line =~ s/THIS_IS_FALSE/0/g;
        $line =~ s/AUTOINCREMENT/AUTO_INCREMENT/g;
        print $line;
    }
}

Aquí hay un script de Python, construido a partir de la respuesta de Shalmanese y un poco de ayuda de Alex martelli en Translating Perl to Python

Lo estoy haciendo wiki comunitario, así que siéntase libre de editar y refactorizar siempre que no rompa la funcionalidad (afortunadamente podemos retroceder): es bastante feo pero funciona

use así (suponiendo que el script se llame dump_for_mysql.py:

sqlite3 sample.db .dump | python dump_for_mysql.py > dump.sql

Que luego puedes importar a mysql

nota: debe agregar restricciones de clave externa manualmente ya que sqlite en realidad no las admite

Aquí está el guión:

#!/usr/bin/env python

import re
import fileinput

def this_line_is_useless(line):
    useless_es = [
        'BEGIN TRANSACTION',
        'COMMIT',
        'sqlite_sequence',
        'CREATE UNIQUE INDEX',
        'PRAGMA foreign_keys=OFF',
    ]
    for useless in useless_es:
        if re.search(useless, line):
            return True

def has_primary_key(line):
    return bool(re.search(r'PRIMARY KEY', line))

searching_for_end = False
for line in fileinput.input():
    if this_line_is_useless(line):
        continue

    # this line was necessary because '');
    # would be converted to \'); which isn't appropriate
    if re.match(r".*, ''\);", line):
        line = re.sub(r"''\);", r'``);', line)

    if re.match(r'^CREATE TABLE.*', line):
        searching_for_end = True

    m = re.search('CREATE TABLE "?(\w*)"?(.*)', line)
    if m:
        name, sub = m.groups()
        line = "DROP TABLE IF EXISTS %(name)s;\nCREATE TABLE IF NOT EXISTS `%(name)s`%(sub)s\n"
        line = line % dict(name=name, sub=sub)
    else:
        m = re.search('INSERT INTO "(\w*)"(.*)', line)
        if m:
            line = 'INSERT INTO %s%s\n' % m.groups()
            line = line.replace('"', r'\"')
            line = line.replace('"', "'")
    line = re.sub(r"([^'])'t'(.)", "\1THIS_IS_TRUE\2", line)
    line = line.replace('THIS_IS_TRUE', '1')
    line = re.sub(r"([^'])'f'(.)", "\1THIS_IS_FALSE\2", line)
    line = line.replace('THIS_IS_FALSE', '0')

    # Add auto_increment if it is not there since sqlite auto_increments ALL
    # primary keys
    if searching_for_end:
        if re.search(r"integer(?:\s+\w+)*\s*PRIMARY KEY(?:\s+\w+)*\s*,", line):
            line = line.replace("PRIMARY KEY", "PRIMARY KEY AUTO_INCREMENT")
        # replace " and ' with ` because mysql doesn't like quotes in CREATE commands 
        if line.find('DEFAULT') == -1:
            line = line.replace(r'"', r'`').replace(r"'", r'`')
        else:
            parts = line.split('DEFAULT')
            parts[0] = parts[0].replace(r'"', r'`').replace(r"'", r'`')
            line = 'DEFAULT'.join(parts)

    # And now we convert it back (see above)
    if re.match(r".*, ``\);", line):
        line = re.sub(r'``\);', r"'');", line)

    if searching_for_end and re.match(r'.*\);', line):
        searching_for_end = False

    if re.match(r"CREATE INDEX", line):
        line = re.sub('"', '`', line)

    if re.match(r"AUTOINCREMENT", line):
        line = re.sub("AUTOINCREMENT", "AUTO_INCREMENT", line)

    print line,

Probablemente la forma más fácil y rápida es usar el comando sqlite .dump, en este caso, crear un volcado de la base de datos de muestra.

sqlite3 sample.db .dump > dump.sql

Luego puede (en teoría) importar esto a la base de datos mysql, en este caso la base de datos de prueba en el servidor de base de datos 127.0.0.1, utilizando la raíz del usuario.

mysql -p -u root -h 127.0.0.1 test < dump.sql

Digo en teoría, ya que hay algunas diferencias entre las gramáticas.

En sqlite comienzan las transacciones

BEGIN TRANSACTION;
...
COMMIT;

MySQL usa solo

BEGIN;
...
COMMIT;

Hay otros problemas similares (los varchars y las comillas dobles vuelven a mi mente) pero nada de encontrar y reemplazar no se pudo solucionar.

Tal vez debería preguntar por qué está migrando, si el problema es el tamaño del rendimiento / base de datos, quizás considere volver a iniciar el esquema, si el sistema se está moviendo a un producto más potente, este podría ser el momento ideal para planificar el futuro de sus datos.

Si está utilizando Python / Django, es bastante fácil:

cree dos bases de datos en settings.py (como aquí https://docs.djangoproject.com/en/1.11/topics/db/multi-db/ )

entonces hazlo así:

objlist = ModelObject.objects.using('sqlite').all()

for obj in objlist:
    obj.save(using='mysql')

• http://sqlfairy.sourceforge.net/
• http://search.cpan.org/dist/SQL-Translator/

aptitude install sqlfairy libdbd-sqlite3-perl

sqlt -f DBI --dsn dbi:SQLite:../.open-tran/ten-sq.db -t MySQL --add-drop-table > mysql-ten-sq.sql
sqlt -f DBI --dsn dbi:SQLite:../.open-tran/ten-sq.db -t Dumper --use-same-auth > sqlite2mysql-dumper.pl
chmod +x sqlite2mysql-dumper.pl
./sqlite2mysql-dumper.pl --help
./sqlite2mysql-dumper.pl --add-truncate --mysql-loadfile > mysql-dump.sql
sed -e 's/LOAD DATA INFILE/LOAD DATA LOCAL INFILE/' -i mysql-dump.sql

echo 'drop database `ten-sq`' | mysql -p -u root
echo 'create database `ten-sq` charset utf8' | mysql -p -u root
mysql -p -u root -D ten-sq < mysql-ten-sq.sql
mysql -p -u root -D ten-sq < mysql-dump.sql

Usualmente uso la función Exportar / importar tablas de IntelliJ DataGrip .

Puedes ver el progreso en la esquina inferior derecha.

[ ]

Acabo de pasar por este proceso, y hay mucha muy buena ayuda e información en este Q / A, pero descubrí que tenía que reunir varios elementos (más algunos de otros Q / A) para obtener una solución de trabajo en Para migrar con éxito.

Sin embargo, incluso después de combinar las respuestas existentes, descubrí que el script de Python no funcionaba completamente para mí, ya que no funcionaba donde había múltiples ocurrencias booleanas en un INSERT. Vea aquí por qué ese fue el caso.

Entonces, pensé en publicar mi respuesta combinada aquí. El crédito va a aquellos que han contribuido en otros lugares, por supuesto. Pero quería devolver algo y ahorrar a otros el tiempo que sigue.

Publicaré el guión a continuación. Pero primero, aquí están las instrucciones para una conversión ...

Ejecuté el script en OS X 10.7.5 Lion. Python salió de la caja.

Para generar el archivo de entrada MySQL de su base de datos SQLite3 existente, ejecute el script en sus propios archivos de la siguiente manera,

Snips$ sqlite3 original_database.sqlite3 .dump | python ~/scripts/dump_for_mysql.py > dumped_data.sql

Luego copié el archivo dumped_sql.sql resultante en una caja de Linux que ejecuta Ubuntu 10.04.4 LTS donde residía mi base de datos MySQL.

Otro problema que tuve al importar el archivo MySQL fue que algunos caracteres UTF-8 unicode (específicamente comillas simples) no se importaban correctamente, por lo que tuve que agregar un interruptor al comando para especificar UTF-8.

El comando resultante para ingresar los datos en una nueva base de datos MySQL vacía es el siguiente:

Snips$ mysql -p -u root -h 127.0.0.1 test_import --default-character-set=utf8 < dumped_data.sql

¡Déjalo cocinar, y eso debería ser! No olvides examinar tus datos antes y después.

Entonces, como lo solicitó el OP, ¡es rápido y fácil, cuando sabes cómo! :-)

Por otro lado, una cosa de la que no estaba seguro antes de analizar esta migración era si se preservarían los valores de campo created_at y updated_at; la buena noticia para mí es que sí lo son, por lo que podría migrar mis datos de producción existentes.

¡Buena suerte!

ACTUALIZAR

Desde que hice este cambio, noté un problema que no había notado antes. En mi aplicación Rails, mis campos de texto se definen como 'cadena', y esto se traslada al esquema de la base de datos. El proceso descrito aquí da como resultado que estos se definan como VARCHAR (255) en la base de datos MySQL. Esto coloca un límite de 255 caracteres en estos tamaños de campo, y cualquier cosa más allá de esto se truncó silenciosamente durante la importación. Creo que para admitir una longitud de texto superior a 255, el esquema MySQL necesitaría usar 'TEXTO' en lugar de VARCHAR (255). El proceso definido aquí no incluye esta conversión.

Aquí está el script Python fusionado y revisado que funcionó para mis datos:

#!/usr/bin/env python

import re
import fileinput

def this_line_is_useless(line):
    useless_es = [
        'BEGIN TRANSACTION',
        'COMMIT',
        'sqlite_sequence',
        'CREATE UNIQUE INDEX',        
        'PRAGMA foreign_keys=OFF'
        ]
    for useless in useless_es:
        if re.search(useless, line):
            return True

def has_primary_key(line):
    return bool(re.search(r'PRIMARY KEY', line))

searching_for_end = False
for line in fileinput.input():
    if this_line_is_useless(line): continue

    # this line was necessary because ''); was getting
    # converted (inappropriately) to \');
    if re.match(r".*, ''\);", line):
        line = re.sub(r"''\);", r'``);', line)

    if re.match(r'^CREATE TABLE.*', line):
        searching_for_end = True

    m = re.search('CREATE TABLE "?([A-Za-z_]*)"?(.*)', line)
    if m:
        name, sub = m.groups()
        line = "DROP TABLE IF EXISTS %(name)s;\nCREATE TABLE IF NOT EXISTS `%(name)s`%(sub)s\n"
        line = line % dict(name=name, sub=sub)
        line = line.replace('AUTOINCREMENT','AUTO_INCREMENT')
        line = line.replace('UNIQUE','')
        line = line.replace('"','')
    else:
        m = re.search('INSERT INTO "([A-Za-z_]*)"(.*)', line)
        if m:
            line = 'INSERT INTO %s%s\n' % m.groups()
            line = line.replace('"', r'\"')
            line = line.replace('"', "'")
            line = re.sub(r"(?<!')'t'(?=.)", r"1", line)
            line = re.sub(r"(?<!')'f'(?=.)", r"0", line)

    # Add auto_increment if it's not there since sqlite auto_increments ALL
    # primary keys
    if searching_for_end:
        if re.search(r"integer(?:\s+\w+)*\s*PRIMARY KEY(?:\s+\w+)*\s*,", line):
            line = line.replace("PRIMARY KEY", "PRIMARY KEY AUTO_INCREMENT")
        # replace " and ' with ` because mysql doesn't like quotes in CREATE commands

    # And now we convert it back (see above)
    if re.match(r".*, ``\);", line):
        line = re.sub(r'``\);', r"'');", line)

    if searching_for_end and re.match(r'.*\);', line):
        searching_for_end = False

    if re.match(r"CREATE INDEX", line):
        line = re.sub('"', '`', line)

    print line,

Recientemente tuve que migrar de MySQL a JavaDB para un proyecto en el que nuestro equipo está trabajando. Encontré una biblioteca Java escrita por Apache llamada DdlUtils que lo hizo bastante fácil. Proporciona una API que le permite hacer lo siguiente:

1. Descubra el esquema de una base de datos y expórtelo como un archivo XML.
2. Modificar una base de datos basada en este esquema.
3. Importe registros de una base de datos a otra, suponiendo que tengan el mismo esquema.

Las herramientas con las que terminamos no estaban completamente automatizadas, pero funcionaron bastante bien. Incluso si su aplicación no está en Java, no debería ser demasiado difícil preparar algunas herramientas pequeñas para realizar una migración única. Creo que pude extraer nuestra migración con menos de 150 líneas de código.

No hay necesidad de ningún script, comando, etc.

solo tiene que exportar su base de datos sqlite como un .csvarchivo y luego importarlo en Mysql usando phpmyadmin.

Lo usé y funcionó increíble ...

Basado en la solución de Jims: ¿Una forma fácil y rápida de migrar SQLite3 a MySQL?

sqlite3 your_sql3_database.db .dump | python ./dump.py > your_dump_name.sql
cat your_dump_name.sql | sed '1d' | mysql --user=your_mysql_user --default-character-set=utf8 your_mysql_db -p  

Esto funciona para mi. Utilizo sed solo para lanzar la primera línea, que no es similar a mysql, pero también podría modificar el script dump.py para tirar esta línea.

Obtenga un volcado de SQL

moose@pc08$ sqlite3 mySqliteDatabase.db .dump > myTemporarySQLFile.sql

Importar volcado a MySQL

Para pequeñas importaciones:

moose@pc08$ mysql -u <username> -p
Enter password:
....
mysql> use somedb;
Database changed
mysql> source myTemporarySQLFile.sql;

o

mysql -u root -p somedb < myTemporarySQLFile.sql

Esto le pedirá una contraseña. Tenga en cuenta: si desea ingresar su contraseña directamente, debe hacerlo SIN espacio, directamente después de -p:

mysql -u root -pYOURPASS somedb < myTemporarySQLFile.sql

Para vertederos más grandes:

mysqlimport u otras herramientas de importación como BigDump .

BigDump te da una barra de progreso:

Ja ... Ojalá hubiera encontrado esto primero! Mi respuesta fue a esta publicación ... script para convertir mysql dump sql file en formato que se pueda importar a sqlite3 db

Combinar los dos sería exactamente lo que necesitaba:

Cuando la base de datos sqlite3 se vaya a usar con ruby, es posible que desee cambiar:

tinyint([0-9]*) 

a:

sed 's/ tinyint(1*) / boolean/g ' |
sed 's/ tinyint([0|2-9]*) / integer /g' |

Por desgracia, esto solo funciona a la mitad porque aunque inserte 1 y 0 en un campo marcado como booleano, sqlite3 los almacena como 1 y 0, por lo que debe pasar y hacer algo como:

Table.find(:all, :conditions => {:column => 1 }).each { |t| t.column = true }.each(&:save)
Table.find(:all, :conditions => {:column => 0 }).each { |t| t.column = false}.each(&:save)

pero fue útil tener el archivo sql para buscar todos los booleanos.

Escribí este simple script en Python3. Se puede usar como una clase incluida o un script independiente invocado a través de un shell de terminal. Por defecto, importa todos los enteros como int(11)y cadenas como varchar(300), pero todo eso se puede ajustar en el constructor o en los argumentos del script, respectivamente.

NOTA: Requiere MySQL Connector / Python 2.0.4 o superior

Aquí hay un enlace a la fuente en GitHub si encuentra el siguiente código difícil de leer: https://github.com/techouse/sqlite3-to-mysql

#!/usr/bin/env python3

__author__ = "Klemen Tušar"
__email__ = "techouse@gmail.com"
__copyright__ = "GPL"
__version__ = "1.0.1"
__date__ = "2015-09-12"
__status__ = "Production"

import os.path, sqlite3, mysql.connector
from mysql.connector import errorcode


class SQLite3toMySQL:
    """
    Use this class to transfer an SQLite 3 database to MySQL.

    NOTE: Requires MySQL Connector/Python 2.0.4 or higher (https://dev.mysql.com/downloads/connector/python/)
    """
    def __init__(self, **kwargs):
        self._properties = kwargs
        self._sqlite_file = self._properties.get('sqlite_file', None)
        if not os.path.isfile(self._sqlite_file):
            print('SQLite file does not exist!')
            exit(1)
        self._mysql_user = self._properties.get('mysql_user', None)
        if self._mysql_user is None:
            print('Please provide a MySQL user!')
            exit(1)
        self._mysql_password = self._properties.get('mysql_password', None)
        if self._mysql_password is None:
            print('Please provide a MySQL password')
            exit(1)
        self._mysql_database = self._properties.get('mysql_database', 'transfer')
        self._mysql_host = self._properties.get('mysql_host', 'localhost')

        self._mysql_integer_type = self._properties.get('mysql_integer_type', 'int(11)')
        self._mysql_string_type = self._properties.get('mysql_string_type', 'varchar(300)')

        self._sqlite = sqlite3.connect(self._sqlite_file)
        self._sqlite.row_factory = sqlite3.Row
        self._sqlite_cur = self._sqlite.cursor()

        self._mysql = mysql.connector.connect(
            user=self._mysql_user,
            password=self._mysql_password,
            host=self._mysql_host
        )
        self._mysql_cur = self._mysql.cursor(prepared=True)
        try:
            self._mysql.database = self._mysql_database
        except mysql.connector.Error as err:
            if err.errno == errorcode.ER_BAD_DB_ERROR:
                self._create_database()
            else:
                print(err)
                exit(1)

    def _create_database(self):
        try:
            self._mysql_cur.execute("CREATE DATABASE IF NOT EXISTS `{}` DEFAULT CHARACTER SET 'utf8'".format(self._mysql_database))
            self._mysql_cur.close()
            self._mysql.commit()
            self._mysql.database = self._mysql_database
            self._mysql_cur = self._mysql.cursor(prepared=True)
        except mysql.connector.Error as err:
            print('_create_database failed creating databse {}: {}'.format(self._mysql_database, err))
            exit(1)

    def _create_table(self, table_name):
        primary_key = ''
        sql = 'CREATE TABLE IF NOT EXISTS `{}` ( '.format(table_name)
        self._sqlite_cur.execute('PRAGMA table_info("{}")'.format(table_name))
        for row in self._sqlite_cur.fetchall():
            column = dict(row)
            sql += ' `{name}` {type} {notnull} {auto_increment}, '.format(
                name=column['name'],
                type=self._mysql_string_type if column['type'].upper() == 'TEXT' else self._mysql_integer_type,
                notnull='NOT NULL' if column['notnull'] else 'NULL',
                auto_increment='AUTO_INCREMENT' if column['pk'] else ''
            )
            if column['pk']:
                primary_key = column['name']
        sql += ' PRIMARY KEY (`{}`) ) ENGINE = InnoDB CHARACTER SET utf8'.format(primary_key)
        try:
            self._mysql_cur.execute(sql)
            self._mysql.commit()
        except mysql.connector.Error as err:
            print('_create_table failed creating table {}: {}'.format(table_name, err))
            exit(1)

    def transfer(self):
        self._sqlite_cur.execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
        for row in self._sqlite_cur.fetchall():
            table = dict(row)
            # create the table
            self._create_table(table['name'])
            # populate it
            print('Transferring table {}'.format(table['name']))
            self._sqlite_cur.execute('SELECT * FROM "{}"'.format(table['name']))
            columns = [column[0] for column in self._sqlite_cur.description]
            try:
                self._mysql_cur.executemany("INSERT IGNORE INTO `{table}` ({fields}) VALUES ({placeholders})".format(
                    table=table['name'],
                    fields=('`{}`, ' * len(columns)).rstrip(' ,').format(*columns),
                    placeholders=('%s, ' * len(columns)).rstrip(' ,')
                ), (tuple(data) for data in self._sqlite_cur.fetchall()))
                self._mysql.commit()
            except mysql.connector.Error as err:
                print('_insert_table_data failed inserting data into table {}: {}'.format(table['name'], err))
                exit(1)
        print('Done!')


def main():
    """ For use in standalone terminal form """
    import sys, argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('--sqlite-file', dest='sqlite_file', default=None, help='SQLite3 db file')
    parser.add_argument('--mysql-user', dest='mysql_user', default=None, help='MySQL user')
    parser.add_argument('--mysql-password', dest='mysql_password', default=None, help='MySQL password')
    parser.add_argument('--mysql-database', dest='mysql_database', default=None, help='MySQL host')
    parser.add_argument('--mysql-host', dest='mysql_host', default='localhost', help='MySQL host')
    parser.add_argument('--mysql-integer-type', dest='mysql_integer_type', default='int(11)', help='MySQL default integer field type')
    parser.add_argument('--mysql-string-type', dest='mysql_string_type', default='varchar(300)', help='MySQL default string field type')
    args = parser.parse_args()

    if len(sys.argv) == 1:
        parser.print_help()
        exit(1)

    converter = SQLite3toMySQL(
        sqlite_file=args.sqlite_file,
        mysql_user=args.mysql_user,
        mysql_password=args.mysql_password,
        mysql_database=args.mysql_database,
        mysql_host=args.mysql_host,
        mysql_integer_type=args.mysql_integer_type,
        mysql_string_type=args.mysql_string_type
    )
    converter.transfer()

if __name__ == '__main__':
    main()

Este script está bien, excepto en este caso que, por supuesto, he conocido:

INSERTAR EN VALORES "requestcomparison_stopword" (149, 'f');
INSERTAR EN VALORES "requestcomparison_stopword" (420, 't');

El script debería dar este resultado:

INSERTAR EN requestcomparison_stopword VALUES (149, 'f');
INSERTAR EN requestcomparison_stopword VALUES (420, 't');

Pero da en cambio esa salida:

INSERTAR EN requestcomparison_stopword VALUES (1490;
INSERTAR EN requestcomparison_stopword VALUES (4201;

con algunos extraños caracteres no ascii alrededor de los últimos 0 y 1.

Esto ya no apareció cuando comenté las siguientes líneas del código (43-46) pero aparecieron otros problemas:

    line = re.sub(r"([^'])'t'(.)", "\1THIS_IS_TRUE\2", line)
    line = line.replace('THIS_IS_TRUE', '1')
    line = re.sub(r"([^'])'f'(.)", "\1THIS_IS_FALSE\2", line)
    line = line.replace('THIS_IS_FALSE', '0')

Este es solo un caso especial, cuando queremos agregar un valor que sea 'f' o 't' pero no estoy realmente cómodo con las expresiones regulares, solo quería detectar este caso para que alguien lo corrija.

De todos modos muchas gracias por ese útil guión !!!

Esta solución simple funcionó para mí:

<?php
$sq = new SQLite3( 'sqlite3.db' );

$tables = $sq->query( 'SELECT name FROM sqlite_master WHERE type="table"' );

while ( $table = $tables->fetchArray() ) {
    $table = current( $table );
    $result = $sq->query( sprintf( 'SELECT * FROM %s', $table ) );

    if ( strpos( $table, 'sqlite' ) !== false )
        continue;

    printf( "-- %s\n", $table );
    while ( $row = $result->fetchArray( SQLITE3_ASSOC ) ) {
        $values = array_map( function( $value ) {
            return sprintf( "'%s'", mysql_real_escape_string( $value ) );
        }, array_values( $row ) );
        printf( "INSERT INTO `%s` VALUES( %s );\n", $table, implode( ', ', $values ) );
    }
}

echo ".dump" | sqlite3 /tmp/db.sqlite > db.sql

cuidado con las declaraciones CREATE