Python 操作数据库


为什么需要数据库

数据量变大,存储查找不方便
需要处理多个表关联
多人合作 一致性
文本数据 不安全
大量冗余数据
扩展不方便 多端复制容易出错

数据库相关概念

DB database 数据库 一系列数据记录的结合。
DBMS 数据库管理系统 存储 截取 安全 备份数据库

分类:

关系型数据库 Relational database 关系模型基础的数据库 简称E-R model
列 attribute 属性字段
行 tuple 记录 属性集合, relation关系
实体关系模型 常用操作
数据查询: 选择,投影,连接,并交差除
数据操作:增删改查

数据库与表

物理层DB, 表示层TABLE
主键, 外键

操作数据库 一对一, 一对多, 多对多

SQL语言 structured query language 结构化查询语言

SQL语言的组成元素
SQL语句类型
SQL语句作用
SQL中的数据类型

结构 UPDATE(从句) a SET b(子句) = c WHERE d=‘x’(谓语 条件)

SQL语句类型

定义语句:数据定义语句DDL 基本是 CREATE,ALTER,RENAME,DROP,TRUNCATE(清空)
操作数据 DML INSERT, UPDATE, DELETE
数据控制 授权访问 DCL GRANT(授权), REVOKE(收回授权 )
查询数据 SELECT, WHERE, GROUP BY, ORDER BY
事务管理 COMMIT(提交), ROLLBACK

数据类型:

文本
CHAR(指定长度 可包含字母,数字,特殊字符,255)
VARCHAR(可变, 最大长度,可包含字母,数字,特殊字符,255)
TINYTEXT(最大长度255的字符串)
TEXT(65535的字符串)
BLOB (二进制 65535)
MEDIUM TEXT(16777215 字符)
MEDIUMBLOB(15777215 二进制)
LONGTEXT(4294967295 字符串)
LONGBLOB(4294967295 二进制)
ENUM(可选范围 65535)
SET(可选范围, 64个 )

数字类型

TINYINT -128 127
SMALLINT
MEDIUMINT
INT
BIGINT
FLOAT
DOUBLE
DECIMAL

加UNSIGNED 非负数

DATE类型

DATE 年月日
DATETIME年月日时分秒
TIMESTAMP 时间戳
TIME 时分秒
YEAR 年

MYSQL的更多类型

5.7.8 支持json
8.0 spatial data

MySql 安装使用

安装 客户端 服务端
服务端架构
服务端代码运行流畅
基本使用 连接 新建 删除 修改

客户端: navicat heidisql

服务架构:

连接 线程处理 使用socket接受客户端连接 端口 3306
查询缓存, 解析器 ,优化器,处理SQL
存储引擎,存储数据到磁盘

服务端代码运行流程
检查环境
设置并发
初始化ssl
初始化服务
初始化服务组件
启动信号响应
初始化ACL
初始化主从
创建关闭线程
创建保持线程
响应连接
退出

CENTOS安装 mariaDB

vim /etc/yum.repos.d/mariaDB.repo 设置源

添加内容:
[mariadb]
name = MariaDB
baseurl = http://yum.mariadb.org/10.1/centos7-amd64
gpgkey = https://yum.mariadb.org/RPM-GPG-KEY-MariaDB
gpgcheck = 1

yum check-update 更新源
yum install MariaDB-server MariaDB-client
systemctl status mysql 检查服务
systemctl start mysql
px aux | grep mysql

mysql -uroot 连接
\q 退出
which mysql 看安装位置
mysqladmin -uroot password dongli1992 设置密码
mysql -h localhost -uroot -pdongli1992 连接

GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'dongli1992' WITH GRANT OPTION; 授权远程登录
FLUSH PRIVILEGES; 刷新

数据库操作

show databases 查看数据库
create database 数据库名 新建数据库
use 数据库名 使用数据库
drop database 删除数据库

数据表

show tables 查看数据表
creat table 表名 (列明, 数据类型) 新建表
drop table 表名 删除表
truncate table 表名 清空表
desc 查看表结构
alter table 表明 add primary key(字段)添加主键
insert into 表名(字段)values(值)
ALTER TABLE 表名 ADD CONSTRAINT FK_OrderItems_Orders FOREIGN KEY (字段) REFERENCES 外表 (字段);

-- 注释

----------------
-- create table
----------------

create table products(
prod_id char(10) not null, --AUTO_INCREMENT
vend_id char(10) not null,
prod_name char(255) not null
);

