模拟sql实现对员工列表的增删改查

现需要对这个员工信息文件，实现增删改查操作
#
# 可进行模糊查询，语法至少支持下面3种:
# 　　
# 　　select  * from staff_table where dept = "IT"
#       select  * from staff_table where enroll_date like "2013"
# 查到的信息，打印后，最后面还要显示查到的条数
# 可创建新员工纪录，以phone做唯一键，staff_id需自增
# 可删除指定员工信息纪录，输入员工id，即可删除
# 可修改员工信息，语法如下:
# 　　UPDATE staff_table SET dept="Market" WHERE where dept = "IT"

思维导图






流程分析

第一部分：SQL解析

• 1.接收用户SQL
  • 判断用户输入是否为SQL
• 2.SQL解析主函数sql_parsing
  • 分发SQL给对应语句的函数来做解析
    • increase_parsing
    • deleting_parsing
    • reform_parsing
    • check_parsing
  • 解析后交给handle_parsing，来控制返回
  • 解析SQL语句中的多条件
    • where_parsing
    • three_parsing
  • 返回解析后的SQL

第二部分：SQL执行

• 1.接收解析后的SQL

• 2.SQL执行主函数sql_perform

  • 分发SQL给对应函数来执行
    • insert
    • delete
    • update
    • select
  • 执行SQL语句时的多条件
    • where_action
    • logic_action
    • limit_action
    • search_action
  • 返回执行SQL的结果。
  • 代码

import os
#第一部分sql解析
def sql_parsing(sql):
    '''
    把sql字符串切分提取命令信息，分发给函数去解析
    :param sql:
    :return:
    '''
    # sql命令操作 解析函数的字典  根据用户的命令来找相对应的函数
    parsing_func={
        'insert':increase_parsing, #增
        'delete':deleting_parsing, #删
        'update':reform_parsing,      #改
        'select':check_parsing,       #查

    }
    print('sql str is %s' %sql)   #打印用户输入的sql
    sql_l=sql.split(' ')            #按空格切分 赋值给列表
    func=sql_l[0]                   #取出用户的sql命名
    res=''
    if func in parsing_func:          #判断用户的命令 是否在pares_func里，不再返回空
        res=parsing_func[func](sql_l)  #把切分后的用户列表传人sql对应的函数里
        res=parsing_func[func](sql_l)  #把切分后的用户列表传人sql对应的函数里
    return res

def increase_parsing(sql_l):
    '''
    增加功能
    :param sql:
    :return:
    '''
    sql_dic={
        'func':insert,
        'delete': [],  # delete选项,留出扩展
        'into': [],  # 表名
        'values': [],  # filter条件

    }
    return handle_parsing(sql_l,sql_dic)



def reform_parsing(sql_l):
    '''
    修改功能
    :param sql:
    :return:
    '''
    sql_dic={
        'func':update,
        'update': [],  # delete选项,留出扩展
        'set': [],  # 表名
        'where': [],  # filter条件

    }
    return handle_parsing(sql_l,sql_dic)



def deleting_parsing(sql_l):
    '''
    删除功能
    :param sql:
    :return:
    '''
    sql_dic={
        'func':delete,
        'delete': [],  # delete选项,留出扩展
        'from': [],  # 表名
        'where': [],  # filter条件

    }
    return handle_parsing(sql_l,sql_dic)


def  check_parsing(sql_l):
    '''

    :param sql:
    :return:
    '''
    sql_dic={
        'func':select,
        'select': [], # 查询字段
        'from': [],   # 数据库.表
        'where': [],  # 条件
        'limit': [],  # 条件，限制

}

    return handle_parsing(sql_l,sql_dic)

