SQLite3를 MySQL로 빠르게 마이그레이션하는 방법

SQLite3를 MySQL로 빠르게 마이그레이션하는 방법

닫혔어. 이 질문은 좀 더 자세히 설명해야 합니다.초점을 맞춥니다.현재 답변을 받고 있지 않습니다.

---

이 질문을 개선하시겠습니까?이 게시물을 편집하여 하나의 문제에 초점을 맞추도록 질문을 업데이트하십시오.

2년 전에 문을 닫았어요

커뮤니티는 11개월 전에 이 질문을 재개할지 여부를 검토한 후 종료했습니다.

원래 종료 이유가 해결되지 않았습니다.

이 질문을 개선하다

SQLite3 데이터베이스를 MySQL로 빠르게 마이그레이션할 수 있는 방법을 알고 계신 분?

모든 사람이 몇 가지 greps 및 perl 표현으로 시작하는 것 같습니다.그리고 특정 데이터셋에 적합한 것을 얻을 수 있지만 데이터가 올바르게 Import되었는지 여부는 알 수 없습니다.아무도 둘 사이를 전환할 수 있는 견고한 도서관을 짓지 못했다는 게 정말 놀랍습니다.

다음은 두 파일 형식 간의 SQL 구문의 모든 차이점 목록입니다.다음 행으로 시작하는 행:

• 트랜잭션 시작
• 저지르다
• sqlite_sequence
• 고유 인덱스 생성

MySQL에서는 사용되지 않습니다.

• 는 SQLite를 사용합니다.CREATE TABLE/INSERT INTO "table_name"은 "MySQL"을 사용합니다.CREATE TABLE/INSERT INTO table_name
• MySQL은 스키마 정의 내에 따옴표를 사용하지 않습니다.
• 은 MySQL 내부 합니다.INSERT INTO
• 은 SQLite MySQL 내의 .INSERT INTO
• 는 SQLite를 사용합니다.'t' ★★★★★★★★★★★★★★★★★」'f'MySQL MySQL 、 Boohans 경 my를 사용합니다.1 ★★★★★★★★★★★★★★★★★」0 do,같은 ('I do, you do'와 같은 문자열이 있을 할 수 ).INSERT INTO)
• Lite를 사용합니다.AUTOINCREMENT은 , MySQL을 사용합니다.AUTO_INCREMENT

여기 매우 기본적인 해킹된 perl 스크립트가 있습니다.이 스크립트는 내 데이터셋에 대해 동작하며 웹에서 발견된 다른 perl 스크립트에 비해 더 많은 조건을 체크합니다.Nu는 당신의 데이터에 대해 작동한다는 것을 보증하지만, 자유롭게 수정하여 여기에 다시 게시할 수 있습니다.

#! /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;
    }
}

다음은 컨버터 목록(2011년 이후 업데이트되지 않음)입니다.

• https://www2.sqlite.org/cvstrac/wiki?p=ConverterTools(또는 archive.org의 스냅샷)

---

