MySql-增删改查语句
02.连接命令：mysql -h[主机地址] -u[用户名] -p[用户密码] 03.创建数据库：create database [库名] 04.显示所有数据库: show databases; 05.打开数据库:use [库名] 06.当前选择的库状态:SELECT DATABASE(); 07.创建数据表:CREATE TABLE [表名]([字段名] [字段类型]([字段要求]) [字段参数], ......); 08.显示数据表字段:describe 表名; 09.当前库数据表结构:show tables; 10.更改表格 11. ALTER TABLE [表名] ADD COLUMN [字段名] DATATYPE 12. 说明：增加一个栏位（没有删除某个栏位的语法。 13. ALTER TABLE [表名] ADD PRIMARY KEY ([字段名]) 14. 说明：更改表得的定义把某个栏位设为主键。 15. ALTER TABLE [表名] DROP PRIMARY KEY ([字段名]) 16. 说明：把主键的定义删除。 17.显示当前表字段:show columns from tablename; 18.删库:drop database [库名]; 19.删表:drop table [表名]； 20.数据操作 21.添加：INSERT INTO [表名] VALUES(‘‘,‘‘,......顺序排列的数据); 22.查询: SELECT * FROM [表名] WHERE ([条件]); 23.建立索引:CREATE INDEX [索引文件名] ON [表名] ([字段名]); 24.删除：DELETE FROM [表名] WHERE ([条件]); 25.修改：UPDATE [表名] SET [修改内容如name = ‘Mary‘] WHERE [条件]； 26. 27.导入外部数据文本: 28.1.执行外部的sql脚本 29.当前数据库上执行:mysql < input.sql 30.指定数据库上执行:mysql [表名] < input.sql 31.2.数据传入命令 load data local infile "[文件名]" into table [表名]; 32.备份数据库：(dos下) 33.mysqldump --opt school>school.bbb 34. 35. 36. 37.提示：常用MySQL命令以";"结束,有少量特殊命令不能加";"结束，如备份数据库 38.一. 增删改查操作 39. 40.================================================================================= 41.1. 增: 42.insert into 表名 values(0,‘测试‘); 43.注：如上语句，表结构中有自动增长的列，也必须为其指定一个值，通常为0 44.insert into 表名(id,name) values(0,‘尹当‘)--同上 45.2.删数据: 46.delete from 表名; 47.delete from 表名 where id=1; 48.删除结构： 49.删数据库：drop database 数据库名; 50.删除表：drop table 表名; 51.删除表中的列:alter table 表名 drop column 列名; 52.3. 改: 53.修改所有：updata 表名 set 列名=‘新的值，非数字加单引号‘ ; 54.带条件的修改：updata 表名 set 列名=‘新的值，非数字加单引号‘ where id=6; 55.4.查: 56.查询所有的数据：select *from 表名; 57.带条件的查询： 58.select *from 表名 where 列名=条件值; 59.Select * from 表名 where 列名 not like（like） ‘字符值‘ 60.分页查询：select *from 表名 limit 每页数量 offset 偏移量; 61. 62. 63. 64.二.操作命令 65. 66.================================================================================= 67.1. 查看数据库信息：show databases; 68.2.查看表信息：show tables; 69.3.查看表的结构：desc 表名 70.4. 新建数据库:create database 数据库名; 71.5.操作指定数据库:use 数据库名; 72.6.新建数据表(先use 操作库); 73.create table 表名(规范为tbl_表名) 74.( 75.id int auto_increment primary key,( auto_increment为自动增长) 76.name varchar(20) primary key 77.)ENGINE=InnoDB DEFAULT CHARSET=gbk//支持事务和设置表的编码 78.6.2添加主外键： 79.alter table 外表名 add constraint FK_名称 foreign key(外列) references 主表名(主列) 80.如现有两表 主表tbl_order 子表tbl_orderdetail 现子表tbl_orderdetail的oid列引用了主表tbl_order的oid列 81.则命令如下： 82.alter table tbl_orderdetail add constraint FK_oid foreign key(oid) references tbl_order(oid) 83.7.导出表，备份到一个文件中，如.txt,.doc 84.cmd命令窗口：mysqldump -u 用户名 -p 需要备份的数据库名 >备份的文件的保存路径和文件名 85.注：如指定的文件不存在，mysql会自动添加一个文件，此命令不能加分号结尾（文件没有备份建数据库操作） 86.8.导入数据库备份文件： 87.(1).在mysql命令窗口 88.(2).新建一个要导入的数据库(因为备份中没有备份建数据库操作) 89.(3).use 当前库名 90.(4).source 备份的文件的保存路径和文件名(此命令不能加分号结尾) 91. 92. 93.三：系统操作 94. 95.================================================================================= 96.1. 打开服务:net start mysql(mysql为配置时，可自定名称) 97.2.关闭服务:net stop mysql 98.3.从cmd 模式进入mysql 99.(1).mysql -u 用户名 -p 回车>输入正确密码>进入欢迎 100.(2).mysql -h IP(本机localhost) -u 用户名 -p 回车>输入正确密码>进入欢迎 101.3.退出：exit/quit; 102.4.修改用户密码:mysqladmin -u 用户名 -p password 新密码 103.5.处理中文乱码： 104.(1).在D:MySQL MySQL Server 5.0data的操作数据为文件中查看是否为以下： 105.default-character-set=gbk 106.default-collation=gbk_chinese_ci 107. 108.(2).查看安装文件默认编码：D:MySQLMySQL Server 5.0>my>default-character-set=gbk 109. 110.================================================================================= 111. 112. 113.启动：net start mySql; 114.进入：mysql -u root -p/mysql -h localhost -u root -p databaseName; 115.列出数据库：show databases; 116.选择数据库：use databaseName; 117.列出表格：show tables； 118.显示表格列的属性：show columns from tableName； 119.建立数据库：source fileName.txt; 120.匹配字符：可以用通配符_代表任何一个字符，％代表任何字符串; 121.增加一个字段：alter table tabelName add column fieldName dateType; 122.增加多个字段：alter table tabelName add column fieldName1 dateType,add columns fieldName2 dateType; 123.多行命令输入:注意不能将单词断开;当插入或更改数据时，不能将字段的字符串展开到多行里，否则硬回车将被储存到数据中; 124.增加一个管理员帐户：grant all on *.* to user@localhost identified by "password"; 125.每条语句输入完毕后要在末尾填加分号‘;‘，或者填加‘g‘也可以； 126.查询时间：select now(); 127.查询当前用户：select user(); 128.查询数据库版本：select version(); 129.查询当前使用的数据库：select database(); 130. 131.1、删除student_course数据库中的students数据表： 132.rm -f student_course/students.* 133. 134.2、备份数据库：(将数据库test备份) 135.mysqldump -u root -p test>c:est.txt 136.备份表格：(备份test数据库下的mytable表格) 137.mysqldump -u root -p test mytable>c:est.txt 138.将备份数据导入到数据库：(导回test数据库) 139.mysql -u root -p test 140. 141.3、创建临时表：(建立临时表zengchao) 142.create temporary table zengchao(name varchar(10)); 143. 144.4、创建表是先判断表是否存在 145.create table if not exists students(……); 146. 147.5、从已经有的表中复制表的结构 148.create table table2 select * from table1 where 1<>1; 149. 150.6、复制表 151.create table table2 select * from table1; 152. 153.7、对表重新命名 154.alter table table1 rename as table2; 155. 156.8、修改列的类型 157.alter table table1 modify id int unsigned;//修改列id的类型为int unsigned 158.alter table table1 change id sid int unsigned;//修改列id的名字为sid，而且把属性修改为int unsigned 159. 160.9、创建索引 161.alter table table1 add index ind_id (id); 162.create index ind_id on table1 (id); 163.create unique index ind_id on table1 (id);//建立唯一性索引 164. 165.10、删除索引 166.drop index idx_id on table1; 167.alter table table1 drop index ind_id; 168. 169.11、联合字符或者多个列(将列id与":"和列name和"="连接) 170.select concat(id,‘:‘,name,‘=‘) from students; 171. 172.12、limit(选出10到20条)<第一个记录集的编号是0> 173.select * from students order by id limit 9,10; 174. 175.13、MySQL不支持的功能 176.事务，视图，外键和引用完整性，存储过程和触发器 177. 178. 179.14、MySQL会使用索引的操作符号 180.<,<=,>=,>,=,between,in,不带%或者_开头的like 181. 182.15、使用索引的缺点 183.1)减慢增删改数据的速度； 184.2）占用磁盘空间； 185.3）增加查询优化器的负担； 186.当查询优化器生成执行计划时，会考虑索引，太多的索引会给查询优化器增加工作量，导致无法选择最优的查询方案； 187. 188.16、分析索引效率 189.方法：在一般的SQL语句前加上explain； 190.分析结果的含义： 191.1）table：表名； 192.2）type：连接的类型，(ALL/Range/Ref)。其中ref是最理想的； 193.3）possible_keys：查询可以利用的索引名； 194.4）key：实际使用的索引； 195.5）key_len：索引中被使用部分的长度（字节）； 196.6）ref：显示列名字或者"const"（不明白什么意思）； 197.7）rows：显示MySQL认为在找到正确结果之前必须扫描的行数； 198.8）extra：MySQL的建议； 199. 200.17、使用较短的定长列 201.1）尽可能使用较短的数据类型； 202.2）尽可能使用定长数据类型； 203.a）用char代替varchar，固定长度的数据处理比变长的快些； 204.b）对于频繁修改的表，磁盘容易形成碎片，从而影响数据库的整体性能； 205.c）万一出现数据表崩溃，使用固定长度数据行的表更容易重新构造。使用固定长度的数据行，每个记录的开始位置都是固定记录长度的倍数，可以很容易被检测到，但是使用可变长度的数据行就不一定了； 206.d）对于MyISAM类型的数据表，虽然转换成固定长度的数据列可以提高性能，但是占据的空间也大； 207. 208.18、使用not null和enum 209.尽量将列定义为not null，这样可使数据的出来更快，所需的空间更少，而且在查询时，MySQL不需要检查是否存在特例，即null值，从而优化查询； 210.如果一列只含有有限数目的特定值，如性别，是否有效或者入学年份等，在这种情况下应该考虑将其转换为enum列的值，MySQL处理的更快，因为所有的enum值在系统内都是以标识数值来表示的； 211. 212.19、使用optimize table 213.对于经常修改的表，容易产生碎片，使在查询数据库时必须读取更多的磁盘块，降低查询性能。具有可变长的表都存在磁盘碎片问题，这个问题对blob数据类型更为突出，因为其尺寸变化非常大。可以通过使用optimize table来整理碎片，保证数据库性能不下降，优化那些受碎片影响的数据表。 optimize table可以用于MyISAM和BDB类型的数据表。实际上任何碎片整理方法都是用mysqldump来转存数据表，然后使用转存后的文件并重新建数据表； 214. 215.20、使用procedure analyse() 216.可以使用procedure analyse()显示最佳类型的建议，使用很简单，在select语句后面加上procedure analyse()就可以了；例如： 217.select * from students procedure analyse(); 218.select * from students procedure analyse(16,256); 219.第二条语句要求procedure analyse()不要建议含有多于16个值，或者含有多于256字节的enum类型，如果没有限制，输出可能会很长； 220. 221.21、使用查询缓存 222.1）查询缓存的工作方式： 223.第一次执行某条select语句时，服务器记住该查询的文本内容和查询结果，存储在缓存中，下次碰到这个语句时，直接从缓存中返回结果；当更新数据表后，该数据表的任何缓存查询都变成无效的，并且会被丢弃。 224.2）配置缓存参数： 225.变量：query_cache _type，查询缓存的操作模式。有3中模式，0：不缓存；1：缓存查询，除非与 select sql_no_cache开头；2：根据需要只缓存那些以select sql_cache开头的查询； query_cache_size：设置查询缓存的最大结果集的大小，比这个值大的不会被缓存。 226. 227.22、调整硬件 228.1）在机器上装更多的内存； 229.2）增加更快的硬盘以减少I/O等待时间； 230.寻道时间是决定性能的主要因素，逐字地移动磁头是最慢的，一旦磁头定位，从磁道读则很快； 231.3）在不同的物理硬盘设备上重新分配磁盘活动； 232.如果可能，应将最繁忙的数据库存放在不同的物理设备上，这跟使用同一物理设备的不同分区是不同的，因为它们将争用相同的物理资源（磁头）。 233. 234. 235. 236. 237. 238. 239. 240.一、连接MYSQL。 241. 242.格式： mysql -h主机地址 -u用户名 －p用户密码 243. 244.1、例1：连接到本机上的MYSQL。 245. 246.首先在打开DOS窗口，然后进入目录 mysqlbin，再键入命令mysql -uroot -p，回车后提示你输密码，如果刚安装好MYSQL，超级用户root是没有密码的，故直接回车即可进入到MYSQL中了，MYSQL的提示符是：mysql> 247. 248.2、例2：连接到远程主机上的MYSQL。假设远程主机的IP为：110.110.110.110，用户名为 root,密码为abcd123。则键入以下命令： 249. 250.mysql -h110.110.110.110 -uroot -pabcd123 251. 252.（注:u与root可以不用加空格，其它也一样） 253. 254.3、退出MYSQL命令： exit （回车） 255. 256.二、修改密码。 257. 258.格式：mysqladmin -u用户名 -p旧密码 password 新密码 259. 260.1、例1：给root加个密码ab12。首先在DOS下进入目录mysqlbin，然后键入以下命令 261. 262.mysqladmin -uroot -password ab12 263. 264.注：因为开始时root没有密码，所以-p旧密码一项就可以省略了。 265. 266.2、例2：再将root的密码改为djg345。 267. 268.mysqladmin -uroot -pab12 password djg345 269. 270.三、增加新用户。（注意：和上面不同，下面的因为是MYSQL环境中的命令，所以后面都带一个分号作为命令结束符） 271. 272.格式：grant select on 数据库.* to 用户名@登录主机 identified by "密码" 273. 274.例1、增加一个用户test1密码为abc，让他可以在任何主机上登录，并对所有数据库有查询、插入、修改、删除的权限。首先用以root用户连入MYSQL，然后键入以下命令： 275. 276.grant select,insert,update,delete on *.* to test1@"%" Identified by "abc"; 277. 278.但例1增加的用户是十分危险的，你想如某个人知道test1的密码，那么他就可以在internet上的任何一台电脑上登录你的mysql数据库并对你的数据可以为所欲为了，解决办法见例2。 279. 280.例 2、增加一个用户test2密码为abc,让他只可以在localhost上登录，并可以对数据库mydb进行查询、插入、修改、删除的操作（localhost指本地主机，即MYSQL数据库所在的那台主机），这样用户即使用知道test2的密码，他也无法从 internet上直接访问数据库，只能通过MYSQL主机上的web页来访问了。 281. 282.grant select,insert,update,delete on mydb.* to test2@localhost identified by "abc"; 283. 284.如果你不想test2有密码，可以再打一个命令将密码消掉。 285. 286.grant select,insert,update,delete on mydb.* to test2@localhost identified by ""; 287. 288.在上篇我们讲了登录、增加用户、密码更改等问题。下篇我们来看看MYSQL中有关数据库方面的操作。注意：你必须首先登录到MYSQL中，以下操作都是在MYSQL的提示符下进行的，而且每个命令以分号结束。 289. 290.一、操作技巧 291. 292.1、如果你打命令时，回车后发现忘记加分号，你无须重打一遍命令，只要打个分号回车就可以了。也就是说你可以把一个完整的命令分成几行来打，完后用分号作结束标志就OK。 293. 294.2、你可以使用光标上下键调出以前的命令。但以前我用过的一个MYSQL旧版本不支持。我现在用的是mysql- 3.23.27-beta-win。 295. 296.二、显示命令 297. 298.1、显示数据库列表。 299. 300.show databases; 301. 302.刚开始时才两个数据库：mysql和test。mysql库很重要它里面有MYSQL的系统信息，我们改密码和新增用户，实际上就是用这个库进行操作。 303. 304.2、显示库中的数据表： 305. 306.use mysql； ／／打开库，学过FOXBASE的一定不会陌生吧 307. 308.show tables; 309. 310.3、显示数据表的结构： 311. 312.describe 表名; 313. 314.4、建库： 315. 316.create database 库名; 317. 318.5、建表： 319. 320.use 库名； 321. 322.create table 表名 (字段设定列表)； 323. 324.6、删库和删表: 325. 326.drop database 库名; 327. 328.drop table 表名； 329. 330.7、将表中记录清空： 331. 332.delete from 表名; 333. 334.8、显示表中的记录： 335. 336.select * from 表名; 337. 338.三、一个建库和建表以及插入数据的实例 339. 340.drop database if exists school; //如果存在SCHOOL则删除 341. 342.create database school; //建立库SCHOOL 343. 344.use school; //打开库SCHOOL 345. 346.create table teacher //建立表TEACHER 347. 348.( 349. 350.id int(3) auto_increment not null primary key, 351. 352.name char(10) not null, 353. 354.address varchar(50) default ’深圳’, 355. 356.year date 357. 358.); //建表结束 359. 360.//以下为插入字段 361. 362.insert into teacher values(’’,’glchengang’,’深圳一中’,’1976-10-10’); 363. 364.insert into teacher values(’’,’jack’,’深圳一中’,’1975-12-23’); 365. 366.注：在建表中（1）将ID设为长度为3的数字字段:int(3)并让它每个记录自动加一:auto_increment并不能为空:not null而且让他成为主字段primary key（2）将NAME设为长度为10的字符字段（3）将ADDRESS设为长度50的字符字段，而且缺省值为深圳。varchar和char有什么区别呢，只有等以后的文章再说了。（4）将YEAR设为日期字段。 367. 368.如果你在mysql提示符键入上面的命令也可以，但不方便调试。你可以将以上命令原样写入一个文本文件中假设为 school.sql，然后复制到c:下，并在DOS状态进入目录mysqlin，然后键入以下命令： 369. 370.mysql -uroot -p密码 < c:school.sql 371. 372.如果成功，空出一行无任何显示；如有错误，会有提示。（以上命令已经调试，你只要将//的注释去掉即可使用）。 373. 374.四、将文本数据转到数据库中 375. 376.1、文本数据应符合的格式：字段数据之间用tab键隔开，null值用 来代替. 377. 378.例： 379. 380.3 rose 深圳二中 1976-10-10 381. 382.4 mike 深圳一中 1975-12-23 383. 384.2、数据传入命令 load data local infile "文件名" into table 表名; 385. 386.注意：你最好将文件复制到mysqlin目录下，并且要先用use命令打表所在的库。 387. 388.五、备份数据库：（命令在DOS的mysqlin目录下执行） 389.mysqldump --opt school>school.bbb 390. 391.注释:将数据库school备份到school.bbb文件，school.bbb是一个文本文件，文件名任取，打开看看你会有新发现。 392. 393. 394. 395.mysql命令行常用命令 396. 397.第一招、mysql服务的启动和停止 398.net stop mysql 399.net start mysql 400.第二招、登陆mysql 401.语法如下： mysql -u用户名 -p用户密码 402.键入命令mysql -uroot -p， 回车后提示你输入密码，输入12345，然后回车即可进入到mysql中了，mysql的提示符是： 403.mysql> 404.注意，如果是连接到另外的机器上，则需要加入一个参数-h机器IP 405.第三招、增加新用户 406.格式：grant 权限 on 数据库.* to 用户名@登录主机 identified by "密码" 407.如，增加一个用户user1密码为password1，让其可以在本机上登录， 并对所有数据库有查询、插入、修改、删除的权限。首先用以root用户连入mysql，然后键入以下命令： 408.grant select,insert,update,delete on *.* to user1@localhost Identified by "password1"; 409.如果希望该用户能够在任何机器上登陆mysql，则将localhost改为"%"。 410.如果你不想user1有密码，可以再打一个命令将密码去掉。 411.grant select,insert,update,delete on mydb.* to user1@localhost identified by ""; 412.第四招： 操作数据库 413.登录到mysql中，然后在mysql的提示符下运行下列命令，每个命令以分号结束。 414.1、 显示数据库列表。 415.show databases; 416.缺省有两个数据库：mysql和 test。 mysql库存放着mysql的系统和用户权限信息，我们改密码和新增用户，实际上就是对这个库进行操作。 417.2、 显示库中的数据表： 418.use mysql; 419.show tables; 420.3、 显示数据表的结构： 421.describe 表名; 422.4、 建库与删库： 423.create database 库名; 424.drop database 库名; 425.5、 建表： 426.use 库名; 427.create table 表名(字段列表); 428.drop table 表名; 429.6、 清空表中记录： 430.delete from 表名; 431.7、 显示表中的记录： 432.select * from 表名; 433.第五招、导出和导入数据 434.1. 导出数据： 435.mysqldump --opt test > mysql.test 436.即将数据库test数据库导出到mysql.test文件，后者是一个文本文件 437.如：mysqldump -u root -p123456 --databases dbname > mysql.dbname 438.就是把数据库dbname导出到文件mysql.dbname中。 439.2. 导入数据: 440.mysqlimport -u root -p123456 < mysql.dbname。 441.不用解释了吧。 442.3. 将文本数据导入数据库: 443.文本数据的字段数据之间用tab键隔开。 444.use test; 445.load data local infile "文件名" into table 表名; 446. 447.SQL常用命令使用方法： 448. 449.(1) 数据记录筛选： 450. 451.sql="select * from 数据表 where 字段名=字段值 order by 字段名 [desc]" 452. 453.sql="select * from 数据表 where 字段名 like ‘%字段值%‘ order by 字段名 [desc]" 454. 455.sql="select top 10 * from 数据表 where 字段名 order by 字段名 [desc]" 456. 457.sql="select * from 数据表 where 字段名 in (‘值1‘,‘值2‘,‘值3‘)" 458. 459.sql="select * from 数据表 where 字段名 between 值1 and 值2" 460. 461.(2) 更新数据记录： 462. 463.sql="update 数据表 set 字段名=字段值 where 条件表达式" 464. 465.sql="update 数据表 set 字段1=值1,字段2=值2 …… 字段n=值n where 条件表达式" 466. 467.(3) 删除数据记录： 468. 469.sql="delete from 数据表 where 条件表达式" 470. 471.sql="delete from 数据表" (将数据表所有记录删除) 472. 473.(4) 添加数据记录： 474. 475.sql="insert into 数据表 (字段1,字段2,字段3 …) valuess (值1,值2,值3 …)" 476. 477.sql="insert into 目标数据表 select * from 源数据表" (把源数据表的记录添加到目标数据表) 478. 479.(5) 数据记录统计函数： 480. 481.AVG(字段名) 得出一个表格栏平均值 482.COUNT(*|字段名) 对数据行数的统计或对某一栏有值的数据行数统计 483.MAX(字段名) 取得一个表格栏最大的值 484.MIN(字段名) 取得一个表格栏最小的值 485.SUM(字段名) 把数据栏的值相加 486. 487.引用以上函数的方法： 488. 489.sql="select sum(字段名) as 别名 from 数据表 where 条件表达式" 490.set rs=conn.excute(sql) 491. 492.用 rs("别名") 获取统的计值，其它函数运用同上。 493. 494.(6) 数据表的建立和删除： 495. 496.CREATE TABLE 数据表名称(字段1 类型1(长度),字段2 类型2(长度) …… ) 497. 498.例：CREATE TABLE tab01(name varchar(50),datetime default now()) 499. 500.DROP TABLE 数据表名称 (永久性删除一个数据表) 501. 502. 503. 504.select * from test.text where 1 *表示所有栏目 test指数据库名text指表名 where指条件 505.Select remark as r id,uid from test.text where 指id uid 2栏显示 as 就是给栏目命名 506.select * from test.text where id>4 指ID大于4的都显示出来 507.select * from test.text where id<>4 指ID 不等于4的都出来 508.select * from test.text where id=1 指ID等于1的出来 509.select * from test.text where id in(1,3,5) 指找出ID为1 3 5的 not in（）则相反 510.select * from test.text where uid like "%王%" 指UID里只要带王字的都出来 %王 表示什么王 ，王%表示 王什么。 511.select * from test.text where remark like "%学%" 指remark里带学的都出来 512.select * from test.text where id between 1 and 10 and uid like "%王%"表示ID 1-10 并且 UID带王字的出来 513.select * from test.text where id not between 1 and 4 指ID不在1-4里面的 出来 514.（1 and 2 表示满足1且满足2 1 or 2 表示满足1和满足2 ）and or可以连接很多条件 515.select * from test.text group by remark 显示列出remark有多少类别 如图↓ 有5类 group by 就是分组命令 516. 517.select * from test.text order by regdate asc 把regdate 按从小到大排列 518.ASC不打就是默认从小到大 DESC表示从大到小 如 order desc 519.select * from test.text order by regdate asc,id desc 这样就查询出日期从小到大 然后在满足日期的排列后 ID从大到小排列 520.select * from test.text limit 0,5 表示取5条记录 如果是3，6 那就是第4-第9条记录被取出 如图↓ 521.如过只写一个6那就等于0，6 522.select * from test.text group by remark order by regdate limit 6 先分组 再排序 LIMIT放最后 这是语法不能颠倒。 523.select count(id) from test.text count()表示查询有多少条信息 这样根据表显示出10条 524.select max(regdate) from test.text max() 查询最大值 只能针对数字 包括日期 根据表显示出2008-10-22 14:41:30 525.select min(regdate)from test.text min() 查询最小值 只能针对数字 包括日期 根据表显示出2008-10-07 13:21:32 526.select avg(id) from test.text avg() 查询平均值 也只针对数字 包括日期 显示出5.5 如算平均分数 527.select sum(id) from test.text sum() 查询累计值 数字包括日期 显示出55 1+2+3+。10=55 如算总分数 528.insert 插入语句 529.insert into `text`(`id`,`uid`,`regdate`,`remark`)values(null,‘ken‘,now(),‘学生‘) 其中null就是没有 now()就是时间日期自动生成 530.字段的类型要设计好。特别注意！ 531. 532. 533. 534. 535.Update 更改语句 536.Update 表名 set 字段=值 where 条件 LIMIT（可省略） 537.update test.text set uid=‘kenchen‘ where id=11 意思是把ID是11的UID 改成kenchen 538. 539.Delete 删除语句 540.Delete from 表命 where limit 541.Delete from text where id=3 意思是把ID=3的信息条删除！ 542. 543.mysql 字段类型说明- - 544. 545. 546.MySQL支持大量的列类型，它可以被分为3类：数字类型、日期和时间类型以及字符串(字符)类型。本节首先给出可用类型的一个概述，并且总结每个列类型的存储需求，然后提供每个类中的类型性质的更详细的描述。概述有意简化，更详细的说明应该考虑到有关特定列类型的附加信息，例如你能为其指定值的允许格式。 547. 548.由MySQL支持的列类型列在下面。下列代码字母用于描述中： 549. 550.M 551.指出最大的显示尺寸。最大的合法的显示尺寸是 255 。 552.D 553.适用于浮点类型并且指出跟随在十进制小数点后的数码的数量。最大可能的值是30，但是应该不大于M-2。 554.方括号(“[”和“]”)指出可选的类型修饰符的部分。 555. 556.注意，如果你指定一个了为ZEROFILL，MySQL将为该列自动地增加UNSIGNED属性。 557. 558.TINYINT[(M)] [UNSIGNED] [ZEROFILL] 559.一个很小的整数。有符号的范围是-128到127，无符号的范围是0到255。 560. 561. 562.SMALLINT[(M)] [UNSIGNED] [ZEROFILL] 563.一个小整数。有符号的范围是-32768到32767，无符号的范围是0到65535。 564. 565.MEDIUMINT[(M)] [UNSIGNED] [ZEROFILL] 566.一个中等大小整数。有符号的范围是-8388608到8388607，无符号的范围是0到16777215。 567. 568.INT[(M)] [UNSIGNED] [ZEROFILL] 569.一个正常大小整数。有符号的范围是-2147483648到2147483647，无符号的范围是0到4294967295。 570. 571.INTEGER[(M)] [UNSIGNED] [ZEROFILL] 572.这是INT的一个同义词。 573.BIGINT[(M)] [UNSIGNED] [ZEROFILL] 574.一个大整数。有符号的范围是-9223372036854775808到9223372036854775807，无符号的范围是0到 575.18446744073709551615。注意，所有算术运算用有符号的BIGINT或DOUBLE值完成，因此你不应该使用大于9223372036854775807（63位)的有符号大整数，除了位函数！注意，当两个参数是INTEGER值时，-、+和*将使用BIGINT运算！这意味着如果你乘2个大整数(或来自于返回整数的函数)，如果结果大于9223372036854775807，你可以得到意外的结果。一个浮点数字，不能是无符号的，对一个单精度浮点数，其精度可以是<=24，对一个双精度浮点数，是在25 和53之间，这些类型如FLOAT和DOUBLE类型马上在下面描述。FLOAT(X)有对应的FLOAT和DOUBLE相同的范围，但是显示尺寸和小数位数是未定义的。在MySQL3.23中，这是一个真正的浮点值。在更早的MySQL版本中，FLOAT(precision)总是有2位小数。该句法为了ODBC兼容性而提供。 576. 577.FLOAT[(M,D)] [ZEROFILL] 578.一个小(单精密)浮点数字。不能无符号。允许的值是-3.402823466E+38到-1.175494351E-38，0 和1.175494351E-38到3.402823466E+38。M是显示宽度而D是小数的位数。没有参数的FLOAT或有<24 的一个参数表示一个单精密浮点数字。 579.DOUBLE[(M,D)] [ZEROFILL] 580.一个正常大小(双精密)浮点数字。不能无符号。允许的值是-1.7976931348623157E+308到-2.2250738585072014E-308、 0和2.2250738585072014E-308到1.7976931348623157E+308。M是显示宽度而D是小数位数。没有一个参数的DOUBLE或FLOAT(X)（25 < = X < = 53）代表一个双精密浮点数字。 581.DOUBLE PRECISION[(M,D)] [ZEROFILL] 582.REAL[(M,D)] [ZEROFILL] 583.这些是DOUBLE同义词。 584.DECIMAL[(M[,D])] [ZEROFILL] 585.一个未压缩(unpack)的浮点数字。不能无符号。行为如同一个CHAR列：“未压缩”意味着数字作为一个字符串被存储，值的每一位使用一个字符。小数点，并且对于负数，“-”符号不在M中计算。如果D是0，值将没有小数点或小数部分。DECIMAL值的最大范围与DOUBLE相同，但是对一个给定的DECIMAL列，实际的范围可以通过M和D的选择被限制。如果D被省略，它被设置为0。如果M被省掉，它被设置为10。注意，在MySQL3.22里，M参数包括符号和小数点。 586. 587. 588.NUMERIC(M,D) [ZEROFILL] 589.这是DECIMAL的一个同义词。 DATE 590.一个日期。支持的范围是‘1000-01-01‘到‘9999-12-31‘。MySQL以‘YYYY-MM-DD‘格式来显示DATE值，但是允许你使用字符串或数字把值赋给DATE列。 591.DATETIME 592.一个日期和时间组合。支持的范围是‘1000-01-01 00:00:00‘到‘9999-12-31 23:59:59‘。MySQL以‘YYYY-MM-DD HH:MM:SS‘格式来显示DATETIME值，但是允许你使用字符串或数字把值赋给DATETIME的列。 593.TIMESTAMP[(M)] 594.一个时间戳记。范围是‘1970-01-01 00:00:00‘到2037年的某时。MySQL以YYYYMMDDHHMMSS、YYMMDDHHMMSS、YYYYMMDD或YYMMDD格式来显示TIMESTAMP值，取决于是否M是14（或省略)、12、8或6，但是允许你使用字符串或数字把值赋给TIMESTAMP列。一个TIMESTAMP列对于记录一个INSERT或UPDATE操作的日期和时间是有用的，因为如果你不自己给它赋值，它自动地被设置为最近操作的日期和时间。你以可以通过赋给它一个NULL值设置它为当前的日期和时间。 595.TIME 596.一个时间。范围是‘-838:59:59‘到‘838:59:59‘。MySQL以‘HH:MM:SS‘格式来显示TIME值，但是允许你使用字符串或数字把值赋给TIME列。 597.YEAR[(2|4)] 598.一个2或4位数字格式的年(缺省是4位)。允许的值是1901到2155，和0000（4位年格式），如果你使用2位，1970-2069( 70-69)。MySQL以YYYY格式来显示YEAR值，但是允许你把使用字符串或数字值赋给YEAR列。（YEAR类型在MySQL3.22中是新类型。） 599.CHAR(M) [BINARY] 600.一个定长字符串，当存储时，总是是用空格填满右边到指定的长度。M的范围是1 ～ 255个字符。当值被检索时，空格尾部被删除。CHAR值根据缺省字符集以大小写不区分的方式排序和比较，除非给出BINARY关键词。NATIONAL CHAR（短形式NCHAR)是ANSI SQL的方式来定义CHAR列应该使用缺省字符集。这是MySQL的缺省。CHAR是CHARACTER的一个缩写。 601.[NATIONAL] VARCHAR(M) [BINARY] 602.一个变长字符串。注意：当值被存储时，尾部的空格被删除(这不同于ANSI SQL规范)。M的范围是1 ～ 255个字符。 VARCHAR值根据缺省字符集以大小写不区分的方式排序和比较，除非给出BINARY关键词值。 VARCHAR是CHARACTER VARYING一个缩写。 603.TINYBLOB 604.TINYTEXT 605.一个BLOB或TEXT列，最大长度为255(2^8-1)个字符。 606.BLOB 607.TEXT 608.一个BLOB或TEXT列，最大长度为65535(2^16-1)个字符。 609.MEDIUMBLOB 610.MEDIUMTEXT 611.一个BLOB或TEXT列，最大长度为16777215(2^24-1)个字符。 612.LONGBLOB 613.LONGTEXT 614.一个BLOB或TEXT列，最大长度为4294967295(2^32-1)个字符。 615.ENUM(‘value1‘,‘value2‘,...) 616.枚举。一个仅有一个值的字符串对象，这个值式选自与值列表‘value1‘、‘value2‘, ...,或NULL。一个ENUM最多能有65535不同的值。 617.SET(‘value1‘,‘value2‘,...) 618.一个集合。能有零个或多个值的一个字符串对象，其中每一个必须从值列表‘value1‘, ‘value2‘, ...选出。一个SET最多能有64个成员。
MySql-增删改查语句
标签：删除语句 成员 ext win 目的 权限 cmd命令 多行 root用户
小编还为您整理了以下内容，可能对您也有帮助：
数据库中增删改查的基本语句是什么
常见如下：
进入mysql命令行: mysql -uroot -p；查看所有数据库: show databases;增加创建数据库： create database niu charset utf8;删除数据库： drop database niu;选择数据库： use databases。
查看所有表： show tables;查看创建数据库的语句：show create database databasename;查看创建表的语句：show create table tablename;查看表结构：desc tablenmae。
相关简介
mysql_stmt_fetch是函数名，mysql_stmt_fetch()返回结果集中的下一行。
仅能当结果集存在时调用它，也就是说，调用了能创建结果集的mysql_stmt_execute()之后，或当mysql_stmt_execute()对整个结果集即行缓冲处理后调用了mysql_stmt_store_result()。
使用mysql_stmt_bind_result()绑定的缓冲，mysql_stmt_fetch()返回行数据。对于当前列集合中的所有列，它将返回缓冲内的数据，并将长度返回到长度指针。
数据库中增删改查的基本语句是什么
常见如下：
进入mysql命令行: mysql -uroot -p；查看所有数据库: show databases;增加创建数据库： create database niu charset utf8;删除数据库： drop database niu;选择数据库： use databases。
查看所有表： show tables;查看创建数据库的语句：show create database databasename;查看创建表的语句：show create table tablename;查看表结构：desc tablenmae。
相关简介
mysql_stmt_fetch是函数名，mysql_stmt_fetch()返回结果集中的下一行。
仅能当结果集存在时调用它，也就是说，调用了能创建结果集的mysql_stmt_execute()之后，或当mysql_stmt_execute()对整个结果集即行缓冲处理后调用了mysql_stmt_store_result()。
使用mysql_stmt_bind_result()绑定的缓冲，mysql_stmt_fetch()返回行数据。对于当前列集合中的所有列，它将返回缓冲内的数据，并将长度返回到长度指针。
mysql中增删改查语法是什么?
select 字段名（多个字段可以用,隔开 *标示全部） from 表名 where条件
insert into 表名(字段名1,字段名2) values('数值1'，'数值2')
语法：update 表名 set 字段名1='更新的值',字段名2='更新的值' where条件
delete from biao where条件
基本上就这四个基本的语法了，如果你觉的有用，就采纳吧
参考资料：http://www.itnet.org.cn/news414.html
mysql中增删改查语法是什么?
select 字段名（多个字段可以用,隔开 *标示全部） from 表名 where条件
insert into 表名(字段名1,字段名2) values('数值1'，'数值2')
语法：update 表名 set 字段名1='更新的值',字段名2='更新的值' where条件
delete from biao where条件
基本上就这四个基本的语法了，如果你觉的有用，就采纳吧
参考资料：http://www.itnet.org.cn/news414.html
数据库中增删改查的基本语句是什么?
数据库中增删改查基本语句：INSERT INTO，表名字段列表。
数据库是存放数据的仓库。它的存储空间很大，可以存放百万条、千万条、上亿条数据。但是数据库并不是随意地将数据进行存放，是有一定的规则的，否则查询的效率会很低。
当今世界是一个充满着数据的互联网世界，充斥着大量的数据。即这个互联网世界就是数据世界。数据的来源有很多，比如出行记录、消费记录、浏览的网页、发送的消息等等。除了文本类型的数据，图像、音乐、声音都是数据。
在数据库的发展历史上，数据库先后经历了层次数据库、网状数据库和关系数据库等各个阶段的发展，数据库技术在各个方面的快速的发展。特别是关系型数据库已经成为目前数据库产品中最重要的一员。
80年代以来，几乎所有的数据库厂商新出的数据库产品都支持关系型数据库，即使一些非关系数据库产品也几乎都有支持关系数据库的接口。
这主要是传统的关系型数据库可以比较好的解决管理和存储关系型数据的问题。随着云计算的发展和大数据时代的到来，关系型数据库越来越无法满足需要，这主要是由于越来越多的半关系型和非关系型数据需要用数据库进行存储管理。
数据库中增删改查的基本语句是什么?
数据库中增删改查基本语句：INSERT INTO，表名字段列表。
数据库是存放数据的仓库。它的存储空间很大，可以存放百万条、千万条、上亿条数据。但是数据库并不是随意地将数据进行存放，是有一定的规则的，否则查询的效率会很低。
当今世界是一个充满着数据的互联网世界，充斥着大量的数据。即这个互联网世界就是数据世界。数据的来源有很多，比如出行记录、消费记录、浏览的网页、发送的消息等等。除了文本类型的数据，图像、音乐、声音都是数据。
在数据库的发展历史上，数据库先后经历了层次数据库、网状数据库和关系数据库等各个阶段的发展，数据库技术在各个方面的快速的发展。特别是关系型数据库已经成为目前数据库产品中最重要的一员。
80年代以来，几乎所有的数据库厂商新出的数据库产品都支持关系型数据库，即使一些非关系数据库产品也几乎都有支持关系数据库的接口。
这主要是传统的关系型数据库可以比较好的解决管理和存储关系型数据的问题。随着云计算的发展和大数据时代的到来，关系型数据库越来越无法满足需要，这主要是由于越来越多的半关系型和非关系型数据需要用数据库进行存储管理。
mysql增删改查语句怎么写
增加语句是insert，例如insert into ttt(id) values(1,2,3);
删除语句是delete，例如delete from ttt where id=1;
修改语句是update，力图update ttt set id=4 where id=2;
mysql增删改查语句怎么写
增加语句是insert，例如insert into ttt(id) values(1,2,3);
删除语句是delete，例如delete from ttt where id=1;
修改语句是update，力图update ttt set id=4 where id=2;
数据库增删改查的基本命令
（推荐教程：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 三个字段下的所有数据。
更多编程相关知识，请访问：编程视频！！
如何利用MySQL Workbench自动生成增删改查语句
1、先用Navicat for MySQL创建名字为shopping的数据库，如下图所示：
2、创建的shopping数据库上运行已有的.sql文件，要注意上面创建的数据库名字shopping最好和原先.sql文件中的名字一样，也可以不一样，如果不一样的话会自动生成原来.sql文件中SQL语句中所命名的数据库。
此时，可以把上面创建的shopping数据库删除了就可以，直接用自动生成的就行。
运行.sql步骤如下：右键你刚才创建的shopping数据库——>运行sql文件...——>选择.sql文件位置——执行即可。
MySQL — 关键字和增删改查
来自MySQL的学习笔记，写的不对的地方大家多多指教哦
SELECT、DISTINCT、FROM、JOIN、ON、WHERE、GROUP BY、HAVING、SUM、COUNT、MAX、AVG、ORDER BY、LIMIT
SELECT->DISTINCT->FROM->JOIN->ON->WHERE->GROUP BY->HAVING->ORDER BY->LIMIT
必须字段：SELECT、FROM
可选字段：DISTINCT、JOIN、ON、WHERE、GROUP BY、HAVING、SUM、COUNT、MAX、AVG、ORDER BY、LIMIT
FROM->ON->JOIN->WHERE->GROUP BY（开始使用SELECT中的别名，后面的语句中都可以使用别名）->SUM、COUNT、MAX、AVG->HAVING->SELECT->DISTINCT->ORDER BY->LIMIT
FROM：从哪个表中检索数据
ON：关联条件，与join一起使用
JOIN：对需要关联的表进行关联
WHERE：过滤数据条件，执行顺序：自下而上、从右到左
GROUP BY：将过滤的数据进行分组，执行顺序：从左往右
SUM：求和
COUNT：数量统计
MAX：最大值
AVG：求平均值
HAVING：对分组的数据过滤条件，与group by一起使用
SELECT：查看结果集
DISTINCT：结果集去重
ORDER BY：排序，升序：ASC；降序：DESC
LIMIT：截取出目标页数据
详细用法会在后面进行补充
首先创建一张表，添加字段，表名字为：goodsmaster
添加数据的语法结构为：
添加数据可以是插入数据或插入查询的结果
1.1 插入数据
运行语句，查询结果：SELECT * FROM goodsmaster
部分字段有做非空约束，那么这边插入部分数据，验证下非空约束
上面的语句运行之后会报错，错误内容为“[Err] 1364 - Field 'barcode' doesn't have a default value”，即“barcode”这个字段有创建非空约束，表示这个字段不能为空，如果插入数据时不给这个字段赋值，那么就需要给它一个默认值。
部分字段没有默认值，可以为空，那么现在验证一下插入数据时，这些字段不进行赋值会有什么结果
运行语句，查询结果：SELECT * FROM goodsmaster
仔细看会发现，上面的语句中插入数据也没有插入“itemnumber”字段，这个字段有添加主键约束，不能为空，但由于设置了自增约束，所以没有赋值也会自动在当前字段最大值+1，这就是自增约束；
上面的语句显示没有进行赋值的字段会默认显示Null。
1.2 插入查询结果
MySQL 支持把查询的结果插入到数据表中，我们可以指定字段，甚至是数值，插入到数据表中。
语法结构为：
删除语句使用DELETE删除，语法结构为：
删除记录可以使用WHERE来筛选删除的数据，下面为删除“barcode”字段数据为006的记录
由于部分数据可以为空，所以再删除的时候，WHERE的过滤条件必须用到主键约束或者唯一性约束的字段。MySQL 的这种安全性设置，主要就是为了防止删除或者修改数据时出现误操作，导致删除或修改了不相关的数据。
删除表中的全部数据
MySQL中用UPDATE来修改数据，语法结构为：
注意：不要修改主键字段的值。因为主键是数据记录的唯一标识，如果修改了主键的值，就有可能会破坏数据的完整性。
语法结构：
具体需要用到的关键字查看本文第一部分即可
MySQL — 关键字和增删改查
来自MySQL的学习笔记，写的不对的地方大家多多指教哦
SELECT、DISTINCT、FROM、JOIN、ON、WHERE、GROUP BY、HAVING、SUM、COUNT、MAX、AVG、ORDER BY、LIMIT
SELECT->DISTINCT->FROM->JOIN->ON->WHERE->GROUP BY->HAVING->ORDER BY->LIMIT
必须字段：SELECT、FROM
可选字段：DISTINCT、JOIN、ON、WHERE、GROUP BY、HAVING、SUM、COUNT、MAX、AVG、ORDER BY、LIMIT
FROM->ON->JOIN->WHERE->GROUP BY（开始使用SELECT中的别名，后面的语句中都可以使用别名）->SUM、COUNT、MAX、AVG->HAVING->SELECT->DISTINCT->ORDER BY->LIMIT
FROM：从哪个表中检索数据
ON：关联条件，与join一起使用
JOIN：对需要关联的表进行关联
WHERE：过滤数据条件，执行顺序：自下而上、从右到左
GROUP BY：将过滤的数据进行分组，执行顺序：从左往右
SUM：求和
COUNT：数量统计
MAX：最大值
AVG：求平均值
HAVING：对分组的数据过滤条件，与group by一起使用
SELECT：查看结果集
DISTINCT：结果集去重
ORDER BY：排序，升序：ASC；降序：DESC
LIMIT：截取出目标页数据
详细用法会在后面进行补充
首先创建一张表，添加字段，表名字为：goodsmaster
添加数据的语法结构为：
添加数据可以是插入数据或插入查询的结果
1.1 插入数据
运行语句，查询结果：SELECT * FROM goodsmaster
部分字段有做非空约束，那么这边插入部分数据，验证下非空约束
上面的语句运行之后会报错，错误内容为“[Err] 1364 - Field 'barcode' doesn't have a default value”，即“barcode”这个字段有创建非空约束，表示这个字段不能为空，如果插入数据时不给这个字段赋值，那么就需要给它一个默认值。
部分字段没有默认值，可以为空，那么现在验证一下插入数据时，这些字段不进行赋值会有什么结果
运行语句，查询结果：SELECT * FROM goodsmaster
仔细看会发现，上面的语句中插入数据也没有插入“itemnumber”字段，这个字段有添加主键约束，不能为空，但由于设置了自增约束，所以没有赋值也会自动在当前字段最大值+1，这就是自增约束；
上面的语句显示没有进行赋值的字段会默认显示Null。
1.2 插入查询结果
MySQL 支持把查询的结果插入到数据表中，我们可以指定字段，甚至是数值，插入到数据表中。
语法结构为：
删除语句使用DELETE删除，语法结构为：
删除记录可以使用WHERE来筛选删除的数据，下面为删除“barcode”字段数据为006的记录
由于部分数据可以为空，所以再删除的时候，WHERE的过滤条件必须用到主键约束或者唯一性约束的字段。MySQL 的这种安全性设置，主要就是为了防止删除或者修改数据时出现误操作，导致删除或修改了不相关的数据。
删除表中的全部数据
MySQL中用UPDATE来修改数据，语法结构为：
注意：不要修改主键字段的值。因为主键是数据记录的唯一标识，如果修改了主键的值，就有可能会破坏数据的完整性。
语法结构：
具体需要用到的关键字查看本文第一部分即可
请问如何对用Java对mysql进行增删改查等方法?
package com.ly520.db;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.List;
import java.util.Vector;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;
/**
* mysql数据库操作类。
*
* @author Ryoma
*
*/
public class MySqlOperate implements SqlOperate {
private Connection con;
private String DBname;
private String sql;
/**
* Mysql数据库初始化包名
*/
private String INIT_SQL_CTX = "org.gjt.mm.mysql.Driver";
/**
* MYSQL数据库服务参数:服务器IP地址和端口
*/
private String SQL_SERVICE = "jdbc:mysql://127.0.0.1:3306?autoReconnect=true&useUnicode=true&characterEncoding=utf-8&mysqlEncoding=utf8";
/**
* MYSQL数据库参数:系统管理用户
*/
private String SQL_SYSTEM_USER = "root";
/**
* MYSQL数据库参数:系统管理密码
*/
private String SQL_SYSTEM_PASSWORD = "123456";
/**
* 初始化链接方法。此方法不需要再使用use Dbname;
*/
public MySqlOperate() {
try {
Context ctx = new InitialContext();
if (ctx == null)
throw new Exception("Boom - No Context");
// java:comp/env/jdbc/imabled_mysql 为配置的连接池的jndi名称。
DataSource ds = (DataSource) ctx
.lookup("java:comp/env/jdbc/imabled_mysql");
con = ds.getConnection();
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* 指定库名的连接方法，此方法没有使用连接池，不赞成使用。
*
* @param DBn
*/
public MySqlOperate(String DBn) {
try {
Class.forName(this.INIT_SQL_CTX);
} catch (java.lang.ClassNotFoundException e) {
e.printStackTrace();
}
try {
con = DriverManager.getConnection(this.SQL_SERVICE + "/" + DBn,
this.SQL_SYSTEM_USER, this.SQL_SYSTEM_PASSWORD);
DBname = DBn;
} catch (SQLException ex) {
ex.printStackTrace();
}
}
public boolean add(String tablename, Hashtable searchdetail) {
Statement stmt = null;
Enumeration key_values = searchdetail.keys();
String key, value;
String temp = (String) key_values.nextElement();
key = temp;
value = "'" + searchdetail.get(temp) + "'";
while (key_values.hasMoreElements()) {
temp = (String) key_values.nextElement();
key = key + "," + temp;
value = value + "," + "'" + searchdetail.get(temp) + "'";
}
try {
useDB();
stmt = con.createStatement();
sql = "insert into " + tablename + " (" + key + ") " + " VALUES ("
+ value + ")";
stmt.executeUpdate(sql);
return true;
} catch (SQLException ex) {
System.out.println("执行的出错的sql语句:" + sql);
ex.printStackTrace();
return false;
} finally {
closeStmt(stmt);
}
}
public boolean batchImport(String tablename, List list, String[] fields)
throws SQLException {
PreparedStatement ps = null;
String key, value;
key = toString(fields);
String[] values = new String[fields.length];
for (int i = 0; i < values.length; i++) {
values[i] = "?";
}
value = toString(values);
try {
useDB();
con.setAutoCommit(false);
System.out.println("insert into " + tablename + " (" + key + ") "
+ " VALUES (" + value + ")");
ps = con.prepareStatement("insert into " + tablename + " (" + key
+ ") " + " VALUES (" + value + ")");
String[] tmpData = null;
for (int i = 0; i < list.size(); i++) {
tmpData = (String[]) list.get(i);
for (int j = 0; j < fields.length && j < tmpData.length; j++) {
ps.setString(j + 1, tmpData[j]);
}
ps.addBatch();// 添加执行的语句。
}
int[] count = ps.executeBatch();// 批量执行
con.commit();
return true;
} catch (SQLException ex) {
throw ex;
} finally {
try {
if (ps != null) {
ps.clearParameters();
ps.close();
ps = null;
}
} catch (SQLException e) {
throw e;
}
}
}
public boolean delete(String tablename, String filter) {
Statement stmt = null;
String value;
try {
useDB();
stmt = con.createStatement();
sql = "delete from " + tablename + " where " + filter;
stmt.executeUpdate(sql);
return true;
} catch (SQLException e) {
System.out.println("执行的出错的sql语句:" + sql);
e.printStackTrace();
return false;
} finally {
closeStmt(stmt);
}
}
public Hashtable list(String sql) {
Hashtable[] infoList = search(sql);
if (infoList == null || infoList.length < 1)
return null;
return infoList[0];
}
public Hashtable list(String tablename, String id) {
String sql = "select * from " + tablename + " where id ='" + id + "'";
return list(sql);
}
public boolean modify(String tablename, Hashtable setdetail, String filter) {
Enumeration key_values = setdetail.keys();
Statement stmt = null;
String value;
String temp = (String) key_values.nextElement();
value = temp + "='" + setdetail.get(temp) + "'";
while (key_values.hasMoreElements()) {
temp = (String) key_values.nextElement();
value = value + "," + temp + "='" + setdetail.get(temp) + "'";
}
try {
useDB();
stmt = con.createStatement();
sql = "update " + tablename + " set " + value + " where " + filter;
int tag = stmt.executeUpdate(sql);
if (tag == 0)
return false;
else
return true;
} catch (SQLException e) {
System.out.println("执行的出错的sql语句:" + sql);
e.printStackTrace();
return false;
} finally {
closeStmt(stmt);
}
}
public Hashtable[] search(String sql) {
ResultSet rs;
Statement stmt = null;
try {
useDB();
stmt = con.createStatement();
rs = stmt.executeQuery(sql);
return toHashtableArray(rs);
} catch (SQLException ex) {
System.out.println("执行的出错的sql语句:" + sql);
ex.printStackTrace();
return null;
} finally {
closeStmt(stmt);
}
}
public Hashtable[] search(String tablename, String[] fieldname,
String filter) {
return search(tablename, fieldname, filter, "");
}
public Hashtable[] search(String tablename, String[] fieldname,
String filter, String ordergroup) {
ResultSet rs;
Statement stmt = null;
String colname = fieldname[0];
for (int i = 1; i < fieldname.length; i++) {
colname += "," + fieldname[i];
}
String queryString = "select " + colname + " from " + tablename;
if (!filter.equals("")) {
queryString = queryString + " where " + filter;
}
if (!ordergroup.equals("")) {
queryString = queryString + " " + ordergroup;
}
return search(sql);
}
/**
* @return the con
*/
public Connection getCon() {
return con;
}
public void close() {
try {
if (con != null)
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 返回使用的数据库
*
* @return the dBname
*/
public String getDBname() {
return DBname;
}
/**
* 设置使用的数据库
*
* @param bname
* the dBname to set
*/
public void setDBname(String bname) {
DBname = bname;
}
/**
* 返回执行的sql语句
*
* @return the sql
*/
public String getSql() {
return sql;
}
/**
* 本方法是为了再没有使用连接池的情况下，首先选择使用的数据库。
*/
private void useDB() {
if (DBname != null && DBname.equals("")) {
String query = "use " + DBname;
Statement stmt = null;
try {
stmt = con.createStatement();
stmt.execute(query);
} catch (SQLException e) {
e.printStackTrace();
} finally {
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
/**
* 关闭Statement
*
* @param stmt
*/
private void closeStmt(Statement stmt) {
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/**
* @param ss
* @return
*/
private String toString(String[] ss) {
String s = "";
for (int i = 0; i < ss.length; i++) {
s += ss[i] + ",";
}
if (s.endsWith(","))
s = s.substring(0, s.length() - 1);
return s;
}
/**
* 把ResultSet转换成Hashtable数组 java.util.Arrays.asList 可以把数组转换成List
*
* @param rs
* @return
*/
private Hashtable[] toHashtableArray(ResultSet rs) {
Vector searchresult = new Vector();
try {
ResultSetMetaData rsmd = rs.getMetaData();
int column = rsmd.getColumnCount();
while (rs.next()) {
Hashtable onerow = new Hashtable();
for (int i = 1; i <= column; i++) {
try {
String columnName = rsmd.getColumnName(i);
String columnValue = rs.getString(columnName);
onerow.put(columnName, columnValue);
} catch (Exception e) {
}
}
searchresult.add(onerow);
}
Hashtable[] searchset = new Hashtable[searchresult.size()];
searchresult.toArray(searchset);
return searchset;
} catch (SQLException e) {
e.printStackTrace();
return null;
}
}
}
请问如何对用Java对mysql进行增删改查等方法?
package com.ly520.db;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.List;
import java.util.Vector;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;
/**
* mysql数据库操作类。
*
* @author Ryoma
*
*/
public class MySqlOperate implements SqlOperate {
private Connection con;
private String DBname;
private String sql;
/**
* Mysql数据库初始化包名
*/
private String INIT_SQL_CTX = "org.gjt.mm.mysql.Driver";
/**
* MYSQL数据库服务参数:服务器IP地址和端口
*/
private String SQL_SERVICE = "jdbc:mysql://127.0.0.1:3306?autoReconnect=true&useUnicode=true&characterEncoding=utf-8&mysqlEncoding=utf8";
/**
* MYSQL数据库参数:系统管理用户
*/
private String SQL_SYSTEM_USER = "root";
/**
* MYSQL数据库参数:系统管理密码
*/
private String SQL_SYSTEM_PASSWORD = "123456";
/**
* 初始化链接方法。此方法不需要再使用use Dbname;
*/
public MySqlOperate() {
try {
Context ctx = new InitialContext();
if (ctx == null)
throw new Exception("Boom - No Context");
// java:comp/env/jdbc/imabled_mysql 为配置的连接池的jndi名称。
DataSource ds = (DataSource) ctx
.lookup("java:comp/env/jdbc/imabled_mysql");
con = ds.getConnection();
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* 指定库名的连接方法，此方法没有使用连接池，不赞成使用。
*
* @param DBn
*/
public MySqlOperate(String DBn) {
try {
Class.forName(this.INIT_SQL_CTX);
} catch (java.lang.ClassNotFoundException e) {
e.printStackTrace();
}
try {
con = DriverManager.getConnection(this.SQL_SERVICE + "/" + DBn,
this.SQL_SYSTEM_USER, this.SQL_SYSTEM_PASSWORD);
DBname = DBn;
} catch (SQLException ex) {
ex.printStackTrace();
}
}
public boolean add(String tablename, Hashtable searchdetail) {
Statement stmt = null;
Enumeration key_values = searchdetail.keys();
String key, value;
String temp = (String) key_values.nextElement();
key = temp;
value = "'" + searchdetail.get(temp) + "'";
while (key_values.hasMoreElements()) {
temp = (String) key_values.nextElement();
key = key + "," + temp;
value = value + "," + "'" + searchdetail.get(temp) + "'";
}
try {
useDB();
stmt = con.createStatement();
sql = "insert into " + tablename + " (" + key + ") " + " VALUES ("
+ value + ")";
stmt.executeUpdate(sql);
return true;
} catch (SQLException ex) {
System.out.println("执行的出错的sql语句:" + sql);
ex.printStackTrace();
return false;
} finally {
closeStmt(stmt);
}
}
public boolean batchImport(String tablename, List list, String[] fields)
throws SQLException {
PreparedStatement ps = null;
String key, value;
key = toString(fields);
String[] values = new String[fields.length];
for (int i = 0; i < values.length; i++) {
values[i] = "?";
}
value = toString(values);
try {
useDB();
con.setAutoCommit(false);
System.out.println("insert into " + tablename + " (" + key + ") "
+ " VALUES (" + value + ")");
ps = con.prepareStatement("insert into " + tablename + " (" + key
+ ") " + " VALUES (" + value + ")");
String[] tmpData = null;
for (int i = 0; i < list.size(); i++) {
tmpData = (String[]) list.get(i);
for (int j = 0; j < fields.length && j < tmpData.length; j++) {
ps.setString(j + 1, tmpData[j]);
}
ps.addBatch();// 添加执行的语句。
}
int[] count = ps.executeBatch();// 批量执行
con.commit();
return true;
} catch (SQLException ex) {
throw ex;
} finally {
try {
if (ps != null) {
ps.clearParameters();
ps.close();
ps = null;
}
} catch (SQLException e) {
throw e;
}
}
}
public boolean delete(String tablename, String filter) {
Statement stmt = null;
String value;
try {
useDB();
stmt = con.createStatement();
sql = "delete from " + tablename + " where " + filter;
stmt.executeUpdate(sql);
return true;
} catch (SQLException e) {
System.out.println("执行的出错的sql语句:" + sql);
e.printStackTrace();
return false;
} finally {
closeStmt(stmt);
}
}
public Hashtable list(String sql) {
Hashtable[] infoList = search(sql);
if (infoList == null || infoList.length < 1)
return null;
return infoList[0];
}
public Hashtable list(String tablename, String id) {
String sql = "select * from " + tablename + " where id ='" + id + "'";
return list(sql);
}
public boolean modify(String tablename, Hashtable setdetail, String filter) {
Enumeration key_values = setdetail.keys();
Statement stmt = null;
String value;
String temp = (String) key_values.nextElement();
value = temp + "='" + setdetail.get(temp) + "'";
while (key_values.hasMoreElements()) {
temp = (String) key_values.nextElement();
value = value + "," + temp + "='" + setdetail.get(temp) + "'";
}
try {
useDB();
stmt = con.createStatement();
sql = "update " + tablename + " set " + value + " where " + filter;
int tag = stmt.executeUpdate(sql);
if (tag == 0)
return false;
else
return true;
} catch (SQLException e) {
System.out.println("执行的出错的sql语句:" + sql);
e.printStackTrace();
return false;
} finally {
closeStmt(stmt);
}
}
public Hashtable[] search(String sql) {
ResultSet rs;
Statement stmt = null;
try {
useDB();
stmt = con.createStatement();
rs = stmt.executeQuery(sql);
return toHashtableArray(rs);
} catch (SQLException ex) {
System.out.println("执行的出错的sql语句:" + sql);
ex.printStackTrace();
return null;
} finally {
closeStmt(stmt);
}
}
public Hashtable[] search(String tablename, String[] fieldname,
String filter) {
return search(tablename, fieldname, filter, "");
}
public Hashtable[] search(String tablename, String[] fieldname,
String filter, String ordergroup) {
ResultSet rs;
Statement stmt = null;
String colname = fieldname[0];
for (int i = 1; i < fieldname.length; i++) {
colname += "," + fieldname[i];
}
String queryString = "select " + colname + " from " + tablename;
if (!filter.equals("")) {
queryString = queryString + " where " + filter;
}
if (!ordergroup.equals("")) {
queryString = queryString + " " + ordergroup;
}
return search(sql);
}
/**
* @return the con
*/
public Connection getCon() {
return con;
}
public void close() {
try {
if (con != null)
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 返回使用的数据库
*
* @return the dBname
*/
public String getDBname() {
return DBname;
}
/**
* 设置使用的数据库
*
* @param bname
* the dBname to set
*/
public void setDBname(String bname) {
DBname = bname;
}
/**
* 返回执行的sql语句
*
* @return the sql
*/
public String getSql() {
return sql;
}
/**
* 本方法是为了再没有使用连接池的情况下，首先选择使用的数据库。
*/
private void useDB() {
if (DBname != null && DBname.equals("")) {
String query = "use " + DBname;
Statement stmt = null;
try {
stmt = con.createStatement();
stmt.execute(query);
} catch (SQLException e) {
e.printStackTrace();
} finally {
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
/**
* 关闭Statement
*
* @param stmt
*/
private void closeStmt(Statement stmt) {
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/**
* @param ss
* @return
*/
private String toString(String[] ss) {
String s = "";
for (int i = 0; i < ss.length; i++) {
s += ss[i] + ",";
}
if (s.endsWith(","))
s = s.substring(0, s.length() - 1);
return s;
}
/**
* 把ResultSet转换成Hashtable数组 java.util.Arrays.asList 可以把数组转换成List
*
* @param rs
* @return
*/
private Hashtable[] toHashtableArray(ResultSet rs) {
Vector searchresult = new Vector();
try {
ResultSetMetaData rsmd = rs.getMetaData();
int column = rsmd.getColumnCount();
while (rs.next()) {
Hashtable onerow = new Hashtable();
for (int i = 1; i <= column; i++) {
try {
String columnName = rsmd.getColumnName(i);
String columnValue = rs.getString(columnName);
onerow.put(columnName, columnValue);
} catch (Exception e) {
}
}
searchresult.add(onerow);
}
Hashtable[] searchset = new Hashtable[searchresult.size()];
searchresult.toArray(searchset);
return searchset;
} catch (SQLException e) {
e.printStackTrace();
return null;
}
}
}
php封装一个类能实现mysql数据库的增删改查(php增删改查mysql实例)
class
sqlHelper{
public
$conn;
public
$dbname="数据库名称";
public
$username="数据库用户名";
public
$password="数据库密码";
public
$host="localhost";
//连接数据库
public
function
__construct(){
$this- if(!$this- die("连接失败".mysql_error()); } mysql_select_db($this- } //执行查询语句 public function execute_dql($sql){ $res=mysql_query($sql,$this- return $res; } //执行增填改语句 public function execute_dml($sql){ $b=mysql_query($sql,$this- if(!$b){ return 3; }else{ if(mysql_affected_rows($this- return 1;//表示OK }else{ return 2;//表示没有行收到影响 } } } } php封装一个类能实现mysql数据库的增删改查(php增删改查mysql实例) class sqlHelper{ public $conn; public $dbname="数据库名称"; public $username="数据库用户名"; public $password="数据库密码"; public $host="localhost"; //连接数据库 public function __construct(){ $this- if(!$this- die("连接失败".mysql_error()); } mysql_select_db($this- } //执行查询语句 public function execute_dql($sql){ $res=mysql_query($sql,$this- return $res; } //执行增填改语句 public function execute_dml($sql){ $b=mysql_query($sql,$this- if(!$b){ return 3; }else{ if(mysql_affected_rows($this- return 1;//表示OK }else{ return 2;//表示没有行收到影响 } } } } 如何使用mysql图形用户界面做增删改查 语法格式为： 如何使用mysql图形用户界面做增删改查 语法格式为：
INSERT [INTO] tbl_name [(col_name,...)] {VALUES|VALUE} ({expr|DEFAULT},...),(...),...
首先，创建一个简单的数据表，如下图所示：
如果省略col_name，则意味着所有的字段按照顺序依次赋值。因为id字段是自动编号的，该字段可以赋值为NULL或DEFAULT，如下图所示：
通过逗号分隔，可以一次性写入多条记录；而且，值可以使用表达式表示，如下图所示：
数据库并没有布尔类型BOOLEAN，如果声明类型为BOOLEAN，则会被转换为TINYINT类型，true转换为1，false转换为0，如下图所示：
INSERT [INTO] tbl_name [(col_name,...)] {VALUES|VALUE} ({expr|DEFAULT},...),(...),...
首先，创建一个简单的数据表，如下图所示：
如果省略col_name，则意味着所有的字段按照顺序依次赋值。因为id字段是自动编号的，该字段可以赋值为NULL或DEFAULT，如下图所示：
通过逗号分隔，可以一次性写入多条记录；而且，值可以使用表达式表示，如下图所示：
数据库并没有布尔类型BOOLEAN，如果声明类型为BOOLEAN，则会被转换为TINYINT类型，true转换为1，false转换为0，如下图所示：