创建一个表

事务的概念

存储引擎
什么是事务
ACID特性/属性/特征/模型
分布式数据库中的事务提交

存储引擎
对表中的数据进行读取写入的程序,默认InnoDB 其他MyISAM,Memory,将表中的数据存储到磁盘。以页为单位,一般16KB

什么是事务

操作数据库从读取到写入的整个流程,一组原子性的sql查询,读取,操作,写入。

ACID特性

原子性 Atomic 由提交或回滚结束一个事务操作,不可分割。

一致性consistency 多次操作不能存在矛盾

共享锁:多个事务共享,读取数据
独占锁:单个事务写入数据,加锁不让其他事务写入
粒度问题 锁的范围
行锁,负载大,执行事务多
表锁,负载小,执行事务少

隔离性 isolation

多个事务相互隔离 ,一个事务提交前,对其他事务不可见
级别 Read uncommitted 未提交 脏读 重复读 幻读
readcommitted 提交 重复读 幻读
repedatable read 重复读| 幻读
serializable 序列化

持久性 durable
提交后保存到磁盘,不能被回滚

分布式数据库中的事务提交 (二阶段提交 2PC)

第一阶段(提交请求,投票阶段)
第二阶段(提交执行阶段)
通过协调者实现

数据库的关联

数据库表格设计:避免数据重复
一类数据一个表,相互之间有关联
主键,外键关联多个表
了解连接(连接,join)方法

重复列合成一列,为自然联结。 仅选择数值相等时,内联结
保留任一方的所有行,把另一方没有的行设置为空值,为外联结,分左右两个方向
第一个表中的每一行与第二个表中的每一行配对成笛卡尔积

数据库查询:

1、select prod_name from products; 查询一列数据
2、select prod_name, prod_id from products; 查询多列
3、select distinct prod_id from products; distinct不重复的数据
4、select prod_name from products limit 3; limit 取前三个,
5、select prod_name from products limit 3, 5; limit取3至5
6、select prod_name from products order by prod_name; order by排序
7、select prod_name, prod_id from products order by prod_name, prod_id; 多列排序
8、select prod_name, prod_id from products order by 2,1;使用位置排序
9、select prod_name, prod_id from products order by 2 desc,1 desc 倒叙
10、select prod_name, prod_id, prod_price from products where prod_price>6 where条件查询(><=!=) # 11、select prod_name, prod_id, prod_price from products where prod_price>6 order by prod_price; 条件查询并排序
12、select prod_name, prod_id, prod_price from products where prod_price between 3 and 5; between在范围之间
13、select prod_name, prod_id, prod_price from products where prod_price is null;空值 is null
14、select prod_name, prod_id, prod_price from products where prod_price >3 and prod_price <6; and 与的关系 # 15、select prod_name, prod_id, prod_price from products where (prod_price >9 or prod_price < 7) and prod_id = 'br01'; or 或关系, and优先级比or高 # 16、select prod_name, prod_id, prod_price, vend_id from products where vend_id in ('dll01', 'brs01') and prod_price >8; in 选择
17、select prod_name, prod_id, prod_price, vend_id from products where not prod_price = 8.99; not 不等于
18、select prod_name, prod_id, prod_price, vend_id from products where prod_name like '%bear' 通配符% 任意任多个字符
19、select prod_name, prod_id, prod_price, vend_id from products where prod_name like '__ inch teddy bear' 通配符 _ 匹配任意一个字符
20、select cust_contact from customers where cust_contact regexp '[a-z]' 正则regexp
21、select concat(vend_name,'-', vend_name) as new from vendors; 字符串拼接 concat
22、select rtrim(vend_name) from vendors;rtrim ltrim 去除空格
23、select trim(' dongli') as new; select后面之间加测试语句快速测试
24、select prod_id, quantity, item_price, quantity*item_price as new from orderitems where quantity=100; 数学运算
25、select order_num from orders where year(order_date) = 2012; 时间筛选 year
25、select avg(prod_price) as avg_price from products where vend_id = 'dll01'; 平均avg 最小值min 最大值max
26、select count(prod_price) as avg_price from products where vend_id = 'dll01'; 统计条目count
27、select count(prod_price) as avg_price, max(prod_price) as max_price from products where vend_id = 'dll01'; 组合
28、select avg(prod_price) as avg_price, vend_id from products group by vend_id 分组 groud by groud by 在order by 前面 用order by 对结果进行排序
29、select avg(prod_price) as avg_price, vend_id from products where prod_price >4 group by vend_id having avg(prod_price) >4分组过滤 having
30、select cust_id from orders where order_num in (select order_num from orderitems where prod_id = 'rgan01'); 嵌套查询一
31、select cust_name, cust_state, (select count(*) from orders where orders.cust_id = customers.cust_id) as order_count from customers 嵌套查询二
32、 select vend_name, prod_price from vendors, products where vendors.vend_id = products.vend_id 内联结
33、select vend_name, prod_price from vendors as v, products as p where v.vend_id = p.vend_id 表别名
34、select c1.cust_contact from customers as c1, customers as c2 where c1.cust_name = c2.cust_name 表别名, 查询时需要多次使用同一个表可以起不同的别名。 and c2.cust_contact='jimjones';
35、select customers.cust_id, orders.order_num from customers inner join orders on customers.cust_id = orders.cust_id 内联结 inner join ...on
36、select customers.cust_id, orders.order_num from customers left outer join orders on customers.cust_id = orders.cust_id 外联结 left/right outer join ...on
37、select cust_name, cust_contact, cust_email from customers where cust_state in ('il','in','mi') union select cust_name, cust_contact, cust_email from customers where cust_name = 'fun4all' 查询结果合并 union
38、update customers set cust_email = 'dongli@linux.cn' where cust_name = 'the toy store' 更新内容 update set
39、INSERT INTO Customers(cust_id, cust_name, cust_address, cust_city, cust_state, cust_zip, cust_country, cust_contact, cust_email)
VALUES('1000000001', 'Village Toys', '200 Maple Lane', 'Detroit', 'MI', '44444', 'USA', 'John Smith', 'sales@villagetoys.com');
insert into 表名(字段)valuse(值)插入数据
40、delete from customers where cust_id = '1111' delete from 删除数据
41、create view productsview as
select cust_name, cust_contact
from customers,orders,orderitems
where customers.cust_id = orders.cust_id
and orderitems.order_num = orders.order_num
and prod_id = 'rgan01'