An alternative method that would work nicely but is rarely mentioned is: use an ORM class that abstracts specific database differences away for you. e.g. you get these in PHP ( 팥), Python (Django's ORM layer, 폭풍, Sql Alchemy), Ruby on Rails ( 액티브 레코드), Cocoa ( 코어 데이터)

즉, 다음과 같이 할 수 있습니다.

1. ORM 클래스를 사용하여 소스 데이터베이스에서 데이터를 로드합니다.
2. 데이터를 메모리에 저장하거나 디스크에 일련화합니다.
3. ORM 클래스를 사용하여 데이터를 대상 데이터베이스에 저장합니다.

이것은 Shalmanese의 답변과 Python으로 번역하는 Perl에서 Alex marteli의 도움을 바탕으로 작성된 Python 스크립트입니다.

커뮤니티 Wiki로 하고 있으니 편집이나 리팩터링도 자유롭게 해 주세요.(다행히 롤백할 수 있습니다)- 보기 흉하지만 동작합니다.

dump_for_mysql.py:

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

그런 다음 mysql로 가져올 수 있습니다.

참고 - sqlite는 외부 키 구속을 실제로 지원하지 않으므로 수동으로 추가해야 합니다.

스크립트를 다음에 나타냅니다.

#!/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,

IntelliJ DataGrip의 테이블 내보내기/가져오기 기능을 주로 사용합니다.

오른쪽 아래 구석에 진행 상황을 볼 수 있습니다.

Python/Django를 사용하고 있다면 매우 간단합니다.

settings.py에 2개의 데이터베이스를 만듭니다(여기 https://docs.djangoproject.com/en/1.11/topics/db/multi-db/) 등).

이렇게 하면 됩니다.

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

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

아마도 가장 간단한 방법은 sqlite.dump 명령을 사용하는 것입니다.이 경우 샘플 데이터베이스의 덤프를 만듭니다.

sqlite3 sample.db .dump > dump.sql

다음으로 (이론적으로) 이것을 mysql 데이터베이스로 Import할 수 있습니다.이 경우 사용자 루트를 사용하여 데이터베이스 서버 127.0.0.1의 테스트 데이터베이스를 Import할 수 있습니다.

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

나는 이론적으로 문법 사이에 몇 가지 차이가 있기 때문에 말한다.

sqlite 트랜잭션이 시작됩니다.

BEGIN TRANSACTION;
...
COMMIT;

MySQL은

BEGIN;
...
COMMIT;

다른 유사한 문제(varchars와 큰 따옴표)도 있지만, 찾을 수 있는 것과 바꿀 수 있는 것은 없습니다.

이행하는 이유에 대해 물어보는 것이 좋을지도 모릅니다.퍼포먼스/데이터베이스 사이즈가 문제라면 스키마의 재로그인을 검토해 주십시오.시스템이 보다 강력한 제품으로 이행하고 있다면 지금이 데이터의 미래를 계획하기에 이상적인 시기입니다.

이제 막 이 프로세스를 진행했는데, 이 Q/A에는 많은 유용한 도움말과 정보가 포함되어 있습니다. 하지만 성공적으로 마이그레이션하려면 다양한 요소(및 다른 Q/A의 일부 요소)를 조합해야 합니다.

그러나 기존 답변을 조합해도 Python 스크립트는 INSERT에 여러 부울이 있는 곳에서는 동작하지 않아 완전히 동작하지 않는다는 것을 알게 되었습니다.왜 그랬는지 여기를 보세요.

그래서 제가 합친 답을 여기에 올리려고 합니다.물론 다른 곳에서 공헌한 사람들에게도 공로가 돌아간다.하지만 나는 뭔가를 돌려주고 싶었고, 다른 사람들의 시간을 절약하고 싶었다.

아래에 대본을 올리겠습니다.하지만 먼저, 여기 변환에 대한 지침이 있습니다...

OS X 10.7.5 Lion에서 스크립트를 실행했습니다.Python은 바로 사용할 수 있었습니다.

기존 SQLite3 데이터베이스에서 MySQL 입력 파일을 생성하려면 다음과 같이 자체 파일에서 스크립트를 실행합니다.

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

그런 다음 결과 dumped_sql.sql 파일을 MySQL 데이터베이스가 상주하는 Ubuntu 10.04.4 LTS를 실행하는 Linux 상자에 복사했습니다.

MySQL 파일을 Import 할 때 또 다른 문제는 일부 Unicode UTF-8 문자(특히 작은 따옴표)가 올바르게 Import되지 않았기 때문에 UTF-8을 지정하기 위해 명령어에 스위치를 추가해야 한다는 것입니다.

데이터를 빈 MySQL 데이터베이스에 입력하는 명령어는 다음과 같습니다.

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

익히면 그만이야!데이터 전후를 꼼꼼히 검토하는 것을 잊지 마십시오.

따라서 OP의 요구대로 쉽고 빠르게 조작할 수 있습니다! :-)

한편, 이 이행에 대해 조사하기 전에는 created_at 및 updated_at 필드 값이 유지되는지 여부에 대해 잘 몰랐습니다.이러한 필드 값은 유지되므로 기존 프로덕션 데이터를 이행할 수 있습니다.

행운을 빕니다.

갱신하다

이 스위치를 켠 후, 이전에는 눈치채지 못했던 문제를 발견하게 되었습니다.내 Rails 응용프로그램에서 내 텍스트 필드는 '문자열'로 정의되고 데이터베이스 스키마로 전달됩니다.여기서 설명하는 프로세스에서는 MySQL 데이터베이스에서 VARCHAR(255)로 정의됩니다.그러면 이러한 필드 크기에 255자 제한이 설정되며, 이 값을 초과하는 항목은 Import 중에 자동으로 잘립니다.255보다 긴 텍스트 길이를 지원하려면 MySQL 스키마가 VARCHAR(255)가 아닌 'TEXT'를 사용해야 한다고 생각합니다.여기서 정의하는 프로세스에는 이 변환이 포함되지 않습니다.

---

다음은 제 데이터에 적합한 통합 및 수정된 Python 스크립트입니다.

#!/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,

• 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

Python3는 Python3를 사용합니다.터미널 셸을 통해 호출되는 포함된 클래스 또는 스탠드아론 스크립트로 사용할 수 있습니다.를 "Import"로 .int(11)은 ""로 지정합니다.varchar(300) 또는 할 수 입니다.

메모: MySQL 커넥터/Python 2.0.4 이후가 필요합니다.

아래 코드를 읽기 어렵다면 GitHub의 소스에 대한 링크입니다.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()

저는 최근에 저희 팀이 진행하고 있는 프로젝트를 위해 MySQL에서 JavaDB로 이행해야 했습니다.Apache가 작성한 Java 라이브러리로 DdlUtils라는 이름으로 매우 쉽게 만들 수 있었습니다.다음 작업을 수행할 수 있는 API를 제공합니다.

1. 데이터베이스의 스키마를 검색하여 XML 파일로 내보냅니다.
2. 이 스키마를 기반으로 DB를 수정합니다.
3. 동일한 스키마를 가진 것으로 가정하여 한 DB에서 다른 DB로 레코드를 가져옵니다.

우리가 사용한 툴은 완전히 자동화되지는 않았지만 꽤 잘 작동했습니다.어플리케이션이 Java 버전이 아니더라도 몇 가지 작은 툴을 사용하여 일회성 마이그레이션을 수행하는 것은 그리 어렵지 않습니다.150줄 미만의 코드만으로 이행을 할 수 있었다고 생각합니다.

SQL 덤프 가져오기

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

MySQL로 덤프 가져오기

소규모 수입의 경우:

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

또는

mysql -u root -p somedb < myTemporarySQLFile.sql

그러면 암호를 입력하라는 메시지가 표시됩니다.하려면 공백 바로 뒤에 입력해야 .-p:

mysql -u root -pYOURPASS somedb < myTemporarySQLFile.sql

덤프가 큰 경우:

mysqlimport 또는 BigDump와 같은 다른 Import 도구.

Big Dump는 진행 표시줄을 제공합니다.

Jims의 솔루션을 기반으로 합니다.SQLite3를 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  

난 이거면 돼.sed를 사용하여 첫 번째 줄을 던집니다.이것은 mysql과 같지 않습니다만, 이 줄을 버리려면 dump.py 스크립트를 수정하는 것이 좋습니다.

스크립트나 명령어 등은 필요 없습니다.

를 sqlite로 ..csvphpmyadmin의 Mysql Import.

내가 썼는데 잘 작동했어...

하... 이걸 먼저 찾았으면 좋았을 텐데!이 게시물에 대한 제 답변은...mysql 덤프 sql 파일을 sqlite3 db로 Import할 수 있는 형식으로 변환하는 스크립트

이 두 가지를 조합하는 것이 바로 제가 필요로 했던 것입니다.

---

sqlite3 데이터베이스를 루비와 함께 사용할 경우 다음과 같이 변경할 수 있습니다.

tinyint([0-9]*) 

대상:

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

부울로 표시된 필드에 1과 0을 삽입해도 sqlite3는 1과 0으로 저장하기 때문에 이 절반만 작동합니다.

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)

