基于Python的数据库实现

FullHouse

发布日期: 2019-02-20 16:15:41 浏览量: 2105
评分：
star star star star star star star_border star_border star_border star_border
*转载请注明来自write-bug.com

1.需求分析

1.1 概述

从底层做起，实现数据库的组织、存储、检索、更新和索引等功能。

1.2 基本功能

  • 设计特定的数据结构，用于存储数据表、视图、索引三种数据库对象的元数据信息，建立数据库系统的数据字典

  • 设计特定的数据结构，用于存储数据表中的数据

  • 设计特定的数据结构，用于存储索引数据

  • 设计特定的数据结构，分别用于存储用户和访问权限的信息

  • 输入“help database”命令，输出所有数据表、视图和索引的信息，同时显示其对象类型；输入“help table 表名”命令，输出数据表中所有属性的详细信息；输入“help view 视图名”命令，输出视图的定义语句；输入“help index 索引名”命令，输出索引的详细信息

  • 解析CREATE、SELECT、INSERT、DELETE、UPDATE等SQL语句的内容；检查SQL语句中的语法错误和语义错误

  • 执行CREATE语句，创建数据表、视图、索引三种数据库对象；创建数据表时需要包含主码外码、唯一性约束、非空约束等完整性约束的定义

  • 执行SELECT语句，从自主设计的数据表中查询数据，并输出结果；在SELECT语句中需要支持GROUP BY、HAVING和ORDER BY子句，需要支持5种聚集函数

  • 执行INSERT、DELETE和UPDATE语句，更新数据表的内容；更新过程中需要检查更新后的数据表是否会违反参照完整性约束。如果是，则提示违反哪一条完整性约束，并拒绝执行更新操作；如果否，提示数据表更新成功，并说明插入、删除或修改了几个元组

  • 当数据表的内容更新后，根据索引的定义，自动更新索引表的内容

  • 在有索引的数据表上执行查询语句时，首先利用索引找到满足条件的元组指针，然后通过指针到数据表中取出相应的元组

  • 执行GRANT语句，为用户授予对某数据库对象的SELECT、INSERT、DELETE、UPDATE等权限；执行REVOKE语句，收回上述权限

  • 用户登录时，需要输入用户名；如果用户没有被授权，则拒绝执行用户查询或更新等操作，并给出提示信息

  • 将SELECT语句转化为关系代数表达式，再利用查询优化算法对关系代数表达式进行优化，输出优化后的关系代数表达式或SELECT语句

1.3 系统需求

  • 开发语言：Python

  • 开发工具：Pycharm

2.概要设计说明

2.1 数据文件存储

设置system库，table_information库，view库为系统初始化后建立的初始数据库。文件使用excel存储。

2.2 模块功能及描述

2.1.1 run函数模块

run函数模块是整个系统的入口，本模块的主要功能是初始化用户，调用各模块，处理用户输入，实现数据库管理功能。

2.1.2 用户验证及登录模块

本模块功能是进行用户的登录认证。

2.1.3 创建表模块

根据标准 SQL 语言将输入语句进行分割，获得表名，各个属性名，属性类型，约束条件等内容，再进行表的创建。

2.1.4 创建视图模块

本模块通过 CREATE VIEW VIEW_NAME AS SELECT …语句来创建视图，将存储视图和对应的语句。

2.1.5 插入数据模块

将用户输入的数据存入相应的表中并进行约束检查。

2.1.6 更新数据模块

根据用户的 WHERE 条件更新符合条件的元组并进行约束检查。

2.1.7 查询数据模块

根据用户的查询条件进行查询。

2.1.8 删除数据模块

根据用户的 WHERE 条件删除符合条件的元组。

2.1.9 帮助模块

  • HELP DATABASE 可查看当前数据库下的所有的表，视图信息

  • help table 表名可输出数据表中所有属性的详细信息

  • 输入“help view 视图名”命令，输出视图的定义语句

  • 输入“help index 索引名”命令，输出索引的详细信息

2.1.10 授权与权限收回模块

通过grant和revork实现用户对表和视图的 CREATE、DELETE、UPDATE、INSERT 四种操作的权限授予与收回。

2.1.11 索引建立和更新模块

使用create语句建立索引，在内容更新后更新索引。

2.3 模块调用图

3.详细设计说明

3.1 环境依赖

本程序用到的库：

