day 4 作业, 员工信息程序，模拟SQL 语句

作业要求：
1、可进行模糊查询，语法至少支持下面3种:
　　select name,age from db1.staff_table where age > 22
　　select * from db1.staff_table where dept = "IT"
    select * from db1.staff_table where enroll_date like "2013"
    select name,age from db1.staff_table where id > = 1 and id < = 5 or name like 李 limit 4
    查到的信息，打印后，最后面还要显示查到的条数
2、可创建新员工纪录，以phone做唯一键，staff_id需自增
insert into db1.staff_table values alex,30,18500841678,运维,2007-8-1

3、可删除指定员工信息纪录，输入员工id，即可删除
    delete from db1.staff_table where id = 1

4、可修改员工信息，语法如下:
　　update db1.staff_table set dept = "Market" where dept = "IT"

*注意：以上需求，要充分使用函数，请尽你的最大限度来减少重复代码

数据库文件，在目录下新建  db1,  在db1 下面新建  staff_table

1,张德,25,18330267967,IT,2017-5-27
2,李四,25,19230267967,运维,2016-5-27
3,王五,35,15673026796,IT,2017-6-27
4,赵六,29,18122263467,测试,2017-5-28
5,董七,25,18556267967,运维6,2014-5-27
6,李张明,26,18122677967,测试,2017-5-21
7,赵四,28,18523267967,运维,2014-5-22
8,董七,25,18556267967,运维,2014-5-27
9,alex,30,18500841678,运维,2007-8-1

 

import os

#定义查询函数，传入解析完成的sql_dict
def select(sql_dict):
    #print("select",sql_dict)
    #1. from
    db, table = sql_dict.get('from')[0].split('.')  # 切分出库名和表名，就是文件路径
    fh = open("%s/%s" % (db, table), 'r', encoding='utf-8')  # 打开文件 根据取到的路径
    #2:where 调用where_action 函数，处理where 条件。
    where_l=sql_dict.get('where')
    filter_res = where_action(fh,where_l)  # 定义where执行函数，查询条件
    fh.close()
    #3:limit 调用 limit 函数，处理limit 条件
    limit_res=limit_action(filter_res,sql_dict.get("limit"))
    #4.select #调用  search_action 函数，处理查询字段条件
    search_res=search_action(limit_res,sql_dict.get("select"))
    #print(search_res)
    count_select= len(search_res[1])
    return [search_res,"共查询到{}条记录".format(count_select)]

#{'insert': [], 'into': ['db1.emp'], 'values': ['alex,30,18500841678,运维,2007-8-1']}
def insert(sql_dict):
    #print(sql_dict)
    db,table=sql_dict.get("into")[0].split(".") #提取数据库字段
    title="id,name,age,phone,dept,enroll_date" #定义数据库字段标题
    max_id,count_insert=0,0 #定义 最大id，及插入计数器
    tmp=[] #定义临时空字典
    values_l=sql_dict.get('values')[0].split(",")
    #处理 sql_dict 字典中values ['alex,30,18500841678,运维,2007-8-1'] 成
    #['alex','30','18500841678','运维','2007-8-1']
    phone=values_l[2] #获取新增数据中的电话号码
    with open("{}/{}".format(db,table),"r",encoding="utf-8") as f_r: #打开数据库表文件
        for line in f_r: #循环表中的数据
            f_a_dict=dict(zip(title.split(","),line.split(",")))#把每一行跟抬头，合并成字典
            if phone in f_a_dict.get("phone"): #对比输入字段中的电话，与表中数据的电话，
                return ("phone 已存在，请检查，重新输入") #如果电话号码已经存在，返回提示。
            a=int(f_a_dict.get("id")) #否则开始取出id
            #print(a)
            max_id = a if a>max_id else max_id #获取字典最大的ID 值
        new_id=max_id+1 #新增字段ID值

    with open ("{}/{}".format(db,table),"a",encoding="utf-8") as f_a: #以append 方式打开数据库表文件
        tmp.append(str(new_id)) #将ID号转成字符串，（否则join 数据类型 int 方法会出错），添加到tmp 临时列表中
        tmp.extend(values_l) #合并临时列表和 用户输入的values 列表
        line=",".join(tmp) #将列表处理成数据库中表的格式
        #print(line)
        f_a.write("\n{}".format(line)) #将数据写入数据库文件
        f_a.flush() #刷新磁盘
        count_insert+=1 #新增计数器 +1
    return [count_insert,"insert sucessful"] #返回数据

