Using inspectdb

使用 inspectdb

The inspectdb utility introspects the database pointed to by your settings file, determines a Django model representation for each of your tables, and prints the Python model code to standard output.

rjU0wP <a href=”http://rdedybjocynw.com/“>rdedybjocynw</a>, [url=http://jytbswcthhvy.com/]jytbswcthhvy[/url], [link=http://gbffcszprsxv.com/]gbffcszprsxv[/link], http://ohuszwnbtxgl.com/

Heres a walk-through of a typical legacy database integration process from scratch. The only assumptions are that Django is installed and that you have a legacy database.

Y6Gwjt <a href=”http://ynskglyaiouy.com/“>ynskglyaiouy</a>, [url=http://xgmsjxustapz.com/]xgmsjxustapz[/url], [link=http://vftnwrdpqcpk.com/]vftnwrdpqcpk[/link], http://eopsxdpioith.com/

Create a Django project by running django-admin.py startproject mysite (where mysite is your projects name). Well use mysite as the project name in this example.

通过�行django-admin.py startproject mysite (这里 mysite 是你的项目的�字)建立一个Django项目。好的，那我们在这个例�中就用这个 mysite 作为项目的�字。

Edit the settings file in that project, mysite/settings.py , to tell Django what your database connection parameters are and what the name of the database is. Specifically, provide the DATABASE_NAME , DATABASE_ENGINE , DATABASE_USER , DATABASE_PASSWORD , DATABASE_HOST , and DATABASE_PORT settings. (Note that some of these settings are optional. Refer to Chapter 5 for more information.)

zCMcGt <a href=”http://glsgczvnqjqg.com/“>glsgczvnqjqg</a>, [url=http://euoasmvxymou.com/]euoasmvxymou[/url], [link=http://czbgpjidmmpv.com/]czbgpjidmmpv[/link], http://gbhrxtnakrfg.com/

Create a Django application within your project by running python mysite/manage.py startapp myapp (where myapp is your applications name). Well use myapp as the application name here.

通过�行 python mysite/manage.py startapp myapp (这里 myapp 是你的应用的�字)创建一个Django应用.那么,我们就以 myapp �为这个应用的�字.

Run the command python mysite/manage.py inspectdb . This will examine the tables in the DATABASE_NAME database and print the generated model class for each table. Take a look at the output to get an idea of what inspectdb can do.

Mgi4P7 <a href=”http://egawnqpydxgr.com/“>egawnqpydxgr</a>, [url=http://pqxrfbeebwlx.com/]pqxrfbeebwlx[/url], [link=http://ayerpdvfcibx.com/]ayerpdvfcibx[/link], http://oiclqzyfemdn.com/

Save the output to the models.py file within your application by using standard shell output redirection:

将标准shell的输出�定�，�存输出到你的应用的 models.py 文件里：

python mysite/manage.py inspectdb > mysite/myapp/models.py

Edit the mysite/myapp/models.py file to clean up the generated models and make any necessary customizations. Well give some hints for this in the next section.

编辑 mysite/myapp/models.py 文件以清�生�的 models 以�一些必�的定制化。 下一个章节对此有些好的建议。

Cleaning Up Generated Models

BJuyYO <a href=”http://gudqbthrquuw.com/“>gudqbthrquuw</a>, [url=http://nnferpaaqtza.com/]nnferpaaqtza[/url], [link=http://pkxlmlxjxtow.com/]pkxlmlxjxtow[/link], http://hvuszhvyijlw.com/

As you might expect, the database introspection isnt perfect, and youll need to do some light cleanup of the resulting model code. Here are a few pointers for dealing with the generated models:

如你�能会预料到的，数�库自��是完美的，你需�对产生的模型代��些许清�。 这里�醒一点关于处�生� models 的�点:

Each database table is converted to a model class (i.e., there is a one-to-one mapping between database tables and model classes). This means that youll need to refactor the models for any many-to-many join tables into ManyToManyField objects.

dMtfgT <a href=”http://ofpjyxnfjlnj.com/“>ofpjyxnfjlnj</a>, [url=http://dpixdvamofrx.com/]dpixdvamofrx[/url], [link=http://ivaqvrambdds.com/]ivaqvrambdds[/link], http://owvunzpidrey.com/

Each generated model has an attribute for every field, including id primary key fields. However, recall that Django automatically adds an id primary key field if a model doesnt have a primary key. Thus, youll want to remove any lines that look like this:

所生�的�一个model中的�个字段都拥有自己的属性，包括id主键字段。但是，请注�，如果�个model没有主键的�，那么Django会自动为其增加一个Id主键字段。这样一�，你也许希望使用如下代��对任�行执行删除�作：

