En utilisant uniquement la DB partie de Django

La réponse est: non, vous ne pouvez pas utiliser l'ORM de Django séparément de Django.

La réponse est: oui, vous pouvez, si vous êtes disposé à charger de grandes parties de Django avec elle. Par exemple, la connexion de base de données qui est utilisé par Django est ouverte lorsqu'une demande de Django se produit. Cela se produit lorsqu'un signal est envoyé afin que vous peut manifestement envoyer ce signal pour ouvrir la connexion sans l'aide de la spécificité de la demande mécanisme. Aussi, vous aurez besoin pour l'installation de diverses applications et les paramètres pour le projet Django.

En fin de compte, il n'est sans doute pas utile de votre temps. SQL Alchimie est relativement bien connue Python ORM, qui est en fait plus puissant que de Django reinhardt, de toute façon, car il prend en charge plusieurs connexions de base de données de connexion et de mise en commun et d'autres bonnes choses.

---

Edit: en réponse à James critiques ailleurs, je vais préciser ce que j'ai décrit dans mon premier post. Alors qu'il est réjouissant de constater que l'un des principaux Django contributeur m'a appelé, je pense toujours que j'ai raison 🙂

Tout d'abord, pensez à ce qui doit être fait pour utiliser l'ORM de Django distincte de toute autre partie. Vous utilisez l'un des méthodes décrit par James pour faire une installation de base de Django. Mais un certain nombre de ces méthodes ne permettent pas à l'aide de la syncdb de commande, ce qui est nécessaire pour créer les tables pour vos modèles. Un settings.py fichier est nécessaire pour cela, avec des variables non seulement pour DATABASE_*, mais aussi INSTALLED_APPLICATIONS avec les chemins corrects pour tous models.py les fichiers.

Il est possible de faire votre propre solution pour utiliser syncdb sans settings.py mais il nécessite des connaissances approfondies de Django. Bien sûr, vous n'avez pas besoin d'utiliser syncdb; les tableaux peuvent être créés de façon indépendante des modèles. Mais il est un aspect de l'ORM qui n'est disponible que si vous mettez un peu d'effort dans le programme d'installation.

Deuxièmement, examiner comment vous pouvez créer vos requêtes à la base de données avec le standard Model.objects.filter() appel. Si cela est fait dans le cadre d'un point de vue, c'est très simple: construire le QuerySet et de visualiser les instances. Par exemple:

tag_query = Tag.objects.filter( name='stackoverflow' )
if( tag_query.count() > 0 ):
    tag = tag_query[0]
    tag.name = 'stackoverflowed'
    tag.save()

Sympa, simple et propre. Maintenant, sans la béquille de Django demande/réponse de système de chaînage, vous devez initialiser la connexion de base de données, faire la requête, puis fermer la connexion. Ainsi l'exemple ci-dessus devient:

from django.db import reset_queries, close_connection, _rollback_on_exception
reset_queries()
try:
    tag_query = Tag.objects.filter( name='stackoverflow' )
    if( tag_query.count() > 0 ):
        tag = tag_query[0]
        tag.name = 'stackoverflowed'
        tag.save()
except:
    _rollback_on_exception()
finally:
    close_connection()

La connexion de base de données de gestion peut également être fait via Django signaux. Tous les ci-dessus est défini dans django/db/init.py. D'autres Orm ont aussi ce genre de gestion de la connexion, mais vous n'avez pas besoin de creuser dans leur source pour savoir comment le faire. SQL Alchimie de la connexion du système de gestion est documenté dans le tutoriels et ailleurs.

Enfin, vous devez garder à l'esprit que la base de données objet de connexion locale pour le thread courant en tout temps, ce qui peut ou peut ne pas vous limiter en fonction de vos besoins. Si votre application n'est pas apatride, comme Django, mais persistant, vous pouvez frapper problèmes de threading.

En conclusion, c'est une question d'opinion. À mon avis, à la fois les limitations de, et l'installation nécessaire pour, ORM de Django reinhardt, distinct du cadre est trop de responsabilité. Il y a parfaitement viable dédié ORM solutions disponibles ailleurs qui sont conçus pour l'utilisation de la bibliothèque. Django n'est pas.