#{'update': ['db1.staff_table'], 'set': ['dept', '=', '"Market"'], 'where': [['dept', '=', '"IT"']]}
def update(sql_dict):
    #print(sql_dict)
    count_update = 0 #定义 修改计数器
    db,table=sql_dict.get("update")[0].split(".") #获取表文件路径
    table_new="new_"+table #新建一个表明
    title="id,name,age,phone,dept,enroll_date" #定义数据库表文件，标题
    with open("{}/{}".format(db, table), 'r', encoding='utf-8') as f_r: #打开原表文件
        with open("{}/{}".format(db, table_new), "w", encoding="utf-8") as f_w: #新建一个新表文件
            for line in f_r: #循环旧表
                f_r_d=dict(zip(title.split(","),line.split(",")))#合并旧表文件为字典
                filter_res=logic_p(f_r_d,sql_dict.get("where")) #调用logic_p 函数，判断这一行数据是否符合where 条件，返回布尔值
                tmp=[] #定义临时空列表
                if filter_res: #如果符合where 条件
                    f_r_d[sql_dict.get("set")[0]]=sql_dict.get("set")[2] #根据set 修改相应的值
                    for i in f_r_d.values():
                        tmp.append(i)
                    line=",".join(tmp) #将字典处理成字符串
                    #print(line)
                    f_w.write(line) #写入新表中
                    count_update += 1 #计数器+1
                else: #如果没有满足where 条件
                    f_w.write(line) #将数据 写到新表中
            f_w.flush() #刷新磁盘
    os.remove("{}/{}".format(db,table)) #移除旧数据文件
    os.rename("{}/{}".format(db,table_new),"{}/{}".format(db,table)) #将新数据表，重命名问旧表的名称
    return [count_update,"update sucessful"]


#{'delete': [], 'from': ['db1.emp'], 'where': [['id', '>', '1']]}
def delete(sql_dict):
    #print(sql_dict)
    db, table = sql_dict.get("from")[0].split(".") #同上面，不做解释了
    table_new = "new_" + table
    where_l=sql_dict.get("where")
    title="id,name,age,phone,dept,enroll_date"
    count_delete=0
    with open("{}/{}".format(db,table),"r",encoding="utf-8") as f_r: #打开旧文件
        with open("{}/{}".format(db, table_new), "w", encoding="utf-8") as f_w:#打开新文件
            for line in f_r: #循环旧文件
                f_r_dict=dict(zip(title.split(","),line.split(","))) #合成字典
                filter_res = logic_p(f_r_dict, where_l)#调用函数对比 行是否符合where 条件
                #print(filter_res)
                if  filter_res: #如果符合
                    count_delete+=1 #计数器+1 ，不处理，相当于删除
                else:
                    f_w.write(line) #如果不满足，写到新文件。
            f_w.flush()
    os.remove("{}/{}".format(db, table)) #同上面函数，不解释了。。。。
    os.rename("{}/{}".format(db, table_new), "{}/{}".format(db, table))
    return [count_delete, "delete sucessful"]

def sql_action(sql): #定义sql 分发处理函数
    sql_l=sql.strip().split(" ")
    #定义 4种功能能的字典，对应4种函数
    kw={
        "select":select_p,
        "insert":insert_p,
        "update":update_p,
        "delete":delete_p
    }
    #print(sql_l[0],kw.keys)
    if sql_l[0] in kw: #如果用户输入的第一个单词符合 4种语法，调用相对于的函数处理
        res=kw.get(sql_l[0])(sql_l)
    else: # 否则提示输入错误
        res=("语法错误请重新输入!")
    return res

def select_p(sql_l): #定义select_p 函数，将函数处理 获取对应语法的字段
    sql_dict={
        "select":[],
        "from":[],
        "where":[],
        "limit":[],
            }
    sql_dict=handle_p(sql_l,sql_dict) #将定义的字典，传给解析sql 、定义的字典，语句的函数
    #print("s_p",sql_dict)
    res=select(sql_dict) #将处理好的 sql 字典，交个对应的函数，处理。
    return res

def insert_p(sql_l): #同上定义 insert_p 函数，
    sql_dict={
        "insert":[],
        "into":[],
        "values":[]
    }
    sql_dict=handle_p(sql_l,sql_dict)
    res=insert(sql_dict)
    return res



