Rapidă modalitate ușoară de a migra SQLite3 să MySQL?
Stie cineva un mod rapid si usor pentru a migra o bază de date SQLite3 să MySQL?
Se pare că toată lumea pentru a începe cu câteva greps și perl expresii și ai cam cam iau ceva care funcționează pentru un anumit set de date, dar nu ai nici o idee dacă-l's importate datele corect sau nu. Am'm in serios surprins nimeni nu's-a construit o bibliotecă solidă, care poate converti între cele două.
Aici o lista cu TOATE diferențele de sintaxă SQL că știu despre între două formate de fișier: Liniile care încep cu:
- BEGIN TRANSACTION
- COMITE
- sqlite_sequence
- CREAREA INDEX UNIC
nu sunt utilizate în MySQL
- SQLlite foloseste
create TABLE/INSERT INTO "table_name"și folosește MySQLcreate TABLE/INSERT INTO nume_tabel - MySQL nu't folosi citate în schema definition
- MySQL foloseste ghilimele simple pentru siruri de caractere în interiorul
INSERT INTOclauze - SQLlite și MySQL au moduri diferite de a scăpa de siruri de caractere în interiorul
INSERT INTOclauze - SQLlite foloseste
't' " și " 'f' pentru boolean, MySQL foloseste1si0(un simplu regex pentru acest lucru poate eșua atunci când aveți un șir de caractere, cum ar fi: 'eu fac, tu nu\'t' în interiorulINSERT INTO`) - SQLLite foloseste AUTOINCREMENT
, MySQL foloseste AUTO_INCREMENT
Aici este un foarte de bază tocat script perl care lucrează pentru mea set de date și verifică mai multe dintre aceste condiții că alte perl script-uri am găsit pe web. Nu guarentees că va lucra pentru datele dvs., dar simțiți-vă liber pentru a modifica și de a posta aici.
#! /usr/bin/perl
while ($line = <>){
if (($line !~ /BEGIN TRANSACTION/) && ($line !~ /COMMIT/) && ($line !~ /sqlite_sequence/) && ($line !~ /CREATE UNIQUE INDEX/)){
if ($line =~ /CREATE TABLE \"([a-z_]*)\"(.*)/){
$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_]*)\"(.*)/){
$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;
}
}
Aici este o listă de convertoare (nu este actualizat din 2011):
de exemplu ai putea face acest lucru:
- Încărcare date din sursa de date folosind ORM clasa.
- Stocarea datelor în memorie sau pentru a serializa disc.
- Stoca datele în baza de date destinație folosind ORM clasa.
Aici este un script python, construit pe Shalmanese's răspuns și ajutor de la Alex martelli la https://stackoverflow.com/questions/1067060/perl-to-python
Am'm ceea ce face comunitatea wiki, astfel încât vă rugăm să nu ezitați să-l editați și refactor atâta timp cât aceasta nu't functionalitatea (din fericire, putem doar să se rostogolească înapoi) - L's destul de urât, dar funcționează
utilizarea ca astfel (presupunând că script-ul este numit dump_for_mysql.py:
sqlite3 sample.db .dump | python dump_for_mysql.py > dump.sqlCare apoi puteți importa în mysql
notă - trebuie să adăugați cheie externă constrânge manual, deoarece sqlite nu't de fapt le sprijine
aici este scriptul:
#!/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,
L's murdar pentru fișiere imagine furnizor de baze de date specifice.
Daca're folosind Șine, o mare plugin-ul există pentru acest lucru. Citește: http://blog.heroku.com/archives/2007/11/23/yamldb_for_databaseindependent_data_dumps/
Update
În prezent menținută furculita: https://github.com/ludicast/yaml_db
MySQL Workbench (licenta GPL) migrează de la SQLite foarte ușor prin intermediul Migrarea bazei de Date wizard. Se instalează pe Windows, Ubuntu, RHEL, Fedora și OS X.
Sunt surprins că nimeni nu's-a menționat până acum, dar nu's, de fapt, un instrument explicit pentru acest lucru. L's în perl, SQL:Traducător: http://sqlfairy.sourceforge.net/
Convertește între cele mai multe orice formă de tabel a datelor (Diferite SQL formate, foaie de calcul Excel), și chiar face diagrame de SQL server.
Probabil rapid, mai simplu mod este folosind sqlite .groapa de gunoi de comandă, în acest caz, creați un depozit de date eșantion.
sqlite3 sample.db .dump > dump.sqlPuteți apoi (în teorie) de import în baza de date mysql, în acest caz testul de date de pe serverul de baze de date 127.0.0.1, folosind utilizatorul root.
mysql -p -u root -h 127.0.0.1 test < dump.sqlSpun teoretic, deoarece există câteva diferențe între gramatici.
În sqlite tranzacții begin
BEGIN TRANSACTION;
...
COMMIT;MySQL foloseste doar
BEGIN;
...
COMMIT;Există și alte probleme similare (varchars și ghilimele duble primăvară înapoi în minte), dar nimic nu găsi și înlocui n't fix.
Poate că ar trebui să întreb de ce sunt migratoare, dacă performanța/ dimensiunea bazei de date este problema, probabil, uita-te la reoginising schema, dacă sistemul este în mișcare de la un mai puternic produs acest lucru ar putea fi momentul ideal pentru a planifica pentru viitorul dumneavoastră de date.
Dacă sunteți folosind Python/Django-l's destul de ușor:
creați două baze de date în settings.py (ca aici https://docs.djangoproject.com/en/1.11/topics/db/multi-db/)
apoi face doar asta:
objlist = ModelObject.objects.using('sqlite').all()
for obj in objlist:
obj.save(using='mysql')
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
Am'am trecut prin acest proces, și nu's o multime de foarte bun ajutor și informații în acest Q/O, dar n-am avut de a trage împreună diferitele elemente (plus unele din alte Q/Ca) pentru a obține o soluție de lucru, în scopul de a migra cu succes.
Cu toate acestea, chiar și după combinarea celor existente răspunsuri, am constatat că Python script-ul nu funcționează pentru mine ca nu a mers acolo unde au fost mai multe boolean evenimente într-un INSERT. A se vedea aici ce acesta a fost cazul.
Deci, m-am gândit'd postul meu a fuzionat raspuns aici. De Credit merge la cei care au contribuit în altă parte, desigur. Dar am vrut să dau ceva înapoi, și de a salva timp altele care urmează.
Am'll post script-ul de mai jos. Dar, în primul rând, aici's instrucțiunile pentru o conversie...
Am rulat script-ul de pe OS X Lion 10.7.5. Python lucra afară de la cutie.
Pentru a genera MySQL fișier de intrare de la dvs. existente bază de date SQLite3, rula script-ul de pe propriile fișiere după cum urmează,
Snips$ sqlite3 original_database.sqlite3 .dump | python ~/scripts/dump_for_mysql.py > dumped_data.sqlApoi am copiat rezultat dumped_sql.sql file de peste la o cutie de Linux care rulează Ubuntu 10.04.4 E unde mi-baza de date MySQL a fost de a locui.
O altă problemă am avut-o atunci când importă MySQL dosar a fost că unele unicode UTF-8 caractere (în special ghilimele simple) nu au fost importate corect, așa că am avut de a adăuga un comutator de comandă pentru a specifica UTF-8.
Rezultate comandă pentru a introduce datele într-un nou noute gol baza de date MySQL este după cum urmează:
Snips$ mysql -p -u root -h 127.0.0.1 test_import --default-character-set=utf8 < dumped_data.sqlSă-l gătească, și că ar trebui să fie! Don't uita pentru a analiza datele, înainte și după.
Deci, ca OP solicitat, l's rapid și ușor, atunci când știi cum! :-)
Ca o paranteza, un singur lucru am fost't de sigur înainte mă uitam în această migrație, a fost dacă created_at și updated_at valori de câmp ar fi păstrat - o veste bună pentru mine este că acestea sunt, așa că am putea migra existent de date de producție.
Mult noroc!
UPDATE
De a face această schimbare, am'am observat o problema pe care nu am't a observat înainte. În Șine de aplicare, textul meu domenii sunt definite ca 'string', iar acest desfășoară prin intermediul a schemei bazei de date. Procesul prezentat aici rezultatele în aceste fiind definit ca VARCHAR(255) în baza de date MySQL. Acest lucru pune o limita de 255 de caractere pe aceste dimensiuni de câmp - și nimic dincolo de acest lucru a fost în tăcere trunchiat în timpul importului. Pentru a sprijini text de lungime mai mare de 255, MySQL schema ar trebui să utilizați 'TEXT' mai degrabă decât VARCHAR(255), cred. Procesul definit aici nu includ această conversie.
Aici's fuzionat și revizuit script Python care a lucrat pentru datele mele:
#!/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,
Recent, am avut de a migra de la MySQL la JavaDB pentru un proiect pe care echipa noastra este de lucru pe. Am găsit-o Java library scris de Apache numit DdlUtils care a făcut acest lucru destul de ușor. Acesta oferă un API care vă permite să faceți următoarele:
- Descoperi o bază de date's schemă și de export-l ca un fișier XML.
- Modifica un DB pornind de la aceasta schema.
- Importa înregistrările de la un DB la altul, presupunând că au aceeași schemă.
Instrumentele care ne-am ales cu nu't complet automatizate, dar ei au lucrat destul de bine. Chiar dacă cererea dumneavoastră nu este în Java, nu ar trebui't fi prea dificil să bici un mic câteva instrumente pentru a face o singură dată migrației. Cred că am fost capabil de a trage al trecerii noastre cu mai puțin de 150 de linii de cod.
Eu folosesc de obicei Export/import tabele funcția de IntelliJ DataGrip.
Puteți vedea progresul în colțul din dreapta jos.
[
]
Bazat pe Jims's soluție: https://stackoverflow.com/questions/18671/quick-easy-way-to-migrate-sqlite3-to-mysql/1067365#1067365
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 Aceasta funcționează și pentru mine. Eu folosesc sed doar pentru a arunca prima linie, care nu este mysql-cum ar fi, dar ar fi bine să modificați dump.py script-ul pentru a arunca această linie de departe.
Python script lucrat după câteva modificări, după cum urmează:
# Remove "PRAGMA foreign_keys=OFF; from beginning of script
# Double quotes were not removed from INSERT INTO "BaselineInfo" table, check if removed from subsequent tables. Regex needed A-Z added.
# Removed backticks from CREATE TABLE
# Added replace AUTOINCREMENT with AUTO_INCREMENT
# Removed replacement,
#line = line.replace('"', '`').replace("'", '`')useless_es = [
'BEGIN TRANSACTION',
'COMMIT',
'sqlite_sequence',
'CREATE UNIQUE INDEX',
'PRAGMA foreign_keys=OFF',
]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('"', "'")...
Obține un SQL dump
[email protected]$ sqlite3 mySqliteDatabase.db .dump > myTemporarySQLFile.sqlImport basculante pentru MySQL
Pentru mici importuri:
[email protected]$ mysql -u <username> -p
Enter password:
....
mysql> use somedb;
Database changed
mysql> source myTemporarySQLFile.sql;sau
mysql -u root -p somedb < myTemporarySQLFile.sqlAcest lucru va solicita o parolă. Vă rugăm să rețineți: Dacă doriți să introduceți parola direct, trebuie să o faci FĂRĂ spațiu, imediat după -p:
mysql -u root -pYOURPASS somedb < myTemporarySQLFile.sqlPentru halde mai mari:
mysqlimport sau alte instrumente de import, cum ar fi BigDump.
BigDump vă oferă o bară de progres:
Nu este nevoie pentru orice scenariu,comanda,etc...
trebuie doar să exportați baza de date sqlite ca `.csv file și apoi importați-l în Mysql folosind phpmyadmin.
L-am folosit si a mers uimitor...
Eu folosesc date încărcător pentru migrarea aproape orice date, ajută-mă pentru a converti MSSQL to MYSQL, MS access la MSSQL, mysql, csv loader, foxpro și MSSQL pentru MS access, MYSQl, CSV, foxpro etc. Din punctul meu de vedere acesta este cel mai bun Instrument de Migrare de Date
Descărcare Gratuită : http://www.dbload.com
acest software afară de la cutie - funcționează pentru mine. incearca-l si lasa pe altul.
https://dbconvert.com/sqlite/mysql/
În plus:
Am avut de a face o mică schimbare: cumva auto_increment de un câmp (un câmp găsit de eroare mesaj) nu a fost activat. Deci, în phpmyadmin nu verifica proprietatea A_I de acest domeniu și funcționează complet. Sper că vă ajută.
Dunn.
Am scris acest script simplu în Python3. Acesta poate fi folosit ca o clasă incluse sau independent scenariul invocat prin intermediul unui terminal de coajă. În mod implicit a importurilor toate numerele întregi ca int(11) și siruri de caractere cavarchar(300), dar toate care pot fi ajustate în constructor sau script argumente respectiv.
NOTĂ: Este nevoie de MySQL Connector/Python 2.0.4 sau mai mare
Aici's un link la sursa pe GitHub dacă veți găsi codul de mai jos greu de citit: https://github.com/techouse/sqlite3-to-mysql
#!/usr/bin/env python3
__author__ = "Klemen Tušar"
__email__ = "[email protected]"
__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()
Ha... aș vrea să am găsit asta în primul rând! Răspunsul meu a fost la acest post... https://stackoverflow.com/questions/489277/script-to-convert-mysql-dump-sql-file-into-format-that-can-be-imported-into-sqlit
Combinând cele două ar fi exact ce am nevoie:
Când o bază de date sqlite3 va fi folosit cu ruby poate doriți să o modificați:
tinyint([0-9]*) a:
sed 's/ tinyint(1*) / boolean/g ' |
sed 's/ tinyint([0|2-9]*) / integer /g' |din păcate, acest lucru doar pe jumătate funcționează pentru că, chiar dacă îl introduceți 1's și 0's într-un câmp marcat boolean, sqlite3 le stochează ca 1's și 0's, astfel încât să aveți pentru a merge prin și de a face ceva de genul:
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)dar a fost util pentru a avea fișierul sql să se uite la pentru a găsi toate booleene.