sql파일이 있어서 부울런을 다 찾을 수 있어서 도움이 됐어요.

이 스크립트는 물론 만난 적이 있는 경우를 제외하고 괜찮습니다.

"requestcomparison_stopword" 값(149,'f')에 삽입합니다."requestcomparison_stopword" 값(420,'t')에 삽입합니다.

스크립트는 다음 출력을 제공합니다.

request comparison_stopword VALUES(149,'f')에 삽입;request comparison_stopword VALUES(420,'t')에 삽입;

대신 다음과 같은 출력을 제공합니다.

request comparison_stopword VALUES (1490;)에 삽입한다.request comparison_stopword VALUES(4201;)에 삽입합니다.

마지막 0과 1 주위에 ASCII가 아닌 이상한 문자가 포함되어 있습니다.

다음 코드 행(43-46)에 코멘트를 달았을 때 이 문제는 발생하지 않았지만 다른 문제가 발생했습니다.

    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')

이것은 단지 특별한 경우일 뿐이고, f나 t의 값을 더하고 싶지만 정규 표현이 별로 마음에 들지 않을 때, 나는 단지 누군가가 이 경우를 수정해 주었으면 하는 것입니다.

어쨌든, 그 편리한 대본 정말 고마워요!!!

다음과 같은 간단한 솔루션이 도움이 되었습니다.

<?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

CREATE 스테이트먼트에 주의하다

언급URL : https://stackoverflow.com/questions/18671/quick-easy-way-to-migrate-sqlite3-to-mysql