#UPDATE db1.staff_table SET dept = "Market" where dept = "IT"
def update_p(sql_l): #同上定义 update_p 函数，
    sql_dict={
        "update":[],
        "set":[],
        "where":[],
    }
    sql_dict = handle_p(sql_l, sql_dict)
    #print("u_p",sql_dict)
    #sql_dict = (sql_dict)
    res=update(sql_dict)
    return res

#delete from db1.emp where id = 1
def delete_p(sql_l): #同上定义 delete_p 函数，
    sql_dict={
        "delete":[],
        "from":[],
        "where":[],
    }
    sql_dict= handle_p(sql_l,sql_dict)
    res=delete(sql_dict)
    return res


def handle_p(sql_l,sql_dict): #定义解析 sql 语句的函数
    tag=False #定义警报器
    for i in sql_l: # 循环 sql_l 语句，将sql 语句相应的字段，填充的sql_dict 字典中
        if len(i) != 0:
            if i in sql_dict:
                key=i
                tag=True
            if tag and i not in sql_dict:
                sql_dict[key].append(i)
    if sql_dict.get("where"):  #如果有where 条件，将where 中字典 调用 where_p 函数，处理 字段不连续问题
        while_l=sql_dict.get("where")
        sql_dict["where"]=where_p(while_l)
    #print("wherel_".format(sql_dict.get("where")))
    #print("handle {}".format(sql_dict.get("where")))
    return sql_dict

#定义函数 将[id > = 1 and id < = 5 or name like 李 limit 4] 处理成[[id > = 1] and [id < = 5] or [name like 李 limit 4]]
def where_p(where_l):
    key=["and","or","not"]  #定义关键字
    tmp=[]
    res=[]
    #print("where_p",where_l)
    for i in where_l: #循环 字段
        #print("where_p",i)
        if i.strip() not in key: #如果不是关键字，加到临时列表中
            tmp.append(i)
        if i in key: #如果是关键字，将上面的临时列表，添加到返回的列表中，并添加关键字到列表
            #tmp=three_p(tmp)
            res.append(tmp)
            tmp=[]
            res.append(i)
    else:#还有最后的关键字后面的条件，也需要添加，例如 or name like 三
        #print("开始",tmp)
        res.append(tmp)
        #print("over w_p",res)

    for l in res:  #将['id','>','=','1'] 处理成 ["id',">=","1"] 方便做布尔运算
        if (l not in key) and ("like" not in l): #设置需要处理的条件，需要的情况才处理 ，不同于视频讲解的思路
            index=res.index(l)  #获取需要处理的字段，在where_l 中的索引。
            res.remove(l)#在where_l 中删除掉，需要处理的 字段列表
            l=three_p(l) #调用 处理函数
            res.insert(index,l)#将处理好的字段列表重新，添加到where_l 列表的位置
        #print(res)
    return res


def three_p(l):  #定义处理 将['id','>','=','1'] 处理成 ["id',">=","1"] 的函数
    key=[">","<","="]  #定义关键字符串
    res=[] #定义空列表用于防治返回值
    char="" #定义空字符串
    #print(l)
    for i in key: #遍历['id','>','=','1'] where_l 子列表
        if i in l: #判断当 遇到关键字
            l.remove(i) #从子列表中删除
            char+=i# 拼接字符串，使得 类似 '>','='  变成'>='
    l.insert(1,char) #将字符串添加到仔列表的中间
    #print(char,l)
    return l  #返回子列表


def where_action(fh,where_l):  #定义 处理 where 条件的函数，用于查询时调用，判断遍历的文件是否符合 where 条件
    title="id,name,age,phone,dept,enroll_date" #定义数据库文件中，字符串的标题
    logic=["and","or","not"] #定义逻辑判断的关键字
    res=[] #定义两个空列表，用于防止返回值
    logic_res=[]
    if len(where_l) != 0: # 判断传入的sql 语句 是否有where 条件，如果有才进行处理，
        for line in fh:
            #print(line)
            f_dict=dict(zip(title.split(","),line.split(","))) #每一行合成字典
            #print(f_dict)
            logic_res=logic_p(f_dict,where_l) #调用逻辑判断的函数
            #print(logic_res)
            if logic_res: #如果逻辑判断结果为 True
                res.append(line.split(",")) #将结果放置在空列表中
    else:  #如果没有where 条件语句就返回 遍历的文件的行
        res=fh.readlines()
    return res

