记录在项目中使用的MySql相关用法.


SUM()函数按条件求和

  • 一般求和 (加和所有lessonStep)

    > sum(lessonStep) 
  • 条件求和 (当 lessonStep为1时, 加1 否则为0)

    > sum( lessonStep = 1 ), 0 )
  • 复杂条件求和 (只统计LessonStep为1, 否则为0)

    > sum(if(lessonStep = 1, lessonStep, 0))
    

COUNT()函数按条件求和

一般求和 (加和所有lessonStep)

count(lessonStep)

条件求和 (当 lessonStep为1时, 加1 否则为0)

count(lessonStep=1 or null)

复杂条件求和 (只统计LessonStep为1, 否则为0)

count(if(lessonStep=1,true,null))

TIMESTAMPDIFF()函数

求两个时间之前间隔 (单位为秒 SECOND)

TIMESTAMPDIFF(SECOND, learing.createDate , learing.modifiedDate) as learnTime,

TO_DAYS函数

用于时间比对

to_days(createDate) = to_days('2019-08-01')

IFNULL

设置默认值

IFNULL( sum( google_minicourserelation.STATUS != 2 AND to_days( google_minicourserelation.createDate) <= to_days(#{param1})), 0 ) AS countMP,

这里使用的python:3.7,工具pycharm:File-settings-project-Interpreter可以进行导包
mongodb安装:https://www.cnblogs.com/tonylaoshi/p/11052427.html
manage.py

import json

from flask import Flask, request
from flask_cors import CORS
#flask_cor解决跨域
from flask_script import Manager
from app import app
from models import User

manager = Manager(app)
CORS(app, supports_credentials=True)

@app.route('/savedata', methods=['GET', 'POST'])
@manager.command
def save():
    datas = request.get_data()
    print(datas)
    user = User('diaodiao',datas)
    user.save()
    return datas

@app.route('/getdata', methods=['GET', 'POST'])
@manager.command
def query_users():
    users = User.query_users()
    # str(users['ObjectId'])
    list = []
    for user in users:
        del user['_id']
        print(user)
        list.append(user)
        # json.dumps(user)
    print(list)
    jsondata = json.dumps(list)
    return jsondata

@app.route('/delete', methods=['GET', 'POST'])
@manager.command
def delete():
    datas = request.get_data()
    print(datas)
    print("------")
    # print(datas['name'])
    name = "DiaoDiao"
    users = User.delete(name)
    if name:
        # return "Remove " + datas.name["name"] + " Ok!"
        return "Remove " + ["name"] + " Ok!"
    else:
        return "用户不存在,请核对后再操作!"

@app.route('/update', methods=['GET', 'POST'])
@manager.command
def update():
    datas = request.get_data()
    print(datas)
    print("------")
    # print(datas['name'])
    name = "DiaoDiao"
    email = "562957147@qq.com"
    users = User.update(name,email)
    if name:
        return "update " + name + " Ok!"
    else:
        return "用户不存在,请核对后再操作!"

if __name__=='__main__':
    # app.run()
    manager.run(debug=True)

manage.py

import pymongo

def get_coll():
    client = pymongo.MongoClient('localhost', 27017)
    db = client.jikexueyuan
    user = db.user_collection
   return user

class User(object):
    def __init__(self, name, datas):
        self.name = name
        self.datas = datas

def save(self):
    user = {"name": self.name, "email": self.datas}
    coll = get_coll()
    id = coll.insert(user)
    print(id)

@staticmethod
def query_users():
    users = get_coll().find()
    return users

@staticmethod
def delete(name):
    users = get_coll().find({"name": name})
    print(name)
    print(users)
    coll = get_coll()
    coll.remove({"name": name})
    return name

@staticmethod
def update(name,email):
    users = get_coll().find({"name": name})
    print(name)
    print(users)
    coll = get_coll()
    coll.find({"name": name})
    coll.update({"name":name},{"$set":{"email":email}})
    return name

作者:jianpeng.diao
版权声明:本文为博主原创文章,转载请附上博文链接!

是什么是Stream流

java.util.stream.Stream

Stream流和传统的IO流,它们都叫流,却是两个完全不一样的概念和东西。

流可以简单的说是处理数据集合的东西,可以申明式流式API来处理集合,而不是写一个逻辑实现。
流分类
流分为顺序流及并行流,顺序流即每个指令按顺序执行,并行流即集合里面的操作并行执行。

List<Integer> numbers = Arrays.asList(1, 2, 3);
// 顺序流
numbers.stream().forEach(n -> System.out.print(n));
//并行流
numbers.parallelStream().forEach(n -> System.out.print(n));

以上例子,顺序流总是输出123,而并行流则每次结果都不一定,并行流使用了ForkJoinPool分而治之
使用流
以下举了流的一些常用的用法。

public class StreamTest {

public static void main(String[] args) {
    System.out.println("过滤-找出年纪大于18岁的人");
    List<User> list = initList();
    list.stream().filter((User user) -> user.getAge() > 18).collect(Collectors.toList())
            .forEach(System.out::println);
    System.out.println();

    System.out.println("最大值-找出最大年纪的人");
    list = initList();
    Optional<User> max = list.stream().max((u1, u2) -> u1.getAge() - u2.getAge());
    System.out.println(max.get());
    System.out.println();

    System.out.println("映射-规纳-求所有人的年纪总和");
    list = initList();
    Optional<Integer> reduce = list.stream().map(User::getAge).reduce(Integer::sum);
    System.out.println(reduce.get());
    System.out.println();

    System.out.println("分组-按年纪分组");
    list = initList();
    Map<Integer, List<User>> userMap = list.stream()
            .collect(Collectors.groupingBy(User::getAge));
    MapUtils.verbosePrint(System.out, null, userMap);
    System.out.println();

    System.out.println("创建-去重-统计");
    Stream<User> userStream = Stream
            .of(new User("u1", 1), new User("u2", 21), new User("u2", 21));
    System.out.println(userStream.distinct().count());
    System.out.println();

}

    public static List<User> initList() {
        List<User> list = new ArrayList<>();
        list.add(new User("oaby", 23));
        list.add(new User("tom", 11));
        list.add(new User("john", 16));
        list.add(new User("jennis", 26));
        list.add(new User("tin", 26));
        list.add(new User("army", 26));
        list.add(new User("mack", 19));
        list.add(new User("jobs", 65));
        list.add(new User("jordan", 23));
        return list;
   } 
}                                                                                                    

输出结果:

过滤-找出年纪大于18岁的人
User [username=oaby, age=23]
User [username=jennis, age=26]
User [username=tin, age=26]
User [username=army, age=26]
User [username=mack, age=19]
User [username=jobs, age=65]
User [username=jordan, age=23]
最大值-找出最大年纪的人
User [username=jobs, age=65]
映射-规纳-求所有人的年纪总和
235
分组-按年纪分组
{
16 = [User [username=john, age=16]]
65 = [User [username=jobs, age=65]]
19 = [User [username=mack, age=19]]
23 = [User [username=oaby, age=23], User [username=jordan, age=23]]
26 = [User [username=jennis, age=26], User [username=tin, age=26], User [username=army, age=26]]
11 = [User [username=tom, age=11]]
}
创建-去重-统计
2

但需要注意的是流只能执行一次,再次使用需要重要打开。

stream()方法和collect()方法都是java8的新特性

stream()优点

1.无存储。stream不是一种数据结构,它只是某种数据源的一个视图,数据源可以是一个数组,Java容器或I/O channel等。
2.为函数式编程而生。对stream的任何修改都不会修改背后的数据源,比如对stream执行过滤操作并不会删除被过滤的元素,而是会产生一个不包含被过滤元素的新stream。
3.惰式执行。stream上的操作并不会立即执行,只有等到用户真正需要结果的时候才会执行。
4.可消费性。stream只能被“消费”一次,一旦遍历过就会失效,就像容器的迭代器那样,想要再次遍历必须重新生成。

stream().map()方法的使用示例:

List<String> list= Arrays.asList("a", "b", "c", "d");
List<String> collect =list.stream().map(String::toUpperCase).collect(Collectors.toList());
System.out.println(collect); //[A, B, C, D]

List<Integer> num = Arrays.asList(1,2,3,4,5);
List<Integer> collect1 = num.stream().map(n -> n * 2).collect(Collectors.toList());
System.out.println(collect1); //[2, 4, 6, 8, 10]

1、@Qualifier

出现场景:

项目中有多个实现类实现同一个接口时,或者一个项目中有多个数据源时,spring容器不知道该注入哪个实现类或者使用哪个数据源,该注解就派上用场。如果不指定具体是哪个实现类的Bean,在Spring Boot启动时就会发生异常(下图):

请输入图片描述

异常的描述信息非常简单,就是告诉开发者,自动注入的地方需要一个Bean,而spring 容器却找到了3个实现类的Bean。

此时可以考虑使用@Primary注解或@Qualifier注解。
我们自动注入的时候,如果有多个候选实现类的bean,spring boot启动的时候就不知道该选择哪个bean进行注入,因此会报错。

使用@Primary可以指定一个首选Bean注入;使用@Qualifier可以在自动注入的地方通过传入一个限定名(也就是类的别名)来选取指定的实现类,只不过必须与类的别名一致(如果不传限定名,就使用类的默认别名)

如果既不用@Primary也不用@Qualifier,那就必须在自动注入的时候直接以类的默认别名来命名。

给(spring ioc容器管理的)类设置别名的方式是:@Service("别名")、@Component("别名") 、@Bean("别名") 等等。
例:

@Autowired
@Qualifier("apClearTaskFileService")
private IAPClearTaskFileService apClearTaskFileService;

@Service("apClearTaskFileService")
public class APClearTaskFileService extends BaseServiceImpl<TaskFileQO,TaskFileVO> implements IAPClearTaskFileService 

一辈子很短,努力的做好两件事就好;第一件事是热爱生活,好好的去爱身边的人;第二件事是努力学习,在工作中取得不一样的成绩,实现自己的价值,而不是仅仅为了赚钱