select * from productsview
where cust_name = 'fun4all' 创建视图 (虚拟表) create view as

数据库索引

什么是索引
索引是允许更快的检索记录的一种优化方法, 使用B+TREE树 或者hash算法, 建立了数据与地址的对应关系。

索引的作用
索引为出现索引列中的每个值创建一个记录
索引包含了排序的数据,和一个指向原始数据的连接。
在查询数据时,避免了一行行进行查找加快速度

索引的类型

primary 主键
unique 数据唯一, 但是可以为NULL
multiple-columm indexes(多列合作主键)

索引的操作
primary key()
或者alter table add primary key

unique key()
alter table add unique()

什么是ORM

object relational mapping 对象 关系 映射
sqlalchemy: python orm工具包

sqlalchemy 的初步使用

declarative_base 创建基类
class 创建数据类
create_engine 创建数据库连接引擎
session 创建会话
object 创建数据对象
query 查询操作

代码演示 基础操作:

from sqlalchemy import create_engine, Integer, String, Column
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
"""用户数据类"""
__tablename__ = 'user'
id = Column('id', Integer, primary_key=True)
name = Column('name', String(50), unique=True)

engine = create_engine('sqlite:///test.db', echo=True) # 创建引擎
# Base.metadata.create_all(bind=engine)

DBsession = sessionmaker(bind=engine) # 创建会话
session = DBsession()

"""实现数据类"""
user = User()
user.id = 2
user.name = 'jiamei'

"""添加提交"""
# session.add(user)
# session.commit()

"""查询"""
res = session.query(User).all()
for i in res:
print(i.id, i.name)

代码演示 基础查询:

from sqlalchemy import create_engine, String, Integer, Column, and_, or_
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()


class User(Base):
    __tablename__ = 'user'
    id = Column('id', Integer, primary_key=True)
    name = Column('name', String(30), unique=True)

    def __repr__(self):
        return self.name


engine = create_engine('mysql+pymysql://root:dongli1992@localhost/dongli')
# Base.metadata.create_all(bind=engine)

DBsession = sessionmaker(bind=engine)
session = DBsession()


def user_add(id, name, fun_session):
    user = User()
    user.id = id
    user.name = name
    fun_session.add(user)
    fun_session.commit()
    return True