Ne pense pas que tous les ci-dessus montre que je n'aime pas Django et de tous les rouages, j'aime vraiment Django beaucoup! Mais je suis réaliste sur les capacités et un ORM bibliothèque n'est pas l'un d'eux.

P. S. Multiples de connexion à la base de soutien est en cours de travaillé sur. Mais il n'est pas là maintenant.

(Je ne fais que le signaler ma solution parce que ma question a dit être un doublon)

Ah ok j'ai compris et afficherons les solutions pour n'importe qui qui essaye de faire la même chose.

Cette solution suppose que vous voulez créer de nouveaux modèles.

D'abord créer un nouveau dossier pour stocker vos fichiers. Nous allons l'appeler "autonome". Dans "autonome", créer les fichiers suivants:

__init__.py
myScript.py
settings.py

Évidemment "myScript.py" peut être nommé que ce soit.

Ensuite, créez un répertoire pour vos modèles.

Nous allons nommer notre modèle répertoire "myApp", mais se rendent compte que cela est une application Django au sein d'un projet, en tant que tel, nom approprié pour la collection de modèles que vous écrivez.

Dans ce répertoire créer 2 fichiers:

__init__.py
models.py

Vous allez avoir besoin d'une copie de manage.py à partir d'un un projet Django, ou vous pouvez simplement prendre une copie de votre Django chemin d'installation:

django\conf\project_template\manage.py

Copie de la manage.py pour votre /autonome répertoire. Ok, donc vous devriez maintenant avoir la structure suivante:

\standAlone
    __init__.py
    myScript.py
    manage.py
    settings.py
\myApp
    __init__.py
    models.py

Ajouter les éléments suivants à votre myScript.py fichier:

# settings.py
from django.conf import settings

settings.configure(
    DATABASE_ENGINE    = "postgresql_psycopg2",
    DATABASE_NAME      = "myDatabase",
    DATABASE_USER      = "myUsername",
    DATABASE_PASSWORD  = "myPassword",
    DATABASE_HOST      = "localhost",
    DATABASE_PORT      = "5432",
    INSTALLED_APPS     = ("myApp")
)

from django.db import models
from myApp.models import *

et les ajouter à votre settings.py fichier:

    DATABASE_ENGINE    = "postgresql_psycopg2"
    DATABASE_NAME      = "myDatabase"
    DATABASE_USER      = "myUsername"
    DATABASE_PASSWORD  = "myPassword"
    DATABASE_HOST      = "localhost"
    DATABASE_PORT      = "5432",
    INSTALLED_APPS     = ("myApp")

et enfin votre myApp/models.py:

# myApp/models.py
from django.db import models

class MyModel(models.Model):
     field = models.CharField(max_length=255)

et c'est tout. Maintenant pour avoir Django gérer votre base de données, dans l'invite de commande, accédez à notre programme /répertoire et exécutez:

manage.py sql MyApp

Je suis à l'aide de l'ORM de django sans un fichier de paramètres. Voici comment:

Dans le stand-alone application lanceur de fichiers:

from django.conf import settings
from django.core.management import execute_from_command_line

#Django settings
settings.configure(DEBUG=False,
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.sqlite3',
            'NAME': '/path/to/dbfile',
            'USER': '',
            'PASSWORD': '',
            'HOST': '',
            'PORT': '',
        }
    },
    INSTALLED_APPS = ('modelsapp',)
)

if not os.path.exists('/path/to/dbfile'):
    sync = ['manage.py', 'syncdb']
    execute_from_command_line(sync)

Maintenant vous avez juste besoin d'un ./modelsapp dossier contenant un __init__.py et un models.py. La config utilise sqlite par souci de simplicité, mais il peut utiliser de la db backends.

Structure de dossier:

./launcher.py
./modelsapp
    __init__.py
    models.py

Notez que vous n'avez pas à avoir un manage.py bon. Le import execute_from_command_line juste le trouve.

À l'aide de Django 2.0 ORM - Un Fichier Requis

from myproject.config import parse_config
from django import setup as django_setup
from django.conf import settings as django_settings

"""
Requirements:
  ODBC Driver: https://www.microsoft.com/en-ca/download/details.aspx?id=36434
  Django Engine: https://pypi.org/project/django-pyodbc-azure/
"""

