Django: 之数据库导入、迁移和联用

Django 数据库导入

从网上下载的一些数据，excel表格，xml文件，txt文件等有时候我们想把它导入数据库，应该如何操作呢？

以下操作符合 Django版本为 1.6 ，兼顾 Django 1.7, Django 1.8 版本，理论上Django 1.4, 1.5 也没有问题，没有提到的都是默认值

备注：你可能会问数据从哪儿来的，比如你用python从以前的blog上获取过来的，想导入现在的博客，或者别人整理好的数据，或者你自己整理的excel表，一个个地在网站后台复制粘贴你觉得好么？这就是批量导入的必要性。

建议先不要看源码，按教程一步步做下去，遇到问题再试试源代码，直接复制粘贴，很快就会忘掉，自己动手打一遍

我们新建一个项目mysite，在新建一个app，名称为blog

django-admin.py startproject mysite
cd mysite
python manage.py startapp blog

把blog中的models.py更改为一下内容

#!/usr/bin/python
#coding:utf-8
 
from django.db import models
 
class Blog(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
     
    def __unicode__(self):
        return self.title

不要忘了把blog加入到settings.py中的INSTALLED_APPS中。

# Application definition
INSTALLED_APPS = (
    ...
     
    # 添加上 blog 这个 app
    'blog',
)

一、同步数据库，创建相应的表

python manage.py syncdb

Django 1.6以下版本会看到：

Django创建了一些默认的表，注意后面哪个红色标记的blog_blog是appname_classname的样式，这个表是我们自己写的Blog类创建的

Django 1.7.6及以上的版本会看到：（第六行即创建了对应的blog_blog表）

Operations to perform:
  Synchronize unmigrated apps: blog
  Apply all migrations: admin, contenttypes, auth, sessions
Synchronizing apps without migrations:
  Creating tables...
    Creating table blog_blog
  Installing custom SQL...
  Installing indexes...
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying sessions.0001_initial... OK
 
You have installed Django's auth system, and don't have any superusers defined.
Would you like to create one now? (yes/no): yes
Username (leave blank to use 'tu'): wulaoer
Email address: 
Password: 
Password (again): 
Superuser created successfully.

二、输入python manage.py shell　　

进入该项目的django环境的终端（windows如何进入对应目录？看Django环境搭建的3.2部分）

先说说如何使用命令新增一篇文章：

$ python manage.py shell
>>> from blog.models import Blog
>>> Blog.objects.create(title="The first blog of my site", 
                        content="I am writing my blog on Terminal")

这样就新增了一篇博文，我们查看以下　　

>>> Blog.objects.all() # 获取所有blog
[<Blog: The first blog of my site>]

还有两种方法（这两种差不多）：

>>> blog2 = Blog()
>>> blog2.title = "title 2"
>>> blog2.content = "content 2"
>>> blog2.save()
或者
>>> blog2 = Blog(title="title 2",content="content 2")
>>> blog2.save()

后面两种方法也很重要，尤其是用在修改数据的时候，要记得最后要保存以下blog.save()，第一种Blog.objects.create()是自动保存的。

三、批量导入

比如我们要导入一个文本，里面是标题和内容，中间用四个*隔开的，示例（pldblog.txt）：

title 1****content 1
title 2****content 2
title 3****content 3
title 4****content 4
title 5****content 5
title 6****content 6
title 7****content 7
title 8****content 8
title 9****content 9

在终端导入有时候有些不方便，我们在最外面哪个mysite目录下写个脚本，叫txt2db.py，把lodblog.txt也放在mysite下

#!/usr/bin/env python
#coding:utf-8
 
import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mysite.settings")
 
'''
Django 版本大于等于1.7的时候，需要加上下面两句
import django
django.setup()
否则会抛出错误 django.core.exceptions.AppRegistryNotReady: Models aren't loaded yet.
'''
 
import django
if django.VERSION >= (1, 7):#自动判断版本
    django.setup()
 
 
def main():
    from blog.models import Blog
    f = open('oldblog.txt')
    for line in f:
        title,content = line.split('****')
        Blog.objects.create(title=title,content=content)
    f.close()
 
if __name__ == "__main__":
    main()
    print('Done!')

好了，我们在终端运行它

python txt2db.py
# 运行完后显示 一个 Done! 导入完成！

四、导入数据重复解决办法

如果你导入数据过多，导入时出错了，或者你手动停止了，导入了一部分，还有一部分没有导入。或者你再次运行上面的命令，你会发现数据重复了，怎么办呢？

django.db.models中还有一个函数叫get_or_create()有就获取过来，没有就创建，用它可以避免重复，但是速度可以会慢些，因为要先尝试获取，看看有没有

只要把上面的

Blog.objects.create(title=title,content=content)

换成下面的就不会重复导入数据了

Blog.objects.get_or_create(title=title,content=content)

返回值是（BlogObject，True/False）新建时返回True，已经存在时返回False。

更多数据库API的知识请参见官网文档：QuerySet API　　

五、用fixture导入

最常见的fixture文件就是python manage.py dumpdata导出的文件，示例如下：

[
  {
    "model": "myapp.person",
    "pk": 1,
    "fields": {
      "first_name": "John",
      "last_name": "Lennon"
    }
  },
  {
    "model": "myapp.person",
    "pk": 2,
    "fields": {
      "first_name": "Paul",
      "last_name": "McCartney"
    }
  }]

你也可以根据自己的models，创建这样的json文件，然后用python manage.py loaddata fixture.json导入

详见:https://docs.djangoproject.com/en/dev/howto/initial-data/

可以写一个脚本，把要导入的数据转换成json文件，这样导入也会更快些！

六、Model.objects.bulk_create()更快更方便

#!/usr/bin/env python
import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mysite.settings")
 
def main():
    from blog.models import Blog
    f = open('oldblog.txt')
    BlogList = []
    for line in f:
        title,content = line.split('****')
        blog = Blog(title=title,content=content)
        BlogList.append(blog)
    f.close()
     
    Blog.objects.bulk_create(BlogList)
 
if __name__ == "__main__":
    main()
    print('Done!')

由于Blog.objects.create()每保存一条就执行一次SQL，而bulk_create()是执行一条SQL存入多条数据，做会块很多！当然用列表解析代替for循环会更快！！

#!/usr/bin/env python
import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mysite.settings")
 
def main():
    from blog.models import Blog
    f = open('oldblog.txt')
     
    BlogList = []
    for line in f:
        parts = line.split('****')
        BlogList.append(Blog(title=parts[0], content=parts[1]))
         
    # 以上四行 也可以用 列表解析 写成下面这样
    # BlogList = [Blog(title=line.split('****')[0], content=line.split('****')[1]) for line in f]
     
    Blog.objects.bulk_create(BlogList)
 
if __name__ == "__main__":
    main()
    print('Done!')

当然也可以利用数据中的导出，在导入的方法，　　

Django 数据迁移

Django数据库不同数据库，SQLite3，MySQL，PostgreSQL之间数据迁移的方案，以及不同机器之间的迁移方案

一、简单的数据导出与导入（简单的迁移）

1、django项目提供了一个导出的方法python manage.py dumpdata，不指定appname时默认为导出所有的app

python manage.py dumpdata [appname] > appname_data.json

比如我们有一个项目叫mysite，里面有一个app叫blog，我们想导出blog的所有数据

python manage.py dumpdata blog > blog_dump.json

2、数据导入，不需要指定appname

python manage.py loaddata blog_dump.json

备注：一些常用的

python manage.py dumpdata auth > auth.json # 导出用户数据

优点：可以兼容各种支持的数据库，也就是说，以前用的是SQLite3，可以导出后，用这种方法导入到MySQL，PostgreSQL等数据库，反过来也可以。

缺点：数据量大的时候，速度相对较慢，表的关系比较复杂的时候可以导入不成功。

二、数据库的迁移

2、1用Django自带的命令

比如早期我们为了开发方便，用sqlite3数据库，后来发现网站数据太多，sqlite3性能有点跟不上了，想换成postgreSQL或者MySQL的时候。

如果我还使用上面的命令，如果你运气好的话，也许会导入成功，流程如下：

2.1.1 从原来的整个数据库导出所有数据

python manage.py dumpdata > mysite_all_data.json

2.1.2 将mysite_all_data.json传送到另一个服务器或者电脑上导入

python manage.py loaddata mysite_all_data.json

如果你运气好的话可能会导入完成，但是往往不那么顺利，原因如下：

a）我们在写models的时候如果用到CharField，就一定要写max_length，在sqlite3中是不检查这个最大长度的，你写最大运行长度为100.你网数据库放10000个，sqlite3都不报错，而且不截断数据的长度，这似乎是slite3的优点，但是也给从sqlite3导入其他数据库带来了困难，因为MySQL和PostgreSQL数据库都会检查最大长度，超出时就报错！

b）Django自带的contentType会导致出现一些问题

用上面的方法只迁移一个app应该问题不大，但是如果有用户，用户组挂钩，事情往往变得糟糕！如果导入后没有对数据进行修改，你可以重新导入，可能还要块一些，如果是手动在后人输入或者修改过，这种方法就不适用了

2.2、用数据库自带的导出导入命令

假定Django用的数据库名称为wulaoer

2.2.1 在PostgreSQL中：

# 导出数据库 zqxt 到 wulaoer.sql 文件中
pg_dump wulaoer > wulaoer.sql
 
# 导入数据库到 新的服务器
psql wulaoer -f wulaoer.sql
 
#注意：数据导入导出可能需要数据库超级权限,用 sudo su postgres 切换到数据库超级用户 postgres

2.2.2 在MySQL中：

使用网页工具，比如phpMyAdmin导入导出很简单，这里就不说了，主要就说一下命令行如何操作：

# 导出数据库 wulaoer 到 wulaoer.sql 文件中
mysqldump -u username -p --database wulaoer > wulaoer.sql
 
# 导入数据库到 新的服务器
mysql -u username -p
输入密码进入 MySQL 命令行
> source /path/to/wulaoer.sql

总结：其他的数据库，请自行搜索如何导入导出，整个数据库导出的好处就是对数据之间的关系处理比较省事，比如自强学堂里面的很多教程，上篇和下一篇是一个一对一的关系，这样的话用python manage.py dumpdata无法导出教程与教程的关系，但是数据库整个导出就没有任何问题，当然也可以写一个脚本导出关系再导入。Django自带的python manage.py dumpdata和python manage.py loaddata最大的好处就是可以跨站数据库进行导入导出。

Django 多数据库联用

以下是讲述在一个django project中使用多个数据库的方法，多个数据库的联用以及多数据库时数据库导入导出的方法。

直接给出一种简单的方法，想了解更多可以到官方，点击此处　　

代码文件下载：

project_name.zip　　

1、每个app都可以单独设置一个数据库

settings.py中有数据库的相关设置，有一个默认的数据库default，我们可以再加一些其他的，比如：

# Database
# https://docs.djangoproject.com/en/1.8/ref/settings/#databases
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    },
    'db1': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'dbname1',
        'USER': 'your_db_user_name',
        'PASSWORD': 'yourpassword',
        "HOST": "localhost",
    },
    'db2': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'dbname2',
        'USER': 'your_db_user_name',
        'PASSWORD': 'yourpassword',
        "HOST": "localhost",
    },
}
 