def user_query(fun_session):
    #    res = fun_session.query(User).all() # 查询所有
    # res = fun_session.query(User).order_by(User.id) # 排序
    res = fun_session.query(User).filter(User.name == 'dongli')  # 筛选
    res1 = fun_session.query(User).filter(User.id &amp;amp;amp;gt; 1)
    res2 = fun_session.query(User).filter(User.name.like('%i'))  # 模糊匹配
    res3 = fun_session.query(User).limit(1)  # 查询几条记录
    res4 = fun_session.query(User).filter(User.name.in_(['dongli', 'dongdong']))  # user.nqme.in_ 选择
    res5 = fun_session.query(User).filter(and_(User.name == 'dongli', User.id == 1))  # and_
    res6 = fun_session.query(User).filter(or_(User.name == 'dongli', User.id == 3))
    # fun_session.query(User).filter(User.id == 1).delete()  # 删除
    fun_session.query(User).filter(User.id == 2).update({'id': 4, 'name': 'XXX'}) # 更新, update(字典)
    print(res.all())
    print(res1.all())
    print(res2.all())
    print(res3.all())
    print(res4.all())
    print(res5.all())
    print(res6.all())
    print(fun_session.query(User).all())
    session.commit()
    # for i in res:
    #     print(i.id, i.name)


if __name__ == '__main__':
    # user_add(1, 'dongli', session)
    # user_add(2, 'jiamei', session)
    # user_add(3, 'dongdong', session)
    user_query(session)

代码演示 表中的关系:


from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()


class Student(Base):
    __tablename__ = 'student'
    id = Column('id', Integer, primary_key=True)
    name = Column('name', String(30), unique=True)
    homeworks = relationship('Homework', back_populates='student', order_by='Homework.id')

    def __repr__(self):
        return self.name


class Homework(Base):
    __tablename__ = 'homework'
    id = Column('id', Integer, primary_key=True)
    score = Column('score', Integer)
    name = Column('name', String(50), unique=True, nullable=False)
    student_id = Column(Integer, ForeignKey('student.id'))  # 表名.字段 设置外键
    student = relationship('Student', back_populates='homeworks')  # 设置映射关系

    def __repr__(self):
        return self.name


engine = create_engine('mysql+pymysql://root:dongli1992@localhost/dongli?charset=utf8')
# Base.metadata.create_all(bind=engine)

DBsession = sessionmaker(bind=engine)
session = DBsession()


def student_add(fun_session, id, name):
    student = Student()
    student.id = id
    student.name = name
    fun_session.add(student)


if __name__ == '__main__':
    """添加学生"""
    # student_add(session, 1, 'dongli')
    # student_add(session, 2, 'jiamei')
    # student_add(session, 3, 'dongdong')
    # session.commit()

    # s1 = session.query(Student).all()[0]
    # print(s1, dir(s1))  # dir 看对象内容
    """学生添加作业"""
    # s1.homeworks = [
    #     Homework(id=101, name='第一份作业', score=60),
    #     Homework(id=102, name='第二份作业', score=70),
    #     Homework(id=103, name='第三份作业', score=80)
    # ]
    # session.commit()
    """作业添加学生"""
    # s2 = session.query(Student).filter(Student.name=='dongli').one()
    # hw4 = Homework(id=104, name='第四份作业', score=90, student=s2)
    # session.add(s2)
    # session.add(hw4)
    # session.commit()
    """根据学生查作业"""
    # print(session.query(Student).all())  # 查询所有
    # print(session.query(Student).filter(Student.name.startswith('d')).all())  # 匹配开头为d的所有
    # print(session.query(Student).filter(Student.name.startswith('d')).first().homeworks)  # first 取第一个
    # print(session.query(Student).filter(Student.name.startswith('j')).one())  # one 唯一一个
    # print(session.query(Student).order_by(Student.id).filter(Student.id&amp;amp;amp;gt;1).all()[1].homeworks)  # order by 排序

    """根据作业查学生"""
    #  print(session.query(Homework).filter(Homework.id &amp;amp;amp;gt; 102).count())  # 统计条目
    #  print(session.query(Homework).filter(Homework.id &amp;amp;amp;gt; 101).first().student)  # 作业差学生
    #  print(session.query(Homework).join(Homework.student).filter(Student.name == 'dongdong').all())  # join 关联查询

from sqlalchemy import Column, String, Integer, ForeignKey, create_engine
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()