config = parse_config()
django_settings.configure(
    DEBUG=True,
    DATABASES={
        'default': {
            'ENGINE': 'sql_server.pyodbc',
            'NAME': config.database_name,
            'HOST': config.database_server,  # exclude '\\MSSQLSERVER'
            'USER': config.database_username,
            'PASSWORD': config.database_password,
            'PORT': '',
            'AUTOCOMMIT': False,
            'OPTIONS': {
                'driver': 'ODBC Driver 11 for SQL Server',
            },
        },
    })
django_setup()


from django.db import models

class Foo(models.Model):
    name = models.CharField(max_length=25)

    class Meta:
        app_label = 'myapp'  # each model will require this

Cet exemple est aussi simple que cela. J'ai déjà un django app appelé thab et en cours d'exécution. Je veux utiliser l'orm de django dans de standing libre de scripts python et d'utiliser les mêmes modèles que j'utilise pour la programmation web. Voici un exemple:

# nothing in my sys.path contains my django project files
import sys
sys.path.append('c:\\apython\\thab')  # location of django app (module) called thab          where my settings.py and models.py is
# my settings.py file is actualy in c:\apython\thab\thab
from thab import settings as s  # need it because my database setting are there
dbs = s.DATABASES
from django.conf import settings
settings.configure(DATABASES=dbs) # configure can only be called once
from thab.models import *
boards = Board.objects.all()
print 'all boards:' + str(boards) # show all the boards in my board table

import django
from django.conf import settings
from backend_mock.admin import settings as s
settings.configure(
    DATABASES=s.DATABASES,
    INSTALLED_APPS=('backend_mock.admin.mocker', )
)
django.setup()

prendre un coup d'oeil à cela, il travaille pour django version 1.8 gte.x

Puis-je utiliser seulement la partie ORM, pour obtenir des classes que la carte de DB tables et de savoir comment lire/écrire à partir de ces tables?

Oui, vous pouvez.

Voici un endroit propre et court explication sur la façon d'utiliser Django modèles et d'abstraction de base de: https://stackoverflow.com/a/49515366/2682613

Django version: 2.0.2

Vous pouvez l'utiliser en dehors d'un projet django.
Mais il y a des choses que vous devez être conscient de.

1. Plusieurs base de données du routeur.

Un routeur ressemble:

class Router(object):
    app_label = ''

    def db_for_read(self, model, **hints):
        if model._meta.app_label == self.app_label:
            return self.app_label
        return None

    def db_for_write(self, model, **hints):
        if model._meta.app_label == self.app_label:
            return self.app_label
        return None

    def allow_relation(self, obj1, obj2, **hints):
        if obj1._meta.app_label == self.app_label or obj2._meta.app_label == self.app_label:
           return True
        return None

    def allow_migrate(self, db, app_label, model=None, **hints):
        if app_label == self.app_label:
            return db == self.app_label
    return None

Vous pouvez utiliser la méta-classe dynamique créer routeur.

def add_db(db_conf):
    app_label = 'al_' + str(uuid4())

    settings.DATABASES[app_label] = db_conf

    router_class_name = 'Router' + app_label.capitalize()
    setattr(
        settings,
        router_class_name,
        type(router_class_name, (Router,), dict(app_label=app_label)),
    )
    settings.DATABASE_ROUTERS.append(
        '.'.join([settings.__name__, router_class_name])
    )
    connections.close_all()
return app_label

2. Django paramètres.

la clé le plus important est TIME_ZONE. DatetimeField et DateField est releated à elle.
Un simple réglage doit être:

SECRET_KEY = 'secret'
DATABASES = {'default': {}}
DATABASE_ROUTERS = []
TIME_ZONE = None

3. close_old_connections.

Framework Django d'exécution par défaut close_old_connections dans chaque demande middleware pour éviter les "mysql a disparu".

---

PS: j'ai écrit un package pour l'utilisation de l'orm de django pas dans le style d'un projet django, https://github.com/jdxin0/django_db(https://github.com/jdxin0/django_db).
Mais vous devez toujours faire attention à la trois les problèmes ci-dessus.Mon colis le méta-classe pour résoudre multi db, ensemble TIME_ZONE=None et laisser close_old_connections à l'utilisateur.