def handle_parsing(sql_l,sql_dic): #解析sql
    '''
    执行sql解析操作，返回sql_dic
    :param sql_l:
    :param sql_dic:
    :return:
    '''

    tag=False                                #设置警报
    for item in sql_l:                        #for循环体   控制用户的sql列表
        if tag and item in sql_dic:           #if判断警报是否是真，并且用户sql的条件 在条件select语句字典里面，则关闭警报
            tag=False                         # tag为假，关闭警报
        if not tag and item in sql_dic:      #判断警报没有拉响 并且用户sql的条件 在条件select语句字典里面
            tag=True                          #警报拉响
            key=item                           #
            continue
        if tag:
            sql_dic[key].append(item)       #for循环体取出的值做判断，成立把值添加到条件对应的字典里
    if sql_dic.get('where'):
        sql_dic['where']=where_parsing(sql_dic.get('where')) #调用where_parse函数 把整理好的用户sql的where语句 覆盖之前没整理好的

    return sql_dic      #返回解析结果到字典里

def where_parsing(where_l):
    '''
    :param where_l:
    :return:
    '''
    res=[]  #定义空列表 返回return的值放进列表里
    key=['and','or','not']  #
    char=''             #拼接好的字符串
    for i in where_l:   #循环体
        if len(i) ==0:continue #判断长度如果是0跳出本次循环
        if i in key:            #判断i的值里是不是有kuy
            if len(char) !=0: #char的长度必须是大于0
                char=three_parsing(char)
                res.append(char)
                res.append(i)
                char=''
        else:char+=i

    else:
        char=three_parsing(char)
        res.append(char)
    return res

def three_parsing(exp_str):
    '''
    将每一个小的过滤条件如,name>=1转换成['name','>=','1']
    :param exp_str:
    :return:
    '''
    key=['>','<','=']
    res=[]
    char=''
    opt=''
    tag=False
    for i in exp_str:
        if i in key:
            tag=True
            if len(char)!=0:
                res.append(char)
                char=''
            opt+=i
        if not tag:
            char+=i
        if tag and i not in key:
            tag=False
            res.append(opt)
            opt=''
            char+=i
    else:
        res.append(char)
    if len(res) ==1:
        res=res[0].split('like')
        res.insert(1,'like')

    return res    #返回res列表结果






# siq执行
def sql_perform(sql_dic):
    '''
    :param sql:
    :return:
    '''
    return sql_dic.get('func')(sql_dic)

def insert(sql):
    '''

    :param sql:
    :return:
    '''
    print('insert %s' %sql_dic)
    db,table=sql_dic.get('into')[0].split('.')
    with open('%s/%s' %(db,table),'ab+') as fh:
        offs=-100
        while True:
            fh.seek(offs,2)
            lines=fh.readlines()
            if len(lines)>1:
                last=lines[-1]
                break

            offs *=2
        last=last.decode(encoding='utf-8')
        last_id=int(last.split(',')[0])
        new_id=last_id+1
        record=sql_dic.get('values')[0].split(',')
        record.insert(0, str(new_id))
        record_str = ','.join(record) + '
'
        fh.write(bytes(record_str, encoding='utf-8'))  # 把添加 id后的用户想添加的sql  用bytes写入文件
        fh.flush()
    return [['insert successful']]

def update(sql_dic):
    #update db1.emp set id='sb' where name like alex
    db,table=sql_dic.get('update')[0].split('.')
    set=sql_dic.get('set')[0].split(',')
    set_l=[]
    for i in set:
        set_l.append(i.split('='))
    bak_file=table+'_bak'
    with open("%s/%s" %(db,table),'r',encoding='utf-8') as r_file,
            open('%s/%s' %(db,bak_file),'w',encoding='utf-8') as w_file:
        update_count=0
        for line in r_file:
            title="id,name,age,phone,dept,enroll_date"
            dic=dict(zip(title.split(','),line.split(',')))
            filter_res=logic_action(dic,sql_dic.get('where'))
            if filter_res:
                for i in set_l:
                    k=i[0]
                    v=i[-1].strip("'")
                    print('k v %s %s' %(k,v))
                    dic[k]=v
                print('change dic is %s ' %dic)
                line=[]
                for i in title.split(','):
                    line.append(dic[i])
                update_count+=1
                line=','.join(line)
            w_file.write(line)

        w_file.flush()
    os.remove("%s/%s" % (db, table))
    os.rename("%s/%s" %(db,bak_file),"%s/%s" %(db,table))
    return [[update_count],['update successful']]

