Loading django/db/migrations/operations/__init__.py 0 → 100644 +1 −0 Original line number Diff line number Diff line from .models import CreateModel, DeleteModel django/db/migrations/operations/base.py 0 → 100644 +38 −0 Original line number Diff line number Diff line class Operation(object): """ Base class for migration operations. It's responsible for both mutating the in-memory model state (see db/migrations/state.py) to represent what it performs, as well as actually performing it against a live database. Note that some operations won't modify memory state at all (e.g. data copying operations), and some will need their modifications to be optionally specified by the user (e.g. custom Python code snippets) """ # If this migration can be run in reverse. # Some operations are impossible to reverse, like deleting data. reversible = True def state_forwards(self, app, state): """ Takes the state from the previous migration, and mutates it so that it matches what this migration would perform. """ raise NotImplementedError() def database_forwards(self, app, schema_editor, from_state, to_state): """ Performs the mutation on the database schema in the normal (forwards) direction. """ raise NotImplementedError() def database_backwards(self, app, schema_editor, from_state, to_state): """ Performs the mutation on the database schema in the reverse direction - e.g. if this were CreateModel, it would in fact drop the model's table. """ raise NotImplementedError() django/db/migrations/operations/models.py 0 → 100644 +26 −0 Original line number Diff line number Diff line from .base import Operation from django.db.migrations.state import ModelState class CreateModel(Operation): """ Create a model's table. """ def __init__(self, name): self.name = name def state_forwards(self, app, state): state.models[app, self.name.lower()] = ModelState(state, app, self.name) def database_forwards(self, app, schema_editor, from_state, to_state): app_cache = to_state.render() schema_editor.create_model(app_cache.get_model(app, self.name)) def database_backwards(self, app, schema_editor, from_state, to_state): """ Performs the mutation on the database schema in the reverse direction - e.g. if this were CreateModel, it would in fact drop the model's table. """ raise NotImplementedError() django/db/migrations/state.py 0 → 100644 +81 −0 Original line number Diff line number Diff line from django.db import models from django.db.models.loading import BaseAppCache class ProjectState(object): """ Represents the entire project's overall state. This is the item that is passed around - we do it here rather than at the app level so that cross-app FKs/etc. resolve properly. """ def __init__(self, models=None): self.models = models or {} self.app_cache = None def clone(self): "Returns an exact copy of this ProjectState" ps = ProjectState( models = dict((k, v.copy()) for k, v in self.models.items()) ) for model in ps.models.values(): model.project_state = ps return ps def render(self): "Turns the project state into actual models in a new AppCache" if self.app_cache is None: self.app_cache = BaseAppCache() for model in self.model.values: model.render(self.app_cache) return self.app_cache class ModelState(object): """ Represents a Django Model. We don't use the actual Model class as it's not designed to have its options changed - instead, we mutate this one and then render it into a Model as required. """ def __init__(self, project_state, app_label, name, fields=None, options=None, bases=None): self.project_state = project_state self.app_label = app_label self.name = name self.fields = fields or [] self.options = options or {} self.bases = bases or None def clone(self): "Returns an exact copy of this ModelState" return self.__class__( project_state = self.project_state, app_label = self.app_label, name = self.name, fields = self.fields, options = self.options, bases = self.bases, ) def render(self, app_cache): "Creates a Model object from our current state into the given app_cache" # First, make a Meta object meta_contents = {'app_label': self.app_label, "app_cache": app_cache} meta_contents.update(self.options) meta = type("Meta", tuple(), meta_contents) # Then, work out our bases # TODO: Use the actual bases if self.bases: raise NotImplementedError("Custom bases not quite done yet!") else: bases = [models.Model] # Turn fields into a dict for the body, add other bits body = dict(self.fields) body['Meta'] = meta body['__module__'] = "__fake__" # Then, make a Model object return type( self.name, tuple(bases), body, ) Loading
django/db/migrations/operations/__init__.py 0 → 100644 +1 −0 Original line number Diff line number Diff line from .models import CreateModel, DeleteModel
django/db/migrations/operations/base.py 0 → 100644 +38 −0 Original line number Diff line number Diff line class Operation(object): """ Base class for migration operations. It's responsible for both mutating the in-memory model state (see db/migrations/state.py) to represent what it performs, as well as actually performing it against a live database. Note that some operations won't modify memory state at all (e.g. data copying operations), and some will need their modifications to be optionally specified by the user (e.g. custom Python code snippets) """ # If this migration can be run in reverse. # Some operations are impossible to reverse, like deleting data. reversible = True def state_forwards(self, app, state): """ Takes the state from the previous migration, and mutates it so that it matches what this migration would perform. """ raise NotImplementedError() def database_forwards(self, app, schema_editor, from_state, to_state): """ Performs the mutation on the database schema in the normal (forwards) direction. """ raise NotImplementedError() def database_backwards(self, app, schema_editor, from_state, to_state): """ Performs the mutation on the database schema in the reverse direction - e.g. if this were CreateModel, it would in fact drop the model's table. """ raise NotImplementedError()
django/db/migrations/operations/models.py 0 → 100644 +26 −0 Original line number Diff line number Diff line from .base import Operation from django.db.migrations.state import ModelState class CreateModel(Operation): """ Create a model's table. """ def __init__(self, name): self.name = name def state_forwards(self, app, state): state.models[app, self.name.lower()] = ModelState(state, app, self.name) def database_forwards(self, app, schema_editor, from_state, to_state): app_cache = to_state.render() schema_editor.create_model(app_cache.get_model(app, self.name)) def database_backwards(self, app, schema_editor, from_state, to_state): """ Performs the mutation on the database schema in the reverse direction - e.g. if this were CreateModel, it would in fact drop the model's table. """ raise NotImplementedError()
django/db/migrations/state.py 0 → 100644 +81 −0 Original line number Diff line number Diff line from django.db import models from django.db.models.loading import BaseAppCache class ProjectState(object): """ Represents the entire project's overall state. This is the item that is passed around - we do it here rather than at the app level so that cross-app FKs/etc. resolve properly. """ def __init__(self, models=None): self.models = models or {} self.app_cache = None def clone(self): "Returns an exact copy of this ProjectState" ps = ProjectState( models = dict((k, v.copy()) for k, v in self.models.items()) ) for model in ps.models.values(): model.project_state = ps return ps def render(self): "Turns the project state into actual models in a new AppCache" if self.app_cache is None: self.app_cache = BaseAppCache() for model in self.model.values: model.render(self.app_cache) return self.app_cache class ModelState(object): """ Represents a Django Model. We don't use the actual Model class as it's not designed to have its options changed - instead, we mutate this one and then render it into a Model as required. """ def __init__(self, project_state, app_label, name, fields=None, options=None, bases=None): self.project_state = project_state self.app_label = app_label self.name = name self.fields = fields or [] self.options = options or {} self.bases = bases or None def clone(self): "Returns an exact copy of this ModelState" return self.__class__( project_state = self.project_state, app_label = self.app_label, name = self.name, fields = self.fields, options = self.options, bases = self.bases, ) def render(self, app_cache): "Creates a Model object from our current state into the given app_cache" # First, make a Meta object meta_contents = {'app_label': self.app_label, "app_cache": app_cache} meta_contents.update(self.options) meta = type("Meta", tuple(), meta_contents) # Then, work out our bases # TODO: Use the actual bases if self.bases: raise NotImplementedError("Custom bases not quite done yet!") else: bases = [models.Model] # Turn fields into a dict for the body, add other bits body = dict(self.fields) body['Meta'] = meta body['__module__'] = "__fake__" # Then, make a Model object return type( self.name, tuple(bases), body, )
