GVKun编程网logo

Django mysql 操作类（django操作mysql数据库）

5

关于Djangomysql操作类和django操作mysql数据库的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于50.2Django连接MySQL，djangoorm数据库(models

关于Django mysql 操作类和django操作mysql数据库的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于50.2 Django 连接MySQL，django orm 数据库(models)操作、Angular4+NodeJs+MySQL 入门-02 MySql操作类、Django 3.0 中连接mysql 8.0,可以不使用pymysql ,升级Mysqlclient即可、django mysql使用pymysql连接设置教程等相关知识的信息别忘了在本站进行查找喔。

本文目录一览：

Django mysql 操作类（django操作mysql数据库）

Django mysql 操作类（django操作mysql数据库）

Django-Chain-PyMysqL

Easy to use PyMysqL in django.

对 PyMysqL 进行封装，增加链式操作，方便快捷进行 CURD 操作

注：基于 Chain-PyMysqL -> https://github.com/Tiacx/chain-pymysql/


一、安装说明（INSTALLATION）

使用 PIP 安装 或 直接下载源码

  • 全自动安装：easy_install django-chain-pyMysqL 或者 pip install django-chain-pyMysqL / pip3 install django-chain-pyMysqL
  • 半自动安装：先下载 https://pypi.org/project/django-chain-pymysql/#files ，解压后运行 python setup.py install
  • 手动安装：将 django-chain-pyMysqL 目录放置于当前目录或者 site-packages 目录
  • 通过 from django_chain_pyMysqL import iMysqL 来引用

二、连接数据库（CONNECTION）

自动读取 django 配置并连接数据库，无需手动设置

注: django 官方文档: https://docs.djangoproject.com/en/4.1/topics/db/multi-db/


三、简单示例（DEMO）

增

from django.http import HttpResponse
from django_chain_pyMysqL import iMysqL


def test(request):
    data = request.POST
    insert_id = iMysqL.table('table1').insert_one(data)

    sql = iMysqL.get_last_sql()

    return HttpResponse(sql + '<hr>' + str(insert_id))

删

from django.http import HttpResponse
from django_chain_pyMysqL import iMysqL


def test(request):
    _id = request.GET.get('id')
    effected_rows = iMysqL.table('table1').delete({'id': _id})

    sql = iMysqL.get_last_sql()

    return HttpResponse(sql + '<hr>' + str(effected_rows))

改

from django.http import HttpResponse
from django_chain_pyMysqL import iMysqL


def test1(request):
    _id = request.GET.get('id')
    _name = request.GET.get('name')
    effected_rows = iMysqL.table('table1').update({'id': _id}, {'name': _name})

    sql = iMysqL.get_last_sql()

    return HttpResponse(sql + '<hr>' + str(effected_rows))


def test2(request):
    data = request.POST
    _id = data.get('id')
    del data['id']
    effected_rows = iMysqL.table('table1').update({'id': _id}, data)

    sql = iMysqL.get_last_sql()

    return HttpResponse(sql + '<hr>' + str(effected_rows))

查

import json
from django.http import HttpResponse
from django_chain_pyMysqL import iMysqL


def test1(request):
    _id = request.GET.get('id')
    info = iMysqL.table('table1').where({'id': _id}).one()

    sql = iMysqL.get_last_sql()

    return HttpResponse(sql + '<hr>' + json.dumps(info, ensure_ascii=False))


def test2(request):
    condition = dict()
    for k, v in request.GET.items():
        if k in ['id', 'name']:
            condition[f't1.{k}'] = v
        elif k in ['age']:
            condition[f't2.{k}'] = v

    where = iMysqL.gen_condition(condition)
    order_by = iMysqL.gen_order_by(request.GET.get('order'), request.GET.get('asc') == '1')
    page = int(request.GET.get('page', 1))
    size = int(request.GET.get('size', 10))
    limit = iMysqL.gen_limit(skip=(page-1)*size, limit=size)
    sql = f'SELECT t1.`name`, avg(t2.age) AS age FROM table1 t1 LEFT JOIN table2 t2 ON t1.id = t2.id WHERE {where} GROUP BY t1.`name` {order_by}{limit}'
    results = iMysqL.execute(sql, fetch=True)

    return HttpResponse(sql + '<hr>' + json.dumps(results, ensure_ascii=False))

事务、多数据库、及其他

注：请看详细说明~


四、详细说明（DETAIL）

详细说明请参考：chain-pyMysqL

https://github.com/Tiacx/chain-pymysql/

50.2 Django 连接MySQL，django orm 数据库(models)操作

50.2 Django 连接MySQL，django orm 数据库(models)操作

 

 如何获取前端数据

request方法：

获取前端数据的方式： request.POST（获取表单中发送的数据）、request.GET  （获取的是url后面跟的数据）

前端：注意name属性的值即为后台大字典的key ，即通过key来取到前端发过来的数据

 

 后端：

views ：  request.POST.get()  方法默认取列表中的最后一个值，request.POST.getlist()    取列表

 

 

1.数据库：Django连接数据库配置：

1.   setting.py : 配置数据库

 

DATABASES = {
    ''default'': {
        ''ENGINE'': ''django.db.backends.mysql'',
        ''NAME'': ''day50'',
        ''HOST'': ''127.0.0.1'',
        ''PORT'': 3306,
        ''USER'': ''root'',
        ''PASSWORD'': ''123''
    }
}

2.    __init__.py:      项目的__init__文件 或者 app的__init__文件

 import pymysql           

 pymysql.install_as_MySQLdb()

3. 重启Django服务即可链接数据库：

 

2. django orm简介

django orm不会帮你创建库  只能帮你自动创建表


    orm对象关系映射
    类                表
    
    对象            记录
    
    属性            字段值
    作用:能够让一个不会数据库操作的小白也能够通过Python面向对象语法 句点符来简单快捷的操作数据

 

3.创建数据库表

1.创建数据库表：数据库必须是先创建好的，然后通过models 创建表

   如果不指定主键字段，Django会默认创建一个id为主键字段

 

 2.   *************************数据库迁移(同步)命令************************

1.python3 manage.py makemigrations  # 仅仅是将你对数据库的改动记录到某个小本本上(migrations文件夹)
2.python3 manage.py migrate  # 将改动真正的同步到数据库中
快捷方法：  makemigrations 、 migrate

 

3. 字段的增删的增删改查操作 （数据完成增删改查之后，直接执行 makemigrations、migrate即可更新到数据库）

字段的增删改查
		字段的增   特别注意
			1.要么给该字段设置默认值
			2.要么运行该字段可以为空
		字段的查
			...
		字段的改 
			修改models代码 之后执行数据库迁移命令即可
		字段的删
			只要注释掉对应的字段 执行数据库迁移命令就会将对应的字段及数据信息全部删除(慎用)

 

 4.数据的增删查改

res.first ()  只能查询到结果中的第一个对象，其它对象怎么取呢?

数据的增删改查
		查
			1.filter()
				from app01 import models
				@@@@   res = models.User.objects.filter(username=''jason'')  # select * from user where username=''jason''
				# 返回的结果是一个列表  支持索引取值但是不支持负数并且不推荐使用 推荐你使用它给你封装好的方法
				user_obj = res.first()   #等于res[0]
                                print(user_obj.name)
				# filter方法条件不存在的时候 不会报错返回的是一个空列表
				"""
				filter括号内直接放多个关键字参数 并且多个关键字参数之间是and关系
				res = models.User.objects.filter(username=''jason'',password=''123'')  # select * from user where username=''jason'' and password=''123'';
				"""
			
			2.查所有的数据
				1.filter() 括号内不写拿所有
					<QuerySet [<User: jason>, <User: egon>, <User: sean>, <User: admin>, <User: 你不行>]>
				2.all()    查询所有数据
					<QuerySet [<User: jason>, <User: egon>, <User: sean>, <User: admin>, <User: 你不行>]>
		增
			1.create()
				user_obj = models.User.objects.create(name=username,password=password)
				print(user_obj,user_obj.name)
				# 该方法有返回值 返回值就是当前被创建的对象本身
			2.对象的绑定方法
				# 方式2
				# 1 先生成一个User对象
				user_obj = models.User(name=username,password=password)
				# 2 调用对象的绑定方法
				user_obj.save()
				
		删
			用户点击谁 你的后端就应该删除
			后端如何获取用户想要删除的数据id？
			models.User.objects.filter(id=delete_id).delete()  # 将filter过滤出来的数据全部删除   批量删除
		
		改
			如何获取用户想要修改的数据id
			根据数据id获取数据并且展示到前端页面供用户查看
			
			# 方式1(推荐)                      批量更新
			models.User.objects.filter(id=edit_id).update(name=username,password=password)
			# 方式2(了解)
			# 1 先获取数据对象
			edit_obj = models.User.objects.filter(id=edit_id).first()
			# 2 再修改对象属性
			edit_obj.name = username
			edit_obj.password = password
			# 3 调用对象的绑定方法保存
			edit_obj.save()

 

 

5.表关系创建

原生sql写法：

出版社对书籍   一对多关系             一个出版社可以出版多本书籍  外键字段建在从表  foreign_key  reference  主键字段

书籍和作者      多对多关系              建立第三张关系表book2author

 

 

 django models 表关系创建

注意点： 1. 多对多外键字段是虚拟字段 ，在表中不会显示，是用用来自动创建第三张关系表的

                2.一对多外键字段，是实际字段，在表中显示，且django 会自动在字段上加后缀‘_id’

from django.db import models

# Create your models here.
class Book(models.Model):
    # id是自动创建的 我们就不写了
    title = models.CharField(max_length=64)
    # price为小数字段 总共8位小数位占2位
    price = models.DecimalField(max_digits=8,decimal_places=2)

    # 出版社与书籍 是一对多外键关系  

    publish = models.ForeignKey(to=''Publish'')  # 默认关联字段就是出版社表的主键字段   还有一个参数为tofield 指定关联字段
    # publish = models.ForeignKey(to=Publish)  # to后面也可以直接写表的变量名 但是需要保证该变量名在当前位置的上方出现

    # 书籍与作者   是多对多外键关系
    authors = models.ManyToManyField(to=''Author'')  # 书籍和作者是多对多关系
    """
    authors字段是一个虚拟字段 不会真正的在表中创建出来
    只是用来告诉django orm 需要创建书籍和作者的第三张关系表
    """

class Publish(models.Model):
    name = models.CharField(max_length=64)
    addr = models.CharField(max_length=64)


class Author(models.Model):
    name = models.CharField(max_length=32)
    phone = models.BigIntegerField()
    # 一对一外键关系建立   建立在出现频次较高的一方
    author_detail = models.OneToOneField(to=''AuthorDetail'')


class AuthorDetail(models.Model):
    age = models.IntegerField()
    addr = models.CharField(max_length=255)

 

 

 

 

 

 

 

 

 

 

　　

Angular4+NodeJs+MySQL 入门-02 MySql操作类

Angular4+NodeJs+MySQL 入门-02 MySql操作类

NodeJs操作MysqL类

此类封装了几个常用的方法：插入，更新，删除，查询，开启事务，事务提交，事务回滚等操作。有一这个类，操作MysqL就方便多了。

批处理，存储过程等方法还没有添加，因为觉得目前写的那里还没有用到批处理的，所以就没有在这里加上，等以后要是用到了要进行批处理的时候，再加上。

以前用C#在操作数据库的时候，也都有类似的操作类：MSsqlHelper，OracleHelper，MysqLHelper等这些，现在只是用NodeJs写了一个操作MysqL，想操作其它数据库，按照这样的思路也应该可以写出来吧。

具体怎么用在以后再讲了，如果心急的话，可以到我的 github（https://github.com/xiaotuni/angular-map-http2）里下载项目，运行起来就可以了。

const MysqL = require('MysqL');

/** * 操作类型，插入，更新，删除，查询 */
const OperatorType = {
  Insert: 0,Update: 1,Delete: 2,QueryList: 3,QueryOne: 4,}

/** * 数据操作类 * QueryOne、Query、Insertsql、Deletesql、Updatesql、BeginTransaction、Rollback、Commit * * @class MysqLHelper */
class MysqLHelper {

  constructor() {
    this.__CreatePool();
  }

  /** * 创建一个资源池 * * @memberof MysqLHelper */
  __CreatePool() {
    this.pool = MysqL.createPool({
      connectionLimit: 10,host: 'localhost',// 数据库连接
      user: 'liaohb',// 数据库名用户名
      password: 'xiaotuni',// 密码
      database: 'nodejs'   // 表空间
    });
  }

  /** * 资源池信息 * * @param {any} error 出错事件出得函数 * @returns * @memberof MysqLHelper */
  poolInfo(error) {
    if (!this.pool) {
      this.__CreatePool();
    }
    if (!this.pool) {
      error && error({ code: 500,msg: '数据库连接失败' });
      return null;
    }
    return this.pool;
  }
  /** * 插入操作 * * @param {any} sql 插入语句 * @param {any} success 成功后调用的方法 * @param {any} error 失败后调用的方法 * @memberof MysqLHelper */
  Query(sql,success,error) {
    this.__Executesql(sql,error,OperatorType.QueryList);
  }
  /** * 查询操作，获取一条语句 * * @param {any} sql 插入语句 * @param {any} success 成功后调用的方法 * @param {any} error 失败后调用的方法 * @memberof MysqLHelper */
  QueryOne(sql,OperatorType.QueryOne);
  }
  /** * 更新操作 * * @param {any} sql 修改语句 * @param {any} Success 成功后调用的方法 * @param {any} Error 失败后调用的方法 * @memberof MysqLHelper */
  Updatesql(sql,Success,Error) {
    this.__Executesql(sql,Error,OperatorType.Update);
  }

  /** * 插入操作 * * @param {any} sql 插入语句 * @param {any} Success 成功后调用的方法 * @param {any} Error 失败后调用的方法 * @memberof MysqLHelper */
  Insertsql(sql,OperatorType.Insert);
  }

  /** * 删除操作 * * @param {any} sql 删除语句 * @param {any} Success 成功后调用的方法 * @param {any} Error 失败后调用的方法 * @memberof MysqLHelper */
  Deletesql(sql,OperatorType.Delete);
  }

  /** * 执行sql语句 * * @param {any} sql sql语句 * @param {any} Success 成功后调用的方法 * @param {any} Error 失败后调用的方法 * @param {any} Type 类型[查询，更新，删除，修改等] * @returns * @memberof MysqLHelper */
  __Executesql(sql,Type) {
    const __self = this;
    const __ProcessResult = (__sql,result,fields,Type) => {
      const _type = Type || OperatorType.QueryOne;
      let __result = result;
      switch (Type) {
        case OperatorType.Insert:
          const { insertId } = result;
          __result = { insertId };
          break;
        case OperatorType.Delete:
          break;
        case OperatorType.Update:
          break;
        case OperatorType.QueryList:
          break;
        case OperatorType.QueryOne:
          __result = result && result.length > 0 ? result[0] : null;
          break;
      }
      return __result;
    };
    const { IsBeginTrConn,BeginTrConn } = this;
    if (!!IsBeginTrConn) {
      console.log('事务线程ID：',BeginTrConn.threadId);
      // 事务处理
      BeginTrConn.query(sql,(err,fields) => {
        if (err) {
          __self.Rollback(err);
          Error && Error(err);
          return;
        }
        const __result = __ProcessResult(sql,Type);
        Success && Success({ fields,result: __result });
      });
    } else {
      const poolInfo = this.poolInfo(Error);
      if (!poolInfo) {
        return;
      }
      const __query = poolInfo.query(sql,fields) => {
        if (err) {
          Error && Error(err);
          return;
        }
        const __result = __ProcessResult(__query.sql,result: __result });
      });
    }
  }

  /** * 开启事务 * * @param {any} Success 成功后调用的方法 * @param {any} Error 失败后调用的方法 * @returns * @memberof MysqLHelper */
  BeginTransaction(Success,Error) {
    const poolInfo = this.poolInfo(Error);
    if (!poolInfo) {
      return;
    }
    const __self = this;
    poolInfo.getConnection((err,conn) => {
      if (err) {
        Error && Error(err);
      }
      conn.beginTransaction((btErr) => {
        if (btErr) {
          Error && Error(btErr);
        }
        console.log('开始事务处理...');
        __self.BeginTrConn = conn;
        __self.IsBeginTrConn = true;
        Success && Success();
      });
    });
  }

  /** * 事务回滚 * * @param {any} ErrorInfo 回滚出错信息 * @returns * @memberof MysqLHelper */
  Rollback(ErrorInfo) {
    const { IsBeginTrConn,BeginTrConn } = this;
    const __self = this;
    if (!IsBeginTrConn) {
      return;
    }
    if (!BeginTrConn) {
      return;
    }

    console.log('Rollback->事务线程ID：',BeginTrConn.threadId);
    BeginTrConn.rollback(() => {
      console.log('事务回滚,回滚原因：',ErrorInfo);
      delete __self.IsBeginTrConn;
      delete __self.BeginTrConn;
    });
  }

  /** * 提交事件 * * @param {any} Success 成功后调用的方法 * @param {any} Error 失败后调用的方法 * @returns * @memberof MysqLHelper */
  Commit(Success,Error) {
    const { IsBeginTrConn,BeginTrConn } = this;
    const __self = this;
    if (!IsBeginTrConn) {
      return;
    }
    if (!BeginTrConn) {
      return;
    }
    BeginTrConn.commit((err) => {
      if (err) {
        console.log('事务提交失败，执行回滚操作...');
        __self.Rollback(err);
        Error && Error(err);
        return;
      }
      console.log('事务提交成功...');
      console.log('Commit->事务提交成功...事务ID：',BeginTrConn.threadId);
      delete __self.IsBeginTrConn;
      delete __self.BeginTrConn;
      Success && Success();
    });
  }

  /** * 关闭连接池 * * @param {any} Success * @param {any} Error * @returns * @memberof MysqLHelper */
  ClosePool(Success,Error) {
    const __self = this;
    const poolInfo = this.poolInfo(Error);
    if (!poolInfo) {
      return;
    }
    poolInfo.end((err) => {
      if (err) {
        Error && Error(err);
        return;
      }
      Success && Success();

      if (__self.__pool) {
        delete this.pool;
        delete this.__pool;
      }
    });
  }
}