def delete(sql):
    db,table=sql_dic.get('from')[0].split('.')
    bak_file=table+'_bak'
    with open("%s/%s" %(db,table),'r',encoding='utf-8') as r_file,
            open('%s/%s' %(db,bak_file),'w',encoding='utf-8') as w_file:
        del_count=0
        for line in r_file:
            title="id,name,age,phone,dept,enroll_date"
            dic=dict(zip(title.split(','),line.split(',')))
            filter_res=logic_action(dic,sql_dic.get('where'))
            if not filter_res:
                w_file.write(line)
            else:
                del_count+=1
        w_file.flush()
    os.remove("%s/%s" % (db, table))
    os.rename("%s/%s" %(db,bak_file),"%s/%s" %(db,table))
    return [[del_count],['delete successful']]

def select(sql_dic):
    '''
    :param sql_dic:
    :return:
    '''
    db,table=sql_dic.get('from')[0].split('.')  # 切分出库名和表名，就是文件路径
    fh=open("%s/%s" % (db,table),'r', encoding='utf-8')  # 打开文件 根据取到的路径
    filter_res=where_action(fh,sql_dic.get('where'))
    fh.close()
    limit_res=limit_action(filter_res,sql_dic.get('limit')) #定义limit执行函数,限制行数
    # for record in limit_res:  # 循环打印 显示用户sql limit的执行结果
    #     print('limit res is %s' %record)

    #lase:select
    search_res=search_action(limit_res,sql_dic.get('select'))  #定义select执行函数
    # for record in search_res:  # 循环打印 显示用户sql select的执行结果
    #     print('select res is %s' %record)

    return search_res



def logic_action(dic, where_l):
        '''
        用户sql select的where多条件 执行对比文件内容
        文件内容 跟所有的 where_l 的条件比较
        :param dic:
        :param where_l:
        :return:
        '''
        # print('from logic_action %s' %dic)  #from logic_action {'id': '23', 'name': '翟超群', 'age': '24', 'phone': '13120378203', 'dept': '运维', 'enroll_data': '2013-3-1
'}
        # print('---- %s' %where_l)  #[['name', 'like', '李'], 'or', ['id', '<=', '4']]
        res = []  # 存放 bool值 结果的空列表
        # where_l=[['name', 'like', '李'], 'or', ['id', '<=', '4']]
        for exp in where_l:  # 循环where条件列表，跟dic做比较
            # dic与exp做bool运算
            if type(exp) is list:  # 只留下 where_l列表里 相关的条件
                # 如果是列表 做bool运算  #[['name', 'like', '李']
                exp_k, opt, exp_v = exp  # 匹配 一个where条件列表的格式
                if exp[1] == '=':  # 如果 列表的运算符是 =号
                    opt = "%s=" % exp[1]  # 用字符串拼接出 两个 ==号
                if dic[exp_k].isdigit():  # 判断是否数字  用户的条件是否对应文件内容(字典)
                    dic_v = int(dic[exp_k])  # 文件内容的数字 转成整形 做比较
                    exp_v = int(exp_v)  # where_l列表的数字 转成整形 做比较
                else:
                    dic_v = "'%s'" % dic[exp_k]  # 不是数字的时候 存取出来
                if opt != 'like':  # 如果运算符 不是 like
                    exp = str(eval("%s%s%s" % (dic_v, opt, exp_v)))  # 转成字符串(逻辑判断后是bool值)：做逻辑判断：文件数字，运算符，用户数字
                else:  # 如果 运算符位置是 like
                    if exp_v in dic_v:  # 判断 sql里like的值 是否在 文件内容里
                        exp = 'True'
                    else:
                        exp = 'False'
            res.append(exp)  # ['True','or','False','or','true']

        # print('---------- %s' %res)
        res = eval(" ".join(res))  # 把bool值列表转成字符串 然后再做逻辑判断  结果是bool值
        return res  # 返回 res结果