``python
from openpyxl import
import os
import re
from index import
from prettytable import PrettyTable
import hashlib
import bisect
import Queue

  2. ##3.2 数据存储
  4. 数据库的数据使用xlsx格式存储，每一个文件对应一个数据库，工作簿对应库中的表，表结构和文件结构对应。
  6. 索引使用文本存储dict。
  8. 使用openpyxl库进行文件内容的操作。
  10. 数据库示例：
  12. ![](/upload/image/125/a7c8b429ad2b2b6df89ecb2b52a7932d.jpg)
  14. ![](/upload/image/125/0a865f7e5408db187c4150f361de55f9.jpg)
  16. ##3.3 run函数的功能
  18. ​```python
  19. * 程序初始化
  20. * 打印欢迎语句
  21. * 处理用户登录与认证
  22. * 处理帮助命令和退出命令
  24. def run():
  25.     Initialization()
  26.     welcome()
  27.     login()
  28.     while True:
  29.         command = get_command()
  30.         #print command
  31.         if command == 'quit' or command == 'exit':
  32.             print("[🍻] Thanks for using L-DBMS. Bye~~")
  33.             exit(0)
  34.         elif command == 'help':
  35.             help()
  36.         else:
  37.             query(command)

3.3 初始化函数的功能

  1. * 创建数据存储目录
  2. * 创建系统数据库文件
  3. * 创建系统用户
  4. * 赋予系统用户权限
  6. def Initialization():
  7.     if not os.path.exists(db_path):
  8.         os.mkdir(db_path)
  9.     if not os.path.exists("data/table_information.xlsx"):
  10.         Workbook().save("data/table_information.xlsx")
  11.     if os.path.exists("data/system.xlsx"):
  12.         print "Initializating......"
  13.     else:
  14.         creat_db('system')
  15.     db = load_workbook("data/system.xlsx")
  16.     permission_tb_col = ['database char[50] pk unique','select char','insert char','delete char','update char']
  17. creat_table('permission', db, 'system',permission_tb_col)

目录结构

3.4 用户验证及登录模块

登陆处理

通过raw_input()函数获取用户输入的用户名和密码，交给check_login()函数来验证是否正确。如果check通过，输出欢迎界面并将全局变量user赋值。

  1. def login():
  2.     global user
  3.     print "Please Login:"
  4.     username = raw_input("username: ")
  5.     password = raw_input("password: ")
  6.     if check_login(username,password):
  7.         print "Login Success!Welcome {}! 😊".format(username)
  8.         user = username
  9.     else:
  10.         print "user not exist or password is wrong!😣 Try again."
  11.         login()

check_login函数通过输入的username查询数据库中对应的密码，将查询结果和用户输入的值的md5加密值进行比较，如果一致，认为成功登陆。
如果密码不正确或无此用户，都输出error并要求用户再一次输入

  1. def check_login(username,password):
  2.     db = load_workbook("data/system.xlsx")
  3.     #right_pswd = select(password,user,{'username':username})
  4.     table = db['user']
  5.     col_list = list(iter_cols(table))
  6.     try:
  7.         pos = col_list[0].index(username)
  8.     except:
  9.         return False
  10.     right_pswd = col_list[1][pos]
  11.     if hashlib.md5(password).hexdigest() == right_pswd:
  12.         return True
  13.     else:
  14.         return False

登陆效果

3.5 创建表模块

语句

  1. create table tbname (id int PK null,user char[10] )

在创建时将约束写入table_information表中。

  1. def creat_table(table_name,current_database,current_dbname,columns_list):
  2.     # create table
  3.     if table_name not in current_database.sheetnames:
  4.         table = current_database.create_sheet(table_name)
  5.     else:
  6.         print (u"数据表已存在,请重新输入.")
  7.         return
  8.     if current_database.worksheets[0].title == 'Sheet':
  9.         del current_database['Sheet']
  10.     #表创建完成，开始创建列
  11.     length = len(columns_list)
  12.     #print length
  13.     tbinfo = load_workbook("data/table_information.xlsx")
  14.     tbinfo_tb = tbinfo[current_dbname]
  15.     tbinfo_rows = tbinfo_tb.max_row
  16.     column_names = []
  17.     for i in range(length):             #将字段的属性写到table_information库中
  18.         column = columns_list[i].split(' ')
  19.         tbinfo_tb.cell(row=tbinfo_rows+1+i,column=1).value = table_name
  20.         tbinfo_tb.cell(row=tbinfo_rows+1+i, column=2).value = column[0]
  21.         tbinfo_tb.cell(row=tbinfo_rows+1+i, column=3).value = column[1]
  22.         for key in column[2:]:
  23.             if key == 'null':
  24.                 tbinfo_tb.cell(row=tbinfo_rows + 1 + i, column=4).value = '1'
  25.             elif key == 'not_null':
  26.                 tbinfo_tb.cell(row=tbinfo_rows + 1 + i, column=4).value = '0'
  27.             elif key == 'unique':
  28.                 tbinfo_tb.cell(row=tbinfo_rows + 1 + i, column=5).value = '1'
  29.             elif key == 'pk':
  30.                 tbinfo_tb.cell(row=tbinfo_rows + 1 + i, column=6).value = '1'
  31.             elif key == 'fk':
  32.                 tbinfo_tb.cell(row=tbinfo_rows + 1 + i, column=7).value = '1'
  33.         column_names.append(column[0])
  34.         for j in range(1, 8):
  35.             if tbinfo_tb.cell(row=tbinfo_rows + 1 + i, column=j).value is None:
  36.                 tbinfo_tb.cell(row=tbinfo_rows + 1 + i, column=j).value = 'NULL'
  37.     tbinfo.save("data/table_information.xlsx")
  38.     for i in range(length):
  39.         table.cell(row=1,column=i+1).value = column_names[i]  #表第一行是列名
  40.     current_dbname = db_path + current_dbname + '.xlsx'
  41.     current_database.save(current_dbname)
  42. print (u"数据表创建完成。")

table_information表（测试数据）

3.6 创建视图模块

语句

  1. creat view view_name as select xx from xx

解析查询语句，将结果存在view库中，每一个视图已视图名作为表名写入view库中，在view库中设置一个sql表原来存储视图和对应的sql语句。

  1. def view(viewname,sql):
  2.     """
  3.     file = view_path + viewname
  4.     view = query(sql,'view')
  5.     f = open(file, "w")
  6.     f.write(str(view))
  7.     f.close()
  8.     print "Success"
  9.     """
  10.     db = load_workbook("data/view.xlsx")
  11.     if viewname not in db.sheetnames:
  12.         table = db.create_sheet(viewname)
  13.     else:
  14.         print ("view is exist.")
  15.         return
  16.     if db.worksheets[0].title == 'Sheet':
  17.         del db['Sheet']
  18.     sql_table = db['sql']
  19.     maxrow = sql_table.max_row  #在sql表中存view名和对应的sql语句
  20.     sql_table.cell(row=maxrow + 1, column = 1).value = viewname
  21.     sql_table.cell(row=maxrow + 1, column = 2).value = sql
  22.     table = db[viewname]
  23.     views = query(sql, 'view')
  24.     for i in range(len(views)):
  25.         for j in range(len(views[i])):
  26.             table.cell(row=i+1, column=j+1).value = views[i][j]
  27. db.save("data/view.xlsx")

3.7 插入模块

支持单组和多组的插入，单组的插入处理就是将sql语句中的要插入的数据处理成字典，再交给insert函数处理。

多组的话将每组字典加入数组再进行处理。在插入数据前通过check_Constraint函数进行约束检查，注释部分是用来处理嵌套语句的，逻辑是通过正则取出其中的子查询语句，带上tag参数交给query函数处理，将结果以数组形式返回。因为对表的操作也是先转化成数组，这样直接处理数组就ok。

  1. def insert(table_name, current_database, current_dbname, columns_list):
  2.     if not check_Constraint(columns_list,table_name):    #columns应为[dict]
  3.         print "Constraint Error"
  4.         return False
  5.     table = current_database[table_name]
  6.     for columns in columns_list:
  7.         table_rows = table.max_row
  8.         table_columns = table.max_column
  9.         length = len(columns)
  10.         # print length
  11.         for i in range(length):
  12.             column = re.search('\((.*?)\)', columns[i], re.S).group(1)
  13.             column_list = column.split(',')
  14.             chk_len = len(column_list)
  15.             if chk_len != table_columns:
  16.                 print ('插入失败，请检查输入的数据数量是否与列数量对应。')
  17.                 return
  19.             else:
  20.                 for j in range(chk_len):
  21.                     table.cell(row=table_rows + i + 1, column=j + 1).value = column_list[j]
  22.                 current_dbname = db_path + current_dbname + '.xlsx'
  23.                 current_database.save(current_dbname)
  24.                 print ("数据插入完成。")
  27. def check_Constraint(columns,tablename):    #columns={'a':'xx'}
  28.     db = load_workbook("system/table_information.xlsx")
  29.     table = db[using_dbname]
  30.     rows = []
  31.     rows_list = list(iter_rows(table))  #所有行
  32.     cols_list = list(iter_cols(table))
  33.     for col in columns:
  34.         value = columns[col]
  35.         for i in range(len(cols_list[0])):  #table对应的行
  36.             if cols_list[0][i] == tablename:
  37.                 rows.append(i)
  38.         for line in rows:
  39.             if rows_list[line][1] == col:
  40.                 typee, is_null, unique, pk, fk = rows_list[line][2:]
  41.                 if is_null == '0':
  42.                     if value == '':
  43.                         return False
  44.                 if unique == '1':
  45.                     if not check_unique(tablename,col,value):
  46.                         return False
  47.                 if pk == '1':
  48.                     if not check_unique(tablename,col,value) or value == '':
  49.                         return False
  50.                 if '[' in typee:
  51.                     typee, maxlen = re.findall('(\w*)\[(\d*)\]',type) #int[10] => int,10
  52.                 else:
  53.                     maxlen = 1000
  54.                 if len(value) > maxlen:
  55.                     return False
  56.                 if typee == 'int':
  57.                     if type(value) != type(1):
  58.                         return False
  59.                 if typee == 'char':
  60.                     if type(value) != type('c'):
  61.                         return False

3.8 更新数据

支持单组和多组的更新，单组的更新处理就是将sql语句中的要插入的数据处理成字典，再交给insert函数处理。

多组的话将每组字典加入数组再进行处理。在更新数据前通过check_Constraint函数进行约束检查，其他功能和insert的逻辑一样。

语句

  1. UPDATE table_name SET column1=value1,column2=value2,... WHERE some_column=some_value;
  1. def update(table_name,current_database,current_dbname,columns_list,update_columns_list):
  2.     if not check_Constraint(update_columns_list,table_name):    #columns应为dict
  3.         print "Constraint Error"
  4.         return False
  5.     table = current_database[table_name]
  6.     table_rows = table.max_row  # 行
  7.     table_columns = table.max_column  # 列
  8.     length = len(columns_list)
  9.     update_row_num = [x for x in range(2,table_rows+1)]
  10.     columns_name = []
  11.     for cell in list(table.rows)[0]:
  12.         columns_name.append(cell.value)
  13.     for key in columns_list:
  14.         flag = 0
  15.         for i in range(len(columns_name)):  # 判断colmuns_list 是否有 not in colmus中的
  16.             if columns_name[i] == key:
  17.                 flag = 1
  18.         if flag == 0:  # 输入的列名不存在
  19.             print("Unknown column '{}' in 'where clause'".format(key))
  20.             return
  21.     for key in columns_list:
  22.         column_num = columns_name.index(key)
  23.         for i in update_row_num[::-1]:  #倒着来
  24.             if table.cell(row=i, column=column_num+1).value != columns_list[key]:
  25.                 update_row_num.remove(i)
  26.     if len(update_row_num) > 0:
  27.         for i in update_row_num[::-1]:
  28.             for j in range(1,table_columns+1):
  29.                 clu_name = table.cell(row=1, column=j).value
  30.                 table.cell(row=i, column=j).value = update_columns_list[clu_name]
  31.     else:
  32.         print("find 0 to update.")
  33.     current_database.save(db_path + current_dbname + '.xlsx')
  34. print("更新完成，影响{}行".format(len(update_row_num)))

3.9 语句处理函数

  1. * ql语句的处理与解析。
  2. * 通过切词和正则来转化数据和调用各函数。
  3. * 通过split将语句按照空格切成数组，先根据首词判断操作再细分。
  4. * tag参数是为insert，view等函数需要用到查询结果但不输出是的标识，如果带着该参数调用select函数，不会打印结果而是将结果以数组返回。
  5. * select操作的谓词通过predicate和symbol参数来标识，带着这两个参数调用select函数，具体参见select模块
  6. * 如果都没匹配最后会输出错误
  8. def query(sql,tag=''):
  9.     sql_word = sql.split(" ")
  10.     if len(sql_word) < 2:
  11.         print "[!] Wrong query!"
  12.         return
  13.     operate = sql_word[0].lower()
  14.     if operate == 'use':
  15.         if sql_word[1] == 'database':
  16.             try:
  17.                 use_db(sql_word[2])
  18.             except:
  19.                 print "[!]Error"
  20.         else:
  21.             print "[!]Syntax Error.\neg:>use database dbname"
  22.     elif operate == 'create':
  23.         if sql_word[1] == 'database':
  24.             try:
  25.                 creat_db(sql_word[2])
  26.             except:
  27.                 print "[!]Create Error"
  28.         elif sql_word[1] == 'table':
  29.             columns_list = re.findall('\((.*)\)', sql)[0].split(',')
  30.             print columns_list, using_dbname
  31.             try:
  32.                 creat_table(sql_word[2], using_db, using_dbname, columns_list)
  33.             except:
  34.                 print "[!]Error"
  35.         elif sql_word[1] == 'view': #creat view test1 as select * from user
  36.             viewname = sql_word[2]
  37.             sql = ' '.join(sql_word[4:])
  38.             view(viewname,sql)
  40.         elif sql_word[1] == 'index':
  41.             return
  42.         else:
  43.             print "[!]Syntax Error."
  44.     elif operate == 'select':
  45.         pos = 0
  46.         for i in range(len(sql_word)):
  47.             if '(' in sql_word[i] and 'select' in sql_word[i]:
  48.                 pos = i
  49.         if pos == 3:
  50.             sql2 = sql_word[3][1:-1]
  51.             query(sql2,tag='nesting')
  52.             sql_word[3] = 'tmp'
  53.             sql = ' '.join(sql_word)
  57.         columns = sql_word[1]
  58.         table_name = sql_word[3]
  59.         if len(sql_word) > 4:
  60.             #try:
  61.             limit = sql_word[5].split()
  62.             predicate = 'and'
  63.             symbol = '='
  64.             if ',' in sql_word[5]:
  65.                 limit = sql_word[5].split(',')
  66.                 predicate = 'and'
  67.             elif '|' in sql_word[5]:
  68.                 limit = sql_word[5].split('|')
  69.                 predicate = 'or'
  70.             elif '>' in sql_word[5]:
  71.                 #limit = sql_word[5].split()
  72.                 symbol = '>'
  73.             elif '<' in sql_word[5]:
  74.                 #limit = sql_word[5].split()
  75.                 symbol = '<'
  76.             elif len(sql_word) > 6:
  77.                 if sql_word[6] == 'in':
  78.                     limit = [sql_word[5] + '=' + sql_word[7]]
  79.                     predicate = 'in'
  80.                 if sql_word[6] == 'like':
  81.                     limit = [sql_word[5] + '=' + sql_word[7]]
  82.                     predicate = 'like'
  83.             #except:
  84.                 #limit = [].append(sql_word[5])
  85.             #print limit
  86.             for i in range(len(limit)):
  87.                 limit[i] = limit[i].split(symbol)
  88.             limit = dict(limit)
  89.             return select(columns, table_name, limit, predicate=predicate, symbol=symbol, tag=tag)
  90.         else:   #没where的情况
  91.             return select(columns, table_name, tag=tag)
  92.     elif operate == 'grant':
  93.         set_permission(sql_word[5], sql_word[3], sql_word[1])
  94.     elif operate == 'revoke':
  95.         del_permission(sql_word[5], sql_word[3], sql_word[1])
  96.     elif operate == 'insert':   #INSERT INTO table_name col1=val1,col2=val2&col3=val3,col4=val4
  97.         table_name = sql_word[2]
  98.         columns_list = []
  99.         if '&' in sql:
  100.             cols = sql_word[3].split('&')   #[{xx},{xx}] 多组
  101.             for p in range(len(cols)):
  102.                 col = cols[p]
  103.                 c = col.split(',')
  104.                 for i in range(len(c)):
  105.                     c[i] = c[i].split('=')
  106.                 cols[p] = dict(c)
  107.             columns_list = cols
  108.         else:
  109.             cols = sql_word[3].split(',')
  110.             for i in range(len(cols)):
  111.                 cols[i] = cols[i].split('=')
  112.             columns_list.append(dict(cols))
  113.         insert(table_name,using_db,using_dbname,columns_list)
  114.     elif operate == 'update':
  115.         return
  116.     elif operate == 'help':
  117.         if sql_word[1] == 'database':
  118.             show_db()
  119.         if sql_word[1] == 'table':
  120.             usdbnm = using_dbname
  121.             use_db('table_information')
  122.             tbname = sql_word[2]
  123.             select('*',usdbnm,{'table':tbname})
  124.         if sql_word[1] == 'view':
  125.             view_name = sql_word[2]
  126.             use_db('view')
  127.             select('sql','sql',{'viewnamw':view_name})
  128.         if sql_word[1] == 'index':
  129.             print "All Index:"
  130.             indexs = os.listdir('data/index/')  # 第二种方法，从保存数据库信息的库中查询
  131.             for index in indexs:
  132.                 if '.DS' not in index:
  133.                     print "[*] " + index[:-5]
  134.     else:
  135.         print "[!]Syntax Error."

3.10 删除模块

会先check用户权限再进行操作。其他逻辑类似insert函数。

  1. def delect(table_name,current_database,current_dbname,columns_list):  #columns_list={'name1':'value1','name2':'value2'}
  3.     table = current_database[table_name]
  4.     table_rows = table.max_row  #行
  5.     table_columns = table.max_column    #列
  6.     length = len(columns_list)
  7.     delect_row_num = [x for x in range(2,table_rows+1)]
  8.     columns_name=[]
  9.     for cell in list(table.rows)[0]:
  10.         columns_name.append(cell.value)
  11.     for key in columns_list:
  12.         flag = 0
  13.         for i in range(len(columns_name)):    #判断colmuns_list 是否有 not in colmus中的
  14.             if columns_name[i] == key:
  15.                 flag = 1
  16.         if flag == 0:   #输入的列名不存在
  17.             print("Unknown column '{}' in 'where clause'".format(key))
  18.             return
  19.     for key in columns_list:
  20.         column_num = columns_name.index(key)
  21.         for i in delect_row_num[::-1]:  #倒着来
  22.             if table.cell(row=i, column=column_num+1).value != columns_list[key]:
  23.                 delect_row_num.remove(i)
  24.     if len(delect_row_num) > 0:
  25.         for i in delect_row_num[::-1]:
  26.             #print i,table_rows
  27.             table.delete_rows(int(i))
  28.     else:
  29.         print("find 0 to delect.")
  30.     current_database.save(db_path + current_dbname + '.xlsx')
  31. print("删除完成，影响{}行".format(len(delect_row_num)))

3.11 权限检查模块

在用户对某对象进行操作之前确定该用户有没有操作权限。用户对对象的操作权限存储在system库中的permission表，在用户进行相关操作时先去查询该用户有没有该操作的权限。

  1. def check_permission(user,database,action):
  2.     table = load_workbook("data/system.xlsx")['permission']
  3.     db_list = list(iter_cols(table))[0][1:]
  4.     row = db_list.index(database)+2
  5.     action_list = list(iter_rows(table))[0]
  6.     col = action_list.index(action)+1
  7.     allow_user = table.cell(row=row, column=col).value.split(',')
  8.     if user in allow_user:
  9.         return True
  10.     else:
  11.         print "Permission not allowed"
  12.         return False

3.12 权限的赋予和回收模块

使用grant和revoke关键字赋予权限和回收权限，实质是对permision表中数据进行更新。

grant语句

  1. grant select on test_tb for testuser

这里第一列是具有权限的对象，不只是数据库，可以是table,view,index，在函数对应函数处理时将数据库名变量换成其他对象就OK。

  1. def set_permission(user,database,action):
  2.     db = load_workbook("data/system.xlsx")
  3.     table = db['permission']
  4.     db_list = list(iter_cols(table))[0][1:]
  5.     row = db_list.index(database) + 2
  6.     action_list = list(iter_rows(table))[0]
  7.     col = action_list.index(action) + 1
  8.     allow_user = table.cell(row=row, column=col).value.split(',')
  9.     if user in allow_user:
  10.         print "user have this permission"
  11.     else:
  12.         table.cell(row=row, column=col).value = table.cell(row=row, column=col).value + ',' + user
  13.         db.save("data/system.xlsx")

revoke语句

  1. revoke select on test_tb for testuser
  1. def del_permission(user,database,action):
  2.     db = load_workbook("data/system.xlsx")
  3.     table = db['permission']
  4.     db_list = list(iter_cols(table))[0][1:]
  5.     row = db_list.index(database) + 2
  6.     action_list = list(iter_rows(table))[0]
  7.     col = action_list.index(action) + 1
  8.     allow_user = table.cell(row=row, column=col).value.split(',')
  9.     if user in allow_user:
  10.         if allow_user.index(user) == 0:
  11.             table.cell(row=row, column=col).value = table.cell(row=row, column=col).value.replace(user, '')
  12.         else:
  13.             table.cell(row=row, column=col).value = table.cell(row=row, column=col).value.replace(',' + user, '')
  14.         db.save("data/system.xlsx")
  15.     else:
  16.         print "user didn't have this permission"

3.13 约束检查模块

检查主码、外码、唯一性约束、非空约束等完整性约束。

单独的约束检查函数，在进行insert,update等操作时直接调用就OK。

  1. def check_Constraint(columns,tablename):    #columns={'a':'xx'}
  2.     db = load_workbook("system/table_information.xlsx")
  3.     table = db[using_dbname]
  4.     rows = []
  5.     rows_list = list(iter_rows(table))  #所有行
  6.     cols_list = list(iter_cols(table))
  7.     for col in columns:
  8.         value = columns[col]
  9.         for i in range(len(cols_list[0])):  #table对应的行
  10.             if cols_list[0][i] == tablename:
  11.                 rows.append(i)
  12.         for line in rows:
  13.             if rows_list[line][1] == col:
  14.                 typee, is_null, unique, pk, fk = rows_list[line][2:]
  15.                 if is_null == '0':
  16.                     if value == '':
  17.                         return False
  18.                 if unique == '1':
  19.                     if not check_unique(tablename,col,value):
  20.                         return False
  21.                 if pk == '1':
  22.                     if not check_unique(tablename,col,value) or value == '':
  23.                         return False
  24.                 if '[' in typee:
  25.                     typee, maxlen = re.findall('(\w*)\[(\d*)\]',type) #int[10] => int,10
  26.                 else:
  27.                     maxlen = 1000
  28.                 if len(value) > maxlen:
  29.                     return False
  30.                 if typee == 'int':
  31.                     if type(value) != type(1):
  32.                         return False
  33.                 if typee == 'char':
  34.                     if type(value) != type('c'):
  35.                         return False
  37. def check_unique(tablename,column,value):
  38.     table = using_db[tablename]
  39.     col_pos = list(iter_rows(table))[0].index(column)   #第几列
  40.     cols_list = list(iter_cols(table))[col_pos][1:]
  41.     if cols_list.count(value) > 1:  #该列中该值数量
  42.         return False
  43.     else:
  44.         return True

3.14 查询模块

  1. * 支持嵌套查询，and,or,in,like谓词。
  2. * 通过eval函数处理比较运算和数学运算
  3. * 通过select等关键字个数判断子查询，子查询通过tag参数调用query函数获得查询结果数组
  4. * query函数中语句的处理很关键，通过一些参数告诉select函数要返回什么样的值。提前讲语句处理成dict或list讲谓词等转换成符号方便select函数的处理。
  5. * 查询时转换成数组方便操作
  7.     elif operate == 'select':
  8.         pos = 0
  9.         for i in range(len(sql_word)):
  10.             if '(' in sql_word[i] and 'select' in sql_word[i]:
  11.                 pos = i
  12.         if pos == 3:
  13.             sql2 = sql_word[3][1:-1]
  14.             query(sql2,tag='nesting')
  15.             sql_word[3] = 'tmp'
  16.             sql = ' '.join(sql_word)
  17.         columns = sql_word[1]
  18.         table_name = sql_word[3]
  19.         if len(sql_word) > 4:
  20.             #try:
  21.             limit = sql_word[5].split()
  22.             predicate = 'and'
  23.             symbol = '='
  24.             if ',' in sql_word[5]:
  25.                 limit = sql_word[5].split(',')
  26.                 predicate = 'and'
  27.             elif '|' in sql_word[5]:
  28.                 limit = sql_word[5].split('|')
  29.                 predicate = 'or'
  30.             elif '>' in sql_word[5]:
  31.                 #limit = sql_word[5].split()
  32.                 symbol = '>'
  33.             elif '<' in sql_word[5]:
  34.                 #limit = sql_word[5].split()
  35.                 symbol = '<'
  36.             elif len(sql_word) > 6:
  37.                 if sql_word[6] == 'in':
  38.                     limit = [sql_word[5] + '=' + sql_word[7]]
  39.                     predicate = 'in'
  40.                 if sql_word[6] == 'like':
  41.                     limit = [sql_word[5] + '=' + sql_word[7]]
  42.                     predicate = 'like'
  43.             #except:
  44.                 #limit = [].append(sql_word[5])
  45.             #print limit
  46.             for i in range(len(limit)):
  47.                 limit[i] = limit[i].split(symbol)
  48.             limit = dict(limit)
  49.             return select(columns, table_name, limit, predicate=predicate, symbol=symbol, tag=tag)
  50.         else:   #没where的情况
  51.             return select(columns, table_name, tag=tag)

select函数，不仅仅提供查询的功能，还用来处理view的一部分数据,通过tag参数来标识数据如何处理。

查询函数

  1. def select(columns,table_name,limit={},predicate='and', symbol='=', tag=''):    #{'c':'x','d':'x'}
  2.     if using_dbname == '':
  3.         print "please choose databse!"
  4.         return
  5.     table = using_db[table_name]
  6.     #print columns
  7.     if columns == '*' and len(limit) == 0:
  8.         columns_name = list(iter_rows(table))[0]
  9.         table_print = PrettyTable(columns_name)
  10.         for i in range(1,len(list(iter_rows(table)))):
  11.             table_print.add_row(list(iter_rows(table))[i])
  12.         table_print.reversesort = True
  13.         if tag == 'view':
  14.             print table_print
  15.             return list(iter_rows(table))   #view
  17.         else:
  18.             print(table_print)
  19.     else:
  20.         sel_cols = columns.split(',')   #*的情况
  21.         rows_list = list(iter_rows(table))  #所有的行
  22.         cols = rows_list[0]
  23.         col_pos = []
  24.         limit_pos = []
  25.         print_row = []
  26.         limit_cols = list(limit)
  27.         symbol = '==' if symbol == '=' else symbol
  28.         if columns[0] != '*':
  29.             for i in range(len(sel_cols)):
  30.                 col_pos.append(cols.index(sel_cols[i])) #要查的列的列号
  31.         else:
  32.             sel_cols = list(iter_rows(table))[0]
  33.             col_pos = range(len(cols))
  34.         for i in range(len(limit)):
  35.             limit_pos.append(cols.index(limit_cols[i])) #where的列
  36.         for i in range(1, len(rows_list)):
  37.             match = 0
  38.             if predicate == 'in':
  39.                 match_list = limit[limit_cols[0]]
  40.                 for j in len(match_list):
  41.                     if rows_list[i][limit_pos[0]] == match_list[j]:
  42.                         print_row.append(i)
  43.             if predicate == 'like':
  44.                 like_word = re.findall('(.*)\%',limit[limit_cols[0]])
  45.                 if like_word in rows_list[i][limit_pos[0]]:
  46.                     print_row.append(i)
  47.             else:
  48.                 for j in range(len(limit_pos)): #通过eval实现比较运算
  49.                     if eval("'" + rows_list[i][limit_pos[j]] + "'" + symbol + "'" + limit[limit_cols[j]] + "'"):
  50.                         match += 1
  51.                 if predicate == None:
  52.                     print_row.append(i)
  53.                 if predicate == 'and' and match == len(limit_pos):  #and时要全部匹配
  54.                     print_row.append(i)     #符合条件的行号
  55.                 if predicate == 'or' and match > 0: #or时至少一个匹配
  56.                     print_row.append(i)
  58.         table_print = PrettyTable(sel_cols)
  59.         for i in range(len(print_row)):
  60.             add_rows = []
  61.             for x in col_pos:
  62.                 add_rows.append(rows_list[print_row[i]][x])
  63.             table_print.add_row(add_rows)
  64.         table_print.reversesort = True
  65.         if tag == 'view':
  66.             return table_print
  67.         elif tag == 'nesting':
  68.             tmpdb = using_db
  69.             table = tmpdb['tmp']
  70.             for i in range(len(sel_cols)):
  71.                 table.cell(row=0,column=i+1).value = sel_cols[i]
  72.             for i in range(len(print_row)):
  73.                 add_rows = []
  74.                 for x in col_pos:
  75.                     add_rows.append(rows_list[print_row[i]][x])
  76.                 for j in range(len(add_rows)):
  77.                     table.cell(row=i+2,column=j+1).value = add_rows[j]
  78.             tmpdb.save("data/" + using_dbname + ".xlsx")
  80.         else:
  81.             #table_print.reversesort = True
  82.             print(table_print)

3.15 索引模块

B+树的索引，将数据先处理成数组，每一组数据包含数据值和数据在表中的位置（起到指针的作用）。B+树的处理单独写了一个类，方便调用处理。

  1. def index(current_database,table_name,column_name):
  2.     table = current_database[table_name]
  3.     table_columns = table.max_column
  4.     table_rows = table.max_row
  5.     column_num = 0
  6.     column_value = []
  7.     column_position = []
  8.     for i in range(1,table_columns+1):
  9.         if table.cell(row=1,column=i).value == column_name:
  10.             column_num = i
  11.     if column_num == 0:
  12.         print "no this column"
  13.         return
  14.     else:
  15.         for i in range(2,table_rows+1):
  16.             column_value.append(str(table.cell(row=i,column=column_num).value))
  17.             column_position.append('<{},{}>'.format(i,column_num))
  18.     column_value.sort()
  19.     for i in range(len(column_value)):
  20.         tmp = [column_value[i],column_position[i]]   #like [1,aaa|<2,1>]
  21.         column_value[i] = tuple(tmp)    #like [(1,aaa|<2,1>)]
  22.     #print column_value[0]
  23.     bt = test_BPTree(column_value)
  24.     indexname = table_name + '|' +column_name
  25.     save_index(str(bt), indexname)
  27. def save_index(bt,indexname):
  28.     line = re.findall(r'\[.*?\]', bt)
  29.     for i in range(len(line)):
  30.         line[i] = line[i][2:-2].replace('|', '')
  31.     file = open('data/index/' + indexname,'w')
  32.     for i in range(len(line)):
  33.         file.writelines(line[i] + '\n')
  34. file.close()

索引的存储，存储生成的b+树，每一行是B+树的一层。存储数据类型是字典。

  1. def select_index(a)
  2.     Pos = BPTree_search(a)
  4. def update_index(table_name, column_name)
  5.     index(using_db, table_name, column_name)

B+树的部分代码

  1. class BPTree(object):
  2. …
  3.     def search(self, node, key):
  4.         i = bisect.bisect_left(node.keys, key)
  5.         if i < len(node.keys) and key == node.keys[i]:
  6.             if node.is_leaf():
  7.                 return (node, i)
  8.             else:
  9.                 return self.search(node.children[i + 1], key)
  10.         if node.is_leaf():
  11.             return (None, None)
  12.         else:
  13.             # self.disk_read(node.children[i])
  14.             return self.search(node.children[i], key)
  16. …
  17.     def insert(self, key, value):
  18.         if len(self.root.keys) == self._maxkeys:
  19.             oldroot = self.root
  20.             self.root = BPNode()
  21.             self.root.children.append(oldroot)
  22.             self.split_child(self.root, 0, oldroot)
  23.             self.insert_nonfull(self.root, key, value)
  24.         else:
  25.             self.insert_nonfull(self.root, key, value)
  26. …
  27. def levels(self):
  28.         leveldict = {}
  30.         for level, node in self.bft(self.root):
  31.             leveldict.setdefault(level, []).append(node)
  33.         return leveldict
  35.     def pprint(self, width=80):
  36.         leveldict = self.levels()
  37.         keys = leveldict.keys()
  38.         for k in keys:
  39.             print ' '.join(str(e) for e in leveldict[k]).center(width)
  40.         return leveldict
  42.     def min(self):
  43.         node = self.root
  44.         while node.children:
  45.             node = node.children[0]
  46.         return node.keys[0]
  48.     def max(self):
  49.         node = self.root
  50.         while node.children:
  51.             node = node.children[-1]
  52.         return node.keys[-1]
  54.     def bft(self, node, level=1):
  55.         """Breadth first traversal."""
  56.         q = Queue.Queue()
  57.         level = level
  58.         q.put((level, node))
  60.         while not q.empty():
  61.             level, node = q.get()
  62.             yield (level, node)
  63.             for e in node.children:
  64.                 q.put((level + 1, e))
  65. …
  66.     def ceiling(self, node, key):
  67.         i = bisect.bisect(node.keys, key)
  68.         if i < len(node.keys) and key == node.keys[i]:
  69.             if node.is_leaf():
  70.                 return key
  71.             else:
  72.                 return self.ceiling(node.children[i + 1], key)
  73.         if node.is_leaf():
  74.             if i == len(node.keys):
  75.                 kp = node.keys[-1]
  76.                 if node.keys[-1] < key:
  77.                     if len(node.next.keys) > 0:
  78.                         return node.next.keys[0]
  79.                 else:
  80.                     return kp
  81.             return node.keys[i]
  82.         else:
  83.             return self.ceiling(node.children[i], key)
  85.     def split_child(self, x, i, y):
  86.         z = BPNode()
  87.         z.keys = y.keys[self.degree:]
  88.         z.values = y.values[self.degree:]
  89.         if not y.is_leaf():
  90.             z.children = y.children[self.degree:]
  91.             y.next = None
  92.         else:
  93.             z.keys.insert(0, y.keys[self.degree - 1])
  94.             z.values.insert(0, y.values[self.degree - 1])
  95.             z.next = y.next
  96.             y.next = z
  97.         x.children.insert(i + 1, z)
  98.         x.keys.insert(i, y.keys[self.degree - 1])
  99.         # x.values.insert(i, y.values[self.degree-1])
  100.         y.keys = y.keys[:self.degree - 1]
  101.         y.values = y.values[:self.degree - 1]
  102.         y.children = y.children[:self.degree]

3.16 help xxx模块

输入“help database”命令，输出所有数据表、视图和索引的信息，同时显示其对象类型；输入“help table 表名”命令，输出数据表中所有属性的详细信息；

输入“help view 视图名”命令，输出视图的定义语句；

输入“help index 索引名”命令，输出索引的详细信息；

  1. elif operate == 'help':
  2.         if sql_word[1] == 'database':
  3.             show_db()
  4.         if sql_word[1] == 'table':
  5.             usdbnm = using_dbname
  6.             use_db('table_information')
  7.             tbname = sql_word[2]
  8.             select('*',usdbnm,{'table':tbname})
  9.         if sql_word[1] == 'view':
  10.             view_name = sql_word[2]
  11.             use_db('view')
  12.             select('sql','sql',{'viewnamw':view_name})
  13.         if sql_word[1] == 'index':
  14.             print "All Index:"
  15.             indexs = os.listdir('data/index/')  # 第二种方法，从保存数据库信息的库中查询
  16.             for index in indexs:
  17.                 if '.DS' not in index:
  18.                     print "[*] " + index[:-5]

3.17 数据库选择和创建模块

定义来一些全局变量：

  1. using_dbname = ''
  2. using_db = Workbook()
  3. db_path = 'data/'
  4. #view_path = 'view/'
  5. user = ''
  1. def use_db(dbname):
  2.     global using_dbname
  3.     global using_db
  4.     if check_permission(user, dbname, 'use'):
  5.         using_dbname = dbname
  6.         using_db = load_workbook(db_path+dbname+'.xlsx')
  7.         print("Database changed.")
  9. def creat_db(dbname):
  10.     dbpath = 'data/' + dbname + '.xlsx'
  11.     database = Workbook()
  12.     database.save(dbpath)
  13.     create_tb_in_tbinfo(dbname)
  14. print(u"数据库创建操作执行成功")

4.用户使用说明

运行程序

  1. > python L-DBMS.py

进入用户登陆界面，输入用户名和密码登录

选择数据库

查询

Help xxx

Exit or quit退出

5.课程设计感想

对sql语句的处理可以说是最麻烦的一部分了，在处理sql语句方面感觉做的还不够优雅，而且功能没做完善。在写代码过程中也是随着遇到的问题学习到了许多。而且认识到了再开始要规划好代码逻辑和数据结构，不然写到一半再改很麻烦。

功能并不完善，奈何时间有限，回去看自己的代码感觉并不优美，一些功能的实现方式甚至用很麻烦的方法解决，还需要努力啊。

上传的附件 cloud_download 基于Python的数据库实现.7z ( 3.08mb, 29次下载 )
error_outline 下载需要12点积分

keyboard_arrow_left上一篇 : 基于ssm框架和mysql的网上选课系统 基于JSP和MYSQL数据库实现的请假管理系统 : 下一篇keyboard_arrow_right

comment 5
FullHouse
2019-02-20 16:15:21
基于Python的数据库实现
mode_comment 评论(0)
Groot_222
2020-12-03 17:20:47
老兄，你的排版在第三部分的时候有问题，有空可以改一改
mode_comment 评论(0)
j1911524845
2020-12-03 20:38:06
你确定你这个可以实现么，全是错，写的啥啊
mode_comment 评论(0)
j1911524845
2020-12-04 20:36:54
你确定你这个可以实现么，全是错，写的啥啊
mode_comment 评论(0)

FullHouse

发送私信

人生百年，转眼成空。幸福靠的不是缘分，而是珍惜

7
文章数
8
评论数
最近文章
highlight comment

Copyright @2020-WRITE-BUG.COM 技术支持 - YCY科技 - 备案/许可证编号：京ICP备16025663号-5

eject