class Admin(Base):
    __tablename__ = 'admin'
    id = Column('id', Integer, primary_key=True)
    name = Column('name', String(30), unique=True)
    hosts = relationship('Host', secondary='Admin_host')

    def __repr__(self):
        return self.name


class Host(Base):
    __tablename__ = 'host'
    id = Column('id', Integer, primary_key=True)
    name = Column('name', String(30), unique=True)
    admins = relationship('Admin', secondary='Admin_host')

    def __repr__(self):
        return self.name


class Adminhost(Base):
    __tablename__ = 'Admin_host'
    admin_id = Column(Integer, ForeignKey('admin.id'), primary_key=True)
    hsot_id = Column(Integer, ForeignKey('host.id'), primary_key=True)


engine = create_engine('mysql+pymysql://root:dongli1992@localhost/dongli?charset=utf8')
Base.metadata.create_all(bind=engine)

DBsession = sessionmaker(bind=engine)
session = DBsession()


def admin_add(session, id, name):
    admin = Admin()
    admin.id = id
    admin.name = name
    session.add(admin)
    return admin


def host_add(session, id, name):
    host = Host()
    host.id = id
    host.name = name
    session.add(host)


if __name__ == '__main__':
    # admin_add(session, 1, 'dongli')
    # admin_add(session, 2, 'jiamei')
    # admin = admin_add(session, 3, 'dongdong')
    # h1 = Host(id=100, name='web.server')
    # h2 = Host(id=200, name='db.server')
    # h3 = Host(id=300, name='dev.server')
    # admin.hosts.append(h1)
    # admin.hosts.append(h2)
    # admin.hosts.append(h3)
    # session.add(admin)
    # session.commit()

    q1 = session.query(Admin).all()
    print(q1)
    q2 = session.query(Admin).filter(Admin.name.endswith('i')).all()
    print(q2)
    print(q1[0].hosts)  # 用户查主机
    q3 = session.query(Host).filter(Host.id == 100).one().admins  # 根据主机查管理员
    print(q3)
    q4 = session.query(Admin).filter( Admin.hosts.any(Host.id == 200)).all()  # 根据主机查管理员2
    print(q4)

mongoDB 基本操作

插入数据

user 数据库名创建数据库
db.users.insertOne({name: "sue",age: 19,status: "P"})查询
db.users.find( { "name": "sue" } )
db.users.insertMany([{ name: "bob", age: 42, status: "A", },{ name: "ahn", age: 22, status: "A", },{ name: "xi", age: 34, status: "D", }])添加多条
db.user.insert()根据参数插入单条或多条,返回状态
db.users.find().pretty() 格式化打印

查询数据