def limit_action(filter_res,limit_l): #执行limit条件 限制行数
    res=[]  #最后的返回值列表
    if len(limit_l) != 0:  #判断 用户sql 是否有 limit条件
        index=int(limit_l[0])   #取出 用户sql limit条件的数字
        res=filter_res[0:index]
    else:  #如果 用户sql 没有 limit条件 就整个返回
        res=filter_res
    return res  #返回最后的sql结果

def search_action(limit_res,select_l):  #执行select执行函数
    res=[]   #最后的返回值列表
    fileds_l = []
    title = "id,name,age,phone,dept,enroll_data"   #title = select的条件
    if select_l[0] == '*' :   #判断 如果 用户sql 的select 条件是 *
        fields_l=title.split(',')   #用户sql 的select 条件是 * ,则匹配所有条件
        res=limit_res   #如果 用户sql 的select 条件是 * 则返回全部
    else:   #判断 如果用户sql的select条件不是 * ，提取用户的select语句条件
        for record in limit_res:   #循环 匹配好的where语句和limit语句的结果
            dic=dict(zip(title.split(','),record))   #每条记录都对应 select条件，生成字典
            r_l=[]   #存放用户sql的select条件
            fields_l=select_l[0].split(',')  #取出用户sql 的select条件
            for i in fields_l:   #循环用户sql的select条件，区分多条件，id,name
                r_l.append(dic[i].strip())  #把用户sql的select多条件 加入 r_l列表
            res.append(r_l)   #把r_l列表 加入res

    return (fields_l,res)  #返回用户sql的select条件，selcet执行结果

def where_action(fh,where_l):  #执行where条件语句  where_l=where的多条件解析后的列表
    #id,name,age,phone,dept,enroll_data
    #10,吴东杭,21,17710890829,运维,1995-08-29
    #['id>7', 'and', 'id<10', 'or', 'namelike']

    # print('in where_action 33[41;1m%s33[0m' %where_l)
    res=[]  #定义最后返回值的列表
    logic_l=['and','or','not']   #定义逻辑运算符
    title="id,name,age,phone,dept,enroll_data"  #定义好表文件内容的标题
    if len(where_l) != 0:  #判断用户sql 是否有where语句
        for line in fh:  #循环 表文件
            dic=dict(zip(title.split(','),line.split(','))) #一条记录 让标题和文件内容一一对应
            #逻辑判断
            logic_res=logic_action(dic,where_l) #让 logic_action函数来操作对比
            if logic_res:  #如果逻辑判断为True
                res.append(line.split(','))  #加入res
    else:
        res=fh.readlines()  #用户sql 没有where语句，则返回表文件所有内容

    # print('>>>>>>>> %s' %res)
    return res #返回执行 where 后的结果


if __name__=='__main__':        #主函数
    while True:
        sql=input("sql>:").strip()  #用户输入sql 命令
        if sql =='exit':         #exit退出登录
            break
        if len(sql)==0:           #用户输入为空字符继续输入
            continue

        sql_dic=sql_parsing(sql)   #用户输入sql转成机构化字典
        if len(sql_dic) == 0:continue  #
        res=sql_perform(sql_dic)   #执行结果赋值给src
        print('33[43;1m%s33[0m' % res[0])
        for i in res[-1]:
            print(i)

'''
测试执行 select语句
select * from db.emp
select * from db.emp limit 2
select * from db.emp where name like 李 or id <= 9 or id = 24 limit 9
select id,name from db.emp where name like 李 or id <= 9 or id = 24 limit 9

测试执行 insert语句
insert into db.emp values gyf,30,18500841678,运维,2007-8-1

测试执行 delete语句
delete from db.emp where id>47

测试执行 update语句
update db.emp set gyf='haha' where id=47
'''