def logic_p(f_dict,where_l): #逻辑判断函数
    res=[]
    #print("logic_p",where_l)
    for exp in where_l: #遍历where 条件列表
        #print(exp)
        if type(exp) is list: #遍历  类似 ['id','>=','2'] ，["name","like","李"]这样的条件
            exp_k,opt,exp_v=exp #多元赋值，类似上面的列表三个值，全部取出
            #exp_v=exp_v.strip('""')
            if opt == "=": #因为用于布尔运算，用户输入的"=",需要替换为"==",
                opt = "=="

            if exp_v.isdigit(): # 判断用户输入的 条件，值是否为 数字 字符串
                exp_v=int(exp_v) #将用户输入的 条件转换为 数字，便于进行布尔运算
                f_dict_v=int(f_dict[exp_k]) #取出数据库 文件中 对应字段的 值
            else: #如果 不是 数字 类型，添加 引号
                f_dict_v="'{}'".format(f_dict[exp_k])
                #print("1",f_dict_v)

            if opt != "like":  #判断 如果 操作条件不是是 like
                #a=f_dict[exp_k]
                # 利用eval 执行布尔运算，返回时改变类型为字符串，因为，还需要再次整个"where 是有条件进行布尔运算，
                #eval 只接受 字符串类型。
                exp=str(eval('{}{}{}'.format(f_dict_v,opt,exp_v)))
            else: #如果是 like 的情况 ,是字符串的判断
                exp_v=exp_v.strip('""')  #这是个坑，把用户输入的 例如"IT" ,这样的去掉""
                #print(exp_v)
                if exp_v in f_dict_v:  #如果where 条件中的 like 在文件中，
                    exp="True" #返回 True
                else:
                    exp="False" #否则 返回False
        res.append(exp) #将 ['id','>=','2'] 类似的判断的结果，返回到列表中，
        #print(res)
    logic_l=" ".join(res) #把列表变成 字符串，中间空格 ，分割 方便再次用
    #print(logic_l)
    res=eval("{}".format(logic_l))# 整个 where 条件做布尔运算
    #print(res)
    return res

def limit_action(filter_res,limit_l): #用于处理 查询语句中的limit条件 的函数
    res=[]
    if len(limit_l) !=0: #对结果列表，进行切片，根据 用户输入的 limit 字段
        index=int(limit_l[0])
        res=filter_res[0:index]
    else:
        res=filter_res
    return res

def search_action(limit_res,select_l): #定义search_action 函数，用于处理 select 条件字段的限制
    res=[]
    f_l=[]
    title = "id,name,age,phone,dept,enroll_date"
    #title_l=["id","name","age","phone","dept","enroll_date"]
    if select_l[0] == "*": #判断，当select 条件是“*”，输出是有字段
        res=limit_res
        f_l=["id","name","age","phone","dept","enroll_date"]
    else: #否则遍历查询结果的列表，
        for i in limit_res:
            dic=dict(zip(title.split(","),i))#合成字典
            r_l=[]
            f_l=select_l[0].split(",")#取出select 条件的字段，用于返回，作为对应结果的标题
            for j in f_l:#遍历条件
                r_l.append(dic.get(j).strip())#从临时行字典中取出相应的字段，加入到结果列表中
            res.append(r_l)
    return [f_l,res] #返回限制条件的标题及结果

print('''
    支持SQL 增，删，改，查。语法如下，输入“exit”退出。
    查：select name,age from db1.staff_table where age > 22
　　    select * from db1.staff_table where dept = "IT"
        select * from db1.staff_table where enroll_date like "2013"
        select name,age from db1.staff_table where id > = 1 and id < = 5 or name like 李 limit 4
    增：insert into db1.staff_table values alex,30,18500841678,运维,2007-8-1
    删：delete from db1.staff_table where id = 1/id > = 2 等
    改：update db1.staff_table set dept = "Market" where dept = "IT" 同上条件
''')  #打印主程序的一些，语法说明
while True: #循环
    sql=input("sql>").strip() #输入前后去除空格
    res=[]
    if sql == "exit": #判断用户输入，是否退出
        break
    if len(res)== 0: #判断是否有返回值，如果没有继续循环让用户输入
        continue
    res=sql_action(sql) #调用分发处理函数
    print(res)#输出结果