TP框架中 数据库的增删改查
| 123456789 | /* 数据库设置 */ ‘DB_TYPE‘ => ‘‘, // 数据库类型 ‘DB_HOST‘ => ‘‘, // 服务器地址 ‘DB_NAME‘ => ‘‘, // 数据库名 ‘DB_USER‘ => ‘‘, // 用户名 ‘DB_PWD‘ => ‘‘, // 密码 ‘DB_PORT‘ => ‘‘, // 端口 ‘DB_PREFIX‘ => ‘‘, // 数据库表前缀 ‘DB_FIELDS_CACHE‘ => true, // 启用字段缓存(开发时这个要写成false) |
下面是我的数据库连接内容
| 1234567891011121314 | <?php return array( //‘配置项‘=>‘配置值‘ /* 数据库设置 */ ‘DB_TYPE‘ => ‘mysql‘, // 数据库类型 ‘DB_HOST‘ => ‘localhost‘, // 服务器地址 ‘DB_NAME‘ => ‘306‘, // 数据库名 ‘DB_USER‘ => ‘root‘, // 用户名 ‘DB_PWD‘ => ‘‘, // 密码 ‘DB_PORT‘ => ‘3306‘, // 端口 ‘DB_PREFIX‘ => ‘‘, // 数据库表前缀 ‘DB_FIELDS_CACHE‘ => false, // 启用字段缓存(开发时这个要是false)); |
连接成功后，然后就是新建模型文件了
二、新建模型文件（具体内容看ThinkPhp框架知识）
（1）找到模块文件夹中的Model文件夹，然后在这个文件夹新建模型文件
a) model本身就是一个类文件
b) 数据库中的每个数据表都对应一个model模型文件
c) 最简单的数据model模型类
自己的模型文件
| 1234567 | <?phpnamespace HomeModel; //命名空间的写法use ThinkModel; //使用模型class InfoModel extends Model{ } |
（2）看下这个数据模型
我们可以再控制器文件夹中进行编写控制文件，这里有了一个控制文件，我就用这个了
打开控制文件，然后写个方法，这里叫做ceshi()
| 123456 | public function ceshi(){ $info = new HomeModelInfoModel(); //造新对象，这里是Info模型 var_dump($info); //输出一下，看下结果 } |
输出看一下结果，注意这里地址栏的写法(在框架知识中已经介绍过了4中访问方式了)：
这是我的路径： 
下面是对应的模型数据：
三、对数据库进行各种查询可以利用这个控制文件中的方法，就直接在这个方法中写了
| 123456 | public function ceshi(){ $info = new HomeModelInfoModel(); //造新对象，这里是Info模型 //下面是数据库操作 } |
（1）查询表中的所有数据（方法：select()）
返回的二维数组（关联的）返回的数据其中的字段名称是小写，这样做数据库时尽量是小写的
例如：
$arr = $info->select();var_dump($arr);输出一下是不是查询的数据库中所有内容。
（2）查询一条数据（方法：find()）
例如：
$arr = $info->find("p002");<br data-filtered="filtered">
var_dump($arr)
select()方法也是可以查询一条或是多条数据，如
$arr = $info->select("p001,p002");var_dump($arr); |
这是查询的：代号是"p001"和"p002"的信息。
（3）条件查询数据（方法：where()）
$arr = $info->where("code=‘p003‘")->select();<br data-filtered="filtered">var_dump($arr); |
（4）切换数据表（方法：table()）只切换一次，第二次就变回来了
例如：
| 1 | $arr = $info->table("nation")->select();<br data-filtered="filtered">var_dump($arr); |
这是切换了一张名为 nation 的表：
（5）选择操作的字段（方法：field()）
例如：
| 1 | $arr = $info->field("name,sex,birthday")->select();<br data-filtered="filtered">var_dump($arr); |
查询字段是：姓名、性别和生日的字段
（6）对数据进行排序（方法：order()）
例如：
| 12 | $arr = $info->order("code desc")->select();var_dump($arr); |
这是对code列进行降序排列，一般是能比较的列用来升降序
（7）分页查询数据（方法：limit()和page()）
例如：limit()
| 12 | $arr = $info->limit("2,2")->select();var_dump($arr); |
这是显示的第2页的内容：limit（） 括号里一个数代表取几条，两个数（m，n）代表跳过m条取n条
例如：page()
| 12 | $arr = $info->page("2,2")->select();var_dump($arr); |
这个也是显示的第2页的内容：page（m，n ）代表取第m页的n条
注意：
limit()和page()的不同之处，
（8）对数据进行分组（方法：table()）
例如：
| 12 | $arr = $info->table("car")->field("max(price)")->group("brand")->select();var_dump($arr); |
这是查询的car表中的最大价格，并且根据brand的字段进行分组
例如：
| 12 | $arr = $info->table("car")->field("max(price)")->group("brand")->having("max(price)>60")->select();var_dump($arr); |
这是上面的那个查询，但是加了一个条件就是价格大于60的
（9）链接查询数据库（方法：join()）
例如：
| 12 | $arr = $info->field("info.code as ‘代号‘, info.name as ‘姓名‘,nation.name as ‘民族‘")->join("nation on info.nation=nation.code")->select();var_dump($arr); |
这是链接查询的两张表（汉语的地方最后用字符，因为后面要用到他的值）两张表如果有相同的列名会后面的覆盖前面的，所以用field改下名字
（10）去重（distinct()）
例如：
| 12 | $arr = $info->table("car")->distinct(true)->field("brand")->select();var_dump($arr); |
这是查询的数据库中重复的字段
到此，就是关于怎么连接数据库和各种查询数据库中的数据，这是基本操作，下面就是对数据的添加、修改、删除操作了
四、对数据表添加数据（方法：add()）
（1）上一篇已经讲过链接数据库了，继续进行对数据库的操作，还是用控制器文件中的HomeController.class文件
看下数据库表中的现有数据，然后在进行添加数据
添加数据有三种方法
1.使用数组方式添加
| 1234 | //1.使用数组方式添加public function tianjia(){ $n = M("nation"); <br data-filtered="filtered"> //造一个对象 $arr = array("Code"=>"n006","Name"=>"哈喽"); //其中的字段名要和数据库中的要保持一致$n->add($arr); //进行添加数据，方法add()} |
运行一下这个方法，注意地址栏要使用正确的路径(这是我的路径)：http://localhost/thinkphp/index.php/Home/Home/tianjia
2.AR方式
赋一下值(给字段赋值然后在添加)
| 1234 | //2.AP方式$n->Code = "n007"; //赋值的方式将每个字段赋值$n->Name = "你好";$n->add(); //最后用添加方法的时候里面就不用写参数了 |
3.自动收集表单（最简单的方式）
注意事项：（1）表单中的name要和数据库中的字段名统一（2）多余的表单可以自动取名，只要不和数据库字段名一样就可以
就要考虑这个操作方法要实现什么逻辑，要是两个逻辑
1.显示页面2.添加数据
这里可以通过if判断语句来实现：如果是空的，就显示页面
| 1234 | if(empty($_POST)){ $this->show(); //显示页面} |
否则就是添加数据的代码，一步步的来，先说显示页面，既然是显示页面就要在视图文件夹添加显示页面了
1.1.打开View文件夹，然后新建文件夹，名字和控制器的名字一样
1.2.然后在Home文件夹中新建一个显示页面，这里我叫的是tianjia.html，打开这个页面，进行编写要显示的内容
表单元素来写的显示页面
| 123456 | <form action="__ACTION__" method="post"> <br data-filtered="filtered"> <!--注意下面的name名字要和数据中的保持一致--> <div>代号：<input type="text" name="Code" /></div> <br /> <div>名称：<input type="text" name="Name" /></div> <input type="submit" value="添加" /></form> |
这个中的ation属性使用的__ACTION__(当前操作方法)，也可以使用__SELF__(自身的操作方法包括传的值会一并使用)系统常量
显示页面成功后就是添加数据的编写了
2.1这个就是判断中的“否则”的语句了
| 123456 | else{ $n = M("nation"); $n->create(); //自动收集表单数据 $n->add(); //添加到数据库中} |
运行一下看下是不是可以自动收集表单内容
（1）第一步还没有内容时，自然是显示页面了
（2）添加一下内容，数据库表中没有的数据，单击提交按钮
（3）看下数据库确定一下是不是已经添加进去了
五、修改数据库中表的数据（方法：save()）
其实这个和添加差不多，也是有三种方法
这里也是在HomeController.class文件中继续编写修改方法
| 12345 | public function xiugai(){<br data-filtered="filtered"> $code = "n009"; //修改数据当然是用到的主键值 $n = M("nation"); //因为要修改数据，所以要用到数据库，这里调用数据 //下面就是修改的方法} |
（1）1.还是用if判断一下
| 1234567 | if(empty($_POST)){ $arrt = $n->find($code); //利用find()方式读取一条数据,里面的参数自然就是主键 $this->assign("shuju",$arrt); //注入变量了，注意这里是$this不是别的 $this->show(); //显示页面} |
2.接下来就是做修改的模板页面了，名字就叫xiugai.html 吧
| 123456 | <form action="__ACTION__" method="post"> <div>代号：<input type="text" name="Code" value="{$shuju.code}"/></div> <!--显示的默认值就是上面的二维数组中的shuju--> <br /> <div>名称：<input type="text" name="Name" value="{$shuju.name}" /></div> <input type="submit" value="修改" /></form> |
看下结果
（2）这个就是修改的“否则”语句了
修改也是有三种方式
1.数组方式
| 12 | //1.数组方式$n->save($_POST); //修改方法save() |
因为已经有了数组，所以直接调用就可以了
2.AR方式
| 1234 | //2.AR方式$n->Code = $_POST["Code"];$n->Name = $_POST["Name"];$n->save(); |
3.自动收集表单
| 123 | //3.自动收集表单$n->create(); //自动收集表单数据$n->save(); |
3.1修改一下数据试试
3.2将上面的值修改为下图所示，然后单击“修改”按钮
3.3确定数据库是不是修改了
六、删除数据库表中的数据（方法：delete()） delete()里面放的一定要是主键值！！！
同样的继续写一个方法 就叫shanchu()吧
| 12345 | public function shanChu(){ $n = M("nation"); $n->delete("n008"); //删除的是n008的数据，删除的方法：delete()} |
执行一下这个方法，然后看下数据库中的数据库中n008的这条数据是否已经被删除了。
到现在对于数据库的修改数据就已经完事了，正常的增删改功能就这么些内容
需要记住：注意事项
添加修改都是三种方式，方法不同，原理都是一样的。
谨记：想要操作数据库一定要连接数据库！！
TP框架中 数据库的增删改查
标签：images .com 使用 table html 框架 模板 sign mod
小编还为您整理了以下内容，可能对您也有帮助：
数据库增删改查基本语句
1、“INSERT INTO”语句，用于向表格中增加新的行。
2、“DELETE”语句，用于删除表中的行。
3、“Update”语句，用于修改表中的数据。
4、“SELECT”语句，用于从表中选取数据。
sql语言特点：
SQL可以完成数据库生命周期中的全部活动，包括定义关系模式、录入数据、建立数据库、查询、更新、维护、数据库重构、数据库安全性控制等一系列操作，这就为数据库应用系统开发提供了良好的环境，在数据库投入运行后，还可根据需要随时逐步修改模式，且不影响数据库的运行，从而使系统具有良好的可扩充性。
数据库的增删改查？
1、数据库增加数据：
1）插入单行
insert [into] <表名> (列名) values (列值)
例：insert into t_table (name,sex,birthday) values ('开心朋朋','男','1980/6/15')
2）将现有表数据添加到一个已有表 insert into <已有的新表> (列名) select <原表列名> from <原表名>
例：insert into t_table ('姓名','地址','电子邮件')
select name,address,email from t_table
3）直接拿现有表数据创建一个新表并填充 select <新建表列名> into <新建表名> from <源表名>例：select name,address,email into t_table from strde
2、数据库删除数据：
1）删除<满足条件的>行
delete from <表名> [where <删除条件>]。
例：delete from t_table where name='开心朋朋'（删除表t_table中列值为开心朋朋的行）
2）删除整个表 truncate table <表名>
truncate table tongxunlu
注意：删除表的所有行，但表的结构、列、约束、索引等不会被删除；不能用语有外建约束引用的表
3、数据库修改数据 update <表名> set <列名=更新值> [where <更新条件>]
例：update t_table set age=18 where name='蓝色小名'
4、数据库查询数据：
1）精确（条件）查询
select <列名> from <表名> [where <查询条件表达试>] [order by <排序的列名>[asc或desc]]
2）查询所有数据行和列。例：select * from a
说明：查询a表中所有行和列
3）使用like进行模糊查询
注意：like运算副只用于字符串，所以仅与char和varchar数据类型联合使用
例：select * from a where name like '赵%'
说明：查询显示表a中，name字段第一个字为赵的记录
4）使用between在某个范围内进行查询
例：select * from a where nianling between 18 and 20
说明：查询显示表a中nianling在18到20之间的记录
5）使用in在列举值内进行查询
例：select name from a where address in ('北京','上海','唐山')
说明：查询表a中address值为北京或者上海或者唐山的记录，显示name字段
扩展资料：
插入之前需要创建数据表，创建方式如下：
CREATE TABLE 表名称
(
列名称1 数据类型,
列名称2 数据类型,
列名称3 数据类型,
....
)
例如：--流程步骤定义表
create table T_flow_step_def(
Step_no int not null, --流程步骤ID
Step_name varchar(30) not null, --流程步骤名称
Step_des varchar(64) not null, --流程步骤描述
Limit_time int not null, --时限
URL varchar(64) not null, --二级菜单链接
Remark varchar(256) not null,
)
参考资料：百度百科-sql语句大全
python对数据库表格里面的内容增删查改怎么写
本文主要给大家介绍了关于python模拟sql语句对员工表格进行增删改查的相关内容，分享出来供大家参考学习，下面来一起看看详细的介绍：
具体需求:
员工信息表程序，实现增删改查操作：
可进行模糊查询，语法支持下面3种:
select name,age from staff_data where age > 22 多个查询参数name,age 用','分割
select * from staff_data where dept = 人事
select * from staff_data where enroll_date like 2013
查到的信息，打印后，最后面还要显示查到的条数
可创建新员工纪录，以phone做唯一键，phone存在即提示,staff_id需自增,添加多个记录record1/record2中间用'/'分割
insert into staff_data values record1/record2
可删除指定员工信息纪录，输入员工id，即可删除
delete from staff_data where staff_id>=5andstaff_id<=10
可修改员工信息，语法如下:
update staff_table set dept=Market,phone=13566677787 where dept = 运维 多个set值用','分割
使用re模块,os模块,充分使用函数精简代码,熟练使用 str.split()来解析格式化字符串
由于,sql命令中的几个关键字符串有一定规律,只出现一次,并且有顺序!!!
按照key_lis = ['select', 'insert', 'delete', 'update', 'from', 'into', 'set', 'values', 'where', 'limit']的元素顺序分割sql.
分割元素作为sql_dic字典的key放进字典中.分割后的列表为b,如果len(b)>1,说明sql字符串中含有分割元素,同时b[0]对应上一个分割元素的值,b[-1]为下一次分割对象!
这样不断迭代直到把sql按出现的所有分割元素分割完毕,但注意这里每次循环都是先分割后赋值!!!当前分割元素比如'select'对应的值,需要等到下一个分割元素
比如'from'执行分割后的列表b,其中b[0]的值才会赋值给sql_dic['select'] ,所以最后一个分割元素的值,不能通过上述循环来完成,必须先处理可能是最后一个分割元素,再正常循环!!
在这sql语句中,有可能成为最后一个分割元素的 'limit' ,'values', 'where', 按优先级别,先处理'limit' ,再处理'values'或 'where'.....
处理完得到sql_dic后,就是你按不同命令执行,对数据文件的增删改查,最后返回处理结果!!
示例代码
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308
# _*_coding:utf-8_*_# Author:Jaye Heimport reimport os def sql_parse(sql, key_lis): ''' 解析sql命令字符串,按照key_lis列表里的元素分割sql得到字典形式的命令sql_dic :param sql: :param key_lis: :return: ''' sql_list = [] sql_dic = {} for i in key_lis: b = [j.strip() for j in sql.split(i)] if len(b) > 1: if len(sql.split('limit')) > 1: sql_dic['limit'] = sql.split('limit')[-1] if i == 'where' or i == 'values': sql_dic[i] = b[-1] if sql_list: sql_dic[sql_list[-1]] = b[0] sql_list.append(i) sql = b[-1] else: sql = b[0] if sql_dic.get('select'): if not sql_dic.get('from') and not sql_dic.get('where'): sql_dic['from'] = b[-1] if sql_dic.get('select'): sql_dic['select'] = sql_dic.get('select').split(',') if sql_dic.get('where'): sql_dic['where'] = where_parse(sql_dic.get('where')) return sql_dic def where_parse(where): ''' 格式化where字符串为列表where_list,用'and', 'or', 'not'分割字符串 :param where: :return: ''' casual_l = [where] logic_key = ['and', 'or', 'not'] for j in logic_key: for i in casual_l: if i not in logic_key: if len(i.split(j)) > 1: ele = i.split(j) index = casual_l.index(i) casual_l.pop(index) casual_l.insert(index, ele[0]) casual_l.insert(index+1, j) casual_l.insert(index+2, ele[1]) casual_l = [k for k in casual_l if k] where_list = three_parse(casual_l, logic_key) return where_list def three_parse(casual_l, logic_key): ''' 处理临时列表casual_l中具体的条件,'staff_id>5'-->['staff_id','>','5'] :param casual_l: :param logic_key: :return: ''' where_list = [] for i in casual_l: if i not in logic_key: b = i.split('like') if len(b) > 1: b.insert(1, 'like') where_list.append(b) else: key = ['<', '=', '>'] new_lis = [] opt = '' lis = [j for j in re.split('([=<>])', i) if j] for k in lis: if k in key: opt += k else: new_lis.append(k) new_lis.insert(1, opt) where_list.append(new_lis) else: where_list.append(i) return where_list def sql_action(sql_dic, title): ''' 把解析好的sql_dic分发给相应函数执行处理 :param sql_dic: :param title: :return: ''' key = {'select': select, 'insert': insert, 'delete': delete, 'update': update} res = [] for i in sql_dic: if i in key: res = key[i](sql_dic, title) return res def select(sql_dic, title): ''' 处理select语句命令 :param sql_dic: :param title: :return: ''' with open('staff_data', 'r', encoding='utf-8') as fh: filter_res = where_action(fh, sql_dic.get('where'), title) limit_res = limit_action(filter_res, sql_dic.get('limit')) search_res = search_action(limit_res, sql_dic.get('select'), title) return search_res def insert(sql_dic, title): ''' 处理insert语句命令 :param sql_dic: :param title: :return: ''' with open('staff_data', 'r+', encoding='utf-8') as f: data = f.readlines() phone_list = [i.strip().split(',')[4] for i in data] ins_count = 0 if not data: new_id = 1 else: last = data[-1] last_id = int(last.split(',')[0]) new_id = last_id+1 record = sql_dic.get('values').split('/') for i in record: if i.split(',')[3] in phone_list: print('\033[1;31m%s 手机号已存在\033[0m' % i) else: new_record = '%s,%s\n' % (str(new_id), i) f.write(new_record) new_id += 1 ins_count += 1 f.flush() return ['insert successful'], [str(ins_count)] def delete(sql_dic, title): ''' 处理delete语句命令 :param sql_dic: :param title: :return: ''' with open('staff_data', 'r', encoding='utf-8') as r_file,\ open('staff_data_bak', 'w', encoding='utf-8') as w_file: del_count = 0 for line in r_file: 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('staff_data') os.rename('staff_data_bak', 'staff_data') return ['delete successful'], [str(del_count)] def update(sql_dic, title): ''' 处理update语句命令 :param sql_dic: :param title: :return: ''' set_l = sql_dic.get('set').strip().split(',') set_list = [i.split('=') for i in set_l] update_count = 0 with open('staff_data', 'r', encoding='utf-8') as r_file,\ open('staff_data_bak', 'w', encoding='utf-8') as w_file: for line in r_file: dic = dict(zip(title.split(','), line.strip().split(','))) filter_res = logic_action(dic, sql_dic.get('where')) if filter_res: for i in set_list: k = i[0] v = i[-1] dic[k] = v line = [dic[i] for i in title.split(',')] update_count += 1 line = ','.join(line)+'\n' w_file.write(line) w_file.flush() os.remove('staff_data') os.rename('staff_data_bak', 'staff_data') return ['update successful'], [str(update_count)] def where_action(fh, where_list, title): ''' 具体处理where_list里的所有条件 :param fh: :param where_list: :param title: :return: ''' res = [] if len(where_list) != 0: for line in fh: dic = dict(zip(title.split(','), line.strip().split(','))) if dic['name'] != 'name': logic_res = logic_action(dic, where_list) if logic_res: res.append(line.strip().split(',')) else: res = [i.split(',') for i in fh.readlines()] return res pass def logic_action(dic, where_list): ''' 判断数据文件中每一条是否符合where_list条件 :param dic: :param where_list: :return: ''' logic = [] for exp in where_list: if type(exp) is list: exp_k, opt, exp_v = exp if exp[1] == '=': opt = '==' logical_char = "'%s'%s'%s'" % (dic[exp_k], opt, exp_v) if opt != 'like': exp = str(eval(logical_char)) else: if exp_v in dic[exp_k]: exp = 'True' else: exp = 'False' logic.append(exp) res = eval(' '.join(logic)) return res def limit_action(filter_res, limit_l): ''' 用列表切分处理显示符合条件的数量 :param filter_res: :param limit_l: :return: ''' if limit_l: index = int(limit_l[0]) res = filter_res[:index] else: res = filter_res return res def search_action(limit_res, select_list, title): ''' 处理需要查询并显示的title和相应数据 :param limit_res: :param select_list: :param title: :return: ''' res = [] fields_list = title.split(',') if select_list[0] == '*': res = limit_res else: fields_list = select_list for data in limit_res: dic = dict(zip(title.split(','), data)) r_l = [] for i in fields_list: r_l.append((dic[i].strip())) res.append(r_l) return fields_list, res if __name__ == '__main__': with open('staff_data', 'r', encoding='utf-8') as f: title = f.readline().strip() key_lis = ['select', 'insert', 'delete', 'update', 'from', 'into', 'set', 'values', 'where', 'limit'] while True: sql = input('请输入sql命令,退出请输入exit:').strip() sql = re.sub(' ', '', sql) if len(sql) == 0:continue if sql == 'exit':break sql_dict = sql_parse(sql, key_lis) fields_list, fields_data = sql_action(sql_dict, title) print('\033[1;33m结果如下:\033[0m') print('-'.join(fields_list)) for data in fields_data: print('-'.join(data))
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对脚本之家的支持。
python对数据库表格里面的内容增删查改怎么写
本文主要给大家介绍了关于python模拟sql语句对员工表格进行增删改查的相关内容，分享出来供大家参考学习，下面来一起看看详细的介绍：
具体需求:
员工信息表程序，实现增删改查操作：
可进行模糊查询，语法支持下面3种:
select name,age from staff_data where age > 22 多个查询参数name,age 用','分割
select * from staff_data where dept = 人事
select * from staff_data where enroll_date like 2013
查到的信息，打印后，最后面还要显示查到的条数
可创建新员工纪录，以phone做唯一键，phone存在即提示,staff_id需自增,添加多个记录record1/record2中间用'/'分割
insert into staff_data values record1/record2
可删除指定员工信息纪录，输入员工id，即可删除
delete from staff_data where staff_id>=5andstaff_id<=10
可修改员工信息，语法如下:
update staff_table set dept=Market,phone=13566677787 where dept = 运维 多个set值用','分割
使用re模块,os模块,充分使用函数精简代码,熟练使用 str.split()来解析格式化字符串
由于,sql命令中的几个关键字符串有一定规律,只出现一次,并且有顺序!!!
按照key_lis = ['select', 'insert', 'delete', 'update', 'from', 'into', 'set', 'values', 'where', 'limit']的元素顺序分割sql.
分割元素作为sql_dic字典的key放进字典中.分割后的列表为b,如果len(b)>1,说明sql字符串中含有分割元素,同时b[0]对应上一个分割元素的值,b[-1]为下一次分割对象!
这样不断迭代直到把sql按出现的所有分割元素分割完毕,但注意这里每次循环都是先分割后赋值!!!当前分割元素比如'select'对应的值,需要等到下一个分割元素
比如'from'执行分割后的列表b,其中b[0]的值才会赋值给sql_dic['select'] ,所以最后一个分割元素的值,不能通过上述循环来完成,必须先处理可能是最后一个分割元素,再正常循环!!
在这sql语句中,有可能成为最后一个分割元素的 'limit' ,'values', 'where', 按优先级别,先处理'limit' ,再处理'values'或 'where'.....
处理完得到sql_dic后,就是你按不同命令执行,对数据文件的增删改查,最后返回处理结果!!
示例代码
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308
# _*_coding:utf-8_*_# Author:Jaye Heimport reimport os def sql_parse(sql, key_lis): ''' 解析sql命令字符串,按照key_lis列表里的元素分割sql得到字典形式的命令sql_dic :param sql: :param key_lis: :return: ''' sql_list = [] sql_dic = {} for i in key_lis: b = [j.strip() for j in sql.split(i)] if len(b) > 1: if len(sql.split('limit')) > 1: sql_dic['limit'] = sql.split('limit')[-1] if i == 'where' or i == 'values': sql_dic[i] = b[-1] if sql_list: sql_dic[sql_list[-1]] = b[0] sql_list.append(i) sql = b[-1] else: sql = b[0] if sql_dic.get('select'): if not sql_dic.get('from') and not sql_dic.get('where'): sql_dic['from'] = b[-1] if sql_dic.get('select'): sql_dic['select'] = sql_dic.get('select').split(',') if sql_dic.get('where'): sql_dic['where'] = where_parse(sql_dic.get('where')) return sql_dic def where_parse(where): ''' 格式化where字符串为列表where_list,用'and', 'or', 'not'分割字符串 :param where: :return: ''' casual_l = [where] logic_key = ['and', 'or', 'not'] for j in logic_key: for i in casual_l: if i not in logic_key: if len(i.split(j)) > 1: ele = i.split(j) index = casual_l.index(i) casual_l.pop(index) casual_l.insert(index, ele[0]) casual_l.insert(index+1, j) casual_l.insert(index+2, ele[1]) casual_l = [k for k in casual_l if k] where_list = three_parse(casual_l, logic_key) return where_list def three_parse(casual_l, logic_key): ''' 处理临时列表casual_l中具体的条件,'staff_id>5'-->['staff_id','>','5'] :param casual_l: :param logic_key: :return: ''' where_list = [] for i in casual_l: if i not in logic_key: b = i.split('like') if len(b) > 1: b.insert(1, 'like') where_list.append(b) else: key = ['<', '=', '>'] new_lis = [] opt = '' lis = [j for j in re.split('([=<>])', i) if j] for k in lis: if k in key: opt += k else: new_lis.append(k) new_lis.insert(1, opt) where_list.append(new_lis) else: where_list.append(i) return where_list def sql_action(sql_dic, title): ''' 把解析好的sql_dic分发给相应函数执行处理 :param sql_dic: :param title: :return: ''' key = {'select': select, 'insert': insert, 'delete': delete, 'update': update} res = [] for i in sql_dic: if i in key: res = key[i](sql_dic, title) return res def select(sql_dic, title): ''' 处理select语句命令 :param sql_dic: :param title: :return: ''' with open('staff_data', 'r', encoding='utf-8') as fh: filter_res = where_action(fh, sql_dic.get('where'), title) limit_res = limit_action(filter_res, sql_dic.get('limit')) search_res = search_action(limit_res, sql_dic.get('select'), title) return search_res def insert(sql_dic, title): ''' 处理insert语句命令 :param sql_dic: :param title: :return: ''' with open('staff_data', 'r+', encoding='utf-8') as f: data = f.readlines() phone_list = [i.strip().split(',')[4] for i in data] ins_count = 0 if not data: new_id = 1 else: last = data[-1] last_id = int(last.split(',')[0]) new_id = last_id+1 record = sql_dic.get('values').split('/') for i in record: if i.split(',')[3] in phone_list: print('\033[1;31m%s 手机号已存在\033[0m' % i) else: new_record = '%s,%s\n' % (str(new_id), i) f.write(new_record) new_id += 1 ins_count += 1 f.flush() return ['insert successful'], [str(ins_count)] def delete(sql_dic, title): ''' 处理delete语句命令 :param sql_dic: :param title: :return: ''' with open('staff_data', 'r', encoding='utf-8') as r_file,\ open('staff_data_bak', 'w', encoding='utf-8') as w_file: del_count = 0 for line in r_file: 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('staff_data') os.rename('staff_data_bak', 'staff_data') return ['delete successful'], [str(del_count)] def update(sql_dic, title): ''' 处理update语句命令 :param sql_dic: :param title: :return: ''' set_l = sql_dic.get('set').strip().split(',') set_list = [i.split('=') for i in set_l] update_count = 0 with open('staff_data', 'r', encoding='utf-8') as r_file,\ open('staff_data_bak', 'w', encoding='utf-8') as w_file: for line in r_file: dic = dict(zip(title.split(','), line.strip().split(','))) filter_res = logic_action(dic, sql_dic.get('where')) if filter_res: for i in set_list: k = i[0] v = i[-1] dic[k] = v line = [dic[i] for i in title.split(',')] update_count += 1 line = ','.join(line)+'\n' w_file.write(line) w_file.flush() os.remove('staff_data') os.rename('staff_data_bak', 'staff_data') return ['update successful'], [str(update_count)] def where_action(fh, where_list, title): ''' 具体处理where_list里的所有条件 :param fh: :param where_list: :param title: :return: ''' res = [] if len(where_list) != 0: for line in fh: dic = dict(zip(title.split(','), line.strip().split(','))) if dic['name'] != 'name': logic_res = logic_action(dic, where_list) if logic_res: res.append(line.strip().split(',')) else: res = [i.split(',') for i in fh.readlines()] return res pass def logic_action(dic, where_list): ''' 判断数据文件中每一条是否符合where_list条件 :param dic: :param where_list: :return: ''' logic = [] for exp in where_list: if type(exp) is list: exp_k, opt, exp_v = exp if exp[1] == '=': opt = '==' logical_char = "'%s'%s'%s'" % (dic[exp_k], opt, exp_v) if opt != 'like': exp = str(eval(logical_char)) else: if exp_v in dic[exp_k]: exp = 'True' else: exp = 'False' logic.append(exp) res = eval(' '.join(logic)) return res def limit_action(filter_res, limit_l): ''' 用列表切分处理显示符合条件的数量 :param filter_res: :param limit_l: :return: ''' if limit_l: index = int(limit_l[0]) res = filter_res[:index] else: res = filter_res return res def search_action(limit_res, select_list, title): ''' 处理需要查询并显示的title和相应数据 :param limit_res: :param select_list: :param title: :return: ''' res = [] fields_list = title.split(',') if select_list[0] == '*': res = limit_res else: fields_list = select_list for data in limit_res: dic = dict(zip(title.split(','), data)) r_l = [] for i in fields_list: r_l.append((dic[i].strip())) res.append(r_l) return fields_list, res if __name__ == '__main__': with open('staff_data', 'r', encoding='utf-8') as f: title = f.readline().strip() key_lis = ['select', 'insert', 'delete', 'update', 'from', 'into', 'set', 'values', 'where', 'limit'] while True: sql = input('请输入sql命令,退出请输入exit:').strip() sql = re.sub(' ', '', sql) if len(sql) == 0:continue if sql == 'exit':break sql_dict = sql_parse(sql, key_lis) fields_list, fields_data = sql_action(sql_dict, title) print('\033[1;33m结果如下:\033[0m') print('-'.join(fields_list)) for data in fields_data: print('-'.join(data))
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对脚本之家的支持。
数据库中增删改查的基本语句是什么?
数据库中增删改查基本语句：INSERT INTO，表名字段列表。
数据库是存放数据的仓库。它的存储空间很大，可以存放百万条、千万条、上亿条数据。但是数据库并不是随意地将数据进行存放，是有一定的规则的，否则查询的效率会很低。
当今世界是一个充满着数据的互联网世界，充斥着大量的数据。即这个互联网世界就是数据世界。数据的来源有很多，比如出行记录、消费记录、浏览的网页、发送的消息等等。除了文本类型的数据，图像、音乐、声音都是数据。
在数据库的发展历史上，数据库先后经历了层次数据库、网状数据库和关系数据库等各个阶段的发展，数据库技术在各个方面的快速的发展。特别是关系型数据库已经成为目前数据库产品中最重要的一员。
80年代以来，几乎所有的数据库厂商新出的数据库产品都支持关系型数据库，即使一些非关系数据库产品也几乎都有支持关系数据库的接口。
这主要是传统的关系型数据库可以比较好的解决管理和存储关系型数据的问题。随着云计算的发展和大数据时代的到来，关系型数据库越来越无法满足需要，这主要是由于越来越多的半关系型和非关系型数据需要用数据库进行存储管理。
数据库中增删改查的基本语句是什么?
数据库中增删改查基本语句：INSERT INTO，表名字段列表。
数据库是存放数据的仓库。它的存储空间很大，可以存放百万条、千万条、上亿条数据。但是数据库并不是随意地将数据进行存放，是有一定的规则的，否则查询的效率会很低。
当今世界是一个充满着数据的互联网世界，充斥着大量的数据。即这个互联网世界就是数据世界。数据的来源有很多，比如出行记录、消费记录、浏览的网页、发送的消息等等。除了文本类型的数据，图像、音乐、声音都是数据。
在数据库的发展历史上，数据库先后经历了层次数据库、网状数据库和关系数据库等各个阶段的发展，数据库技术在各个方面的快速的发展。特别是关系型数据库已经成为目前数据库产品中最重要的一员。
80年代以来，几乎所有的数据库厂商新出的数据库产品都支持关系型数据库，即使一些非关系数据库产品也几乎都有支持关系数据库的接口。
这主要是传统的关系型数据库可以比较好的解决管理和存储关系型数据的问题。随着云计算的发展和大数据时代的到来，关系型数据库越来越无法满足需要，这主要是由于越来越多的半关系型和非关系型数据需要用数据库进行存储管理。
如何实现数据列表的增删改?
这个简单，就是写几个jsp页面：
1、一个jsp查询数据库表（网上查查怎么用JDBC），生成的html列出来数据表内容，每行的后面加一个“删除”，一个“修改”，分别链接到负责删除和修改的jsp，参数是ID字段的值，比如delete.jsp?id=223，modify.jsp?id=223这样
页面下面加个按钮，指向新增页面add.jsp
2、delete.jsp，根据参数，拼出来删除的sql语句，执行，类似delete from yourtable where id=223
3、modify.jsp，针对数据库表的各个字段，生成一个html form，每个字段对应一个input，根据参数，查询出数据表当前值，放在表单各Input中，表单提交到modifysubmit.jsp，后者中生成update sql，完成修改
4、add.jsp，跟modify差不多，就是没有填现有值的步骤，也是分两步，一步生成表单让用户填，一步提交到数据库。追问谢谢！我还想问一下：
如果我想一次选中多条记录删除该怎么办？还有同时编辑多条记录呢？在编辑数据的过程中，能不能不要老是提交？
追答删多条：可以在每条记录前生成checkbox，其name是id字段值，下面添加批量删除按钮，在提交处理中，根据用户选中的多条记录，生成多条delete sql
编辑过程不提交，看看ajax吧
同时编辑多条，这个不好做。
如何实现数据列表的增删改?
这个简单，就是写几个jsp页面：
1、一个jsp查询数据库表（网上查查怎么用JDBC），生成的html列出来数据表内容，每行的后面加一个“删除”，一个“修改”，分别链接到负责删除和修改的jsp，参数是ID字段的值，比如delete.jsp?id=223，modify.jsp?id=223这样
页面下面加个按钮，指向新增页面add.jsp
2、delete.jsp，根据参数，拼出来删除的sql语句，执行，类似delete from yourtable where id=223
3、modify.jsp，针对数据库表的各个字段，生成一个html form，每个字段对应一个input，根据参数，查询出数据表当前值，放在表单各Input中，表单提交到modifysubmit.jsp，后者中生成update sql，完成修改
4、add.jsp，跟modify差不多，就是没有填现有值的步骤，也是分两步，一步生成表单让用户填，一步提交到数据库。追问谢谢！我还想问一下：
如果我想一次选中多条记录删除该怎么办？还有同时编辑多条记录呢？在编辑数据的过程中，能不能不要老是提交？
追答删多条：可以在每条记录前生成checkbox，其name是id字段值，下面添加批量删除按钮，在提交处理中，根据用户选中的多条记录，生成多条delete sql
编辑过程不提交，看看ajax吧
同时编辑多条，这个不好做。
数据库增删改查的基本命令
（推荐教程：mysql视频教程）
数据库增删改查基本语句
数据库增加数据
在 MySQL 中可以使用 INSERT INTO 语句向数据库已有的表中插入一行或者多行元组数据。
语法格式：
INSERT INTO 表名 ( 列名1, 列名2,...列名N ) VALUES ( 值1, 值2,...值N );
如果数据是字符型，必须使用单引号或者双引号，如："value"。
表名：指定被操作的表名。
列名：指定需要插入数据的列名。若向表中的所有列插入数据，则全部的列名均可以省略，直接采用 INSERT<表名>VALUES(…) 即可。
VALUE 子句：该子句包含要插入的数据清单。数据清单中数据的顺序要和列的顺序相对应。
示例：在 tb_courses 表中插入一条新记录，course_id 值为 1，course_name 值为“Network”，course_grade 值为 3，info 值为“Computer Network”。
在执行插入操作之前，查看 tb_courses 表
mysql> SELECT * FROM tb_courses;Empty set (0.00 sec)
查询结果显示当前表内容为空，没有数据，接下来执行插入数据的操作，输入的 SQL 语句和执行过程如下所示。
mysql> INSERT INTO tb_courses -> (course_id,course_name,course_grade,course_info) -> VALUES(1,'Network',3,'Computer Network');Query OK, 1 rows affected (0.08 sec)mysql> SELECT * FROM tb_courses;+-----------+-------------+--------------+------------------+| course_id | course_name | course_grade | course_info |+-----------+-------------+--------------+------------------+| 1 | Network | 3 | Computer Network |+-----------+-------------+--------------+------------------+1 row in set (0.00 sec)
可以看到插入记录成功。在插入数据时，指定了 tb_courses 表的所有字段，因此将为每一个字段插入新的值。
说明：
INSERT 语句后面的列名称顺序可以不是 tb_courses 表定义时的顺序，即插入数据时，不需要按照表定义的顺序插入，只要保证值的顺序与列字段的顺序相同就可以。
使用 INSERT 插入数据时，允许列名称列表 column_list 为空，此时值列表中需要为表的每一个字段指定值，并且值的顺序必须和数据表中字段定义时的顺序相同。
注意：虽然使用 INSERT 插入数据时可以忽略插入数据的列名称，若值不包含列名称，则 VALUES 关键字后面的值不仅要求完整，而且顺序必须和表定义时列的顺序相同。如果表的结构被修改，对列进行增加、删除或者位置改变操作，这些操作将使得用这种方式插入数据时的顺序也同时改变。如果指定列名称，就不会受到表结构改变的影响。
数据库删除数据
在 MySQL 中，可以使用 DELETE 语句来删除表的一行或者多行数据。
语法格式为：
DELETE FROM 表名 [WHERE 子句] [ORDER BY 子句] [LIMIT 子句]
删除指定数据：
DELETE FROM 表名称 WHERE 列名称 = 值
语法说明如下：
表名：指定要删除数据的表名。
ORDER BY 子句：可选项。表示删除时，表中各行将按照子句中指定的顺序进行删除。
WHERE 子句：可选项。表示为删除操作限定删除条件，若省略该子句，则代表删除该表中的所有行。
LIMIT 子句：可选项。用于告知服务器在控制命令被返回到客户端前被删除行的最大值。
注意：在不使用 WHERE 条件的时候，将删除所有数据。
示例1：删除表中的全部数据
删除 tb_courses_new 表中的全部数据，输入的 SQL 语句和执行结果如下所示。
mysql> DELETE FROM tb_courses_new;Query OK, 3 rows affected (0.12 sec)mysql> SELECT * FROM tb_courses_new;Empty set (0.00 sec)
示例2：根据条件删除表中的数据
在 tb_courses_new 表中，删除 course_id 为 4 的记录，输入的 SQL 语句和执行结果如下所示。
mysql> DELETE FROM tb_courses -> WHERE course_id=4;Query OK, 1 row affected (0.00 sec)mysql> SELECT * FROM tb_courses;+-----------+-------------+--------------+------------------+| course_id | course_name | course_grade | course_info |+-----------+-------------+--------------+------------------+| 1 | Network | 3 | Computer Network || 2 | Database | 3 | MySQL || 3 | Java | 4 | Java EE |+-----------+-------------+--------------+------------------+3 rows in set (0.00 sec)
由运行结果可以看出，course_id 为 4 的记录已经被删除。
数据库修改数据
在 MySQL 中，可以使用 UPDATE 语句来修改、更新一个或多个表的数据。
语法格式为：
UPDATE 表名 SET 字段=值 [WHERE 子句 ][ORDER BY 子句] [LIMIT 子句]
例：
UPDATE 表名称 SET 列名称 = 新值 WHERE 列名称 = 某值
语法说明如下：
表名：用于指定要更新的表名称。
SET 子句：用于指定表中要修改的列名及其列值。其中，每个指定的列值可以是表达式，也可以是该列对应的默认值。如果指定的是默认值，可用关键字 DEFAULT 表示列值。
WHERE 子句：可选项。用于限定表中要修改的行。若不指定，则修改表中所有的行。
ORDER BY 子句：可选项。用于限定表中的行被修改的次序。
LIMIT 子句：可选项。用于限定被修改的行数。
注意：修改一行数据的多个列值时，SET 子句的每个值用逗号分开即可。
示例1：修改表中的数据
在 tb_courses_new 表中，更新所有行的 course_grade 字段值为 4，输入的 SQL 语句和执行结果如下所示。
mysql> UPDATE tb_courses_new -> SET course_grade=4;Query OK, 3 rows affected (0.11 sec)Rows matched: 4 Changed: 3 Warnings: 0mysql> SELECT * FROM tb_courses_new;+-----------+-------------+--------------+------------------+| course_id | course_name | course_grade | course_info |+-----------+-------------+--------------+------------------+| 1 | Network | 4 | Computer Network || 2 | Database | 4 | MySQL || 3 | Java | 4 | Java EE || 4 | System | 4 | Operating System |+-----------+-------------+--------------+------------------+4 rows in set (0.00 sec)
示例1：根据条件修改表中的数据
在 tb_courses 表中，更新 course_id 值为 2 的记录，将 course_grade 字段值改为 3.5，将 course_name 字段值改为“DB”，输入的 SQL 语句和执行结果如下所示。
mysql> UPDATE tb_courses_new -> SET course_name='DB',course_grade=3.5 -> WHERE course_id=2;Query OK, 1 row affected (0.13 sec)Rows matched: 1 Changed: 1 Warnings: 0mysql> SELECT * FROM tb_courses_new;+-----------+-------------+--------------+------------------+| course_id | course_name | course_grade | course_info |+-----------+-------------+--------------+------------------+| 1 | Network | 4 | Computer Network || 2 | DB | 3.5 | MySQL || 3 | Java | 4 | Java EE || 4 | System | 4 | Operating System |+-----------+-------------+--------------+------------------+4 rows in set (0.00 sec)
注意：保证 UPDATE 以 WHERE 子句结束，通过 WHERE 子句指定被更新的记录所需要满足的条件，如果忽略 WHERE 子句，MySQL 将更新表中所有的行。
数据库查询数据
在 MySQL 中，可以使用 SELECT 语句来查询数据。查询数据是指从数据库中根据需求，使用不同的查询方式来获取不同的数据，是使用频率最高、最重要的操作。
SELECT 的语法格式如下：
SELECT{* | <字段列名>}[FROM <表 1>, <表 2>…[WHERE <表达式>[GROUP BY <group by definition>[HAVING <expression> [{<operator> <expression>}…]][ORDER BY <order by definition>][LIMIT[<offset>,] <row count>]]其中，各条子句的含义如下：
{*|<字段列名>}包含星号通配符的字段列表，表示所要查询字段的名称。
<表 1>，<表 2>…，表 1 和表 2 表示查询数据的来源，可以是单个或多个。
WHERE <表达式>是可选项，如果选择该项，将限定查询数据必须满足该查询条件。
GROUP BY< 字段 >，该子句告诉 MySQL 如何显示查询出来的数据，并按照指定的字段分组。
[ORDER BY< 字段 >]，该子句告诉 MySQL 按什么样的顺序显示查询出来的数据，可以进行的排序有升序（ASC）和降序（DESC），默认情况下是升序。
[LIMIT[<offset>，]<row count>]，该子句告诉 MySQL 每次显示查询出来的数据条数。
下面先介绍一些简单的 SELECT 语句，关于 WHERE、GROUP BY、ORDER BY 和 LIMIT 等限制条件就不细说了。
1、查询表中所有字段
查询所有字段是指查询表中所有字段的数据。MySQL 提供了以下 2 种方式查询表中的所有字段。
SELECT 可以使用“*”查找表中所有字段的数据，语法格式如下：
SELECT * FROM 表名;
使用“*”查询时，只能按照数据表中字段的顺序进行排列，不能改变字段的排列顺序。
示例：从 tb_students_info 表中查询所有字段的数据，SQL 语句和运行结果如下所示。
mysql> use test_db;Database changedmysql> SELECT * FROM tb_students_info;+----+--------+---------+------+------+--------+------------+| id | name | dept_id | age | sex | height | login_date |+----+--------+---------+------+------+--------+------------+| 1 | Dany | 1 | 25 | F | 160 | 2015-09-10 || 2 | Green | 3 | 23 | F | 158 | 2016-10-22 || 3 | Henry | 2 | 23 | M | 185 | 2015-05-31 || 4 | Jane | 1 | 22 | F | 162 | 2016-12-20 || 5 | Jim | 1 | 24 | M | 175 | 2016-01-15 || 6 | John | 2 | 21 | M | 172 | 2015-11-11 || 7 | Lily | 6 | 22 | F | 165 | 2016-02-26 || 8 | Susan | 4 | 23 | F | 170 | 2015-10-01 || 9 | Thomas | 3 | 22 | M | 178 | 2016-06-07 || 10 | Tom | 4 | 23 | M | 165 | 2016-08-05 |+----+--------+---------+------+------+--------+------------+10 rows in set (0.26 sec)
结果显示，使用“*”通配符时，将返回所有列，数据列按照创建表时的顺序显示。
注意：一般情况下，除非需要使用表中所有的字段数据，否则最好不要使用通配符“*”。虽然使用通配符可以节省输入查询语句的时间，但是获取不需要的列数据通常会降低查询和所使用的应用程序的效率。使用“*”的优势是，当不知道所需列的名称时，可以通过“*”获取它们。
2、查询表中指定的字段
查询表中的某一个字段的语法格式为：
SELECT < 列名 > FROM < 表名 >;
示例：
查询 tb_students_info 表中 name 列所有学生的姓名，SQL 语句和运行结果如下所示。
mysql> SELECT name FROM tb_students_info;+--------+| name |+--------+| Dany || Green || Henry || Jane || Jim || John || Lily || Susan || Thomas || Tom |+--------+10 rows in set (0.00 sec)
输出结果显示了 tb_students_info 表中 name 字段下的所有数据。
使用 SELECT 声明可以获取多个字段下的数据，只需要在关键字 SELECT 后面指定要查找的字段名称，不同字段名称之间用逗号“，”分隔开，最后一个字段后面不需要加逗号，语法格式如下：
SELECT <字段名1>,<字段名2>,…,<字段名n> FROM <表名>;
示例：
从 tb_students_info 表中获取 id、name 和 height 三列，SQL 语句和运行结果如下所示。
mysql> SELECT id,name,height -> FROM tb_students_info;+----+--------+--------+| id | name | height |+----+--------+--------+| 1 | Dany | 160 || 2 | Green | 158 || 3 | Henry | 185 || 4 | Jane | 162 || 5 | Jim | 175 || 6 | John | 172 || 7 | Lily | 165 || 8 | Susan | 170 || 9 | Thomas | 178 || 10 | Tom | 165 |+----+--------+--------+10 rows in set (0.00 sec)
输出结果显示了 tb_students_info 表中 id、name 和 height 三个字段下的所有数据。
更多编程相关知识，请访问：编程视频！！
数据库增删改查的基本命令
（推荐教程：mysql视频教程）
数据库增删改查基本语句
数据库增加数据
在 MySQL 中可以使用 INSERT INTO 语句向数据库已有的表中插入一行或者多行元组数据。
语法格式：
INSERT INTO 表名 ( 列名1, 列名2,...列名N ) VALUES ( 值1, 值2,...值N );
如果数据是字符型，必须使用单引号或者双引号，如："value"。
表名：指定被操作的表名。
列名：指定需要插入数据的列名。若向表中的所有列插入数据，则全部的列名均可以省略，直接采用 INSERT<表名>VALUES(…) 即可。
VALUE 子句：该子句包含要插入的数据清单。数据清单中数据的顺序要和列的顺序相对应。
示例：在 tb_courses 表中插入一条新记录，course_id 值为 1，course_name 值为“Network”，course_grade 值为 3，info 值为“Computer Network”。
在执行插入操作之前，查看 tb_courses 表
mysql> SELECT * FROM tb_courses;Empty set (0.00 sec)
查询结果显示当前表内容为空，没有数据，接下来执行插入数据的操作，输入的 SQL 语句和执行过程如下所示。
mysql> INSERT INTO tb_courses -> (course_id,course_name,course_grade,course_info) -> VALUES(1,'Network',3,'Computer Network');Query OK, 1 rows affected (0.08 sec)mysql> SELECT * FROM tb_courses;+-----------+-------------+--------------+------------------+| course_id | course_name | course_grade | course_info |+-----------+-------------+--------------+------------------+| 1 | Network | 3 | Computer Network |+-----------+-------------+--------------+------------------+1 row in set (0.00 sec)
可以看到插入记录成功。在插入数据时，指定了 tb_courses 表的所有字段，因此将为每一个字段插入新的值。
说明：
INSERT 语句后面的列名称顺序可以不是 tb_courses 表定义时的顺序，即插入数据时，不需要按照表定义的顺序插入，只要保证值的顺序与列字段的顺序相同就可以。
使用 INSERT 插入数据时，允许列名称列表 column_list 为空，此时值列表中需要为表的每一个字段指定值，并且值的顺序必须和数据表中字段定义时的顺序相同。
注意：虽然使用 INSERT 插入数据时可以忽略插入数据的列名称，若值不包含列名称，则 VALUES 关键字后面的值不仅要求完整，而且顺序必须和表定义时列的顺序相同。如果表的结构被修改，对列进行增加、删除或者位置改变操作，这些操作将使得用这种方式插入数据时的顺序也同时改变。如果指定列名称，就不会受到表结构改变的影响。
数据库删除数据
在 MySQL 中，可以使用 DELETE 语句来删除表的一行或者多行数据。
语法格式为：
DELETE FROM 表名 [WHERE 子句] [ORDER BY 子句] [LIMIT 子句]
删除指定数据：
DELETE FROM 表名称 WHERE 列名称 = 值
语法说明如下：
表名：指定要删除数据的表名。
ORDER BY 子句：可选项。表示删除时，表中各行将按照子句中指定的顺序进行删除。
WHERE 子句：可选项。表示为删除操作限定删除条件，若省略该子句，则代表删除该表中的所有行。
LIMIT 子句：可选项。用于告知服务器在控制命令被返回到客户端前被删除行的最大值。
注意：在不使用 WHERE 条件的时候，将删除所有数据。
示例1：删除表中的全部数据
删除 tb_courses_new 表中的全部数据，输入的 SQL 语句和执行结果如下所示。
mysql> DELETE FROM tb_courses_new;Query OK, 3 rows affected (0.12 sec)mysql> SELECT * FROM tb_courses_new;Empty set (0.00 sec)
示例2：根据条件删除表中的数据
在 tb_courses_new 表中，删除 course_id 为 4 的记录，输入的 SQL 语句和执行结果如下所示。
mysql> DELETE FROM tb_courses -> WHERE course_id=4;Query OK, 1 row affected (0.00 sec)mysql> SELECT * FROM tb_courses;+-----------+-------------+--------------+------------------+| course_id | course_name | course_grade | course_info |+-----------+-------------+--------------+------------------+| 1 | Network | 3 | Computer Network || 2 | Database | 3 | MySQL || 3 | Java | 4 | Java EE |+-----------+-------------+--------------+------------------+3 rows in set (0.00 sec)
由运行结果可以看出，course_id 为 4 的记录已经被删除。
数据库修改数据
在 MySQL 中，可以使用 UPDATE 语句来修改、更新一个或多个表的数据。
语法格式为：
UPDATE 表名 SET 字段=值 [WHERE 子句 ][ORDER BY 子句] [LIMIT 子句]
例：
UPDATE 表名称 SET 列名称 = 新值 WHERE 列名称 = 某值
语法说明如下：
表名：用于指定要更新的表名称。
SET 子句：用于指定表中要修改的列名及其列值。其中，每个指定的列值可以是表达式，也可以是该列对应的默认值。如果指定的是默认值，可用关键字 DEFAULT 表示列值。
WHERE 子句：可选项。用于限定表中要修改的行。若不指定，则修改表中所有的行。
ORDER BY 子句：可选项。用于限定表中的行被修改的次序。
LIMIT 子句：可选项。用于限定被修改的行数。
注意：修改一行数据的多个列值时，SET 子句的每个值用逗号分开即可。
示例1：修改表中的数据
在 tb_courses_new 表中，更新所有行的 course_grade 字段值为 4，输入的 SQL 语句和执行结果如下所示。
mysql> UPDATE tb_courses_new -> SET course_grade=4;Query OK, 3 rows affected (0.11 sec)Rows matched: 4 Changed: 3 Warnings: 0mysql> SELECT * FROM tb_courses_new;+-----------+-------------+--------------+------------------+| course_id | course_name | course_grade | course_info |+-----------+-------------+--------------+------------------+| 1 | Network | 4 | Computer Network || 2 | Database | 4 | MySQL || 3 | Java | 4 | Java EE || 4 | System | 4 | Operating System |+-----------+-------------+--------------+------------------+4 rows in set (0.00 sec)
示例1：根据条件修改表中的数据
在 tb_courses 表中，更新 course_id 值为 2 的记录，将 course_grade 字段值改为 3.5，将 course_name 字段值改为“DB”，输入的 SQL 语句和执行结果如下所示。
mysql> UPDATE tb_courses_new -> SET course_name='DB',course_grade=3.5 -> WHERE course_id=2;Query OK, 1 row affected (0.13 sec)Rows matched: 1 Changed: 1 Warnings: 0mysql> SELECT * FROM tb_courses_new;+-----------+-------------+--------------+------------------+| course_id | course_name | course_grade | course_info |+-----------+-------------+--------------+------------------+| 1 | Network | 4 | Computer Network || 2 | DB | 3.5 | MySQL || 3 | Java | 4 | Java EE || 4 | System | 4 | Operating System |+-----------+-------------+--------------+------------------+4 rows in set (0.00 sec)
注意：保证 UPDATE 以 WHERE 子句结束，通过 WHERE 子句指定被更新的记录所需要满足的条件，如果忽略 WHERE 子句，MySQL 将更新表中所有的行。
数据库查询数据
在 MySQL 中，可以使用 SELECT 语句来查询数据。查询数据是指从数据库中根据需求，使用不同的查询方式来获取不同的数据，是使用频率最高、最重要的操作。
SELECT 的语法格式如下：
SELECT{* | <字段列名>}[FROM <表 1>, <表 2>…[WHERE <表达式>[GROUP BY <group by definition>[HAVING <expression> [{<operator> <expression>}…]][ORDER BY <order by definition>][LIMIT[<offset>,] <row count>]]其中，各条子句的含义如下：
{*|<字段列名>}包含星号通配符的字段列表，表示所要查询字段的名称。
<表 1>，<表 2>…，表 1 和表 2 表示查询数据的来源，可以是单个或多个。
WHERE <表达式>是可选项，如果选择该项，将限定查询数据必须满足该查询条件。
GROUP BY< 字段 >，该子句告诉 MySQL 如何显示查询出来的数据，并按照指定的字段分组。
[ORDER BY< 字段 >]，该子句告诉 MySQL 按什么样的顺序显示查询出来的数据，可以进行的排序有升序（ASC）和降序（DESC），默认情况下是升序。
[LIMIT[<offset>，]<row count>]，该子句告诉 MySQL 每次显示查询出来的数据条数。
下面先介绍一些简单的 SELECT 语句，关于 WHERE、GROUP BY、ORDER BY 和 LIMIT 等限制条件就不细说了。
1、查询表中所有字段
查询所有字段是指查询表中所有字段的数据。MySQL 提供了以下 2 种方式查询表中的所有字段。
SELECT 可以使用“*”查找表中所有字段的数据，语法格式如下：
SELECT * FROM 表名;
使用“*”查询时，只能按照数据表中字段的顺序进行排列，不能改变字段的排列顺序。
示例：从 tb_students_info 表中查询所有字段的数据，SQL 语句和运行结果如下所示。
mysql> use test_db;Database changedmysql> SELECT * FROM tb_students_info;+----+--------+---------+------+------+--------+------------+| id | name | dept_id | age | sex | height | login_date |+----+--------+---------+------+------+--------+------------+| 1 | Dany | 1 | 25 | F | 160 | 2015-09-10 || 2 | Green | 3 | 23 | F | 158 | 2016-10-22 || 3 | Henry | 2 | 23 | M | 185 | 2015-05-31 || 4 | Jane | 1 | 22 | F | 162 | 2016-12-20 || 5 | Jim | 1 | 24 | M | 175 | 2016-01-15 || 6 | John | 2 | 21 | M | 172 | 2015-11-11 || 7 | Lily | 6 | 22 | F | 165 | 2016-02-26 || 8 | Susan | 4 | 23 | F | 170 | 2015-10-01 || 9 | Thomas | 3 | 22 | M | 178 | 2016-06-07 || 10 | Tom | 4 | 23 | M | 165 | 2016-08-05 |+----+--------+---------+------+------+--------+------------+10 rows in set (0.26 sec)
结果显示，使用“*”通配符时，将返回所有列，数据列按照创建表时的顺序显示。
注意：一般情况下，除非需要使用表中所有的字段数据，否则最好不要使用通配符“*”。虽然使用通配符可以节省输入查询语句的时间，但是获取不需要的列数据通常会降低查询和所使用的应用程序的效率。使用“*”的优势是，当不知道所需列的名称时，可以通过“*”获取它们。
2、查询表中指定的字段
查询表中的某一个字段的语法格式为：
SELECT < 列名 > FROM < 表名 >;
示例：
查询 tb_students_info 表中 name 列所有学生的姓名，SQL 语句和运行结果如下所示。
mysql> SELECT name FROM tb_students_info;+--------+| name |+--------+| Dany || Green || Henry || Jane || Jim || John || Lily || Susan || Thomas || Tom |+--------+10 rows in set (0.00 sec)
输出结果显示了 tb_students_info 表中 name 字段下的所有数据。
使用 SELECT 声明可以获取多个字段下的数据，只需要在关键字 SELECT 后面指定要查找的字段名称，不同字段名称之间用逗号“，”分隔开，最后一个字段后面不需要加逗号，语法格式如下：
SELECT <字段名1>,<字段名2>,…,<字段名n> FROM <表名>;
示例：
从 tb_students_info 表中获取 id、name 和 height 三列，SQL 语句和运行结果如下所示。
mysql> SELECT id,name,height -> FROM tb_students_info;+----+--------+--------+| id | name | height |+----+--------+--------+| 1 | Dany | 160 || 2 | Green | 158 || 3 | Henry | 185 || 4 | Jane | 162 || 5 | Jim | 175 || 6 | John | 172 || 7 | Lily | 165 || 8 | Susan | 170 || 9 | Thomas | 178 || 10 | Tom | 165 |+----+--------+--------+10 rows in set (0.00 sec)
输出结果显示了 tb_students_info 表中 id、name 和 height 三个字段下的所有数据。
更多编程相关知识，请访问：编程视频！！
用SQL语句随便写一条数据库增删改查语句
一、增：有2种方法
1.使用insert插入单行数据：
语法：insert [into] <表名> [列名] values <列值>
例：insert into Strdents (姓名,性别,出生日期) values ('王伟华','男','1983/6/15')
注意：如果省略表名，将依次插入所有列
2.使用insert,select语句将现有表中的 数据添加到已有的新表中
语法：insert into <已有的新表> <列名> select <原表列名> from <原表名>
例：insert into addressList ('姓名','地址','电子邮件')select name,address,email
from Strdents
注意：查询得到的数据个数、顺序、数据类型等，必须与插入的项保持一致
二、删：有2中方法
1.使用delete删除数据某些数据
语法：delete from <表名> [where <删除条件>]
例：delete from a where name='王伟华'（删除表a中列值为王伟华的行）
注意：删除整行不是删除单个字段，所以在delete后面不能出现字段名
2.使用truncate table 删除整个表的数据
语法：truncate table <表名>
例：truncate table addressList
注意：删除表的所有行，但表的结构、列、约束、索引等不会被删除；不能
用于有外建约束引用的表
三、改 使用update更新修改数据
语法：update <表名> set <列名=更新值> [where <更新条件>]
例：update addressList set 年龄=18 where 姓名='王伟华'
注意：set后面可以紧随多个数据列的更新值（非数字要引号）；where子句是可选的（非数字要引号），用来条件，如果不选则整个表的所有行都被更新
四、查
语法：select <列名> from <表名> [where <查询条件表达试>] [order by <排序的列
名>[asc或desc]]
1).查询所有数据行和列
例：select * from a
说明：查询a表中所有行和
2).查询部分行列--条件查询
例：select i,j,k from a where f=5
说明：查询表a中f=5的所有行，并显示i,j,k3列
3).在查询中使用AS更改列名
例：select name as 姓名 from a where gender='男'
说明：查询a表中性别为男的所有行，显示name列，并将name列改名为（姓名）显示
4).查询空行
例：select name from a where email is null
说明：查询表a中email为空的所有行，并显示name列；SQL语句中用is null或者is not null
来判断是否为空行
5).在查询中使用常量
例：select name '北京' as 地址 from a
说明：查询表a，显示name列，并添加地址列，其列值都为'北京'
6).查询返回行数(关键字：top )
例1：select top 6 name from a
说明：查询表a，显示列name的前6行，top为关键字（oracle 中没有top关键字
用rownum替代）
select * from a where rownum<6
7).查询排序（关键字：order by , asc , desc）
例：select name
from a
where grade>=60
order by desc
说明：查询表中成绩大于等于60的所有行，并按降序显示name列；默认为ASC升序
程序员的项目简介增删改查怎么描述？
在软件开发中，"增删改查"（CRUD）是用来描述在数据库中进行的基本操作的术语。这四个操作包括：
增加（Create）：向数据库中添加新的记录。
读取（Retrieve）：从数据库中获取记录。
更新（Update）：修改数据库中的现有记录。
删除（Delete）：从数据库中删除记录。
在一个程序员的项目的简介中，你可能会描述这个项目如何支持这些操作。例如：
增加：该项目是否允许用户创建新的数据记录？例如，一个在线商店可能会让用户添加新的产品。
读取：该项目是否允许用户查看数据库中的记录？例如，用户可能能够查看他们的订单历史记录。
更新：该项目是否允许用户修改数据库中的记录？例如，用户可能能够更新他们的个人资料。
删除：该项目是否允许用户从数据库中删除记录？例如，用户可能能够取消他们的订单。
描述这些功能如何实现的，使用的技术，以及它们如何符合项目的需求和目标，将是一个有用的方式来描述一个项目。