module.exports = MysqLHelper;

Django 3.0 中连接mysql 8.0,可以不使用pymysql ,升级Mysqlclient即可

Django 3.0 中连接mysql 8.0,可以不使用pymysql ,升级Mysqlclient即可

python 中,连接mysql一般都推荐用pymysql ,而且在django中,网上的教程都是这么连接mysql的.

import pymysql

pymysql.install_as_MySQLdb()

这实际是pymysql模块调用了模块中的一个函数 install_as_MySQLdb(),这个函数的注释是这么说的.

After this function is called, any application that imports MySQLdb or
_mysql will unwittingly actually use pymysql.

大概意思是:

　　调用此函数后，任何导入MySQLdb或_mysql的应用程序都会在不经意间实际使用pymysql。

最近在使用Django 3.0 中, 导入 Pymsql的时候报错,提示Mysqlclient版本问题,.既然django 在我们选择使用MYSQL的情景时,实际自动调用的是MySQLdb, Pymysql是可有可无的,我就直接pip install 了最新版的MySQLdb, 版本号是1.4.6, 在没使用Pymysql, 也不用在settings中自己导入MySQLdb的情况下,顺利连接我的MySQL .

我本地的安装的是MySQL8.0 ,用来练习Django中的ORM操作,没有发现问题. 我还没测试过Mysql 5.6 5.7版本.估计也没问题,(注:django不支持Mysql5.6以下的版本)