db.users.find( { status: "A" } ) 条件查询
db.users.find( { status: { $in: [ "P", "D" ] } } ) $in选出状态是P或者是D的 $eq 等于 $lt 小于 $gt大于 $get 大于等于 $lte 小于等于 $ne 不等于 $nin 不在范围内
db.users.find({status:'A',$or:[{age:{$lt:30}}, {type:1}]}) 复合查询文档选择集合中`status`` 等于 "A" 并且 要么 age 小于 ($lt) 30 要么 type 等于 1 的所有文档
db.users.find({favorites:{artist:'Picasso',food:'pizza'}}) 嵌套组合查询
db.users.find({'favorites.artist':'Picasso'}) 嵌套查询
db.users.find( { badges: [ "blue", "black" ] } ) 匹配数组
db.users.find( { badges: "black" } )匹配一个数组元素
db.users.find( { "badges.0": "black" } )查询指定元素
db.users.find( { finished: { $elemMatch: { $gt: 15, $lt: 20 } } } ) 查询指定元素条件 必须同一元素满足
db.users.find( { finished: { $gt: 15, $lt: 20 } } ) 多个元素满足 或者同一元素满足
db.users.find( { 'points.0.points': { $lte: 55 } } ) 嵌入文档查询
db.users.find( { 'points.points': { $lte: 55 } } )不指定位置列出所有的
db.users.find( { points: { $elemMatch: { points: { $lte: 70 }, bonus: 20 } } } ) 查询 points 数组有至少一个包含 points 小于等于 70 并且字段 bonus 等于 20 的内嵌文档的文档
db.users.find( { "points.points": { $lte: 70 }, "points.bonus": 20 } )查询了 points 数组包含了以某种组合满足查询条件的元素的文档;例如,一个元素满足 points 小于等于 70 的条件并且有另一个元素满足 bonus 等于 20 的条件,或者一个元素同时满足两个条件
db.users.find( { status: "A" }, { name: 1, status: 1 } )只返回指定的字段及 _id 字段您可以通过在映射中指定排除的字段删除结果中的 _id 字段,如下面的案例所示:
db.users.find( { status: "A" }, { name: 1, status: 1, _id: 0 } )
db.users.find( { status: "A" }, { favorites: 0, points: 0 } ) 排除多个字段
db.users.find({ status: "A" },{ name: 1, status: 1, "favorites.food": 1 } 嵌套筛选
db.users.find({ status: "A" },{ "favorites.food": 0 }) 嵌套排除
db.users.find( { status: "A" }, { name: 1, status: 1, "points.bonus": 1 } ) 嵌套筛选
db.users.find( { status: "A" }, { name: 1, status: 1, points: { $slice: -1 } } ) 对于包含数组的字段,MongoDB提供了下面的映射操作符: $elemMatch, $slice, 以及 $ 。
MongoDB中不同的运算符对待 null 值不一样.
db.users.insert([{ "_id" : 900, "name" : null },{ "_id" : 901 }])
db.users.find( { name: null } )
如果该查询使用了 sparse 索引,不管怎样,那么该查询将仅仅匹配 null 值,而不匹配不存在的字段.
{ name : { $type: 10 } } 查询 仅仅 匹配那些包含值是 null 的 name 字段的文档,亦即 条目 字段的值是BSON类型中的 Null (即 10 ):
db.users.find( { name : { $type: 10 } } )该查询只返回文 条目 字段是 null 值的文档:
db.users.find( { name : { $exists: false } } )该查询只返回那些 没有 包含 条目 字段的文档:

更新文档中指定字段

db.users.updateOne({ "favorites.artist": "Picasso" },{$set: { "favorites.food": "pie", type: 3 },$currentDate: { lastModified: true }}) 更新字段
db.users.updateMany({ "favorites.artist": "Picasso" },{$set: { "favorites.artist": "Pisanello", type: 3 },$currentDate: { lastModified: true }} 更新多个
db.users.update({ "favorites.artist": "Pisanello" },{$set: { "favorites.food": "pizza", type: 0, },$currentDate: { lastModified: true }}) 更新字段
db.users.update({ "favorites.artist": "Pisanello" },{$set: { "favorites.food": "pizza", type: 0, },$currentDate: { lastModified: true }},{ multi: true })更新多个
db.users.replaceOne({ name: "abc" },{ name: "amy", age: 34, type: 2, status: "P", favorites: { "artist": "Dali", food: "donuts" } }) 替换
db.users.update({ name: "xyz" },{ name: "mee", age: 25, type: 1, status: "A", favorites: { "artist": "Matisse", food: "mango" } })

删除所有文档

db.users.deleteMany({})
db.collection.remove() 删除 所有 文档:
db.users.remove({})
要想从一个集合里删除所有文档,使用 drop() 方法删除整个集合,包括索引然后重建该集合和索引或许会更高效.
db.users.deleteMany({ status : "A" }) 删除符合条件的文档
对于大量的删除操作,把你想要保留的文档复制到一个新的集合然后使用 db.collection.drop() 方法删除原集合或许会更高效。
db.collection.deleteOne() 删除1个符合条件的文档
db.users.remove( { status: "D" }, 1) 移除一个符合条件的文档

 

python 操作mongo

from pymongo import MongoClient

client = MongoClient()
client.database_name() 查看数据库
client.数据库名 旋转数据库 如果没有自动创建
client.drop_database('dongli') 删除数据库
db = client.数据库名 创建数据库
db.list_collection_names() 查看集合
db.create_collection('users') 创建集合
collect.insert_one({'name': 'dongli'}) 插入记录
collect.find().count()统计多少记录
collect.find() 查询所有 返回迭代器
collect.count_documents({'user':'she'}) 统计条件记录条数
[i for i in collect.find().sort('name',pymongo.DESCENDING)] 排序 正序ascending
collect.update_one({"name":'dongli'},{'$set':{'name':'dongdong'}}) 修改
collect.delete_one({'name':'dongdong'}) 删除
deleted_count 看删除是否成功

redis 基本使用

1 . 下载Redis 使用wget下载,命令如下:
http://download.redis.io/redis-stable.tar.gz

2 . 解压Redis
下载完成后,使用tar命令解压下载文件:
$ tar -xzvf redis-3.0.4.tar.gz

3 . 编译安装Redis
切换至程序目录,并执行make命令编译:
$ cd redis-3.0.4
$ make

4.安装
切换至redis的src目录
$cd src
$ cp redis-server redis-cli /usr/local/bin
$cp redis-sentinel redis-benchmark redis-check-aof redis-check-dump /usr/local/bin

5、创建配置目录
$mkdir /etc/redis
$mkdir -p /var/lib/redis/6379
$cp redis.conf /etc/redis/6379.conf
$vi /etc/redis/6379.conf

6、修改6379.conf中的内容
daemonize yes
pidfile /var/run/redis_6379.pid
port 6379
loglevel notice
dir /var/lib/redis/6379
# requirepass foobared 更改密码

7.创建服务
$sysctl -w vm.overcommit_memory=1
$sysctl -w net.core.somaxconn=512.
$echo never > /sys/kernel/mm/transparent_hugepage/enabled
$cp utils/redis_init_script /etc/init.d/redis_6379
$vi /etc/systemd/system/redis.service

redis.service的内容
[Unit]
Description=Redis on port 6379
[Service]
Type=forking
ExecStart=/etc/init.d/redis_6379 start
ExecStop=/etc/init.d/redis_6379 stop
[Install]
WantedBy=multi-user.target

8.服务更新

$systemctl enable redis
#务必要进行reload
$systemctl daemon-reload
#在centos7下可用service命令启动
$service redis start
#查看服务状态
$service redis status
#在低于centos7版本下用systemctl
$systemctl start redis

数据操作

字符串

set key value 添加数据
get key 获取数据

默认有16个数据库
select 索引切换数据库
exists age 判断有没有key
append 追加
strlen 查看长度
flushdb 清空数据库
incr 自增
decr 自减
incrby key 2 每次增多少
decrby key 2 每次减多少
set key EX/PX 设置过期时间 NX key不存在才生效 XX 存在才设置
ttl key 看过期时间
getset 获取到再修改
setex 设置key value 过期时间
setnx 不存在才执行
setrange 修改指定位置的值
getrange 获取某一部分的值
setbit day 1 1 设置值的布尔值
getbit day 获取
mset 设置多个
mget 获取多个

list

lpush 插入列表
lrange 查询列表
lpushx 追加已经存在的列表
lpop 删除第一个元素
llen 获取列表长度
lrem 删除几个指定值的元素
lindex 取出指定索引的元素
lset 设置指定索引的元素
ltrim 删除两边的元素
linsert key after/before 插入元素
rpush 从右开始插入
rpushx
rpop
rpoplpush 头尾交换

set

sadd 添加set
smembers 查询set
sismembers 判断在不在集合里面
scard 获取集合中元素个数
srandmembers 随机获取元素
spop 随机删除一个元素
srem 删除元素
smove 移动元素
sdiff 取集合的不同 差集
sdiffstore 取出不同的元素放到一个集合中
sinter 交集
sinterstore 交集存储
sunion 并集
sunionstore 并集存储

zset 有序集合

zadd key 权重 value
zrange 查看元素 【withscores】选项带分数
zcard 查看zset成员个数
zrank 获取索引
zcount 获取符合条件的个数
zrem 删除
zscore 看成员分数
zincrby 增加分值
zrangbyscore 从分值获取成员 limit
zrevrange 反向获取
zrevrangebyscore 分数反向获取
zrevrank

hash

hset 添加
hget 获取
hexists 判断有没有字段
hdel 删除字段
hsetnx 不存在生效
hincrby 增长
hmset 添加多个
hmget 获取多个
hgetall 获取所有
hkeys 获取所有的key
hvals 获取所有的值

key命令

keys * 所有
del 删除
exists 判断有没有
move 移动到其他数据库
rename 更改名字
renamenx 不存在时生效
ttl 过期时间
persist 持久化
expire 持久化后设置过期时间
expireat 过期时间戳
type 查看key的类型
randomkey 随机取key

事务

multi 启动事务
exec 提交事务
discard 回滚

主从

slaveof ip 端口
修改绑定端口
修改配置文件方式 slaveof
info replication 查看状态

持久化:

rbd
配置文件 dbfilename:
路径

aof
方式
appendolny =yes

python 使用redis
安装 redis 命令几乎相同


最后更新于:2018-10-17 16:24:39