How to write this class for Django's data model (converting from Propel's YML format)

Question

I am converting a web project that currently uses the Propel ORM, to a django project.

My first task is to 'port' the model schema to django's.

I have read the django docs, but they do not appear to be in enough detail. Case in point, how may I 'port' a (contrived) table defined in the Propel YML schema as follows:

  demo_ref_country:
    code:             { type: varchar(4), required: true, index: unique }
    name:             { type: varchar(64), required: true, index: unique }
    geog_region_id:   { type: integer, foreignTable: demo_ref_geographic_region, foreignReference: id, required: true, onUpdate: cascade, onDelete: restrict }
    ccy_id:           { type: integer, foreignTable: demo_ref_currency_def, foreignReference: id, required: true, onUpdate: cascade, onDelete: restrict }
    flag_image_path:  { type: varchar(64), required: true, default: ''}
    created_at: ~

    _indexes:

      idx_f1:         [geog_region_id, ccy_id, created_at]

    _uniques:

      idxu_f1_key:    [code, geog_region_id, ccy_id]

Here is my (feeble) attempt so far:

class Country(models.Model):
    code = models.CharField(max_length=4)  # Erm, no index on this column .....
    name = models.CharField(max_length=64) # Erm, no index on this column .....
    geog_region_id = models.ForeignKey(GeogRegion)  # Is this correct ? (how about ref integrity constraints ?
    ccy_id = models.ForeignKey(Currency) # Is this correct?
    flag_image_path = models.CharField(max_length=64) # How to set default on this col?
    created_at = models.DateTimeField()    # Will this default to now() ?
    # Don't know how to specify indexes and unique indexes ....

[Edit]

To all those suggesting that I RTFM, I understand your frustration. Its just that the documentation is not very clear to me. It is probably a Pythonic way of documentation - but coming from a C++ background, I feel the documentation could be improved to make it more accesible for people coming from different languages.

Case in point: the documentation merely states the class name and an **options parameter in the ctor, but doesn't tell you what the possible options are.

For example class CharField(max_length=None,[**options])

There is a line further up in the documentation that gives a list of permissible options, which are applicable to all field types.

However, the options are provided in the form:

Field.optionname

The (apparently implicit) link between a class property and a constructor argument was not clear to me. It appears that if a class has a property foo, then it means that you can pass an argument named foo to its constructor. Does that observation hold true for all Python classes?

Answer 1

The indexes are automatically generated for your references to other models (i.e. your foreign keys). In other words: your geog_region_id is correct (but it would be better style to call it geog_region).

You can set default values using the default field option.

Answer 2

I'm sorry, you haven't read the docs. A simple search for index, unique or default on the field reference page reveals exactly how to set those options.

Edit after comment I don't understand what you mean about multiple lines. Python doesn't care how many lines you use within brackets - so this:

name = models.CharField(unique=True, db_index=True)

is exactly the same as this:

name = models.CharField(
          unique=True,
          db_index=True
       )

Django doesn't support multi-column primary keys, but if you just want a multi-column unique constraint, see unique_together.

Answer 3

import datetime
class Country(models.Model):
    code = models.CharField(max_length=4, unique=True) 
    name = models.CharField(max_length=64)
    geog_region = models.ForeignKey(GeogRegion)  
    ccy = models.ForeignKey(Currency, unique=True)
    flag_image_path = models.CharField(max_length=64, default='') 
    created_at = models.DateTimeField(default=datetime.now())

(I'm no expert on propel's orm)

Django always tries to imitate the "cascade on delete" behaviour, so no need to specify that somewhere. By default all fields are required, unless specified differently. For the datetime field see some more options here. All general field options here.

Answer 4

code = models.CharField(max_length=4)  # Erm, no index on this column .....
name = models.CharField(max_length=64) # Erm, no index on this column .....

You can pass the unique = True keyword argument and value for both of the above.

geog_region_id = models.ForeignKey(GeogRegion)  # Is this correct ? (how about ref integrity constraints ?
ccy_id = models.ForeignKey(Currency) # Is this correct?

The above lines are correct if GeogRegion and Currency are defined before this model. Otherwise put quotes around the model names. For e.g. models.ForeignKey("GeogRegion"). See documentation.

flag_image_path = models.CharField(max_length=64) # How to set default on this col?

Easy. Use the default = "/foo/bar" keyword argument and value.

created_at = models.DateTimeField()    # Will this default to now() ?

Not automatically. You can do default = datetime.now (remember to first from datetime import datetime). Alternately you can specify auto_now_add = True.

# Don't know how to specify indexes and unique indexes ....

Take a look at unique_together.

You'll see that the document I have linked to is the same pointed out by others. I strongly urge you to read the docs and work through the tutorial.

Answer 5

Class demo_ref_country(models.Model)
    code= models.CharField(max_length=4, db_index=True, null=False)
    name= models.CharField(max_length=64, db_index=True, null=False)
    geog_region = models.ForeignKey(geographic_region, null=False)
    ccy = models.ForeignKey(Currency_def, null=False)
    flag = models.ImageField(upload_to='path to directory', null=False, default="home")
    created_at = models.DateTimeField(auto_now_add=True, db_index=True)

class Meta:
    unique_together = (code, geog_region, ccy)

You can set default values,, db_index paramaeter creates indexes for related fields. You can use unique=True for seperate fields, but tahat unique together will check uniqueness in columns together.

UPDATE: First of all, i advice you to read documentatin carefully, since django gives you a lot of opportunuties, some of them have some restrictions... Such as, unique_together option is used just for django admin. It means if you create a new record or edit it via admin interface, it will be used. If you will alsa insert data with other ways (like a DataModel.objects.create statement) its better you use uniaue=True in field definition like:

code= models.CharField(max_length=4, db_index=True, null=False, unique=True)

ForeignKey fields are unique as default, so you do not need to define uniqueness for them.

Django supports method override, so you can override Model save and delete methods as you like. check it here. Django also allows you to write raw sql queries you can check it here

As i explained, unique together is a django admin feature. So dont forget to add unique=True to required fields. Unique together also allows you to define diffrent unique pairs, such as;

unique_together = (('id','code'),('code','ccy','geog_region'))

That means, id and code must be unique together and code, ccy and geog_region must be unique together

UPDATE 2: Prior to your question update...

It is better yo start from tutorials. It defines basics with good examples.

As for doc style, let me give you an example, but if you start from tutors, it will be easier for you... There are from model structure... Doc here

BooleanField

class BooleanField(**options)

that defines, the basic structure of a database field, () is used, and it has some parameters taken as options. that is the part:

models.BooleansField()

Since this is a field struvture, available options are defines as:

unique

Field.unique

So,

models.BooleansField(unique=True)

That is the general usage. Since uniqu is a basic option available to all field types, it classified as field.unique. There are some options available to a single field type, like symmetrical which is a ManyToMany field option, is classified as ManyToMany.Symmetrical

For the queryset

class QuerySet([model=None])

That is used as you use a function, but you use it to filter a model, with other words, write a filter query to execute... It has some methods, like filter...

filter(**kwargs)

Since this takes some kwargs, and as i told before, this is used to filter your query results, so kwargs must be your model fields (database table fields) Like:

MyModel.objects.filter(id=15)

what object is defines in the doc, but it is a manager that helps you get related objects.

Doc contains good examples, but you have to start from tutors, that is what i can advice you...