看来老方法有 OUT 了的可能性.

发布出来供大家参考, 如果有版本兼容性问题,还劳烦在本帖下留言,供大家分享.

补充:

django3.0官方文档说,3.0需要mysqlclient 1.3.13或者更高版本的支持,并且mysqlclient是推荐的数据库驱动程序.

除了mysqlclient, django还可以使用Connector/Python 作为mysql的数据库驱动程序,这个驱动可以在dev.mysql.com下载. 这个驱动是Oracle提供的纯python驱动, 不需要MySQL客户端库或标准库之外的任何Python模块作为支持.

不管mysqlclient还是Connector/Python都支持线程安全和连接池特性。

原文出处：https://www.cnblogs.com/worldinmyeyes/p/12093495.html

django mysql使用pymysql连接设置教程

django mysql使用pymysql连接设置教程

django MysqL使用pyMysqL连接设置方法

在项目的__init__.py中添加以下代码：

import pyMysqL

pyMysqL.install_as_MysqLdb()


关于Django mysql 操作类和django操作mysql数据库的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于50.2 Django 连接MySQL，django orm 数据库(models)操作、Angular4+NodeJs+MySQL 入门-02 MySql操作类、Django 3.0 中连接mysql 8.0,可以不使用pymysql ,升级Mysqlclient即可、django mysql使用pymysql连接设置教程等相关知识的信息别忘了在本站进行查找喔。

本文标签：

上一篇mysql更改执行计划_数据量增加导致MySQL执行计划改变（mysql执行计划参数）

下一篇maven工程(二)运行环境修改和获取mysql数据库数据（maven 环境）

相关文章