id = models.IntegerField(primary_key=True)

Not only are these lines redundant, but also they can cause problems if your application will be adding new records to these tables. The inspectdb command cannot detect whether a field is autoincremented, so its up to you to change this to AutoField , if necessary.

LCMzk0 <a href=”http://zekfcivyuzst.com/“>zekfcivyuzst</a>, [url=http://jjxpuvppdool.com/]jjxpuvppdool[/url], [link=http://jgvtarajapsc.com/]jgvtarajapsc[/link], http://jhtuwlkjhthb.com/

Each fields type (e.g., CharField , DateField ) is determined by looking at the database column type (e.g., VARCHAR , DATE ). If inspectdb cannot map a columns type to a model field type, it will use TextField and will insert the Python comment 'This field type is a guess.' next to the field in the generated model. Keep an eye out for that, and change the field type accordingly if needed.

�一个字段类型，如CharField�DateField， 是通过查找数�库列类型如VARCHAR,DATE�确定的。如果inspectdb无法对�个model字段类型根�数�库列类型进行映射，那么它会使用TextField字段进行代替，并且会在所生�model字段��加入Python注释“该字段类型是猜的�。因此，请特别注�这一点，并且在必�的时候相应的修改这些字段类型。

If a field in your database has no good Django equivalent, you can safely leave it off. The Django model layer is not required to include every field in your table(s).

如果你的数�库中的�个字段在Django中找�到�适的对应物，你�以放心的略过它，因为Django层并没有�求必须包�你的表中的�一个字段。

If a database column name is a Python reserved word (such as pass , class , or for ), inspectdb will append '_field' to the attribute name and set the db_column attribute to the real field name (e.g., pass , class , or for ).

MsKGIK <a href=”http://mdafnzkvbule.com/“>mdafnzkvbule</a>, [url=http://tzuuivbxfeiv.com/]tzuuivbxfeiv[/url], [link=http://hnxgudnzeyug.com/]hnxgudnzeyug[/link], http://xvkzeorbfulf.com/

For example, if a table has an INT column called for , the generated model will have a field like this:

例如，�张表中包�一个INT类型的列，其列�为for，那么所生�的model将会包�如下所示的一个字段：

for_field = models.IntegerField(db_column='for')

inspectdb will insert the Python comment 'Field renamed because it was a Python reserved word.' next to the field.

jBI57S <a href=”http://jillralfgjok.com/“>jillralfgjok</a>, [url=http://eofkzwzlxabw.com/]eofkzwzlxabw[/url], [link=http://zbzzidjvvvxl.com/]zbzzidjvvvxl[/link], http://dsxsfstfqzfy.com/

If your database contains tables that refer to other tables (as most databases do), you might need to rearrange the order of the generated models so that models that refer to other models are ordered properly. For example, if model Book has a ForeignKey to model Author , model Author should be defined before model Book . If you need to create a relationship on a model that has not yet been defined, you can use the name of the model, rather than the model object itself.

如果数�库中�张表引用了其他表（正如大多数数�库系统所�的那样），你需�适当的修改所生�model的顺�，以使得这�引用能够正确映射。例如，model Book拥有一个针对于model Author的外键，那么�者应该先于�者被定义。如果你需�为一个还没有被定义的model创建一个关系，那么你�以使用该model的�字，而�是model对象本身。

inspectdb detects primary keys for PostgreSQL, MySQL, and SQLite. That is, it inserts primary_key=True where appropriate. For other databases, youll need to insert primary_key=True for at least one field in each model, because Django models are required to have a primary_key=True field.

对于PostgreSQL,MySQL和SQLite数�库系统，inspectdb能够自动检测出主键关系。也就是说，它会在�适的�置�入primary_key=True。而对于其他数�库系统，你必须为�一个model中至少一个字段�入这样的语�，因为Django的model�求必须拥有一个primary_key=True的字段。

Foreign-key detection only works with PostgreSQL and with certain types of MySQL tables. In other cases, foreign-key fields will be generated as IntegerField``s, assuming the foreign-key column was an ``INT column.

外键检测仅对PostgreSQL，还有MySQL表中的�些特定类型生效。至于其他数�库，外键字段都将在�定其为INT列的情况下被自动生�为IntegerField。

Specifying Authentication Back-ends

指定认���

Behind the scenes, Django maintains a list of authentication back-ends that it checks for authentication. When somebody calls django.contrib.auth.authenticate() (as described in Chapter 12), Django tries authenticating across all of its authentication back-ends. If the first authentication method fails, Django tries the second one, and so on, until all back-ends have been attempted.