# use multi-database in django
# add by WeizhongTu
DATABASE_ROUTERS = ['project_name.database_router.DatabaseAppsRouter']
DATABASE_APPS_MAPPING = {
    # example:
    #'app_name':'database_name',
    'app1': 'db1',
    'app2': 'db2',
}

在project_name文件夹中存放database_route.py文件，内容如下：

# -*- coding: utf-8 -*-
from django.conf import settings
 
DATABASE_MAPPING = settings.DATABASE_APPS_MAPPING
 
 
class DatabaseAppsRouter(object):
    """
    A router to control all database operations on models for different
    databases.
 
    In case an app is not set in settings.DATABASE_APPS_MAPPING, the router
    will fallback to the `default` database.
 
    Settings example:
 
    DATABASE_APPS_MAPPING = {'app1': 'db1', 'app2': 'db2'}
    """
 
    def db_for_read(self, model, **hints):
        """"Point all read operations to the specific database."""
        if model._meta.app_label in DATABASE_MAPPING:
            return DATABASE_MAPPING[model._meta.app_label]
        return None
 
    def db_for_write(self, model, **hints):
        """Point all write operations to the specific database."""
        if model._meta.app_label in DATABASE_MAPPING:
            return DATABASE_MAPPING[model._meta.app_label]
        return None
 
    def allow_relation(self, obj1, obj2, **hints):
        """Allow any relation between apps that use the same database."""
        db_obj1 = DATABASE_MAPPING.get(obj1._meta.app_label)
        db_obj2 = DATABASE_MAPPING.get(obj2._meta.app_label)
        if db_obj1 and db_obj2:
            if db_obj1 == db_obj2:
                return True
            else:
                return False
        return None
 
    def allow_syncdb(self, db, model):
        """Make sure that apps only appear in the related database."""
 
        if db in DATABASE_MAPPING.values():
            return DATABASE_MAPPING.get(model._meta.app_label) == db
        elif model._meta.app_label in DATABASE_MAPPING:
            return False
        return None

这样就实现了指定的app使用指定的数据库了，当然你也可以多个sqlite3一起使用，相当于可以给每个app都可以单独设置一个数据库！如果不设置或者有设置的app就会自动使用默认的数据库

2、多个数据库联用时数据库导入导出

使用的时候和一个数据库的区别是：

如果不是defalut(默认数据库)要在命令后加--database=数据库对应的settings.py中的名称 如： --database=db1 或 --database=db2

数据库同步（创建表）

python manage.py syncdb #同步默认的数据库，和原来的没有区别
 
#同步数据库 db1 (注意：不是数据库名是db1,是settings.py中的那个db1，不过你可以使这两个名称相同，容易使用)
python manage.py syncdb --database=db1

数据导出

python manage.py dumpdata app1 --database=db1 > app1_fixture.json
python manage.py dumpdata app2 --database=db2 > app2_fixture.json
python manage.py dumpdata auth > auth_fixture.json

数据导入

python manage.py loaddata app1_fixture.json --database=db1
python manage.py loaddata app2_fixture.json --database=db2