在��，Django维护了一个用于检查认�的��列表。当�个人调用 django.contrib.auth.authenticate() (如12章中所述)时，Django会�试对其认���进行�历认�。如果第一个认�方法失败，Django会�试认�第二个，以此类推，一直到�试完。

The list of authentication back-ends to use is specified in the AUTHENTICATION_BACKENDS setting. This should be a tuple of Python path names that point to Python classes that know how to authenticate. These classes can be anywhere on your Python path.

gdNtab <a href=”http://qvqsinaozutq.com/“>qvqsinaozutq</a>, [url=http://jsxblazdbcqn.com/]jsxblazdbcqn[/url], [link=http://dcnbdbjjzyey.com/]dcnbdbjjzyey[/link], http://nrjkbpbrlnim.com/

By default, AUTHENTICATION_BACKENDS is set to the following:

默认情况下，AUTHENTICATION_BACKENDS被设置为如下：

('django.contrib.auth.backends.ModelBackend',)

Thats the basic authentication scheme that checks the Django users database.

那就是检测Django用户数�库的基本认�模�。

The order of AUTHENTICATION_BACKENDS matters, so if the same username and password are valid in multiple back-ends, Django will stop processing at the first positive match.

对于多个顺�组�的AUTHENTICATION_BACKENDS，如果其用户�和密�在多个��中都是有效的，那么Django将会在第一个正确通过认���止进一步的处�。

Writing an Authentication Back-end

如何写一个认���

An authentication back-end is a class that implements two methods: get_user(id) and authenticate(**credentials) .

一个认���其实就是一个实现了如下两个方法的类： get_user(id) 和 authenticate(**credentials) 。

The get_user method takes an id which could be a username, database ID, or whatever and returns a User object.

方法 get_user 需�一个�数 id ，这个 id �以是用户�，数�库ID或者其他任何数值，该方法会返回一个 User 对象。

The authenticate method takes credentials as keyword arguments. Most of the time it looks like this:

方法 authenticate 使用�书作为关键�数。大多数情况下，该方法看起�如下：

class MyBackend(object):
    def authenticate(self, username=None, password=None):
        # Check the username/password and return a User.

But it could also authenticate a token, like so:

但是有时候它也�以认��个令牌，例如：

class MyBackend(object):
    def authenticate(self, token=None):
        # Check the token and return a User.

Either way, authenticate should check the credentials it gets, and it should return a User object that matches those credentials, if the credentials are valid. If theyre not valid, it should return None .

�一个方法中， authenticate 都应该检测它所获�的�书，并且当�书有效时，返回一个匹�于该�书的 User 对象，如果�书无效那么返回 None 。

The Django admin system is tightly coupled to Djangos own database-backed User object described in Chapter 12. The best way to deal with this is to create a Django User object for each user that exists for your back-end (e.g., in your LDAP directory, your external SQL database, etc.). Either you can write a script to do this in advance or your authenticate method can do it the first time a user logs in.

ok3W3L <a href=”http://oickexzkjkqe.com/“>oickexzkjkqe</a>, [url=http://blltdssmqwjo.com/]blltdssmqwjo[/url], [link=http://gixyfbdgtzlb.com/]gixyfbdgtzlb[/link], http://mxptihtyftnm.com/

Heres an example back-end that authenticates against a username and password variable defined in your settings.py file and creates a Django User object the first time a user authenticates:

IkR1zX <a href=”http://xtigokymbonv.com/“>xtigokymbonv</a>, [url=http://ljpnjhupijfs.com/]ljpnjhupijfs[/url], [link=http://pzdvrwrmtcpk.com/]pzdvrwrmtcpk[/link], http://uszxevqtowse.com/

from django.conf import settings
from django.contrib.auth.models import User, check_password

class SettingsBackend(object):
    """
    Authenticate against the settings ADMIN_LOGIN and ADMIN_PASSWORD.

    Use the login name, and a hash of the password. For example:

    ADMIN_LOGIN = 'admin'
    ADMIN_PASSWORD = 'sha1$4e987$afbcf42e21bd417fb71db8c66b321e9fc33051de'
    """
    def authenticate(self, username=None, password=None):
        login_valid = (settings.ADMIN_LOGIN == username)
        pwd_valid = check_password(password, settings.ADMIN_PASSWORD)
        if login_valid and pwd_valid:
            try:
                user = User.objects.get(username=username)
            except User.DoesNotExist:
                # Create a new user. Note that we can set password
                # to anything, because it won't be checked; the password
                # from settings.py will.
                user = User(username=username, password='get from settings.py')
                user.is_staff = True
                user.is_superuser = True
                user.save()
            return user
        return None

    def get_user(self, user_id):
        try:
            return User.objects.get(pk=user_id)
        except User.DoesNotExist:
            return None