数据库操作

来源：互联网发布：好记的淘宝店铺名字编辑：程序博客网时间：2024/05/20 08:45

第11章数据库操作（一）

第一节 MySQL 的基本操作

一、MySQL数据库简介

MySQL是一种跨平台的、网络上运行的、中(大)型的数据库服务器软件。

可在网上下载。瑞典

分为企业版(Enterprise edition)和社区版(community edition)

二、服务器的启动与停止

1、启动服务器

使用命令mysqld

2、停止服务器

使用命令mysqladmin

格式：mysqladmin -u 用户名 -p 密码 shutdown

三、登录与退出

1、登录

mysql -u 用户名 [–p 密码]

如：

mysql –u root

2、退出

使用命令

exit;

quit;

\q;

四、修改密码

1、修改root密码

通过grant命令修改

grant all on *.* to root@localhost identified by "123";

2、添加普通用户名

只有root用户才有权限建立其它用户。

grant all on *.* to dbuser@localhost identified by '123'

说明:grant 与on 之间是各种权限，例如:insert,select,update等

on 之后是数据库名和表名,第一个*表示所有的数据库，第二个*表示所有的表

root可以改成你的用户名，＠后可以跟域名或IP地址，identified by 后面的是登录用的密码

grant create,upadte,insert,delete,drop,alter on st.* to dbuser2@localhost identified by '123'

创建一个用户可对 st 数据库操作，对此数据库有create,upadte,insert,delete,drop,alter等权限

mysql> grant create ,delete on *.* to db1@localhost identified by '123';

Query OK, 0 rows affected (0.00 sec)

mysql> \q

Bye

C:\Documents and Settings\tai>mysql -u db1 -p

Enter password: ***

Welcome to the MySQL monitor. Commands end with ; or \g.

Your MySQL connection id is 4 to server version: 5.0.24-community

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> use lx;

Database changed

mysql> create table st(

-> name char(6));

Query OK, 0 rows affected (0.06 sec)

mysql> insert st values("aaa");

ERROR 1142 (42000): INSERT command denied to user 'db1'@'localhost' for table 's

mysql> update st set name="11";

ERROR 1142 (42000): UPDATE command denied to user 'db1'@'localhost' for table 's

grant all on *.* to root@ 192.168.0.220 Identified by "123";

第二种方法：

use mysql;

update user set password=password('123') where user='root';

其中password是加密函数，将123按md5算法进行加密。

update user set password=PASSWORD('1234') WHERE USER='root';

password用于修改mysql的用户密码，如果是应用与web程序建议使用md5()函数，

insert into users(names,pwd) values('aa',md5('123456'))

取消权限：

先给权限：

mysql> grant select,insert,update on *.* to user6@localhost identified by 'x';

Query OK, 0 rows affected (0.03 sec)

取消权限：

mysql> revoke insert on *.* from user6@localhost;

Query OK, 0 rows affected (0.00 sec)

删除用户：

删除一个用户：

C:\>mysql -u root mysql

mysql> select host,user from user;

mysql> delete from user where user='user6';

五、MySQL的data文件夹

建立的数据库以一个文件夹的方式存放在data文件夹中。

文件类型文件名扩展名文件内容

样式文件 .frm 描述表的结构（它的列、列类型、索引等）

数据文件 .MYD() 包含表里所有的数据

索引文件 .MYI() 包含数据文件上的所有索引

Db.opt 数据库使用的字符集

六、数据库操作

1、建立数据库

CREATE DATABASE 数据库名；

创建一个数据库

如： create databse bookdb;

2、打开数据库

USE 数据库名

作用：打开数据库

mysql> USE db1;

mysql> SELECT * FROM mytable

3、删除数据库

DROP DATABASE 数据库名；

删除数据库所有表并删除数据库。

4、显示所有的数据库

show databases;

七、名字的大小写敏感性

在MySQL中，数据库和表对应于在那些目录下的目录和文件，因而，内在的操作系统的敏感性决定数据库和表命名的大小写敏感性。这意味着数据库和表名在Unix上是区分大小写的，而在Win32上忽略大小写。

八、列类型

MySQL支持大量的列类型，它可以被分为3类：数字类型、日期和时间类型以及字符串(字符)类型。

1、数字类型

TINYINT[UNSIGNED]

一个很小的整数。有符号的范围是-128到127，无符号的范围是0到255。

SMALLINT[UNSIGNED]

一个小整数。有符号的范围是-32768到32767，无符号的范围是0到65535。

MEDIUMINT [UNSIGNED]

一个中等大小整数。有符号的范围是-8388608到8388607，无符号的范围是0到16777215。

INT [UNSIGNED]

一个正常大小整数。有符号的范围是-2147483648到2147483647，无符号的范围是0到4294967295。

INTEGER[UNSIGNED]

这是INT的一个同义词。

BIGINT[UNSIGNED]

一个大整数。有符号的范围是-9223372036854775808到9223372036854775807，无符号的范围是0到18446744073709551615。

FLOAT

一个小(单精密)浮点数字。不能无符号。允许的值是-3.402823466E+38到-1.175494351E-38，0 和1.175494351E-38到3.402823466E+38。

DOUBLE

一个正常大小(双精密)浮点数字。不能无符号。允许的值是-1.7976931348623157E+308到-2.2250738585072014E-30　

2、日期类型

DATE

一个日期。支持的范围是'1000-01-01'到'9999-12-31'。MySQL以'YYYY-MM-DD'格式来显示DATE值，但是允许你使用字符串或数字把值赋给DATE列。

DATETIME

一个日期和时间组合。支持的范围是'1000-01-01 00:00:00'到'9999-12-31 23:59:59'。MySQL以'YYYY-MM-DD HH:MM:SS'格式来显示DATETIME值，但是允许你使用字符串或数字把值赋给DATETIME的列。

TIMESTAMP[(M)]

一个时间戳记。范围是'1970-01-01 00:00:00'到2037年的某时。MySQL以YYYYMMDDHHMMSS、YYMMDDHHMMSS、YYYYMMDD或YYMMDD格式来显示TIMESTAMP值，取决于是否M是14（或省略)、12、8或6.

TIME

一个时间。范围是'-838:59:59'到'838:59:59'。MySQL以'HH:MM:SS'格式来显示TIME值，但是允许你使用字符串或数字把值赋给TIME列。

YEAR[(2|4)]

一个2或4位数字格式的年(缺省是4位)。允许的值是1901到2155，和0000（4位年格式），如果你使用2位，1970-2069( 70-69)。MySQL以YYYY格式来显示YEAR值，但是允许你把使用字符串或数字值赋给YEAR列。

3、字符类型

CHAR [BINARY]

一个定长字符串，当存储时，总是是用空格填满右边到指定的长度。M的范围是1 ～ 255个字符。当值被检索时，空格尾部被删除。CHAR值根据缺省字符集以大小写不区分的方式排序和比较，除非给出BINARY关键词。

CHAR是CHARACTER的一个缩写。

VARCHAR[BINARY]

一个变长字符串。注意：当值被存储时，尾部的空格被删除(这不同于ANSI SQL规范)。M的范围是1 ～ 255个字符。 VARCHAR值根据缺省字符集以大小写不区分的方式排序和比较，除非给出BINARY关键词值。 VARCHAR是CHARACTER VARYING一个缩写。

text与Blob类型

blob Binary large object

+-----------------------+-------------+--------------------+

Data Type | Size | Bytes |

+--------------------------+----------+--------------------+

|TINYTEXT and TINYBLOB | 2^8-1 |255 |

+-----------------------+-------------+--------------------+

| TEXT and BLOB |2^16-1 |65,535 |

+-----------------------+-------------+--------------------+

|MEDIUMTEXT and |2^24-1 | 16,777,215 |

|MEDIUMBLOB | | |

+-----------------------+-------------+--------------------+

|LONGTEXT and LONGBLOB |2^32-1 | 4,294,967,295 |

+-----------------------+-------------+--------------------+

文本类型一般存放文本文件，Blob一般存放图片

九、注释句法

MySQL服务器支持# to end of line、-- to end of line和

/* in-line or multiple-line */

mysql> select 1+1; # This comment continues to the end of line

mysql> select 1+1; -- This comment continues to the end of line

十、表操作

1、表的创建

use bookdb;

CREATE TABLE books

(id VARCHAR(8)

PRIMARY KEY,

name VARCHAR(24),

title VARCHAR(96),

price FLOAT,

yr INT,

description VARCHAR(30),

saleAmount INT);

CREATE TABLE messages (

mid INT NOT NULL AUTO_INCREMENT ,

name CHAR(20) NOT NULL,

email CHAR(40),

date DATE NOT NULL,

message TEXT NOT NULL,

primary key(mid)

);

CREATE TABLE messages (

mid INT NOT NULL AUTO_INCREMENT primary key,

name CHAR(20) NOT NULL,

email CHAR(40),

date DATE NOT NULL,

message varchar(100)

);

AUTO_INCREMENT：仅用于整数列类型，使这一列上的数值自动增长。初始值可用AUTO_INCREMENT选项确明指定，缺省为1。AUTO_INCREMENT列还必须指定为UNIQUE索引或PRIMARY KEY，而且应该为NOT NULL。

还可用CREATE TABLE IF NOT EXISTS

如果不存在创建、如果存在则不创建

CREATE TABLE IF NOT EXISTS students

(

id SMALLINT UNSIGNED NOT NULL AUTO_INCREMENT,

name VARCHAR(30) NOT NULL,

age INT NOT NULL,

PRIMARY KEY (id),

INDEX(name,age)

)

利用SELECT的结果创建表

CREATE TABLE young_students SELECT * FROM students

CREATE TABLE young_students SELECT no FROM students

Young_students 只有一列

只有结构：

CREATE TABLE new_table_name SELECT * FROM talbe_name WHERE 1<>1

使用：

使用CONCAT联合多列

SELECT CONCAT(name,":",math) AS basic_info FROM students

create table user_table(

user_id int(11) auto_increment,

user_name varchar(50) not null,

user_pass varchar(50) not null,

email varchar(100),

primary key(user_id),

unique(user_name)

);

PRIMARY 主键,一个表中只能有一个主键,

该键值不能为 NULL ,不能重复

UNIQUE 唯一键(或称第二辅助键),一个表中可以有多个

alter table user_table drop primary key;

ERROR 1075 (42000): Incorrect table definition; there can be only one auto colu

n and it must be defined as a key

原因：auto——increment必须为主键，修改类型

mysql> alter table user_table change user_id user_id int;

Query OK, 0 rows affected (0.09 sec)

Records: 0 Duplicates: 0 Warnings: 0

mysql> alter table user_table drop primary key;

Query OK, 0 rows affected (0.06 sec)

Records: 0 Duplicates: 0 Warnings: 0

插入数据

INSERT INTO MESSAGES(NAME,EMAIL) VALUES("DF","DFD");

mid列值自动增长

2、表结构的修改

ALTER TABLE message DROP nickname;

ALTER TABLE message MODIFY name CHAR(60) NOT NULL;

3、INSERT命令

INSERT INTO books VALUES('201', '王芳',

'Java编程指南',

33.75, 1999, '让读者轻轻松松掌握Java语言', 1000);

INSERT INTO books VALUES('202', '张丙',

'Weblogic技术参考', 45.99,

2002, '真的不错耶', 2000);

INSERT INTO books VALUES('203', '孙艳',

'Oracle数据库教程',

40, 2003, '关于Oracle的最畅销的技术书', 2000);

INSERT INTO books VALUES('204', '大卫',

'从Oak到Java: 语言的革命',

20.75, 1998, '很值得一看', 2000);

INSERT INTO books VALUES('205', '阿明',

'Apache从入门到精通',

50.75, 2002, '权威的Apache技术资料', 2000);

INSERT INTO books VALUES('206', '洪军',

'Java与数据算法 ',

54.75, 2002, '权威的Java技术资料', 2000);

4、显示表的结构　

　　describe 表名; 　

5、显示数据库中的所有表

show tables;显示指定数据库的表：

SHOW TABLES FROM 数据库名称;

6、将表中记录清空　

delete from 表名;　

7、删除表文件

drop table 表名

DROP TABLE IF EXISTS firstdb.users;

IF EXISTS语句在含有DROP TABLE的SQL脚本中很有用，如果不存在待删除的表，脚本会继续向下执行而不会抛出错误。

将一个表里的数据插入到另一个表里

INSERT INTO 目标表 (字段1, 字段2, ...) SELECT 字段1, 字段2, ... FROM 来源表;

INSERT INTO students2 SELECT * FROM students3;

将students3里的数据插入到student2里

十一、用户变量

你可以用SET句法设置一个变量：

SET @variable= 表达式

如set @a1=5;

select @a1;

十二、Latin1（iso-8859-1）编码

33 ! 161 ¡ Inverted exclamation

34 " 162 ¢ Cent sign

35 # 163 £ Pound sterling

36 $ 164 ¤ General currency sign

37 % 165 ¥ Yen sign

38 & 166 ¦ Broken vertical bar

39 ' 167 § Section sign

40 ( 168 ¨ Umlaut (dieresis)

41 ) 169 © Copyright

42 * 170 ª Feminine ordinal

43 + 171 « Left angle quote, guillemotleft

44 , 172 ¬ Not sign

45 - 173 Soft hyphen

46 . 174 ® Registered trademark

47 / 175 ¯ Macron accent

48 0 176 ° Degree sign

49 1 177 ± Plus or minus

50 2 178 ² Superscript two

51 3 179 ³ Superscript three

52 4 180 ´ Acute accent

53 5 181 µ Micro sign

54 6 182 ¶ Paragraph sign

55 7 183 · Middle dot

56 8 184 ¸ Cedilla

57 9 185 ¹ Superscript one

58 : 186 º Masculine ordinal

59 ; 187 » Right angle quote, guillemotright

60 < 188 ¼ Fraction one-fourth

61 = 189 ½ Fraction one-half

62 > 190 ¾ Fraction three-fourths

63 ? 191 ¿ Inverted question mark

64 @ 192 À Capital A, grave accent ("À")

65 A 193 Á Capital A, acute accent ("Á")

66 B 194 Â Capital A, circumflex accent ("Â")

67 C 195 Ã Capital A, tilde ("Ã")

68 D 196 Ä Capital A, dieresis or umlaut mark ("Ä")

69 E 197 Å Capital A, ring ("Å")

70 F 198 Æ Capital AE dipthong (ligature) ("Æ")

71 G 199 Ç Capital C, cedilla ("Ç")

72 H 200 È Capital E, grave accent ("È")

73 I 201 É Capital E, acute accent ("É")

74 J 202 Ê Capital E, circumflex accent ("Ê")

75 K 203 Ë Capital E, dieresis or umlaut mark ("Ë")

76 L 204 Ì Capital I, grave accent ("Ì")

77 M 205 Í Capital I, acute accent ("Í")

78 N 206 Î Capital I, circumflex accent ("Î")

79 O 207 Ï Capital I, dieresis or umlaut mark ("Ï")

80 P 208 Ð Capital Eth, Icelandic ("Ð")

81 Q 209 Ñ Capital N, tilde ("Ñ")

82 R 210 Ò Capital O, grave accent ("Ò")

83 S 211 Ó Capital O, acute accent ("Ó")

84 T 212 Ô Capital O, circumflex accent ("Ô")

85 U 213 Õ Capital O, tilde ("Õ")

86 V 214 Ö Capital O, dieresis or umlaut mark ("Ö")

87 W 215 × Multiply sign

88 X 216 Ø Capital O, slash ("Ø")

89 Y 217 Ù Capital U, grave accent ("Ù")

90 Z 218 Ú Capital U, acute accent ("Ú")

91 [ 219 Û Capital U, circumflex accent ("Û")

92 \ 220 Ü Capital U, dieresis or umlaut mark ("Ü")

93 ] 221 Ý Capital Y, acute accent ("Ý")

94 ^ 222 Þ Capital THORN, Icelandic ("Þ")

95 _ 223 ß Small sharp s, German (sz ligature) ("ß")

96 ` 224 à Small a, grave accent ("à")

97 a 225 á Small a, acute accent ("á")

98 b 226 â Small a, circumflex accent ("â")

99 c 227 ã Small a, tilde ("ã")

100 d 228 ä Small a, dieresis or umlaut mark ("ä")

101 e 229 å Small a, ring ("å")

102 f 230 æ Small ae dipthong (ligature) ("æ")

103 g 231 ç Small c, cedilla ("ç")

104 h 232 è Small e, grave accent ("è")

105 i 233 é Small e, acute accent ("é")

106 j 234 ê Small e, circumflex accent ("ê")

107 k 235 ë Small e, dieresis or umlaut mark ("ë")

108 l 236 ì Small i, grave accent ("ì")

109 m 237 í Small i, acute accent ("í")

110 n 238 î Small i, circumflex accent ("î")

111 o 239 ï Small i, dieresis or umlaut mark ("ï")

112 p 240 ð Small eth, Icelandic ("ð")

113 q 241 ñ Small n, tilde ("ñ")

114 r 242 ò Small o, grave accent ("ò")

115 s 243 ó Small o, acute accent ("ó")

116 t 244 ô Small o, circumflex accent ("ô")

117 u 245 õ Small o, tilde ("õ")

118 v 246 ö Small o, dieresis or umlaut mark ("ö")

119 w 247 ÷ Division sign

120 x 248 ø Small o, slash ("ø")

121 y 249 ù Small u, grave accent ("ù")

122 z 250 ú Small u, acute accent ("ú")

123 { 251 û Small u, circumflex accent ("û")

124 | 252 ü Small u, dieresis or umlaut mark ("ü")

125 } 253 ý Small y, acute accent ("ý")

126 ~ 254 þ Small thorn, Icelandic ("þ")

255 ÿ Small y, dieresis or umlaut mark ("ÿ")

十三、字符集

缺省字符集是Latin1（ISO-8859-1）；

mysql> SHOW CHARACTER SET;

+----------+-----------------------------+---------------------+--------+

+----------+-----------------------------+---------------------+--------+

| big5 | Big5 Traditional Chinese | big5_chinese_ci | 2 |

| dec8 | DEC West European | dec8_swedish_ci | 1 |

| cp850 | DOS West European | cp850_general_ci | 1 |

| hp8 | HP West European | hp8_english_ci | 1 |

| swe7 | 7bit Swedish | swe7_swedish_ci | 1 |

| tis620 | TIS620 Thai | tis620_thai_ci | 1 |

| gb2312 | GB2312 Simplified Chinese | gb2312_chinese_ci | 2 |

| cp1250 | Windows Central European | cp1250_general_ci | 1 |

| gbk | GBK Simplified Chinese | gbk_chinese_ci | 2 |

...

CREATE TABLE tbl_name (column_list)

[[DEFAULT] CHARACTER SET charset_name] [COLLATE collation_name]]

CREATE DATABASE db_name

[[DEFAULT] CHARACTER SET charset_name][COLLATE collation_name]]

1）把小写字母‘a’和‘b’视为与‘A’和‘B’等价；（2）然后比较编码。我们称这是一个大小写不敏感的校对规则。

校对规则命名约定：它们以其相关的字符集名开始，通常包括一个语言名，并且以_ci（大小写不敏感）、_cs（大小写敏感）

mysql --default-character-set=gbk -u root

mysql> CREATE DATABASE dbCN DEFAULT CHARACTER SET gbk COLLATE gbk_chinese_ci;

CREATE TABLE dbCN.cn (

id CHAR(10) NOT NULL,

Name varchar(20) NOT NULL

);

创建表时指定默认字符

例:CREATE TABLE listitem ( `id` int ) DEFAULT CHARSET=gbk;

十四、通过MY.INI中文问题

C:\windows\MY.INI

没有需要自己建立

[client]

#password = your_password

port = 3306

socket = /tmp/mysql.sock

# Here follows entries for some specific programs

# The MySQL server

[mysqld]

default-character-set=gbk

port = 3306

socket = /tmp/mysql.sock

skip-locking

key_buffer = 16K

max_allowed_packet = 1M

table_cache = 4

sort_buffer_size = 64K

read_buffer_size = 256K

read_rnd_buffer_size = 256K

net_buffer_length = 2K

thread_stack = 64K

server-id = 1

# Uncomment the following if you want to log updates

#log-bin=mysql-bin

# Uncomment the following if you are NOT using BDB tables

#skip-bdb

# Uncomment the following if you are using InnoDB tables

#innodb_data_home_dir = /usr/local/var/

#innodb_data_file_path = ibdata1:10M:autoextend

#innodb_log_group_home_dir = /usr/local/var/

#innodb_log_arch_dir = /usr/local/var/

# You can set .._buffer_pool_size up to 50 - 80 %

# of RAM but beware of setting memory usage too high

#innodb_buffer_pool_size = 16M

#innodb_additional_mem_pool_size = 2M

# Set .._log_file_size to 25 % of buffer pool size

#innodb_log_file_size = 5M

#innodb_log_buffer_size = 8M

#innodb_flush_log_at_trx_commit = 1

#innodb_lock_wait_timeout = 50

[mysqldump]

quick

max_allowed_packet = 16M

[mysql]

default-character-set=gbk

no-auto-rehash

# Remove the next comment character if you are not familiar with SQL

#safe-updates

[isamchk]

key_buffer = 8M

sort_buffer_size = 8M

[myisamchk]

key_buffer = 8M

sort_buffer_size = 8M

[mysqlhotcopy]

interactive-timeout

打开windows目录下MY.INI,将下面的默认字符改为GBK

[mysql]

default-character-set=gbk

[mysqld]

default-character-set=gbk

十五、数据的导入与导出

在dos提示符下执行命令:

c:\>mysqldump mydata -u root -p >mydata.sql

c:\>mysql mydata -u root -p <mydata.Sql

从备份文件恢复一个数据库：

mysql> drop table tab1,tab2;
Query OK, 0 rows affected (0.00 sec)

mysql> show tables;
Empty set (0.00 sec)

mysql> exit
Bye

C:\>mysql -u root mydata < mydata.sql

十六、source命令

Source 源文件名

Drop database book;

create database book ;

Use book;

CREATE TABLE books

(id VARCHAR(8)

PRIMARY KEY,

name VARCHAR(24),

title VARCHAR(96),

price FLOAT,

yr INT,

description VARCHAR(30),

saleAmount INT);

INSERT INTO books VALUES('201', '王芳',

'Java编程指南',

33.75, 1999, '让读者轻轻松松掌握Java语言', 1000);

INSERT INTO books VALUES('202', '张丙',

'Weblogic技术参考', 45.99,

2002, '真的不错耶', 2000);

INSERT INTO books VALUES('203', '孙艳',

'Oracle数据库教程',

40, 2003, '关于Oracle的最畅销的技术书', 2000);

INSERT INTO books VALUES('204', '大卫',

'从Oak到Java: 语言的革命',

20.75, 1998, '很值得一看', 2000);

INSERT INTO books VALUES('205', '阿明',

'Apache从入门到精通',

50.75, 2002, '权威的Apache技术资料', 2000);

INSERT INTO books VALUES('206', '洪军',

'Java与数据算法 ',

54.75, 2002, '权威的Java技术资料', 2000);

十五、

十七、找回管理员的密码

建立c:\windows\my.Ini

[client]

#password = your_password

port = 3306

socket = /tmp/mysql.sock

# Here follows entries for some specific programs

# The MySQL server

[mysqld]

port = 3306

socket = /tmp/mysql.sock

skip-locking

key_buffer = 16K

max_allowed_packet = 1M

table_cache = 4

sort_buffer_size = 64K

read_buffer_size = 256K

read_rnd_buffer_size = 256K

net_buffer_length = 2K

thread_stack = 64K

skip-grant-tables

server-id = 1

# Uncomment the following if you want to log updates

#log-bin=mysql-bin

# Uncomment the following if you are NOT using BDB tables

#skip-bdb

# Uncomment the following if you are using InnoDB tables

#innodb_data_home_dir = /usr/local/var/

#innodb_data_file_path = ibdata1:10M:autoextend

#innodb_log_group_home_dir = /usr/local/var/

#innodb_log_arch_dir = /usr/local/var/

# You can set .._buffer_pool_size up to 50 - 80 %

# of RAM but beware of setting memory usage too high

#innodb_buffer_pool_size = 16M

#innodb_additional_mem_pool_size = 2M

# Set .._log_file_size to 25 % of buffer pool size

#innodb_log_file_size = 5M

#innodb_log_buffer_size = 8M

#innodb_flush_log_at_trx_commit = 1

#innodb_lock_wait_timeout = 50

[mysqldump]

quick

max_allowed_packet = 16M

[mysql]

no-auto-rehash

# Remove the next comment character if you are not familiar with SQL

#safe-updates

[isamchk]

key_buffer = 8M

sort_buffer_size = 8M

[myisamchk]

key_buffer = 8M

sort_buffer_size = 8M

[mysqlhotcopy]

interactive-timeout

在my.ini的[mysqld]字段加入
skip-grant-tables

跳过权限检查表，所有用户都拥有所有权限，极度危险

一般用于忘记root密码

然后重启你的mysqld,这样就没有密码了.

然后进入mysql,重新加入密码
grant all on *.* to root@localhost identified by "123";

最后去掉my.ini中的skip-grant-tables

重启mysqld

或mysqld --skip-grant-tables

十八、ql的 limit $offset,$pagesize

每页多少条记录（$PageSize）

当前是第几页（$Page）

共有多少页（$Pages）

select * from table limit $offset,$pagesize"; // $offset:偏移量, $pagesize:每页多少条记录

例如:

前10条记录： select * from table limit 0,10

第11至20条记录: select * from table limit 10,10

第21至30条记录: select * from table limit 20,10

十九、模糊查询

like:

select * from students where name like '李%' (注意查询条件中有“%”，则说明是部分匹

配，而且还有先后信息在里面，即查找以“李”开头的匹配项。所以若查询有“李”的所有对象，应该命令：'%李%';若是第二个字为李，则应为'_李%'或'_李_'或'_李_'。)

_:表示与一个字符匹配

%：0个或多个字符

修改表的常用操作

mysql :alter table命令：

alter_specification:

ADD [COLUMN] create_definition [FIRST | AFTER column_name ]

or ADD INDEX [index_name] (index_col_name,...)

or ADD PRIMARY KEY (index_col_name,...)

or ADD UNIQUE [index_name] (index_col_name,...)

or ALTER [COLUMN] col_name {SET DEFAULT literal | DROP DEFAULT}

or CHANGE [COLUMN] old_col_name create_definition

or MODIFY [COLUMN] create_definition

or DROP [COLUMN] col_name

or DROP PRIMARY KEY

or DROP INDEX index_name

or RENAME [AS] new_tbl_name

or table_options

//主键

alter table tabelname add new_field_id int(5) unsigned default 0 not null auto_increment ,add primary key (new_field_id);

//增加一个新列

alter table t2 add d timestamp;

alter table infos add ex tinyint not null default '0';

//删除列

alter table t2 drop column c;

//重命名列

alter table t1 change a b integer;

//改变列的类型

alter table t1 change b b bigint not null;

alter table infos change list list tinyint not null default '0';

//重命名表

alter table t1 rename t2;

加索引

mysql> alter table tablename change depno depno int(5) not null;

mysql> alter table tablename add index 索引名 (字段名1[，字段名2 …]);

mysql> alter table tablename add index emp_name (name);

加主关键字的索引

mysql> alter table tablename add primary key(id);

加唯一限制条件的索引

mysql> alter table tablename add unique emp_name2(cardnumber);

删除某个索引

mysql>alter table tablename drop index emp_name;

修改表：

增加字段：

mysql> ALTER TABLE table_name ADD field_name field_type;

修改原字段名称及类型：

mysql> ALTER TABLE table_name CHANGE old_field_name new_field_name field_type;

删除字段：

mysql> ALTER TABLE table_name DROP field_name;

*****************************

SELECT something FROM table

WHERE TO_DAYS(NOW()) - TO_DAYS(date_col) <= 30;

DAYOFWEEK(date)

返回日期date的星期索引(1=星期天，2=星期一, ……7=星期六)。这些索引值对应于ODBC标准。

mysql> select DAYOFWEEK('1998-02-03');

-> 3

WEEKDAY(date)

返回date的星期索引(0=星期一，1=星期二, ……6= 星期天)。

mysql> select WEEKDAY('1997-10-04 22:23:00');

-> 5

mysql> select WEEKDAY('1997-11-05');

-> 2

DAYOFMONTH(date)

返回date的月份中日期，在1到31范围内。

mysql> select DAYOFMONTH('1998-02-03');

-> 3

DAYOFYEAR(date)

返回date在一年中的日数, 在1到366范围内。

mysql> select DAYOFYEAR('1998-02-03');

-> 34

MONTH(date)

返回date的月份，范围1到12。

mysql> select MONTH('1998-02-03');

-> 2

DAYNAME(date)

返回date的星期名字。

mysql> select DAYNAME("1998-02-05");

-> 'Thursday'

MONTHNAME(date)

返回date的月份名字。

mysql> select MONTHNAME("1998-02-05");

-> 'February'

QUARTER(date)

返回date一年中的季度，范围1到4。

mysql> select QUARTER('98-04-01');

-> 2

WEEK(date)

WEEK(date,first)

对于星期天是一周的第一天的地方，有一个单个参数，返回date的周数，范围在0到52。2个参数形式WEEK()允许

你指定星期是否开始于星期天或星期一。如果第二个参数是0，星期从星期天开始，如果第二个参数是1，

从星期一开始。

mysql> select WEEK('1998-02-20');

-> 7

mysql> select WEEK('1998-02-20',0);

-> 7

mysql> select WEEK('1998-02-20',1);

-> 8

YEAR(date)

返回date的年份，范围在1000到9999。

mysql> select YEAR('98-02-03');

-> 1998

HOUR(time)

返回time的小时，范围是0到23。

mysql> select HOUR('10:05:03');

-> 10

MINUTE(time)

返回time的分钟，范围是0到59。

mysql> select MINUTE('98-02-03 10:05:03');

-> 5

SECOND(time)

回来time的秒数，范围是0到59。

mysql> select SECOND('10:05:03');

-> 3

第二节其他常用操作

一、插入现在时间

insert into t1 values(now());

只有timestamp支持默认时间为now()

create table t3(

d3 timestamp not Null default now());

二、将mysql表中的主键删除掉

alter table user drop primary key;

增加一个自动增长列字段。

alter table user add id int auto_increment not null primary key;

将no字段中只有一个字符的记录删除掉。

delete from students where length(no)=1

三、zerofill

mysql> create table lx8(

-> id int zerofill);

Query OK, 0 rows affected (0.06 sec)

mysql> insert into lx8 values(1);

Query OK, 1 row affected (0.00 sec)

mysql> select * from lx8;

+------------+

| id |

+------------+

| 0000000001 |

+------------+

1 row in set (0.02 sec)

mysql> create table lx9(

-> id int(11) zerofill);

Query OK, 0 rows affected (0.06 sec)

mysql> insert into lx9 values(1);

Query OK, 1 row affected (0.00 sec)

mysql> select * from lx9;

+-------------+

| id |

+-------------+

| 00000000001 |

+-------------+

1 row in set (0.00 sec)

mysql> create table lx10(

-> id int(13) zerofill);

Query OK, 0 rows affected (0.06 sec)

mysql> insert into lx10 values(1);

Query OK, 1 row affected (0.00 sec)

mysql> select * from lx10;

+---------------+

| id |

+---------------+

| 0000000000001 |

+---------------+

1 row in set (0.00 sec)

mysql>

四、查看权限：

use mysql;
select host,user,password from user;

五、存储过程：（选学）

mysql> select *  from aa;
+------+------+
| id   | name |
+------+------+
|    1 | aa   |
|    2 | bb   |
|    3 | cc   |
+------+------+
3 rows in set (0.00 sec)

delimiter //

CREATE PROCEDURE test()
BEGIN
  DECLARE done INT DEFAULT 0;
  DECLARE myid INT;
  DECLARE cur1 CURSOR FOR SELECT id FROM aa;
  DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done = 1;

  OPEN cur1;
  REPEAT
    FETCH cur1 INTO myid;
    IF NOT done THEN
       INSERT INTO bb(id) VALUES (myid);
    END IF;
  UNTIL done END REPEAT;
  CLOSE cur1;
END
//
Query OK, 0 rows affected (0.00 sec)

mysql> select * from bb//
Empty set (0.00 sec)

mysql> CALL test()//
Query OK, 1 row affected (0.06 sec)

mysql> select * from bb//
+------+------+
| id   | name |
+------+------+
|    1 | NULL |
|    2 | NULL |
|    3 | NULL |
+------+------+
3 rows in set (0.00 sec)

六、批量导入数据

mysql> LOAD DATA LOCAL INFILE "e:\stlx.SQL" INTO TABLE students FIELDS TERMINATED BY ',' ;

数据：

123551,张三,90,80,80

导入指定列

导入指定的列
LOAD DATA INFILE "e:/lx.sql" INTO TABLEUsers(username, password, active);

七、导出数据

select * from student into outfile 'c:/temp2.sql' fields terminated by ','

lines terminated by '\n';

八、（选学）关于information_schema

information_schema是一个虚拟数据库，并不物理存在，在select的时候，从其他数据库获取相应的信息。

SCHEMATA 表：记录所有数据库

　　SCHEMA_NAME　　数据库名

TABLES 表：记录各个数据库中的表

　　 TABLES_SCHEMA　　表所在数据库

　　TABLE_NAME　　表名

COLUMNS 表：记录所有字段

　　 TABLES_SCHEMA　　字段所在数据库

　　TABLE_NAME　　字段所在表名

　　COLUMN_NAME　　字段名

　　ORDINAL_POSITION　　在表中的排序位置

　　COLLUMN_DEFAULT　　默认值

　　DATA_TYPE　　字段数据类型

　　CHARACTER_MAXIMUM_LENGTH　　字符串最大长度

　　NUMERIC_PRECISION　　数字精度？

　　NUMERIC_SCALE　　小数位数吧？

　　CHARACTER_SET_NAME　　编码(utf8)

　　 COLUMN_NAME　　编码(utf8_unicode_ci)

　　COLUMN_KEY　　值为PRI时为主键

　　EXTRA　　值为auto_increment时为自增长

　　PRIVILEGES　　及联更新吧？（select,insert,update,references）

以下的语句可以查出超过1000行数据的表

select concat(table_schema,'.',table_name) as table_name,table_rows

from information_schema.tables where table_rows > 1000

order by table_rows desc;

查询五个最大表

SELECT concat(table_schema,'.',table_name) table_name,

concat(round(data_length/(1024*1024),2),'M') data_length

FROM information_schema.TABLES

ORDER BY data_length DESC LIMIT 5;

九、触发器（选学）

CREATE TABLE t25

(s1 INT, s2 CHAR(5), PRIMARY KEY (s1),

CHECK (LEFT(s2,1)='A'))

ENGINE=INNODB;

delimiter //

CREATE TRIGGER t25_bi

BEFORE INSERT ON t25

FOR EACH ROW

IF LEFT(NEW.s2,1)<>'A' THEN SET NEW.s1=0; END IF;//

delimiter ;

INSERT INTO t25 VALUES (66,'a');

INSERT INTO t25 VALUES (67,'b');

这是个小例子,当Student表的StudentID列被发生更改时,BorrowStudent表的StudentID列也跟着更改.如果 Student表删除某记录,BorrowStudent也删除对应StudentID的记录.

/*先删除将要创建而存在的表*/

drop table if exists Student;

drop table if exists BorrowStudent;

/* 创建表*/

create table Student(

StudentID int not null primary key,

StudentName varchar(30) not null,

StudentSex enum('m','f') default 'm'

)engine=myisam;

create table BorrowStudent(

BorrowRecord int not null auto_increment primary key,

StudentID int not null,

BorrorDate date,

ReturnDate date,

foreign key(StudentID) references Student(StudentID)

)engine=myisam;

/*插入记录*/

insert into Student values(1235412,'java','m');

insert into Student values(3214562,'jiajia','m');

insert into Student values(5441253,'purana','f');

insert into BorrowStudent(StudentID,BorrorDate,ReturnDate)

values(1235412,'2007-01-01','2007-01-07');

insert into BorrowStudent(StudentID,BorrorDate,ReturnDate)

values(3214562,'2007-01-01','2007-01-07');

insert into BorrowStudent(StudentID,BorrorDate,ReturnDate)

values(5441253,'2007-01-01','2007-01-07');

/*创建触发器*/

delimiter $$

drop trigger if exists tduStudent$$

drop trigger if exists tddStudent$$

create trigger tduStudent before update

on Student for each row

begin

if new.StudentID!=old.StudentID then

update BorrowStudent

set BorrowStudent.StudentID=new.StudentID

where BorrowStudent.StudentID=old.StudentID;

end if;

end$$

create trigger tddStudent before delete

on Student for each row

begin

delete

from BorrowStudent

where BorrowStudent.StudentID=old.StudentID;

end$$

delimiter ;

delimiter //

CREATE TRIGGER students_bi2

BEFORE INSERT ON students

FOR EACH ROW

IF New.math>100 or NEW.math<0 THEN SET NEW.math=0; END IF;//

CREATE TABLE students (

no CHAR(6) primary key,

name VARCHAR(10),

math int,

english int,

physics int

) Engine=innodb;

INSERT INTO students VALUES('199901', '张小盐', 69,98,88);

INSERT INTO students VALUES('199902', '王六奖', 68,78,85);

INSERT INTO students VALUES('199903', '历小记', 77,66,56);

INSERT INTO students VALUES('199904', '胡名明', 66,97,83);

INSERT INTO students VALUES('199905', '柳名将', 88,80,77);

INSERT INTO students VALUES('199906', '金六副', 66,78,45);

INSERT INTO students VALUES('199907', '语境竟', 55,77,90);

INSERT INTO students VALUES('199908', '钟名讳', 90,99,78);

第二节 JDBC的概念及组成、操作步骤

一、JDBC的概念

JDBC(Java data Base Connectivity)是为了支持数据库功能而提供的

一组类的集合。

可以处理各种数据库

可以方便地在Java语言中使用SQL语言。

二、JDBC的基本功能

JDBC的基本的功能：建立与数据的连接、执行SQL声明和处理执行结果。

三、JDBC的组成

构成JDBC的类都在Java的sql包中，它们的名称和基本功能如下：

　　*java.sql.DriverManager

　　对驱动程序类进行管理,数据连接的创建。

　　*java.sql.Connection

　　代表与某一数据库的连接，支持Statement的创建。

　　*java.sql.Statement

　　在连接中执行一静态的SQL声明并取得执行结果。

　　*java.sql.PreparedStatement

　　Statement的子类。

　　java.sql.ResultSet

代表执行SQL语句后产生的数据结果。

四、导入java.sql包

在程序的开头，必须有如下代码：

import java.sql.*;

五、登记驱动程序

1、连接Oracle

Class.forName("oracle.jdbc.driver.OracleDriver");

2、连接Mysql

Class.forName("com.mysql.jdbc.Driver");

3、连接 SQL Server数据库

Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

4、连接DB2数据库

Class.forName("com.ibm.db2.jdbc.app.DB2Driver ");

5、连接PostgreSQL数据库

Class.forName("org.postgresql.Driver")

6、ODBC连接

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

六、建立连接字符串

1、连接 oracle数据库

连接字符串"jdbc:oracle:thin:@192.168.0.35:1521:Lea","scott","tiger"

2、连接Mysql

String url="jdbc:mysql://localhost:3306/bookdb ";

3、连接 SQL Server数据库

连接字符串："jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=pubs

4、连接DB2数据库

String url="jdbc:db2://localhost:5000/sample"

5、连接PostgreSQL数据库

String url ="jdbc:postgresql://localhost/soft"

6、ODBC连接

连接字符串"jdbc:odbc:book","dbuser","123"

七、建立连接

1、DriverManager类的使用

作用:对驱动类进行管理,数据连接的创建。

2、getConnection方法

加载了驱动器对象后，可以用DriverManager中的方法getConnection建立与特定数据库的连接。

public static Connection getConnection(String url,String user,String password) throws SQLException;

　DriverManager将从已注册的JDBC驱动器对象中返回与此驱动器对象相关的一个Connection类的实例。

强调:

数据库操作错误时，发生SQLException。

Connection conn= DriverManager.getConnection(url,user,password);

八、建立Statement(语句)对象

1、Connection类

代表与数据库的连接

2、生成对象

加载了驱动器对象后，可以用DriverManager中的方法getConnection建立与特定数据库的连接。

3、createStatement方法

public statement createStatement() throws SQLException;

强调:

数据库操作错误时，发生SQLException。

九、执行查询或更新(建立结果集对象)

1、Statement类

　Statement对象用来向数据库发送查询和命令

2、Statement对象的创建方法

Connection类的createStatement方法来创建

3、executeQuery方法

　　public ResultSet executeQuery(String sql)throw SQLExecption;

　　这个方法一般用于执行SQL的SELECT声明。

它的返回值是ResultSet类的对象。

数据库操作错误时，发生SQLException。　

ResultSet rs=stmt.executeQuery(sql);

4、ResultSet类

结果集ResultSet是用来代表执行SQL声明后产生的结果集合的类。

它的对象一般在Statement类放其子类通过executeQuery执行SQL语句后产生， ResultSet的通常形式类似于数据库中的表，包含有符合查询要求的所有行。

十、结果处理

1、记录指针的移动

指针的初始位置指向第一行之前，ResultSet类中提供如下的next方法来移动指针，

每调用一次next方法，指针下移一行：

　　public boolean next()

　　当指针所指已经是结果集最后一行时，再调用next方法，返回值为false，表明结果集已处理完毕。

通常处理结果集的程序段具有下面的结构：

　　while(rs.next())

　　{...

　　//处理每一结果行

　　}

强调：

要注意的是，结果集的第一条也要在第一次调用next方法后才能取到。

2、字段值的获取

　　get+列值类型(列名)

　　get+列值类型(列序号)

其中列名和列序号都用来指定要获取值的列。如

　　rs.getInt("id");

　　rs.getString("name");

也可以等价地执行

　　rs.getInt(1);

　　rs.getString(2);

十一、关闭连接

用Connection对象的close方法。

http://redking.blog.51cto.com/27212/110742

第四节数据库的基本操作

一、使用的表文件

mysql --default-character-set=gbk -u root

create database st default character set gbk;

CREATE TABLE students (

no CHAR(6) primary key,

name VARCHAR(10),

math int,

english int,

physics int

) Engine=innodb;

INSERT INTO students VALUES('199901', '张小盐', 69,98,88);

INSERT INTO students VALUES('199902', '王六奖', 68,78,85);

INSERT INTO students VALUES('199903', '历小记', 77,66,56);

INSERT INTO students VALUES('199904', '胡名明', 66,97,83);

INSERT INTO students VALUES('199905', '柳名将', 88,80,77);

INSERT INTO students VALUES('199906', '金六副', 66,78,45);

INSERT INTO students VALUES('199907', '语境竟', 55,77,90);

INSERT INTO students VALUES('199908', '钟名讳', 90,99,78);

二、查询操作

1、基本查询

此程序可完成对整个表的查询

package databasepro;

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.Statement;

import java.sql.ResultSet;

import java.sql.SQLException;

/**

* 对数据库查询的实例

* @author tjh

public class DBQueryTest11 {

/**

*可完成对学生信息的查询

public static void main(String args[]) {

//一定要注意使用的数据库名、表名、用户名、密码。

//定义连接对象，代表与数据库的连接

Connection conn=null;

//定义SQL语句对象，此对象可执行sql命令。

Statement stat=null;

//定义结果集对象，表示Statement对象执行查询的结果

ResultSet rs=null;

try {

//注册驱动程序

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

String user = "dbuser";

String password = "123";

//建立连接对象

conn = DriverManager.getConnection(url, user, password);

//建立sql语句对象,此对象可执行sql命令。

stat = conn.createStatement();

String querySql = "select * from students";

//建立结果集对象

rs = stat.executeQuery(querySql);

//进行查询操作

while (rs.next()) {

System.out.print(rs.getString("no"));

System.out.print("\t" + rs.getString("name"));

System.out.print("\t" + rs.getInt("math"));

System.out.print("\t" + rs.getInt("english"));

System.out.println("\t" + rs.getInt("physics"));

}

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}

finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

程序的运行：

将mysql-connector-java-5.0.3-bin.jar放在d:\java中

1、通过我的电脑来进行设置，然后直接编译运行即可

运行结果

学号姓名数学成绩英语成绩物理成绩性别入学日期

199901 张小盐 69 98 88 男 1999-09-01

199902 王六奖 68 78 85 女 1999-09-02

199903 历小记 77 66 56 男 1999-09-01

199904 胡名明 66 97 83 男 1999-09-03

199905 柳名将 88 80 77 男 1999-09-01

199906 金六副 66 78 45 男 1999-09-01

199907 语境竟 55 77 90 女 1999-09-04

199908 钟名讳 90 99 78 男 1999-09-07

2、

编译 javac -cp d:\java\mysql-connector-java-5.0.3-bin.jar DB1.java

运行java -cp d:\java\mysql-connector-java-5.0.3-bin.jar;. DB1

在netBeans中运行

强调：

为什么会出现 com.mysql.jdbc.Driver异常信息

答：

类路径没有设好

2、参数查询

/**

* 工程: DatabasePro

* 文件: DBQueryTest2.java

* 包: databasepro

* 单位: 黑龙江八一农垦大学计算机系

* 版权: 无

* 版本: 1.0

* 变更历史: 2008-3-23 14:36:00 PM (tjh) 创建

package databasepro;

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.Statement;

import java.sql.ResultSet;

import java.sql.SQLException;

import javax.swing.JOptionPane;

/**

* 数据库参数查询实例

* @author tjh

public class DBQueryTest2 {

/**

*可完成对学生信息的参数查询

public static void main(String args[]) {

//一定要注意使用的数据库名、表名、用户名、密码。

//定义连接对象，代表与数据库的连接

Connection conn=null;

//定义SQL语句对象，此对象可执行sql命令。

Statement stat=null;

//定义结果集对象，表示Statement对象执行查询的结果

ResultSet rs=null;

try {

//注册驱动程序

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

String user = "dbuser";

String password = "123";

//建立连接对象

conn = DriverManager.getConnection(url, user, password);

//建立语句对象

stat = conn.createStatement();

//输入要查询的姓名

String studentName = JOptionPane.showInputDialog(null, "输入要查询的姓名");

String querySql = "select * from students where name='" + studentName + "'";

//建立结果集对象

rs = stat.executeQuery(querySql);

System.out.println("学号\t姓名\t数学成绩\t英语成绩\t物理成绩");

rs = stat.executeQuery(querySql);

StringBuilder stringRS = showAllRecords(rs);

System.out.print(stringRS);

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

public static StringBuilder showAllRecords(ResultSet rs) throws SQLException {

StringBuilder stringRS1 = new StringBuilder();

stringRS1.append("学号");

stringRS1.append("\t姓名");

stringRS1.append("\t数学成绩");

stringRS1.append("\t英语成绩");

stringRS1.append("\t物理成绩\n");

//进行查询操作

while (rs.next()) {

stringRS1.append(rs.getString("no"));

stringRS1.append("\t" + rs.getString("name"));

stringRS1.append("\t" + rs.getInt("math"));

stringRS1.append("\t" + rs.getInt("english"));

stringRS1.append("\t" + rs.getInt("physics") + "\n");

}

return stringRS1;

}

上例的另外一种写法

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import javax.swing.JOptionPane;

/**

* @author tai

public class DBQueryTest2 {

/**

*可完成对学生信息的参数查询

public static void main(String args[]) {

//一定要注意使用的数据库名、表名、用户名、密码。

//定义连接对象，代表与数据库的连接

Connection conn=null;

//定义SQL语句对象，此对象可执行sql命令。

Statement stat=null;

//定义结果集对象，表示Statement对象执行查询的结果

ResultSet rs=null;

try {

//注册驱动程序

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

String user = "root";

String password = "123";

//建立连接对象

conn = DriverManager.getConnection(url, user, password);

//建立语句对象

stat = conn.createStatement();

//输入要查询的姓名

String studentName = JOptionPane.showInputDialog(null, "输入要查询的姓名");

String querySql = "select * from students where name='" + studentName + "'";

//建立结果集对象

rs = stat.executeQuery(querySql);

System.out.println("学号\t姓名\t数学成绩\t英语成绩\t物理成绩");

rs = stat.executeQuery(querySql);

if(rs.next()){

showOneRow(rs);

}else{

System.out.println("查无此人");

}

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

public static void showOneRow(ResultSet rs) throws SQLException {

System.out.println("===========================================");

System.out.println("第" + rs.getRow() + "条记录内容");

System.out.print("学号" + rs.getString("no"));

System.out.println("\t姓名" + rs.getString("name"));

}

练习：

1、输入学号，首先判断此学号是否存在

若存在，显示数学成绩，并判断成绩是否及格

用户登录实例：

方法1：

首先判断用户名是否存在，然后判断密码是否正确。

方法2：

同时判断用户名和密码是否正确。

3、练习：

输入表名从不同表查询数据。

3、模糊查询

/**

* 工程: DatabasePro

* 文件: DBQueryTest1.java

* 包: databasepro

* 单位: 黑龙江八一农垦大学计算机系

* 版权: 无

* 版本: 1.0

* 变更历史: 2008-3-23 14:36:00 PM (tjh) 创建

package databasepro;

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.Statement;

import java.sql.ResultSet;

import java.sql.SQLException;

import javax.swing.JOptionPane;

/**

* 数据库参数查询实例

* @author tjh

public class DBQueryTest3 {

/**

*可完成对学生信息的参数查询

public static void main(String args[]) {

//一定要注意使用的数据库名、表名、用户名、密码。

Connection conn;

Statement stat;

ResultSet rs;

try {

//注册驱动程序

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

String user = "dbuser";

String password = "123";

//建立连接对象

conn = DriverManager.getConnection(url, user, password);

//建立语句对象

stat = conn.createStatement();

String studentName = JOptionPane.showInputDialog(null, "输入要查询的姓名");

String querySql = "select * from students where name like '%" + studentName + "%'";

//建立结果集对象

rs = stat.executeQuery(querySql);

System.out.println("学号\t姓名\t数学成绩\t英语成绩\t物理成绩");

//进行查询操作

while (rs.next()) {

System.out.print(rs.getString("no"));

System.out.print("\t" + rs.getString("name"));

System.out.print("\t" + rs.getInt("math"));

System.out.print("\t" + rs.getInt("english"));

System.out.println("\t" + rs.getInt("physics"));

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

4、其他实例（使用字符串）

package databasepro;

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.Statement;

import java.sql.ResultSet;

import java.sql.SQLException;

/**

* 对数据库查询的实例

* @author tjh

public class DBQueryTest11 {

/**

*可完成对学生信息的查询

public static void main(String args[]) {

//一定要注意使用的数据库名、表名、用户名、密码。

Connection conn=null;

Statement stat=null;

ResultSet rs=null;

StringBuilder stringRS=new StringBuilder();

try {

//注册驱动程序

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

String user = "dbuser";

String password = "123";

//建立连接对象

conn = DriverManager.getConnection(url, user, password);

//建立语句对象

stat = conn.createStatement();

String querySql = "select * from students";

//建立结果集对象

rs = stat.executeQuery(querySql);

System.out.print("学号");

System.out.print("\t姓名");

System.out.print("\t数学成绩");

System.out.print("\t英语成绩");

System.out.println("\t物理成绩");

//进行查询操作

while (rs.next()) {

stringRS.append(rs.getString("no"));

stringRS.append("\t" + rs.getString("name"));

stringRS.append("\t" + rs.getInt("math"));

stringRS.append("\t" + rs.getInt("english"));

stringRS.append("\t" + rs.getInt("physics")+"\n");

}

System.out.print(stringRS);

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

***********************

package databasepro;

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.Statement;

import java.sql.ResultSet;

import java.sql.SQLException;

/**

* 对数据库查询的实例

* @author tjh

public class DBQueryTest11 {

/**

*可完成对学生信息的查询

public static void main(String args[]) {

Connection conn = null;

Statement stat = null;

ResultSet rs = null;

StringBuilder stringRS = new StringBuilder();

try {

//注册驱动程序

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

String user = "dbuser";

String password = "123";

//建立连接对象

conn = DriverManager.getConnection(url, user, password);

//建立语句对象

stat = conn.createStatement();

String querySql = "select * from students";

//建立结果集对象

rs = stat.executeQuery(querySql);

stringRS = showAllRecords(rs);

System.out.print(stringRS);

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}

finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

public static StringBuilder showAllRecords(ResultSet rs) throws SQLException {

StringBuilder stringRS1 = new StringBuilder();

stringRS1.append("学号");

stringRS1.append("\t姓名");

stringRS1.append("\t数学成绩");

stringRS1.append("\t英语成绩");

stringRS1.append("\t物理成绩\n");

//进行查询操作

while (rs.next()) {

stringRS1.append(rs.getString("no"));

stringRS1.append("\t" + rs.getString("name"));

stringRS1.append("\t" + rs.getInt("math"));

stringRS1.append("\t" + rs.getInt("english"));

stringRS1.append("\t" + rs.getInt("physics") + "\n");

}

return stringRS1;

}

***********************

模糊查询

package ch08;

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.Statement;

import java.sql.ResultSet;

import java.sql.SQLException;

/**

* 对数据库查询的实例

* @author tjh

public class DBQueryTest1 {

/**

*可完成对学生信息的查询

public static void main(String args[]) {

//一定要注意使用的数据库名、表名、用户名、密码。

Connection conn = null;

Statement stat = null;

ResultSet rs = null;

StringBuilder stringRS = new StringBuilder();

try {

//注册驱动程序

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

String user = "dbuser";

String password = "123";

//建立连接对象

conn = DriverManager.getConnection(url, user, password);

//建立语句对象

stat = conn.createStatement();

String querySql = "select * from students";

//建立结果集对象

rs = stat.executeQuery(querySql);

System.out.print("学号");

System.out.print("\t姓名");

System.out.print("\t数学成绩");

System.out.print("\t英语成绩");

System.out.println("\t物理成绩");

//进行查询操作

while (rs.next()) {

String name = rs.getString("name");

//查找姓“张”字的记录

// if (name.startsWith("张")) {

//if (name.substring(0,1).equals("张")) {

//if (name.indexOf("张")==0) {

//查找姓名中有“小”字的记录

if (name.indexOf("小") != -1) {

stringRS.append(rs.getString("no"));

stringRS.append("\t" + rs.getString("name"));

stringRS.append("\t" + rs.getInt("math"));

stringRS.append("\t" + rs.getInt("english"));

stringRS.append("\t" + rs.getInt("physics") + "\n");

}

System.out.print(stringRS);

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

} finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

三、使用SQLServer数据库

例18-5

使用的表文件

drop table mytable1;

create table mytable1(

sid int,

name char(10),

sex char(4)

);

insert into mytable1 values(100,'张三','男');

insert into mytable1 values(101,'李四','女');

insert into mytable1 values(102,'王五','男');

insert into mytable1 values(103,'赵六','女');

*************程序

import java.sql.*;

public class TestSQLServer2{

public static void main(String[] args) {

//一定要注意使用的数据库名、表名、用户名、密码。

try{

Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

Connection con = DriverManager.getConnection

("jdbc:microsoft:sqlserver://127.0.0.1:1433;databasename=pubs","tom","cat");

Statement stmt = con.createStatement();

ResultSet rs = stmt.executeQuery("select * from mytable1");

while(rs.next()){

System.out.print("sid：" + rs.getInt(1));

System.out.print("\tname：" + rs.getString(2).trim());

System.out.print("\tsex：" + rs.getString(3).trim());

System.out.println();

}

rs.close();

stmt.close();

con.close();

}catch(Exception e){

e.printStackTrace();

}

四、创建表与添加记录

Statement对象的executeUpdate方法更新数据库和表中的记录

1、executeUpdate方法

　　public int executeUpdate(String sql) throw SQLException.

　　作用：用于执行SQL的INSERT、UPDATE等命令

返回值：

　　当执行INSERT等SQL声明时，此方法的返回值是执行了这个SQL声明后所影响的记录的总行数。若返回值为0，则表示执行未对数据库造成影响。

　　数据库操作错误时，发生SQLException。

如:

executeUpdate("UPDATE students SET 数学成绩 = 88 WHERE 姓名='王名'");

2、强调

数据库操作错误时，

创建表文件时，表文件已经存在

执行insert时主键重复

update命令时语句不对

会发生SQLException。

3、实例

package databasepro;

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.Statement;

import java.sql.ResultSet;

import java.sql.SQLException;

/**

* 创建表实例

* @author tjh

public class DBCreateTableTest {

/**

*建立表、并且对表进行插入、查询、删除等操作

public static void main(String args[]) {

//一定要注意使用的数据库名、表名、用户名、密码。

//定义连接对象，代表与数据库的连接

Connection conn=null;

//定义SQL语句对象，此对象可执行sql命令。

Statement stat=null;

//定义结果集对象，表示Statement对象执行查询的结果

ResultSet rs=null;

try {

//注册驱动程序

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

//建立连接对象

conn = DriverManager.getConnection(url, "dbuser", "123");

//建立语句对象

stmt = conn.createStatement();

//建立表

stmt.executeUpdate("create table mytable(id int, name char(10), phone char(10))");

//向表中插入数据

stmt.executeUpdate("insert into mytable values(55,'Tom','67666939')");

//建立结果集对象

rs = stmt.executeQuery("select * from mytable");

System.out.println("编号\t姓名\t电话");

//进行查询操作

while (rs.next()) {

System.out.println(rs.getString(1) + "\t" + rs.getString(2) + "\t" + rs.getString(3));

}

//删除表

stmt.execute("drop table mytable");

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

e.printStackTrace();

} finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stmt != null) {

stmt.close();

}

} catch (Exception e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

注： execute

boolean execute(String sql)

throws SQLException

执行给定的 SQL 语句

可以执行查询或更新

五、修改与删除记录

executeUpdate("DELETE FROM students WHERE no = ‘199904’ ");

注:你可以使用一个Statement对象进行删除和查询操作，但需要注意的是，当查询语句返回结果集后，没有立即输出结果集的记录，而接着执行了删除语句，那么结果集就不能输出记录了。要想输出记录就必须重新返回结果集。

***********

package databasepro;

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.Statement;

import java.sql.ResultSet;

import java.sql.SQLException;

/**

* 对数据库更新、删除的实例

* @author tjh

public class DBUpdateTest1 {

/**

*可完成对学生信息的更新、删除、查询

public static void main(String args[]) {

//一定要注意使用的数据库名、表名、用户名、密码。

//定义连接对象，代表与数据库的连接

Connection conn=null;

//定义SQL语句对象，此对象可执行sql命令。

Statement stat=null;

//定义结果集对象，表示Statement对象执行查询的结果

ResultSet rs=null;

try {

//注册驱动程序

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

String user = "dbuser";

String password = "123";

//建立连接对象

conn = DriverManager.getConnection(url, user, password);

//建立语句对象

stat = conn.createStatement();

stat.executeUpdate("INSERT INTO students " +

"VALUES('199996', '钟名', 91,99,78)");

String querySql = "select * from students";

//建立结果集对象

rs = stat.executeQuery(querySql);

showAllRecords(rs);

//注意no=199908可不加单引号

stat.executeUpdate("update students set math=100 where no=199908");

rs = stat.executeQuery(querySql);

showAllRecords(rs);

stat.executeUpdate("delete from students where no=199908");

rs = stat.executeQuery(querySql);

showAllRecords(rs);

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (Exception e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

public static void showAllRecords(ResultSet rs) throws SQLException {

System.out.println("===========================================");

System.out.print("学号");

System.out.print("\t姓名");

System.out.print("\t数学成绩");

System.out.print("\t英语成绩");

System.out.println("\t物理成绩");

//进行查询操作

while (rs.next()) {

System.out.print(rs.getString("no"));

System.out.print("\t" + rs.getString("name"));

System.out.print("\t" + rs.getInt("math"));

System.out.print("\t" + rs.getInt("english"));

System.out.println("\t" + rs.getInt("physics"));

}

练习：将上例的insert、删除、修改用

用输入对话框来完成。

六、游动查询

1、不带参数的con.createStatement()

不带参数的con.createStatement()生成的Statement对象生成结果集，

的next()方法只能顺序地查询数据.

但此项对MySQL数据库不好使。

2、滚动的结果集

当需要在结果集中前后移动、或显示结果集指定的一条记录等等。

这时，我们必须要返回一个可滚动的结果集。

Statement stmt=con.createStatement(int type ,int concurrency);

然后，根据参数的type、concurrency的取值情况，stmt返回相应类型的结果集：

ResultSet re=stmt.executeQuery(SQL语句);

(1)type的取值决定滚动方式，取值可以是：

ResultSet.TYPE_FORWORD_ONLY (1003)：结果集的游标只能向下滚动。

ResultSet.TYPE_SCROLL_INSENSITIVE(1004) ：结果集的游标可以上下移动, 当数据库变化时，当前结果集不变。

ResultSet.TYPE_SCROLL_SENSITIVE(1005) ：返回可滚动的结果集，当数据库变化时，当前结果集同步改变。

(2)Concurrency 取值决定是否可以用结果集更新数据库，

Concurrency取值：

ResultSet.CONCUR_READ_ONLY(1007)：不能用结果集更新数据库中的表。

ResultSet.CONCUR_UPDATETABLE(1008)：能用结果集更新数据库中的表。

(3)默认值

TYPE_FORWARD_ONLY，CONCUR_READ_ONLY 。

3、常用ResultSet方法

public boolean previous()：将游标向上移动，该方法返回boolean型数据，当移到结果集第一行之前时返回false.

public void beforeFirst：将游标移动到结果集的初始位置，即在第一行之前。

public void afterLast()：将游标移到结果集最后一行之后。

public void first()：将游标移到结果集的第一行。

public void last()：将游标移到结果集的最后一行。

public boolean isAfterLast()：判断游标是否在最后一行之后。

public boolean isBeforeFirst()：判断游标是否在第一行之前

public boolean ifFirst()：判断游标是否指向结果集的第一行。

public boolean isLast()：判断游标是否指向结果集的最后一行。

public int getRow()：得到当前游标所指行的行号，行号从1开始，如果结果集没有行，返回0

public boolean absolute(int row)：将游标移到参数row指定的行号。

第一行为1，第二行为2

对上例的改进：

package databasepro;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

public class DBQueryTest5 {

public static void main(String a[]) {

//一定要注意使用的数据库名、表名、用户名、密码。

//定义连接对象，代表与数据库的连接

Connection conn=null;

//定义SQL语句对象，此对象可执行sql命令。

Statement stat=null;

//定义结果集对象，表示Statement对象执行查询的结果

ResultSet rs=null;

try {

//注册驱动程序

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

String user = "dbuser";

String password = "123";

//建立连接对象

conn = DriverManager.getConnection(url, user, password);

//建立语句对象

//stat = conn.createStatement(ResultSet.TYPE_FORWORD_ONLY,

ResultSet.CONCUR_READ_ONLY);

//下一条命令在mysql与上一条等价

stat = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);

String querySql = "select * from students";

//建立结果集对象

rs = stat.executeQuery(querySql);

System.out.print("学号");

System.out.print("\t姓名");

System.out.print("\t数学成绩");

System.out.print("\t英语成绩");

System.out.println("\t物理成绩");

//进行查询操作

while (rs.next()) {

System.out.print(rs.getString("no"));

System.out.print("\t" + rs.getString("name"));

System.out.print("\t" + rs.getInt("math"));

System.out.print("\t" + rs.getInt("english"));

System.out.println("\t" + rs.getInt("physics"));

}

rs.first();

showOneRow(rs);

rs.next();

showOneRow(rs);

rs.last();

showOneRow(rs);

rs.absolute(4);

showOneRow(rs);

rs.relative(-1);

showOneRow(rs);

rs.previous();

showOneRow(rs);

System.out.print("数据库操作成功");

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}

finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

public static void showOneRow(ResultSet rs) throws SQLException {

System.out.println("===========================================");

System.out.println("第" + rs.getRow() + "条记录内容");

System.out.print("学号" + rs.getString("no"));

System.out.println("\t姓名" + rs.getString("name"));

}

练习：

1、

从键盘输入记录号：显示相应的记录

首先判断记录号是否合法。

2、显示第m条到第N连续的记录

3、显示第2、4、6、8条记录

******** 在下例中 rs.first();不好使

因为默认值为ResultSet.TYPE_FORWARD_ONLY;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

public class DBTest11 {

public static void main(String a[]) {

Connection conn = null;

Statement stat = null;

ResultSet rs = null;

try {

//注册驱动程序

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

conn = DriverManager.getConnection("jdbc:odbc:student", "", "");

//建立语句对象

stat = conn.createStatement();

String querySql = "select * from students";

//建立结果集对象

rs = stat.executeQuery(querySql);

System.out.print("学号");

System.out.print("\t姓名");

System.out.print("\t数学成绩");

System.out.print("\t英语成绩");

System.out.println("\t物理成绩");

rs.next();

// rs.first();

showOneRow(rs);

System.out.print("数据库操作成功");

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println(e.getMessage());

e.printStackTrace();

}

finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

public static void showOneRow(ResultSet rs) throws SQLException {

System.out.println("===========================================");

// System.out.println("第" + rs.getRow() + "条记录内容");

System.out.print("学号" + rs.getString("no"));

System.out.println("\t姓名" + rs.getString("name"));

}

4、使用可更新的结果集

使用的表文件

create table teacher(tid int, name char(20), salary float(7,2));

alter table teacher add primary key(tid);

insert into teacher values(1001,'张三',1800.2);

insert into teacher values(1002,'李四',2540);

insert into teacher values(1003,'王五',4587.25);

import java.sql.*;

public class TestUpdatableResultSet{

public static void main(String args[]){

Connection conn = null;

try{

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=GBK";

conn = DriverManager.getConnection(url,"root","");

Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);

ResultSet rs = stmt.executeQuery("select tid,name,salary from teacher");

//ResultSet rs = stmt.executeQuery("select teacher.* from teacher");

//更新前结果集中数据

while(rs.next()){

showOneRow(rs);

}

//更新和删除记录

rs.beforeFirst();

while(rs.next()){

String name = rs.getString("name").trim();

if(name.equals("李四")){

double sal = rs.getDouble("salary");

rs.updateDouble("salary", sal + 8888);

rs.updateRow();

}else if(name.equals("张三")){

rs.deleteRow();

}

//插入新记录

rs.moveToInsertRow();

rs.updateInt("tid",1005);

rs.updateString("name","云飞扬");

rs.updateDouble("salary",2840);

rs.insertRow();

rs.close();

//结果集更新后后数据库中数据

System.out.println("--------------------------------------------");

rs = stmt.executeQuery("select * from teacher");

while(rs.next()){

showOneRow(rs);

}

rs.close();

}catch(Exception e){

e.printStackTrace();

}finally{

try{

if(conn != null){

conn.close();

}

}catch(Exception e){

e.printStackTrace();

}

public static void showOneRow(ResultSet rs) throws SQLException{

System.out.print("第" + rs.getRow() + "行: ");

System.out.print(rs.getInt(1));

System.out.print("\t" + rs.getString(2));

System.out.print("\t" + rs.getDouble(3));

System.out.println();

}

六、在NetBeans中进行数据库操作

连接 db2 9.7 express-C

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.Statement;

import java.sql.ResultSet;

import java.sql.SQLException;

/**

* 对数据库查询的实例

* @author tjh

public class Main {

/**

*可完成对学生信息的查询

public static void main(String args[]) {

//一定要注意使用的数据库名、表名、用户名、密码。

//定义连接对象，代表与数据库的连接

Connection conn=null;

//定义SQL语句对象，此对象可执行sql命令。

Statement stat=null;

//定义结果集对象，表示Statement对象执行查询的结果

ResultSet rs=null;

try {

//注册驱动程序

Class.forName("COM.ibm.db2.jdbc.app.DB2Driver");

String url = "jdbc:db2:student";

String user = "";

String password = "";

//建立连接对象

conn = DriverManager.getConnection(url, user, password);

//建立sql语句对象,此对象可执行sql命令。

stat = conn.createStatement();

String querySql = "select * from st";

//建立结果集对象

rs = stat.executeQuery(querySql);

//进行查询操作

while (rs.next()) {

System.out.print(rs.getString(1));

System.out.print("\t" + rs.getString(2));

}

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}

finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

数据库连接类

package test.dbc;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

public class DBConnection {

public static Connection getConnection() {

//一定要注意使用的数据库名、表名、用户名、密码。

Connection conn = null;

String driver = "com.mysql.jdbc.Driver";

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

String username = "root";

String password = "";

try {

//登记驱动程序

Class.forName(driver);

//得到连接

conn = DriverManager.getConnection(url, username, password);

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (SQLException e) {

e.printStackTrace();

}

//返回连接

return conn;

}

public static void close(Connection conn,Statement pstmt,ResultSet rs){

try{

if(rs!=null){rs.close();}

if(pstmt!=null){pstmt.close();}

if(conn!=null){conn.close();}

}catch(Exception e){

e.printStackTrace();

}

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import test.dbc.DBConnection;

public class DataBaseDemo {

public static void main(String a[]) {

//定义连接对象，代表与数据库的连接

Connection conn=null;

//定义SQL语句对象，此对象可执行sql命令。

Statement stat=null;

//定义结果集对象，表示Statement对象执行查询的结果

ResultSet rs=null;

try {

conn=DBConnection.getConnection();

//建立语句对象

stat = conn.createStatement();

//下一条命令在mysql与上一条等价

//stat = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);

String querySql = "select * from students";

//建立结果集对象

rs = stat.executeQuery(querySql);

System.out.print("学号");

System.out.print("\t姓名");

System.out.print("\t数学成绩");

System.out.print("\t英语成绩");

System.out.println("\t物理成绩");

//进行查询操作

while (rs.next()) {

System.out.print(rs.getString("no"));

System.out.print("\t" + rs.getString("name"));

System.out.print("\t" + rs.getInt("math"));

System.out.print("\t" + rs.getInt("english"));

System.out.println("\t" + rs.getInt("physics"));

}

rs.first();

showOneRow(rs);

rs.next();

showOneRow(rs);

rs.last();

showOneRow(rs);

rs.absolute(5);

showOneRow(rs);

rs.relative(-1);

showOneRow(rs);

rs.previous();

showOneRow(rs);

System.out.print("数据库操作成功");

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}

finally {

DBConnection.close(conn, stat, rs);

}

public static void showOneRow(ResultSet rs) throws SQLException {

System.out.println("===========================================");

System.out.println("第" + rs.getRow() + "条记录内容");

System.out.print("学号" + rs.getString("no"));

System.out.println("\t姓名" + rs.getString("name"));

}

另一种连接：

package db;

import java.sql.*;

public class DBConn {

String sDBDriver = "com.mysql.jdbc.Driver";

String sConnStr = "jdbc:mysql://localhost:3306/student?characterEncoding=gbk";

Connection connect = null;

Statement stmt;

ResultSet rs = null;

public DBConn() {

try {

Class.forName(sDBDriver);

connect = DriverManager.getConnection(sConnStr, "root", "");

stmt = connect.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_READ_ONLY);

} catch(ClassNotFoundException e) {

System.err.println("class not found");

} catch(SQLException e1){

System.out.println(e1.getMessage());

}

public ResultSet executeQuery(String sql) {

try {

rs = stmt.executeQuery(sql);

} catch(SQLException ex) {

System.err.println(ex.getMessage());

}

return rs;

}

public int executeUpdate(String sql) {

int result = 0;

try {

result = stmt.executeUpdate(sql);

} catch(SQLException exc) {

System.err.println(exc.getMessage());

}

return result;

}

第五节数据库的预编译操作

一、PreparedStatement类

l PreparedStatement类是Statement类的子类。

l 一个PreparedStatement的对象中包含的SQL声明是动态的，

因此当需要多次执行同一条SQL声明时，利用PreparedStatement提高执行效率。

l PreparedStatement的对象所包含的SQL声明中有一个或多个参数。

1、创建PreparedStatement对象

　　public PreparedStatement prepareStatement(String sql) throws SQLException;

　　例：

　　PreparedStatement pstmt=con.prepareStatement("INSERT INTO testTable(id,name) VALUES(?,?)");

2、参数的赋值

　　PreparedStatement中提供了大量的setXXX方法参数进行赋值。根据参数的SQL类型应选用合适的setXXX方法。

setInt，setLong，setString，setBoolean，setShort，setByte方法。

二、在应用程序中使用预编译操作

package databasepro;

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

public class DBPreparedTest {

public static void main(String[] args) {

//一定要注意使用的数据库名、表名、用户名、密码。

//定义连接对象，代表与数据库的连接

Connection conn = null;

//定义预编译语句对象，此对象可执行动态sql命令。

PreparedStatement preStat = null;

//定义结果集对象，表示PreparedStatement对象执行查询的结果

ResultSet rs = null;

try {

Class.forName("com.mysql.jdbc.Driver");

String user = "dbuser";

String password = "123";

String url = "jdbc:mysql://localhost:3306/student?characterEncoding=gbk";

conn = DriverManager.getConnection(url, user, password);

//查询记录

preStat = conn.prepareStatement("SELECT * FROM students WHERE english>?");

//第一次查询

preStat.setInt(1, 70);

rs = preStat.executeQuery();

showAllRecords(rs);

//第二次查询

preStat.setInt(1, 60);

rs = preStat.executeQuery();

showAllRecords(rs);

//插入数据

preStat = conn.prepareStatement("INSERT INTO " +

"students " +

"VALUES(?,?,?,?,?)");

preStat.setString(1, "199959");

preStat.setString(2, "wang");

preStat.setInt(3, 98);

preStat.setInt(4, 78);

preStat.setInt(5, 99);

preStat.executeUpdate();

System.out.println("插入数据成功");

//修改记录

String updatestr = "update students set math=? where no=?";

preStat = conn.prepareStatement(updatestr);

preStat.setInt(1, 99);

preStat.setString(2, "199909");

preStat.executeUpdate();

System.out.println("修改记录成功");

//删除记录

String delstr = "delete from students where no=?";

preStat = conn.prepareStatement(delstr);

preStat.setString(1, "199920");

preStat.executeUpdate();

System.out.println("删除记录成功");

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}

finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if ( preStat != null) {

preStat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

public static void showAllRecords(ResultSet rs) throws SQLException {

System.out.println("===========================================");

System.out.print("学号");

System.out.print("\t姓名");

System.out.print("\t数学成绩");

System.out.print("\t英语成绩");

System.out.println("\t物理成绩");

//进行查询操作

while (rs.next()) {

System.out.print(rs.getString("no"));

System.out.print("\t" + rs.getString("name"));

System.out.print("\t" + rs.getInt("math"));

System.out.print("\t" + rs.getInt("english"));

System.out.println("\t" + rs.getInt("physics"));

}

三、用PreparedStatement代替Statement.

基于以下的原因:

1.代码的可读性和可维护性.

stmt.executeUpdate("insert into tb_name (col1,col2,col2,col4) values ('"+var1+"','"+var2+"',"+var3+",'"+var4+"')");

perstmt = con.prepareStatement("insert into tb_name (col1,col2,col2,col4) values (?,?,?,?)");

perstmt.setString(1,var1);

perstmt.setString(2,var2);

perstmt.setString(3,var3);

perstmt.setString(4,var4);

perstmt.executeUpdate();

2.PreparedStatement尽最大可能提高性能.

每一种数据库都会尽最大努力对预编译语句提供最大的性能优化.因为预编译语句有可能被重复调用.所以语句在被DB的编译器编译后的执行代码被缓存下来,那么下次调用时只要是相同的预编译语句就不需要编译,只要将参数直接传入编译过的语句执行代码中(相当于一个涵数)就会得到执行.这并不是说只有一个Connection中多次执行的预编译语句被缓存,而是对于整个DB中,只要预编译的语句语法和缓存中匹配.那么在任何时候就可以不需要再次编译而可以直接执行.而statement的语句中,即使是相同一操作,而由于每次操作的数据不同所以使整个语句相匹配的机会极小,几乎不太可能匹配.比如:

insert into tb_name (col1,col2) values ('11','22');

insert into tb_name (col1,col2) values ('11','23');

即使是相同操作但因为数据内容不一样,所以整个个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存.

当然并不是所以预编译语句都一定会被缓存,数据库本身会用一种策略,比如使用频度等因素来决定什么时候不再缓存已有的预编译结果.以保存有更多的空间存储新的预编译语句.

第六节使用ODBC操作数据库

一、使用的表文件

Drop database book;

create database book ;

Use book;

CREATE TABLE books

(id VARCHAR(8)

PRIMARY KEY,

name VARCHAR(24),

title VARCHAR(96),

price FLOAT,

yr INT,

description VARCHAR(30),

saleAmount INT);

INSERT INTO books VALUES('201', '王芳',

'Java编程指南',

33.75, 1999, '让读者轻轻松松掌握Java语言', 1000);

INSERT INTO books VALUES('202', '张丙',

'Weblogic技术参考', 45.99,

2002, '真的不错耶', 2000);

INSERT INTO books VALUES('203', '孙艳',

'Oracle数据库教程',

40, 2003, '关于Oracle的最畅销的技术书', 2000);

INSERT INTO books VALUES('204', '大卫',

'从Oak到Java: 语言的革命',

20.75, 1998, '很值得一看', 2000);

INSERT INTO books VALUES('205', '阿明',

'Apache从入门到精通',

50.75, 2002, '权威的Apache技术资料', 2000);

INSERT INTO books VALUES('206', '洪军',

'Java与数据算法 ',

54.75, 2002, '权威的Java技术资料', 2000);

二、ODBC数据源

ODBC: Open DataBase Connection

打开控制面板选择“ODBC 数据源”选项

数据源有三种：用户数据源: 系统数据源：文件数据源:

1、用户数据源

存储了如何与指定数据提供连接的信息，只有当前用户有权使用,且只能用于当前机器上。

2、系统数据源

存储了如何与指定数据提供连接的信息，当前机器上的所有用户都可以使用

3、文件数据源

不区分用户，不区分机器,以文件存储在磁盘上。

三、JDBC-ODBC桥接器

如果使用JDBC─ODBC桥接器访问数据库，事先必须设置数据源。

为了要连接到数据库，需要建立一个JDBC─ODBC桥接器，即加载桥接器驱动程序。

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

}

catch(ClassNotFoundException e)

{}

三、ODBC数据源的设置

五、在应用程序中使用JDBC-ODBC

强调:

如果使用JDBC-ODBC的话不用设置字符集

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.Statement;

import java.sql.ResultSet;

import java.sql.SQLException;

public class DBJDBC_ODBCTest {

public static void main(String[] args) {

Connection conn=null;

Statement stat=null;

ResultSet rs=null;

try {

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

conn = DriverManager.getConnection("jdbc:odbc:book", "", "");

stat = conn.createStatement();

String sql = "select * from books";

rs = stat.executeQuery(sql);

System.out.println("编号\t作者\t书名 \t 价格\t出版日期");

//进行查询操作

while (rs.next()) {

System.out.print(rs.getInt("id"));

System.out.print("\t" + rs.getString("name"));

System.out.print("\t " + rs.getString("title"));

System.out.print("\t " + rs.getFloat("price"));

System.out.println("\t " + rs.getInt("yr"));

}

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}

finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

强调：

如果没有建立数据源或数据源名错误，则会给出

[Microsoft][ODBC 驱动程序管理器] 未发现数据源名称并且未指定默认驱动程序

第七节元数据(MetaData)

描述其它数据的数据。

一、RusultSetMetaData类

　　 ResultSetMetaData来获得对结果集的列的数目、列值类型和其它特性的描述性信息。　　

ResultSetMetaData 的对象通过ResultSet的方法getMetaData获得。比如假设rs是已获得的结果集，可以用下面语句来获得该结果集对应的信息描述对象：

　　ResultSetMelaData rmd=rs.getMetaData()；

　　ResultSetMetaData类提供了大量有用的方法以获取有关结果集的信息。这些方法主要包括：

　　* Public int getColumnCount()

　　该方法的功能是获得结果集的总列数。

　　* public String getColumnName(int column)

　　该方法的功能是获得指定序号列的名称。

　　* public String getColumnTypeName(int column)

该方法的功能是获得指定序号列在数据源中特定的SQL类名。

方法摘要

String

getCatalogName(int column)
获取指定列的表目录名称。

String

getColumnClassName(int column)
如果调用方法 ResultSet.getObject 从列中检索值，则返回构造其实例的 Java 类的完全限定名称。

int

getColumnCount()
返回此 ResultSet 对象中的列数。

int

getColumnDisplaySize(int column)
指示指定列的最大标准宽度，以字符为单位。

String

getColumnLabel(int column)
获取用于打印输出和显示的指定列的建议标题。

String

getColumnName(int column)
获取指定列的名称。

int

getColumnType(int column)
检索指定列的 SQL 类型。

String

getColumnTypeName(int column)
检索指定列的数据库特定的类型名称。

int

getPrecision(int column)
获取指定列的小数位数。

int

getScale(int column)
获取指定列的小数点右边的位数。

String

getSchemaName(int column)
获取指定列的表模式。

String

getTableName(int column)
获取指定列的名称。

boolean

isAutoIncrement(int column)
指示是否自动为指定列进行编号，这样这些列仍然是只读的。

boolean

isCaseSensitive(int column)
指示列的大小写是否有关系。

boolean

isCurrency(int column)
指示指定的列是否是一个哈希代码值。

boolean

isDefinitelyWritable(int column)
指示在指定的列上进行写操作是否明确可以获得成功。

int

isNullable(int column)
指示指定列中的值是否可以为 null。

boolean

isReadOnly(int column)
指示指定的列是否明确不可写入。

boolean

isSearchable(int column)
指示是否可以在 where 子句中使用指定的列。

boolean

isSigned(int column)
指示指定列中的值是否带正负号。

boolean

isWritable(int column)
指示在指定的列上进行写操作是否可以获得成功。

二、实例　　

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

public class DBMetaDataTest {

public static void main(String[] args) {

Connection conn = null;

Statement stmt = null;

ResultSet rs = null;

try {

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/book";

String user = "dbuser";

String password = "123";

conn = DriverManager.getConnection(url, user, password);

//创建一个SQL语句操作对象

stmt = conn.createStatement();

//执行SQL声明

rs = stmt.executeQuery("Select * from books");

System.out.println("======================================");

ResultSetMetaData rsmd = rs.getMetaData();

//获得结果集列数

int columnCount = rsmd.getColumnCount();

System.out.println("列序号\t列名\t数据类型");

for (int i = 1; i <= columnCount; i++) {

System.out.println(" " + i + " \t" +

rsmd.getColumnName(i) + "\t" +

rsmd.getColumnTypeName(i));

}

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}

finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stmt != null) {

stmt.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

实例二：

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

public class DBTest {

public static void main(String a[]) {

Connection conn = null;

Statement stat = null;

ResultSet rs = null;

try {

//注册驱动程序

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

String user = "root";

String password = "";

//建立连接对象

conn = DriverManager.getConnection(url, user, password);

//建立语句对象

stat = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);

String querySql = "select * from students";

//建立结果集对象

rs = stat.executeQuery(querySql);

ResultSetMetaData rsmd = rs.getMetaData();

//获得结果集列数

int columnCount = rsmd.getColumnCount();

StringBuffer columeName=new StringBuffer();

for (int i = 1; i <= columnCount; i++) {

columeName.append(

rsmd.getColumnName(i) + "\t") ;

}

System.out.println(columeName);

// System.out.print("学号");

// System.out.print("\t姓名");

// System.out.print("\t数学成绩");

// System.out.print("\t英语成绩");

// System.out.println("\t物理成绩");

//进行查询操作

while (rs.next()) {

System.out.print(rs.getString("no"));

System.out.print("\t" + rs.getString("name"));

System.out.print("\t" + rs.getInt("math"));

System.out.print("\t" + rs.getInt("english"));

System.out.println("\t" + rs.getInt("physics"));

}

System.out.print("数据库操作成功");

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

e.printStackTrace();

}

finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

实例三：

* To change this template, choose Tools | Templates

* and open the template in the editor.

package ch10;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

public class DBTest {

public static void main(String a[]) {

Connection conn = null;

Statement stat = null;

ResultSet rs = null;

try {

//注册驱动程序

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

String user = "root";

String password = "";

//建立连接对象

conn = DriverManager.getConnection(url, user, password);

//建立语句对象

stat = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);

String querySql = "select no as 学号,name as 姓名 ,math as 数学,english as 英语,physics as 物理 from students";

//建立结果集对象

rs = stat.executeQuery(querySql);

ResultSetMetaData rsmd = rs.getMetaData();

//获得结果集列数

int columnCount = rsmd.getColumnCount();

StringBuffer columeName=new StringBuffer();

// for (int i = 1; i <= columnCount; i++) {

// columeName.append(

// rsmd.getColumnName(i) + "\t") ;

// }

//getColumnLabel方法返回字段别名

for (int i = 1; i <= columnCount; i++) {

columeName.append(

rsmd.getColumnLabel(i) + "\t") ;

}

System.out.println(columeName);

// System.out.print("学号");

// System.out.print("\t姓名");

// System.out.print("\t数学成绩");

// System.out.print("\t英语成绩");

// System.out.println("\t物理成绩");

//进行查询操作

while (rs.next()) {

System.out.print(rs.getString("学号")+"\t");

System.out.print(rs.getString("姓名")+"\t");

System.out.print(rs.getInt("数学")+"\t");

System.out.print(rs.getInt("英语")+"\t");

System.out.println(rs.getInt("物理")+"\t");

}

System.out.print("数据库操作成功");

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

e.printStackTrace();

}

finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

三、DatabaseMetaData

import java.sql.*;

public class TestMetaData{

public static void main(String args[]){

Connection conn = null;

try{

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

conn = DriverManager.getConnection(url,"root","");

ResultSet rs = null;

DatabaseMetaData dmd = conn.getMetaData();

if (dmd == null) {

System.out.println ("No Meta available");

} else {

System.out.println ("数据库名称:" + dmd.getDatabaseProductName());

System.out.println ("数据库版本:" + dmd.getDatabaseProductVersion());

System.out.println ("数据库驱动程序：" + dmd.getDriverName());

System.out.println ("驱动程序版本号：" + dmd.getDriverVersion());

System.out.println ("--------------------------------------------");

System.out.println ("结果集类型及支持情况(true-支持,false-不支持)");

System.out.println ("TYPE_FORWARD_ONLY: " +

dmd.supportsResultSetType(ResultSet.TYPE_FORWARD_ONLY));

System.out.println ("TYPE_SCROLL_INSENSITIVE: " +

dmd.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE));

System.out.println ("TYPE_SCROLL_SENSITIVE: " +

dmd.supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE));

System.out.println ("CONCUR_READ_ONLY: " +

dmd.supportsResultSetType(ResultSet.CONCUR_READ_ONLY));

System.out.println ("CONCUR_UPDATABLE: " +

dmd.supportsResultSetType(ResultSet.CONCUR_UPDATABLE));

}

}catch(Exception e){

e.printStackTrace();

}finally{

try{

if(conn != null){

conn.close();

}

}catch(Exception e){

e.printStackTrace();

}

例二、

import java.sql.*;

public class TestMetaData1 {

public static void main(String args[]) {

Connection conn = null;

try {

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

conn = DriverManager.getConnection(url, "root", "");

DatabaseMetaData dmd = conn.getMetaData();

//检索可在给定类别中使用的表的描述

ResultSet rs = dmd.getTables(null, null, null, new String[]{"table"});

//定义ResultSetMetaData对象

ResultSetMetaData rsmd = rs.getMetaData();

//返回此 ResultSet 对象中的列数

int cols = rsmd.getColumnCount();

for (int i = 1; i <= cols; i++) {

//获取指定列的名称。

System.out.print(rsmd.getColumnName(i) + "\t");

}

System.out.println("");

while (rs.next()) {

for (int i = 1; i <= cols; i++) {

System.out.print(rs.getString(i) + "\t");

}

System.out.println("");

}

} catch (Exception e) {

e.printStackTrace();

}

第八节存储过程

一、存储过程的基本操作

1、存储过程的建立

create procedure p2() select * from students;

set @eng1=80;

create procedure p7( eng int)

select * from students where english>eng;

call p7(@eng1);

2、存储过程的删除

DROP PROCEDURE name

二、CallableStatement类

CallableStatement 对象为所有的 DBMS 提供了一种调用储存过程的方法。

有两种形式：一种形式带参数，另一种形式不带参数。

import java.sql.CallableStatement;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

public class DBCallProcTest1 {

public static void main(String[] args) {

//一定要注意使用的数据库名、表名、用户名、密码。

Connection conn = null;

//声明存储过程对象，此对象可执行存储过程

CallableStatement cstmt = null;

ResultSet rs=null;

String url = "jdbc:mysql://localhost:3306/student?characterEncoding=gbk";

try {

Class.forName("com.mysql.jdbc.Driver");

String user = "dbuser";

String password = "123";

conn = DriverManager.getConnection(url, user, password);

cstmt = conn.prepareCall("{call p2()}");

//执行储存过程。

rs = cstmt.executeQuery();

System.out.println("学号\t姓名\t数学成绩\t英语成绩\t物理成绩");

//进行查询操作

while (rs.next()) {

System.out.print(rs.getString("no"));

System.out.print("\t" + rs.getString("name"));

System.out.print("\t" + rs.getInt("math"));

System.out.print("\t" + rs.getInt("english"));

System.out.println("\t" + rs.getInt("physics"));

}

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

} finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (cstmt != null) {

cstmt.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

*************

import java.sql.CallableStatement;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

public class DBCallProcTest2 {

public static void main(String[] args) {

Connection conn = null;

//声明存储过程对象，此对象可执行存储过程

CallableStatement cstmt = null;

ResultSet rs=null;

String url = "jdbc:mysql://localhost:3306/student?characterEncoding=gbk";

try {

Class.forName("com.mysql.jdbc.Driver");

String user = "dbuser";

String password = "123";

conn = DriverManager.getConnection(url, user, password);

cstmt = conn.prepareCall("{call p7(?)}");

cstmt.setInt(1,80);

//执行储存过程。

rs = cstmt.executeQuery();

System.out.println("学号\t姓名\t数学成绩\t英语成绩\t物理成绩");

//进行查询操作

while (rs.next()) {

System.out.print(rs.getString("no"));

System.out.print("\t" + rs.getString("name"));

System.out.print("\t" + rs.getInt("math"));

System.out.print("\t" + rs.getInt("english"));

System.out.println("\t" + rs.getInt("physics"));

}

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (cstmt != null) {

cstmt.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

存储过程：

create procedure p7( eng int)

select * from students where english>eng;

第九节 mysql中的数据类型

一、数据库类型与 Java类型对照表

数据库类型 Java类型

int int

bigint java.math.BigInteger

float float

double Double

decimal java.math.BigDecimal

字符型

char java.lang.String

varchar

tinytext

text

mediumtext

longtext

日期型

date java.sql.Date

datetime java.sql.Timestamp

timestamp java.sql.Timestamp

逻辑型：

bit boolean

注意：

java.sql.Date主要是用于sql中的！
而java.util.Date用语一般的环境下都行！

实例：

import java.sql.Date;

public class SQLDateTest {

public static void main(String args[]) {

java.util.Date d2 = new java.util.Date();

//下面的Date为java.sql.Date,此Date没有不带参数的构造方法

Date d1 = new Date(d2.getTime());

System.out.println(d1);

}

二、实例

mysql --default-character-set=gbk -u root

create database st default character set gbk;

Use st;

CREATE TABLE students1 (

no CHAR(6) primary key,

name VARCHAR(10),

math int,

english int,

physics int,

Sex bit,

rxrq date

) Engine=innodb;

或：

CREATE TABLE students1 (

no CHAR(6) primary key,

name VARCHAR(10),

math int,

english int,

physics int

);

alter table students1 add sex bit,add rxrq date;

INSERT INTO students1 VALUES('199901', '张小盐', 69,98,88,1,'1999-9-1');

INSERT INTO students1 VALUES('199902', '王六奖', 68,78,85,0,'1999-9-2');

INSERT INTO students1 VALUES('199903', '历小记', 77,66,56,1,'1999-9-1');

INSERT INTO students1 VALUES('199904', '胡名明', 66,97,83,1,'1999-9-3');

INSERT INTO students1 VALUES('199905', '柳名将', 88,80,77,1,'1999-9-1');

INSERT INTO students1 VALUES('199906', '金六副', 66,78,45,1,'1999-9-1');

INSERT INTO students1 VALUES('199907', '语境竟', 55,77,90,0,'1999-9-4');

INSERT INTO students1 VALUES('199908', '钟名讳', 90,99,78,1,'1999-9-7');

/**

* 工程: DatabasePro

* 文件: DBQueryTest1.java

* 包: databasepro

* 单位: 黑龙江八一农垦大学计算机系

* 版权: 无

* 版本: 1.0

* 变更历史: 2008-3-23 14:36:00 PM (tjh) 创建

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.Statement;

import java.sql.ResultSet;

import java.sql.SQLException;

/**

* 对数据库查询的实例

* @author tjh

public class DBTest66 {

/**

*可完成对学生信息的查询

public static void main(String args[]) {

//一定要注意使用的数据库名、表名、用户名、密码。

Connection conn = null;

//定义连接对象，代表与数据库的连接

ResultSet rs=null;

//定义SQL语句对象，此对象可执行sql命令。

Statement stat=null;

//定义结果集对象，表示Statement对象执行查询的结果

try {

//注册驱动程序

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st2?characterEncoding=gbk";

String user = "root";

String password = "";

//建立连接对象

conn = DriverManager.getConnection(url, user, password);

//建立语句对象

stat = conn.createStatement();

String querySql = "select * from students1";

//建立结果集对象

rs = stat.executeQuery(querySql);

System.out.println("学号\t姓名\t数学成绩\t英语成绩\t物理成绩\t性别\t入学日期");

//进行查询操作

while (rs.next()) {

System.out.print(rs.getString("no"));

System.out.print("\t" + rs.getString("name"));

System.out.print("\t" + rs.getInt("math"));

System.out.print("\t" + rs.getInt("english"));

System.out.print("\t" + rs.getInt("physics"));

//以下五条命令和上面五条命令作用一样,但不提倡使用

//System.out.print( rs.getString(1));

//System.out.print("\t" + rs.getString(2));

//System.out.print("\t" + rs.getInt(3));

//System.out.print("\t" + rs.getInt(4));

//System.out.println("\t" + rs.getInt(5));

if (rs.getBoolean("sex")) {

System.out.print("\t" + "男");

} else {

System.out.print("\t" + "女");

}

//注意类型为java.sql.Date

java.sql.Date d1=rs.getDate("rxrq");

System.out.println(d1.toString());

//System.out.println("\t" + rs.getDate("rxrq"));

}

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

}

finally {

try {

if (rs != null) {

rs.close();

}

} catch (SQLException e) {

System.out.println("结果集关闭错误");

e.printStackTrace();

}

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

第十节 JDBC的事务处理(Truncation)

一、mysql的数据库引擎

mysql有两种数据库引擎一种是MyISAM，一种是InnoDB

MyISAM 发音为 "my-z[ei]m"；InnoDB 发音为 "in-no-db"

1、InnoDb 存储引擎

　　InnoDb 存储引擎,支持事务,行锁,外键.InnoDb 设计用来处理大数据量时提供最好的性能.

2、MyISAM 存储引擎

所有数据值先存储低字节。这使得数据机和操作系统分离。二进制轻便性的唯一要求是机器使用补码（如最近20年的机器有的一样）和IEEE浮点格式（在主流机器中也完全是主导的）。

·大文件（达63位文件长度）在支持大文件的文件系统和操作系统上被支持。

·当把删除和更新及插入混合的时候，动态尺寸的行更少碎片。这要通过合并相邻被删除的块，以及若下一个块被删除，就扩展到下一块来自动完成。

·每个MyISAM表最大索引数是64。这可以通过重新编译来改变。每个索引最大的列数是16个。

·最大的键长度是1000字节。这也可以通过编译来改变。对于键长度超过250字节的情况，一个超过1024字节的的键块被用上。

·BLOB和TEXT列可以被索引。

·NULL值被允许在索引的列中。这个占每个键的0-1个字节。

·所有数字键值以高字节为先被存储以允许一个更高地索引压缩。

·当记录以排好序的顺序插入（就像你使用一个AUTO_INCREMENT列之时），索引树被劈开以便高节点仅包含一个键。这改善了索引树的空间利用率。

·每表一个AUTO_INCREMEN列的内部处理。MyISAM为INSERT和UPDATE操作自动更新这一列。这使得AUTO_INCREMENT列更快（至少10%）。在序列顶的值被删除之后就不能再利用。（当AUTO_INCREMENT列被定义为多列索引的最后一列，可以出现重使用从序列顶部删除的值的情况）。AUTO_INCREMENT值可用ALTER TABLE或myisamch来重置。

·如果数据文件中间的表没有自由块了，在其它线程从表读的同时，你可以INSERT新行到表中。（这被认识为并发操作）。自由块的出现是作为删除行的结果，或者是用比当前内容多的数据对动态长度行更新的结果。当所有自由块被用完（填满），未来的插入又变成并发。

·你可以把数据文件和索引文件放在不同目录，

·每个字符列可以又不同的字符集，

·支持true VARCHAR类型；VARCHAR列以存储在2个字节中的长度来开始。

·有VARCHAR的表可以有固定或动态记录长度。

·VARCHAR和CHAR列可以多达64KB。

主要区别：

对于MYSQL你要使用事务以及行级锁就必须使用innodb引擎。
你要使用全文索引，那必须使用myisam。
INNODB的实用性，安全性，稳定性更高但是效率比MYISAM稍差，但是有的功能是MYISAM没有

二、事物的概念与处理

u 一项事务是由一条或是多条表达式所组成的一个不可分割的工作单元。

在connection类中提供了3个控制事务的方法：

（1） setAutoCommit(Boolean autoCommit):设置是否自动提交事务；

（2） commit();提交事务；

（3） rollback();撤消事务；

u 在JDBC中，事务操作默认是自动提交。默认的情况为自动提交事务，也就是说，每一条对数据库的更新的sql语句代表一项事务，操作成功后，系统自动调用commit（）来提交，否则将调用rollback（）来撤消事务

u JDBC中，可以通过调用setAutoCommit(false)来禁止自动提交。之后就可以把多个数据库操作的表达式作为一个事务，在操作完成后调用commit()来进行整体提交。倘若其中一个表达式操作失败，都不会执行到commit()，并且将产生响应的异常。此时就可以在异常捕获时调用rollback()进行回退。这样做可以保持多次更新操作后，相关数据的一致性。

。

例如在银行的转帐事务中，假定张三从自己的帐号上把1000元转到李四的帐号上，相关的sql语句如下：

update account set monery=monery-1000 where name='zhangsan'

update account set monery=monery+1000 where name='lisi'

这个两条语句必须作为一个完成的事务来处理。只有当两条都成功执行了，才能提交这个事务。如果有一句失败，整个事务必须撤消。

void rollback()

throws SQLException取消在当前事务中进行的所有更改，此方法应该只在已禁用自动提交模式时使用。

抛出：

SQLException - 如果发生数据库访问错误或者此 Connection 对象处于自动提交模式下

三、实例

create database student default character set gbk;

use student;

CREATE TABLE students (

no CHAR(6) primary key,

name VARCHAR(10),

math int,

english int,

physics int) Engine=innodb;

或：

CREATE TABLE students (

no CHAR(6) primary key,

name VARCHAR(10),

math int,

english int,

physics int) Engine=myisam;

alter table students engine=innodb;

INSERT INTO students VALUES('199901', '张小盐', 69,98,88);

INSERT INTO students VALUES('199902', '王六奖', 68,78,85);

INSERT INTO students VALUES('199903', '历小记', 77,66,56);

INSERT INTO students VALUES('199904', '胡名明', 66,97,83);

INSERT INTO students VALUES('199905', '柳名将', 88,80,77);

INSERT INTO students VALUES('199906', '金六副', 66,78,45);

INSERT INTO students VALUES('199907', '语境竟', 55,77,90);

INSERT INTO students VALUES('199908', '钟名讳', 90,99,78);

//DBTest6.java

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

/**

* @author tai

public class DBTest6 {

public static void main(String args[]) throws Exception {

//一定要注意使用的数据库名、表名、用户名、密码。

//定义连接对象，代表与数据库的连接

Connection conn=null;

//定义SQL语句对象，此对象可执行sql命令。

Statement stat=null;

//定义结果集对象，表示Statement对象执行查询的结果

ResultSet rs=null;

try {

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st2?characterEncoding=gbk";

String user = "root";

String password = "";

conn = DriverManager.getConnection(url, user, password);

stat = conn.createStatement();

//设置事务为非自动提交

//conn.setAutoCommit(false);

stat.executeUpdate("insert into students values ('199929','刘奇1',67,78,89)");

stat.executeUpdate("insert into students values ('199929','刘奇2',67,78,89)");

stat.executeUpdate("insert into students values ('199926','刘奇3',67,78,88)");

//提交事务

// conn.commit();

rs = stat.executeQuery("SELECT * FROM Students");

StringBuilder stringRS = showAllRecords(rs);

System.out.print(stringRS);

} catch (SQLException e) {

System.out.println(e.getMessage());

try {

//回滚事务

//conn.rollback();

} catch (SQLException e1) {

System.out.println("回滚错误");

}

} finally {

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

public static StringBuilder showAllRecords(ResultSet rs) throws SQLException {

StringBuilder stringRS1 = new StringBuilder();

stringRS1.append("学号");

stringRS1.append("\t姓名");

stringRS1.append("\t数学成绩");

stringRS1.append("\t英语成绩");

stringRS1.append("\t物理成绩\n");

//进行查询操作

while (rs.next()) {

stringRS1.append(rs.getString("no"));

stringRS1.append("\t" + rs.getString("name"));

stringRS1.append("\t" + rs.getInt("math"));

stringRS1.append("\t" + rs.getInt("english"));

stringRS1.append("\t" + rs.getInt("physics") + "\n");

}

return stringRS1;

}

1、问题

保留粉色注释和将注释去掉，会得到什么结果为什么？

2、修改表

alter table students engine=MyISAM;

将注释去掉，会得到什么结果为什么？

*********

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.Statement;

import java.sql.ResultSet;

/**

* @author tai

public class DBTest6 {

或者写为：

public static void main (String args[]) throws Exception

{

Connection con=null;

Statement stat;

ResultSet rs;

try{

Class.forName("com.mysql.jdbc.Driver");

String url="jdbc:mysql://localhost:3306/student?characterEncoding=gbk";

String user="root";

String password="";

con= DriverManager.getConnection(url,user,password);

stat = con.createStatement();

//设置事务为非自动提交

//con.setAutoCommit(false);

stat.executeUpdate("insert into students values ('199929','刘奇1',67,78,89)");

stat.executeUpdate("insert into students values ('199929','刘奇2',67,78,89)");

stat.executeUpdate("insert into students values ('199926','刘奇3',67,78,88)");

//con.commit();

ResultSet result

= stat.executeQuery("SELECT * FROM Students");

result.next();

System.out.println(result.getString(1));

}

catch (Exception ex){

// con.rollback();

System.out.println("异常信息"+ex.getMessage());

}

}}

第十一节批量处理记录

1、addBatch方法

void addBatch(String sql) throws SQLException

将给定的 SQL 命令添加到此 Statement 对象的当前命令列表中。

通过调用方法 executeBatch 可以批量执行此列表中的命令。

参数：

sql - 通常此参数为静态的 SQL INSERT 或 UPDATE 语句

抛出：

SQLException - 如果发生数据库访问错误，或者驱动程序不支持批量更新

void addBatch()throws SQLException

将一组参数添加到此 PreparedStatement 对象的批处理命令中。

抛出：

SQLException - 如果发生数据库访问错误

2、executeBatch方法

int[] executeBatch()throws SQLException

将一批命令提交给数据库来执行，如果全部命令执行成功，则返回更新计数组成的数组。

包含批中每个命令的一个元素的更新计数所组成的数组。

3、使用Statement

package dbdemo;

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.SQLException;

import java.sql.Statement;

public class BatchTest {

public static void main(String[] args) {

Connection conn = null;

Statement stat = null;

String url = "jdbc:mysql://localhost:3306/st2?characterEncoding=gbk";

try {

Class.forName("com.mysql.jdbc.Driver");

String user = "root";

String password = "";

conn = DriverManager.getConnection(url, user, password);

stat =

//设置事务为非自动提交

conn.createStatement();

conn.setAutoCommit(false);

stat.addBatch("insert into students values ('199931','刘奇1',67,78,89)");

stat.addBatch("insert into students values ('199930','刘奇2',67,78,89)");

stat.addBatch("insert into students values ('199935','刘奇3',67,78,88)");

stat.addBatch("update students set math=90 where math>80");

stat.executeBatch();

//提交事务

conn.commit();

System.out.println("添加记录成功");

/*下面程序可以打印每条命令影响的命令数

int[ ] counts = stat.executeBatch();

for(int i=0;i<counts.length;i++){

System.out.println(counts[i]);

}

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println(e.getMessage());

try{

conn.rollback();

}catch(SQLException e1){

System.out.println("回滚错误");

}

finally {

try {

if (stat != null) {

stat.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

4、使用PreparedStatement

import java.sql.DriverManager;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.SQLException;

public class DBPreStatementBatchTest {

public static void main(String[] args) {

Connection conn = null;

//定义预编译语句对象，此对象可执行动态sql命令。

PreparedStatement pstmt = null;

String url = "jdbc:mysql://localhost:3306/st2?characterEncoding=gbk";

try {

Class.forName("com.mysql.jdbc.Driver");

String user = "root";

String password = "";

conn = DriverManager.getConnection(url, user, password);

String insertstr = "insert into students values (?,?,?,?,?)";

pstmt = conn.prepareStatement(insertstr);

//设置事务为非自动提交

conn.setAutoCommit(false);

pstmt.setString(1, "199976");

pstmt.setString(2, "刘奇");

pstmt.setInt(3, 99);

pstmt.setInt(4, 89);

pstmt.setInt(5, 79);

pstmt.addBatch();

pstmt.setString(1, "199977");

pstmt.setString(2, "刘奇1");

pstmt.setInt(3, 96);

pstmt.setInt(4, 86);

pstmt.setInt(5, 76);

pstmt.addBatch();

pstmt.setString(1, "199979");

pstmt.setString(2, "刘奇3");

pstmt.setInt(3, 96);

pstmt.setInt(4, 86);

pstmt.setInt(5, 76);

pstmt.addBatch();

pstmt.executeBatch();

//提交事务

conn.commit();

System.out.print("添加记录成功");

} catch (ClassNotFoundException e) {

System.out.println("驱动程序不存在或名字写错");

System.out.println(e.getMessage());

} catch (SQLException e) {

System.out.println(e.getMessage());

try{

conn.rollback();

}catch(SQLException e1){

System.out.println("回滚错误");

}

finally {

try {

if (pstmt != null) {

pstmt.close();

}

} catch (SQLException e) {

System.out.println("语句对象关闭错误");

e.printStackTrace();

}

try {

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("连接关闭错误");

e.printStackTrace();

}

第十二节综合实例

一、使用的表文件

CREATE TABLE note

(

id int not null primary key , --

title varchar(20) not null ,

author varchar(20) not null ,

content varchar(50) not null

) ;

二、程序代码

//DBConnection.java

package note;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

public class DBConnection {

public static Connection getConnection() {

//一定要注意使用的数据库名、表名、用户名、密码。

Connection conn = null;

String driver = "com.mysql.jdbc.Driver";

String url = "jdbc:mysql://localhost:3306/st2";

String username = "root";

String password = "";

try {

//登记驱动程序

Class.forName(driver);

//得到连接

conn = DriverManager.getConnection(url, username, password);

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (SQLException e) {

e.printStackTrace();

}

//返回连接

return conn;

}

//Note.Java

package note;

public class Note {

private int id;

private String title;

private String author;

private String content;

public void setId(int id) {

this.id = id;

}

public void setTitle(String title) {

this.title = title;

}

public void setAuthor(String author) {

this.author = author;

}

public void setContent(String content) {

this.content = content;

}

public int getId() {

return this.id;

}

public String getTitle() {

return this.title;

}

public String getAuthor() {

return this.author;

}

public String getContent() {

return this.content;

}

public String toString(){

return "[noteid=" + getId() + ", title='" + getTitle() + "', Author='" + getAuthor() + "', content='" + getContent() + "']";

}

//NoteDAO.Java

package note;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

public class NoteDAO {

public boolean insert(Note note) {

String sql = "INSERT INTO note(id,title,author,content) VALUES(?,?,?,?)";

//得到连接对象

Connection conn = DBConnection.getConnection();

//定义预编译语句对象，此对象可执行动态sql命令。

PreparedStatement pstmt = null;

boolean insertSuccessFlag = false;

try {

pstmt = conn.prepareStatement(sql);

pstmt.setInt(1, note.getId());

pstmt.setString(2, note.getTitle());

pstmt.setString(3, note.getAuthor());

pstmt.setString(4, note.getContent());

//执行pstmt表示的插入命令

pstmt.executeUpdate();

pstmt.close();

insertSuccessFlag = true;

} catch (SQLException e) {

System.out.println("插入操作中出现错误！！！");

System.out.println(e);

} finally {

try {

if (pstmt != null) {

pstmt.close();

}

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

e.printStackTrace();

}

return insertSuccessFlag;

}

// 修改操作

public boolean update(Note note) {

String sql = "UPDATE note SET title=?,author=?,content=? WHERE id=?";

Connection conn = DBConnection.getConnection();

PreparedStatement pstmt = null;

boolean updateSuccessFlag = false;

try {

pstmt = conn.prepareStatement(sql);

pstmt.setString(1, note.getTitle());

pstmt.setString(2, note.getAuthor());

pstmt.setString(3, note.getContent());

pstmt.setInt(4, note.getId());

pstmt.executeUpdate();

updateSuccessFlag = true;

} catch (SQLException e) {

System.out.println("更新操作中出现错误！！！");

System.out.println(e);

} finally {

try {

if (pstmt != null) {

pstmt.close();

}

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

e.printStackTrace();

}

return updateSuccessFlag;

}

// 删除操作

public boolean delete(int id) {

String sql = "DELETE FROM note WHERE id=?";

PreparedStatement pstmt = null;

Connection conn = DBConnection.getConnection();

boolean deleteSuccessFlag = false;

try {

pstmt = conn.prepareStatement(sql);

pstmt.setInt(1, id);

pstmt.executeUpdate();

pstmt.close();

deleteSuccessFlag = true;

} catch (SQLException e) {

System.out.println("删除操作中出现错误！！！");

System.out.println(e);

} finally {

try {

if (pstmt != null) {

pstmt.close();

}

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

e.printStackTrace();

}

return deleteSuccessFlag;

}

// 按ID查询

public Note queryById(int id) {

Note note = null;

String sql = "SELECT id,title,author,content FROM note WHERE id=?";

Connection conn = DBConnection.getConnection();

PreparedStatement pstmt = null;

ResultSet rs = null;

try {

pstmt = conn.prepareStatement(sql);

pstmt.setInt(1, id);

rs = pstmt.executeQuery();

//此处为什么不用while,用while可不可以

if (rs.next()) {

note = new Note();

note.setId(rs.getInt(1));

note.setTitle(rs.getString(2));

note.setAuthor(rs.getString(3));

note.setContent(rs.getString(4));

}

} catch (SQLException e) {

System.out.println("操作中出现错误！！！");

} finally {

try {

if (rs != null) {

rs.close();

}

if (pstmt != null) {

pstmt.close();

}

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

e.printStackTrace();

}

return note;

}

//NoteTest.Java

package note;

import javax.swing.JOptionPane;

public class NoteTest {

public static void main(String args[]) {

此段代码都完成了哪些操作？

Note note = null;

NoteDAO noteDAO = new NoteDAO();

note = new Note();

note.setId(22);

note.setAuthor("wang");

note.setContent("learn c#");

note.setTitle("C#");

if (noteDAO.insert(note)) {

JOptionPane.showMessageDialog(null, "插入操作成功");

}

note = new Note();

note.setId(23);

note.setAuthor("zhangsan");

note.setContent("learn java");

note.setTitle("java");

if (noteDAO.insert(note)) {

JOptionPane.showMessageDialog(null, "插入操作成功");

}

note = new Note();

note.setId(155);

note.setAuthor("liu");

note.setContent("learn c");

note.setTitle("C");

if (noteDAO.insert(note)) {

JOptionPane.showMessageDialog(null, "插入操作成功");

}

if (noteDAO.delete(155)) {

JOptionPane.showMessageDialog(null, "删除操作成功");

}

Note note1 = noteDAO.queryById(22);

System.out.println(note1);

note1 = noteDAO.queryById(23);

note1.setAuthor("lee");

note1.setContent("java");

note1.setTitle("learn java");

if(noteDAO.update(note1))

JOptionPane.showMessageDialog(null, "更新操作成功");

}

三、数据库的另外一种封装形式

package db;

import java.sql.*;

public class DBConn {

String sDBDriver = "com.mysql.jdbc.Driver";

String sConnStr = "jdbc:mysql://localhost:3306/student?characterEncoding=gbk";

Connection connect = null;

Statement stmt;

ResultSet rs = null;

public DBConn() {

try {

Class.forName(sDBDriver);

connect = DriverManager.getConnection(sConnStr, "root", "");

stmt = connect.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_READ_ONLY);

} catch(ClassNotFoundException e) {

System.err.println("class not found");

} catch(SQLException e1){

System.out.println(e1.getMessage());

}

public ResultSet executeQuery(String sql) {

try {

rs = stmt.executeQuery(sql);

} catch(SQLException ex) {

System.err.println(ex.getMessage());

}

return rs;

}

public int executeUpdate(String sql) {

int result = 0;

try {

result = stmt.executeUpdate(sql);

} catch(SQLException exc) {

System.err.println(exc.getMessage());

}

return result;

}

四、简单登陆操作

create table user_table(

user_id int(11) auto_increment,

user_name varchar(50) not null,

user_pass varchar(50) not null,

email varchar(100),

primary key(user_id),

unique(user_name)

);

insert into user_table values(200901,"abc","123","yisjfds@163.com");

insert into user_table values(200902,"cde","456","yisjfds@163.com");

insert into user_table values(200903,"efg","789","yisjfds@163.com");

insert into user_table values(200904,"ghi","147","yisjfds@tom.com");

insert into user_table values(200905,"ijk","258","yisjfds@126.com");

参照上表完成一个数据库查询程序：

通过键盘输入用户名和密码

如果此用户名和密码正确则打印登陆成功，

否则打印登陆不成功。

（1）用单个类完成造作

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import javax.swing.*;

public class Test{

public static void main(String args[]){

Connection conn=null;

PreparedStatement pstmt=null;

ResultSet rs=null;

try{

String url="jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

String user="root";

String pass=null;

Class.forName("com.mysql.jdbc.Driver");

conn=DriverManager.getConnection(url,user,pass);

}catch(ClassNotFoundException e){

System.out.println("数据库连接错误！");

}catch(SQLException e){

e.printStackTrace();

}

try{

String userName=JOptionPane.showInputDialog(null, "输入用户名");

String userPassword=JOptionPane.showInputDialog(null, "输入密码");

String sql="select user_pass from user_table where user_name=? ";

pstmt=conn.prepareStatement(sql);

pstmt.setString(1,userName);

rs=pstmt.executeQuery();

if(rs.next()){

if(rs.getString(1).equals(userPassword)){

JOptionPane.showMessageDialog(null, "成功登陆！");

}

else{

JOptionPane.showMessageDialog(null, "密码错误！");

}

else{

JOptionPane.showMessageDialog(null, "用户名错误！");

}

}catch(SQLException e){

System.out.println("数据库操作错误！！");

e.printStackTrace();

}catch(Exception e){

e.printStackTrace();

}finally{

try{

if(conn!=null){

conn.close();

}

if(pstmt!=null){

pstmt.close();

}

if(rs!=null){

rs.close();

}

}catch(SQLException e){

e.printStackTrace();

}

（2）模仿上例用四个类来完成操作

参考答案：

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

public class DBConnection {

public static Connection getConnection() {

//一定要注意使用的数据库名、表名、用户名、密码。

Connection conn = null;

String driver = "com.mysql.jdbc.Driver";

String url = "jdbc:mysql://localhost:3306/st";

String username = "root";

String password = "";

try {

//登记驱动程序

Class.forName(driver);

//得到连接

conn = DriverManager.getConnection(url, username, password);

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (SQLException e) {

e.printStackTrace();

}

//返回连接

return conn;

}

//User.Java

public class User{

private int id;

private String name;

private String pass;

private String email;

public void setId(int id){

this.id=id;

}

public void setName(String name){

this.name=name;

}

public void setPass(String pass){

this.pass=pass;

}

public void setEmail(String email){

this.email=email;

}

public int getId(){

return id;

}

public String getName(){

return name;

}

public String getPass(){

return pass;

}

public String getEmail(){

return email;

}

public String toString(){

return "id= "+getId()+" name= "+getName()+" pass= "+getPass()+" email= "+getEmail();

}

//UserDAO.java

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

public class UserDAO {

public boolean insert(User user) {

String sql = "insert into user_table values(?,?,?,?)";

Connection conn = DBConnection.getConnection();

PreparedStatement pstmt = null;

boolean insertSuccessFlag = false;

try {

pstmt = conn.prepareStatement(sql);

pstmt.setInt(1, user.getId());

pstmt.setString(2, user.getName());

pstmt.setString(3, user.getPass());

pstmt.setString(4, user.getEmail());

//执行pstmt表示的插入命令

pstmt.executeUpdate();

pstmt.close();

insertSuccessFlag = true;

} catch (SQLException e) {

System.out.println("插入操作中出现错误！！！");

System.out.println(e);

} finally {

try {

if (pstmt != null) {

pstmt.close();

}

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

e.printStackTrace();

}

return insertSuccessFlag;

}

// 修改操作

public boolean update(User user) {

String sql = "UPDATE user_table SET user_name=?,user_pass=?,email=? WHERE user_id=?";

Connection conn = DBConnection.getConnection();

PreparedStatement pstmt = null;

boolean updateSuccessFlag = false;

try {

pstmt = conn.prepareStatement(sql);

pstmt.setString(1, user.getName());

pstmt.setString(2, user.getPass());

pstmt.setString(3, user.getEmail());

pstmt.setInt(4, user.getId());

pstmt.executeUpdate();

updateSuccessFlag = true;

} catch (SQLException e) {

System.out.println("更新操作中出现错误！！！");

System.out.println(e);

} finally {

try {

if (pstmt != null) {

pstmt.close();

}

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

e.printStackTrace();

}

return updateSuccessFlag;

}

// 删除操作

public boolean delete(int id) {

String sql = "DELETE FROM user_table WHERE user_id=?";

PreparedStatement pstmt = null;

Connection conn = DBConnection.getConnection();

boolean deleteSuccessFlag = false;

try {

pstmt = conn.prepareStatement(sql);

pstmt.setInt(1, id);

pstmt.executeUpdate();

pstmt.close();

deleteSuccessFlag = true;

} catch (SQLException e) {

System.out.println("删除操作中出现错误！！！");

System.out.println(e);

} finally {

try {

if (pstmt != null) {

pstmt.close();

}

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

e.printStackTrace();

}

return deleteSuccessFlag;

}

// 按ID查询

public User queryById(int id) {

User user = null;

String sql = "SELECT * FROM user_table WHERE user_id=?";

Connection conn = DBConnection.getConnection();

PreparedStatement pstmt = null;

ResultSet rs = null;

try {

pstmt = conn.prepareStatement(sql);

pstmt.setInt(1, id);

rs = pstmt.executeQuery();

//此处为什么不用while,用while可不可以

if (rs.next()) {

user = new User();

user.setId(rs.getInt(1));

user.setName(rs.getString(2));

user.setPass(rs.getString(3));

user.setEmail(rs.getString(4));

}

} catch (SQLException e) {

System.out.println("操作中出现错误！！！");

} finally {

try {

if (rs != null) {

rs.close();

}

if (pstmt != null) {

pstmt.close();

}

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

e.printStackTrace();

}

return user;

}

public int findByNameAndPassword(String username, String password) {

Connection conn = DBConnection.getConnection();

PreparedStatement pstmt = null;

ResultSet rs = null;

int result=0;

try {

String querySql = "select user_pass from user_table where user_name=?";

pstmt = conn.prepareStatement(querySql);

pstmt.setString(1, username);

rs = pstmt.executeQuery();

if (rs.next()) {

if (password.equals(rs.getString("user_pass"))) {

result=1;

} else {

result=2;

}

} catch (SQLException e) {

System.out.println("数据库操作错误");

System.out.println(e.getMessage());

} finally {

try {

if (rs != null) {

rs.close();

}

if (pstmt != null) {

pstmt.close();

}

if (conn != null) {

conn.close();

}

} catch (SQLException e) {

System.out.println("关闭错误");

e.printStackTrace();

}

return result;

}

//Test1.Java

import javax.swing.JOptionPane;

public class Test1 {

public static void main(String args[]) {

UserDAO userDAO = new UserDAO();

String studentName = JOptionPane.showInputDialog(null, "输入用户名");

String studentPass = JOptionPane.showInputDialog(null, "输入密码");

int flag = userDAO.findByNameAndPassword(studentName, studentPass);

if (flag == 0) {

System.out.print("用户名不正确");

} else if (flag == 1) {

System.out.print("正确的用户名和密码");

} else if (flag == 2) {

System.out.print("密码不正确!");

}

第十三节数据库应用实例

一、jsp中的简单应用

mysql --default-character-set=gbk-u root

create database student default character set gbk;

use student;

CREATE TABLE students (

no CHAR(6) primary key,

name VARCHAR(10),

math int,

english int,

physics int) Engine=innodb;

INSERT INTO students VALUES('199901', '张小盐', 69,98,88);

INSERT INTO students VALUES('199902', '王六奖', 68,78,85);

INSERT INTO students VALUES('199903', '历小记', 77,66,56);

INSERT INTO students VALUES('199904', '胡名明', 66,97,83);

INSERT INTO students VALUES('199905', '柳名将', 88,80,77);

INSERT INTO students VALUES('199906', '金六副', 66,78,45);

INSERT INTO students VALUES('199907', '语境竟', 55,77,90);

INSERT INTO students VALUES('199908', '钟名讳', 90,99,78);

<%@ page contentType="text/html;charset=GBK" %>

<%@ page import="java.sql.*" %>

<HTML>

<BODY>

Connection con;

Statement sql;

ResultSet rs;

try{

Class.forName("com.mysql.jdbc.Driver");

//或写成

//DriverManager.registerDriver(new com.mysql.jdbc.Driver());

String url="jdbc:mysql://localhost:3306/student?characterEncoding=gbk";

String user="root";

String password="";

con= DriverManager.getConnection(url,user,password);

sql=con.createStatement();

rs=sql.executeQuery("SELECT * FROM students");

out.print("<Table Border>");

out.print("<TR>");

out.print("<TH width=100>"+"学号");

out.print("<TH width=100>"+"姓名");

out.print("<TH width=50>"+"数学成绩");

out.print("<TH width=50>"+"英语成绩");

out.print("<TH width=50>"+"物理成绩");

out.print("</TR>");

while(rs.next())

{

out.print("<TR>");

out.print("<TD >"+rs.getString(1)+"</TD>");

out.print("<TD >"+rs.getString(2)+"</TD>");

out.print("<TD >"+rs.getInt(3)+"</TD>");

out.print("<TD >"+rs.getInt(4)+"</TD>");

out.print("<TD >"+rs.getInt(5)+"</TD>");

out.print("</TR>") ;

}

out.print("</Table>");

con.close();

}

catch(SQLException e1) {out .print(e1.getMessage());}

</BODY>

</HTML>

二、在GUI中的应用

1、使用的表文件

CREATE TABLE `nobel` (

`id` int(11) NOT NULL,

`author` varchar(20) default NULL,

`subject` varchar(20) default NULL,

`works` varchar(20) default NULL,

`ttime` varchar(20) default NULL,

`country` varchar(20) default NULL,

PRIMARY KEY (`id`)

);

程序：

//DBConnection.java

package jdbcswing2;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

public class DBConnection {

public static Connection getConnection(){

Connection conn=null;

String driver = "com.mysql.jdbc.Driver";

String url = "jdbc:mysql://localhost:3306/instant";

String username = "root";

String password = "";

try {

Class.forName(driver);

conn = DriverManager.getConnection(url,username,password);

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (SQLException e) {

e.printStackTrace();

}

return conn;

}

//Nobel.java

package jdbcswing2;

public class Nobel {

private int id;

private String time;

private String subject;

private String author;

private String works;

private String country;

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getTime() {

return time;

}

public void setTime(String time) {

this.time = time;

}

public String getSubject() {

return subject;

}

public void setSubject(String subject) {

this.subject = subject;

}

public String getAuthor() {

return author;

}

public void setAuthor(String author) {

this.author = author;

}

public String getWorks() {

return works;

}

public void setWorks(String works) {

this.works = works;

}

public String getCountry() {

return country;

}

public void setCountry(String country) {

this.country = country;

}

//NobelOperate.java

package jdbcswing2;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

public class NobelOperate {

public static boolean add(Nobel no){

PreparedStatement pstmt = null;

int x = 0;

Connection conn = DBConnection.getConnection();

String sql = "insert into nobel (id,author,subject,works,ttime,country) values (?,?,?,?,?,?)";

try {

pstmt = conn.prepareStatement(sql);

pstmt.setInt(1, no.getId());

pstmt.setString(2, no.getAuthor());

pstmt.setString(3, no.getSubject());

pstmt.setString(4, no.getWorks());

pstmt.setString(5, no.getTime());

pstmt.setString(6, no.getCountry());

x = pstmt.executeUpdate();

} catch (SQLException e) {

e.printStackTrace();

} finally{

try {

if(pstmt!=null)

pstmt.close();

if(conn!=null)

conn.close();

} catch (SQLException e) {

e.printStackTrace();

}

if(x==1){

return true;

}else {

return false;

}

public static boolean del(int id){

Statement stmt = null;

int x = 0;

Connection conn = DBConnection.getConnection();

String sql = "delete from nobel where id="+id;

try {

stmt = conn.createStatement();

x = stmt.executeUpdate(sql);

} catch (SQLException e) {

e.printStackTrace();

} finally{

try {

if(stmt!=null)

stmt.close();

if(conn!=null)

conn.close();

} catch (SQLException e) {

e.printStackTrace();

}

if(x==1){

return true;

}else {

return false;

}

public static boolean modify(Nobel no) {

PreparedStatement pstmt = null;

int x = 0;

Connection conn = DBConnection.getConnection();

String sql = "update nobel set author=?,subject=?,works=?,ttime=?,country=? where id="+no.getId();

try {

pstmt = conn.prepareStatement(sql);

pstmt.setString(1, no.getAuthor());

pstmt.setString(2, no.getSubject());

pstmt.setString(3, no.getWorks());

pstmt.setString(4, no.getTime());

pstmt.setString(5, no.getCountry());

x = pstmt.executeUpdate();

} catch (SQLException e) {

e.printStackTrace();

} finally{

try {

if(pstmt!=null)

pstmt.close();

if(conn!=null)

conn.close();

} catch (SQLException e) {

e.printStackTrace();

}

if(x==1){

return true;

} else {

return false;

}

public static Nobel query(int id){

PreparedStatement pstmt = null;

Statement stmt = null;

Connection conn = DBConnection.getConnection();

ResultSet rs = null;

Nobel no = new Nobel();

String sql = "select author,subject,works,ttime,country from nobel where id = " +id;

try {

stmt = conn.createStatement();

rs = stmt.executeQuery(sql);

if(rs.next()) {

no.setAuthor(rs.getString("author"));

no.setSubject(rs.getString("subject"));

no.setWorks(rs.getString("works"));

no.setTime(rs.getString("ttime"));

no.setCountry(rs.getString("country"));

}

} catch (SQLException e) {

System.out.println(123);

e.printStackTrace();

} finally{

try {

if(rs!=null)

rs.close();

if(pstmt!=null)

pstmt.close();

if(conn!=null)

conn.close();

} catch (SQLException e) {

e.printStackTrace();

}

return no;

}

//NobelGUI.java

package jdbcswing2;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JMenuBar;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JTextField;

import javax.swing.SwingUtilities;

public class NobelGUI implements ActionListener {

private JFrame jFrame;

private JPanel jContentPane;

private JMenuBar jJMenuBar;

private JLabel lblId = null;

private JTextField tfId = null;

private JLabel lblAuthor = null;

private JTextField tfAuthor = null;

private JLabel lblsubject = null;

private JComboBox cbsubject = null;

private JLabel lblworks = null;

private JTextField tfworks = null;

private JLabel lbltime = null;

private JTextField tftime = null;

private JLabel lblcountry = null;

private JTextField tfcountry = null;

private JButton btnadd = null;

private JButton btndel = null;

private JButton btnmodify = null;

private JButton btnquery = null;

private JTextField getTfId() {

if (tfId == null) {

tfId = new JTextField();

tfId.setBounds(new Rectangle(115, 36, 197, 25));

}

return tfId;

}

private JTextField getTfAuthor() {

if (tfAuthor == null) {

tfAuthor = new JTextField();

tfAuthor.setBounds(new Rectangle(115, 75, 197, 25));

}

return tfAuthor;

}

private JComboBox getCbsubject() {

if (cbsubject == null) {

String[] str = { "和平奖", "物理奖", "文学奖", "化学奖", "生物奖", "经济奖" };

cbsubject = new JComboBox(str);

cbsubject.setBounds(new Rectangle(115, 115, 197, 25));

}

return cbsubject;

}

private JTextField getTfworks() {

if (tfworks == null) {

tfworks = new JTextField();

tfworks.setBounds(new Rectangle(115, 151, 197, 25));

tfworks.setText("");

}

return tfworks;

}

private JTextField getTftime() {

if (tftime == null) {

tftime = new JTextField();

tftime.setBounds(new Rectangle(115, 190, 197, 25));

}

return tftime;

}

private JTextField getTfcountry() {

if (tfcountry == null) {

tfcountry = new JTextField();

tfcountry.setBounds(new Rectangle(115, 227, 197, 25));

}

return tfcountry;

}

private JButton getBtnadd() {

if (btnadd == null) {

btnadd = new JButton();

btnadd.setBounds(new Rectangle(36, 282, 64, 28));

btnadd.addActionListener(this);

btnadd.setText("添加");

}

return btnadd;

}

private JButton getBtndel() {

if (btndel == null) {

btndel = new JButton();

btndel.setBounds(new Rectangle(108, 282, 64, 28));

btndel.addActionListener(this);

btndel.setText("删除");

}

return btndel;

}

private JButton getBtnmodify() {

if (btnmodify == null) {

btnmodify = new JButton();

btnmodify.setBounds(new Rectangle(180, 282, 64, 28));

btnmodify.addActionListener(this);

btnmodify.setText("修改");

}

return btnmodify;

}

private JButton getBtnquery() {

if (btnquery == null) {

btnquery = new JButton();

btnquery.setBounds(new Rectangle(254, 282, 64, 28));

btnquery.addActionListener(this);

btnquery.setText("查找");

}

return btnquery;

}

public static void main(String[] args) {

// TODO 自动生成方法存根

SwingUtilities.invokeLater(new Runnable() {

public void run() {

NobelGUI application = new NobelGUI();

application.getJFrame().setVisible(true);

}

});

}

private JFrame getJFrame() {

if (jFrame == null) {

jFrame = new JFrame();

jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

jFrame.setResizable(false);

jFrame.setLocation(new Point(500, 265));

jFrame.setJMenuBar(getJJMenuBar());

jFrame.setSize(353, 375);

jFrame.setContentPane(getJContentPane());

jFrame.setTitle("诺贝尔信息管理");

}

return jFrame;

}

private JPanel getJContentPane() {

if (jContentPane == null) {

lblcountry = new JLabel();

lblcountry.setBounds(new Rectangle(37, 228, 72, 25));

lblcountry.setText("获奖人国家");

lbltime = new JLabel();

lbltime.setBounds(new Rectangle(37, 193, 61, 25));

lbltime.setText("获奖时间");

lblworks = new JLabel();

lblworks.setBounds(new Rectangle(37, 152, 61, 25));

lblworks.setText("获奖作品");

lblsubject = new JLabel();

lblsubject.setBounds(new Rectangle(37, 114, 61, 25));

lblsubject.setText("获奖科目");

lblAuthor = new JLabel();

lblAuthor.setText("获奖人");

lblAuthor.setBounds(new Rectangle(37, 75, 61, 25));

lblId = new JLabel();

lblId.setBounds(new Rectangle(37, 36, 61, 25));

lblId.setPreferredSize(new Dimension(52, 20));

lblId.setText("证书编号");

jContentPane = new JPanel();

jContentPane.setLayout(null);

jContentPane.setBackground(Color.lightGray);

jContentPane.add(lblId, null);

jContentPane.add(getTfId(), null);

jContentPane.add(lblAuthor, null);

jContentPane.add(getTfAuthor(), null);

jContentPane.add(lblsubject, null);

jContentPane.add(getCbsubject(), null);

jContentPane.add(lblworks, null);

jContentPane.add(getTfworks(), null);

jContentPane.add(lbltime, null);

jContentPane.add(getTftime(), null);

jContentPane.add(lblcountry, null);

jContentPane.add(getTfcountry(), null);

jContentPane.add(getBtnadd(), null);

jContentPane.add(getBtndel(), null);

jContentPane.add(getBtnmodify(), null);

jContentPane.add(getBtnquery(), null);

}

return jContentPane;

}

private JMenuBar getJJMenuBar() {

if (jJMenuBar == null) {

jJMenuBar = new JMenuBar();

}

return jJMenuBar;

}

public void actionPerformed(ActionEvent e) {

if (e.getActionCommand().equals("添加")) {

if (tfId.getText().trim().equals("")

|| tftime.getText().trim().equals("")

|| tfAuthor.getText().trim().equals("")

|| tfworks.getText().trim().equals("")

|| tfcountry.getText().trim().equals("")) {

JOptionPane.showMessageDialog(jFrame, "请添写相应的信息");

} else {

Nobel no = new Nobel();

no.setId(Integer.parseInt(tfId.getText()));

no.setAuthor(tfAuthor.getText());

no.setSubject((String)cbsubject.getSelectedItem());

no.setWorks(tfworks.getText());

no.setCountry(tfcountry.getText());

no.setTime(tftime.getText());

boolean flag = NobelOperate.add(no);

if(flag){

JOptionPane.showMessageDialog(jFrame, "添加成功");

} else {

JOptionPane.showMessageDialog(jFrame, "添加失败");

}

} else if (e.getActionCommand().equals("删除")) {

if(tfId.getText().trim().equals("")){

JOptionPane.showMessageDialog(jFrame, "请选择一条记录");

} else {

int id = Integer.parseInt(tfId.getText());

boolean flag = NobelOperate.del(id);

if(flag) {

JOptionPane.showMessageDialog(jFrame, "删除成功");

tfId.setText("");

tfAuthor.setText("");

tfcountry.setText("");

tftime.setText("");

tfworks.setText("");

} else {

JOptionPane.showMessageDialog(jFrame, "删除失败");

}

} else if (e.getActionCommand().equals("修改")) {

if (tfId.getText().trim().equals("")

|| tftime.getText().trim().equals("")

|| tfAuthor.getText().trim().equals("")

|| tfworks.getText().trim().equals("")

|| tfcountry.getText().trim().equals("")) {

JOptionPane.showMessageDialog(jFrame, "请添写相应的信息");

} else {

Nobel no = new Nobel();

no.setId(Integer.parseInt(tfId.getText()));

no.setAuthor(tfAuthor.getText());

no.setSubject((String)cbsubject.getSelectedItem());

no.setWorks(tfworks.getText());

no.setCountry(tfcountry.getText());

no.setTime(tftime.getText());

boolean flag = NobelOperate.modify(no);

if(flag) {

JOptionPane.showMessageDialog(jFrame, "修改成功");

} else {

JOptionPane.showMessageDialog(jFrame, "修改失败");

}

} else if (e.getActionCommand().equals("查找")) {

if(tfId.getText().trim().equals("")){

JOptionPane.showMessageDialog(jFrame, "请选择一条记录");

} else {

int id = Integer.parseInt(tfId.getText());

Nobel no = NobelOperate.query(id);

// tfId.setText(String.valueOf(no.getId()));

tfAuthor.setText(no.getAuthor());

tftime.setText(no.getTime());

tfworks.setText(no.getWorks());

tfcountry.setText(no.getCountry());

cbsubject.setSelectedItem(no.getSubject());

}

*************

finally {

try {

stmt.close();

pstmt.close();

conn.close();

} catch (Exception e) {

}

应当改为：

finally {

try {

if(stmt!=null) { stmt.close();

}

if(pstmt!=null) {pstmt.close();

}

if(conn != null) {conn.close();

}

} catch (Exception e) {

}

否则，如果conn.createStatement()抛出异常,stmt未赋值

在finally部分调用stmt仍然是异常，导致conn不会close().

附录：用结果更新数据

注意：使用结果集更新而不是使用Statement更新。

常用方法：

updateXxx方法：

如：

updateString(列号，值） updateString(字段名，值）

updateInt(列号，值） updateInt(字段名，值）

updateFloat(列号，值） updateFloat(字段名，值）

drop table teacher;

create table teacher(tid int not null primary key, name char(20), salary float(7,2));

insert into teacher values(1001,'张三',1800.2);

insert into teacher values(1002,'李四',2540);

insert into teacher values(1003,'王五',4587.25);

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

public class TestUpdatableResultSet{

public static void main(String args[]){

Connection conn = null;

Statement stmt = null;

ResultSet rs = null;

try {

//注册驱动程序

Class.forName("com.mysql.jdbc.Driver");

String url = "jdbc:mysql://localhost:3306/st?characterEncoding=gbk";

//建立连接对象

conn = DriverManager.getConnection(url, "dbuser", "123");

//建立语句对象

stmt = conn.createStatement();

stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);

rs = stmt.executeQuery("select tid,name,salary from teacher");

//ResultSet rs = stmt.executeQuery("select teacher.* from teacher");

//更新前结果集中数据

while(rs.next()){

showOneRow(rs);

}

//更新和删除记录

rs.beforeFirst();

while(rs.next()){

String name = rs.getString("name").trim();

if(name.equals("李四")){

double sal = rs.getDouble("salary");

rs.updateDouble("salary", sal + 8888);

rs.updateRow();

}else if(name.equals("张三")){

rs.deleteRow();

}

//插入新记录

rs.moveToInsertRow();

rs.updateInt("tid",1005);

rs.updateString("name","云飞扬");

rs.updateDouble("salary",2840);

rs.insertRow();

rs.close();

//结果集更新后后数据库中数据

System.out.println("--------------------------------------------");

rs = stmt.executeQuery("select * from teacher");

while(rs.next()){

showOneRow(rs);

}

rs.close();

}catch(Exception e){

e.printStackTrace();

}finally{

try{

if(conn != null){

conn.close();

}

}catch(Exception e){

e.printStackTrace();

}

public static void showOneRow(ResultSet rs) throws SQLException{

System.out.print("第" + rs.getRow() + "行: ");

System.out.print(rs.getInt(1));

System.out.print("\t" + rs.getString(2));

System.out.print("\t" + rs.getDouble(3));

System.out.println();

}

public static void showOneRow(ResultSet rs) throws SQLException{

System.out.print("第" + rs.getRow() + "行: ");

System.out.print(rs.getInt(1));

System.out.print("\t" + rs.getString(2));

System.out.print("\t" + rs.getDouble(3));

System.out.println();

}

一、修改密码

1.直接修改：

mysqladmin -u root password new_password

mysqladmin –u root password 123

密码设为123.

mysqladmin –u root password '123'

密码设为'123'.

对密码进行修改,将新密码设为345

mysqladmin –u root -p password 345

输入旧密码

对普通用户密码进行修改,将新密码设为5656

mysqladmin –u dbuser1 -p password '5656'

输入旧密码

2.通过表文件修改密码：

use mysql;

update user set password=PASSWORD('1234') WHERE USER='root';

password用于修改mysql的用户密码，如果是应用与web程序建议使用md5()函数，

insert into users(names,pwd) values('aa',md5('123456'))

二、管理员的密码丢失了怎么办?

建立c:\windows\my.Ini

[client]

#password = your_password

port = 3306

socket = /tmp/mysql.sock

# Here follows entries for some specific programs

# The MySQL server

[mysqld]

port = 3306

socket = /tmp/mysql.sock

skip-locking

key_buffer = 16K

max_allowed_packet = 1M

table_cache = 4

sort_buffer_size = 64K

read_buffer_size = 256K

read_rnd_buffer_size = 256K

net_buffer_length = 2K

thread_stack = 64K

skip-grant-tables

server-id = 1

# Uncomment the following if you want to log updates

#log-bin=mysql-bin

# Uncomment the following if you are NOT using BDB tables

#skip-bdb

# Uncomment the following if you are using InnoDB tables

#innodb_data_home_dir = /usr/local/var/

#innodb_data_file_path = ibdata1:10M:autoextend

#innodb_log_group_home_dir = /usr/local/var/

#innodb_log_arch_dir = /usr/local/var/

# You can set .._buffer_pool_size up to 50 - 80 %

# of RAM but beware of setting memory usage too high

#innodb_buffer_pool_size = 16M

#innodb_additional_mem_pool_size = 2M

# Set .._log_file_size to 25 % of buffer pool size

#innodb_log_file_size = 5M

#innodb_log_buffer_size = 8M

#innodb_flush_log_at_trx_commit = 1

#innodb_lock_wait_timeout = 50

[mysqldump]

quick

max_allowed_packet = 16M

[mysql]

no-auto-rehash

# Remove the next comment character if you are not familiar with SQL

#safe-updates

[isamchk]

key_buffer = 8M

sort_buffer_size = 8M

[myisamchk]

key_buffer = 8M

sort_buffer_size = 8M

[mysqlhotcopy]

interactive-timeout

在my.ini的[mysqld]字段加入
skip-grant-tables

跳过权限检查表，所有用户都拥有所有权限，极度危险

一般用于忘记root密码

然后重启你的mysqld,这样就没有密码了.

然后进入mysql,重新加入密码
grant all on *.* to root@localhost identified by "123";

最后去掉my.ini中的skip-grant-tables

重启mysqld

或mysqld --skip-grant-tables

Linux下是my.cnf文件

怎样批量输入数据

MYSQL脚本执行:

创建数据库和表或往表中插入批量数据,若你一条条手工输入,

那无疑是一种痛苦,既慢又容易出错.

这时SQL脚本便是非常明智的选择.

MySql里脚本执行很简单,只要一条命令就可以

首先编写SQL到文本文档或SQL文档,然后保存,假设保存在C盘

然后在SQL命令行里输入source c:\***.TXT;

批量测试：

create table db_test(name varchar(10),birthday date);

alter table db_test modify birthday varchar(40);

数据库：

create database homework
use homework

drop table bbc
create table bbc(
Name Varchar(50) not null Primary Key,
Region Varchar(60),
Area Decimal(10),
Population Decimal(11),
Gdp Decimal(14),
)
--Name国家名称，Region国家所在地区，Area国家面积，Population国家人口，Gdp国民生产总值

insert into bbc(Name,Region,Area,Population,Gdp) values ('美国','北美洲',11111,1000,100)
insert into bbc(Name,Region,Area,Population,Gdp) values ('加拿大','北美洲',501,900,1500)
insert into bbc(Name,Region,Area,Population,Gdp) values ('刚果','非洲',3,2000,2010)
insert into bbc(Name,Region,Area,Population,Gdp) values ('俄比亚','非洲',11111,200000,200)
insert into bbc(Name,Region,Area,Population,Gdp) values ('日本','亚洲',5,400,400)
insert into bbc(Name,Region,Area,Population,Gdp) values ('朝鲜','亚洲',6,500000,5500)
insert into bbc(Name,Region,Area,Population,Gdp) values ('null','null',null,null,null)

select * from bbc

select count(distinct Area) from bbc

--显示指定列的不包括null值的行数，*号表示所有列，distinct表示不重复，all表示所有可以重复
select count(distinct Area) as 面积, count(Region)as 地区 from bbc

select avg(gdp) from bbc where Region = '非洲'--国民生产平均值
select max(area), min(gdp) from bbc where region = '亚洲'--面积最大和国民生产最小值

--显示世界人口总和
select sum(Population) from bbc

--列出所有地区，每个地区只能显示一次
select distinct Region from bbc

--显示Gdp超过所有非洲国家总和的国家
select name from bbc
where gdp>(select sum(gdp) from bbc where region='非洲')

--显示每个地区以及该地区国家总数
select distinct Region,count(name) from bbc group by region

--显示欧洲的人口总数和总Gdp
select sum(Population),sum(Gdp) from bbc where Region = '欧洲'

--列出人口总数不少于55555的地区
select Region from bbc group by Region having sum(Population)>55555

--显示每个地区的总人口和总面积。以总人口来排序
select sum(Population)as 人口,sum(Area) as 面积 from bbc group by Population

--显示每个地区以及该地区国家总人口数不少于1000的国家总数
select Region,count(*) from bbc where Population >= 1000 group by Region

--显示每个地区的总人口数和面积，以总人口来排序，仅显示那些面积超过500的地区
select Region,sum(Population)as 人口,sum(Area)面积 from bbc group by Region having sum(Area)>500

drop table nobel
create table nobel(
yr int,
subject Varchar(15),
winner Varchar(50),
)
insert into nobel (yr,Subject,winner) values (1966,'物理奖','牛顿')
insert into nobel (yr,Subject,winner) values (1996,'计算机','比尔盖茨')
insert into nobel (yr,Subject,winner) values (1989,'生物奖','爱因斯坦')
insert into nobel (yr,Subject,winner) values (1976,'和平奖','爱因斯坦')
insert into nobel (yr,Subject,winner) values (1977,'文学奖','鲁迅')
insert into nobel (yr,Subject,winner) values (1966,'物理奖','牛顿')
insert into nobel (yr,Subject,winner) values (1996,'计算机','比尔盖茨')
insert into nobel (yr,Subject,winner) values (1989,'生物奖','爱因斯坦')
insert into nobel (yr,Subject,winner) values (1976,'和平奖','马克思')
insert into nobel (yr,Subject,winner) values (1976,'和平奖','恩格斯')
insert into nobel (yr,Subject,winner) values (1966,'物理奖','牛顿')

select * from nobel

--给出诺贝尔获奖总人数
select count(winner) from nobel

--给出诺贝尔物理奖的获奖总次数
select count(subject) from nobel where subject = '物理奖'

--显示得奖超过一次的获奖者
select winner from nobel group by winner having count(subject)>1

--显示每个奖项获奖总次数
select subject,count(*)as 次数 from nobel group by subject

--显示每个奖项有多少年获奖
select subject,count(*)as 年 from nobel group by subject

--显示每个奖项在2000年获奖的人数
select yr,winner from nobel group by yr,winner having yr=2000

--显示每个奖项不同获奖者的人数
select distinct subject,count(distinct winner) from nobel group by subject

--显示当年有三个物理奖的年份
select yr from nobel group by subject,yr having subject='物理奖' and count(subject)=3

--显示2000年及以后，有三个人获得同一奖项的年份以及奖项
select yr,subject from nobel group by yr,subject having count(winner)=3 and yr<2000

create table nobel(

id int primary key,

author varchar(20),

subject varchar(20),

works varchar(20),

ttime varchar(20),

country varchar(20)

);

连接查询：

CREATE TABLE `t_supplier` (

`id` int(11) NOT NULL,

`name` varchar(50) NOT NULL,

PRIMARY KEY (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `t_goods` (

`Id` int(11) NOT NULL AUTO_INCREMENT,

`Supplier_Id` int(11) NOT NULL,

`Name` varchar(50) DEFAULT NULL,

PRIMARY KEY (`Id`),

KEY `Supplier_Id` (`Supplier_Id`),

CONSTRAINT `t_goods_ibfk_1` FOREIGN KEY (`Supplier_Id`) REFERENCES `t_supplier` (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

insert into t_Supplier values (1,'天津供应商'),(2,'北京供应商');

insert into t_Goods values(1,1,'天津产品1'),(2,1,'天津产品2'),(3,2,'北京产品1'),(4,2,'北京产品2');

-- 查询语句，注意group 的用法

select * from t_supplier s

left join t_goods g on g.supplier_id=s.id

group by s.id

-- 查询结果

所有的供应商，和其一个产品

**********

Mysql语句

create database shanghai  建一个名叫“shanghai”的数据库
mysql> create table ygb(id varchar(6)
-> ,name varchar(10)
-> ,age int
-> ,sal int
-> ,bir date
-> ,sex varchar(5)
-> );
Query OK, 0 rows affected (0.00 sec)            建一个名叫“员工表”的数据表(编号、姓名、年龄、工资、出生日期、
性别（male表示男fmale表示女）).
mysql> insert into ygb values
-> ("10","lili","20","1000","1988-01-02","fmale"),
-> ("11","lucy","20","2000","1988-11-12","fmale"),
-> ("12","tom","22","3000","1986-09-02","male"),
-> ("13","jack","25","4000","1986-03-15","male");     这里注意最后用分号
Query OK, 4 rows affected (0.00 sec)
Records: 4  Duplicates: 0  Warnings: 0
mysql> select *from ygb;
+------+------+------+------+------------+-------+
| id   | name | age  | sal  | bir        | sex   |
+------+------+------+------+------------+-------+
| 10   | lili |   20 | 1000 | 1988-01-02 | fmale |
| 11   | lucy |   20 | 2000 | 1988-11-12 | fmale |
| 12   | tom  |   22 | 3000 | 1986-09-02 | male  |
| 13   | jack |   25 | 4000 | 1986-03-15 | male  |
+------+------+------+------+------------+-------+
4 rows in set (0.00 sec)
以后都以这个为例子

1.1.1
计算:
mysql> select 4+4,(5+5)/5;
+-----+---------+
| 4+4 | (5+5)/5 |
+-----+---------+
|   8 |    2.00 |
+-----+---------+
1 row in set (0.00 sec)
1.1.2显示当前时间:
mysql> select now();
+---------------------+
| now()               |
+---------------------+
| 2008-07-17 10:03:37 |
+---------------------+
1 row in set (0.00 sec)
1.1.3 显示用户
mysql>select user();
+----------------+
| user()         |
+----------------+
| [email=root@localhost]root@localhost[/email] |
+----------------+
1 row in set (0.00 sec)
1.1.4拥有某个列的最大值的记录（行）
mysql> select id,name,bir from ygb order by bir desc limit 1;
+------+------+------------+
| id   | name | bir        |
+------+------+------------+
| 11   | lucy | 1988-11-12 |
+------+------+------------+
1 row in set (0.00 sec)
1.1.5查询id,name,nl(年龄)最大的男与女
mysql> select id,name,max(age) as nl from ygb group by sex;
+------+------+------+
| id   | name | nl   |
+------+------+------+
| 10   | lili |   20 |
| 12   | tom  |   25 |
+------+------+------+
2 rows in set (0.00 sec)
1.1.6 or用法(或者的意思)
mysql> select *from ygb where id=10 or name="lucy";
+------+------+------+------+------------+-------+
| id   | name | age  | sal  | bir        | sex   |
+------+------+------+------+------------+-------+
| 10   | lili |   20 | 1000 | 1988-01-02 | fmale |
| 11   | lucy |   20 | 2000 | 1988-11-12 | fmale |
+------+------+------+------+------------+-------+
2 rows in set (0.00 sec)
1.1.7 and用法(和)
mysql> select *from ygb where bir>"1986-01-01" and sal<2000;
+------+------+------+------+------------+-------+
| id   | name | age  | sal  | bir        | sex   |
+------+------+------+------+------------+-------+
| 10   | lili |   20 | 1000 | 1988-01-02 | fmale |
+------+------+------+------+------------+-------+
1 row in set (0.00 sec)
1.1.8 or与and混用
mysql> select *from ygb where (bir>"1986-01-01" and sal<2000) or
-> (sal>1000 and age>22);
+------+------+------+------+------------+-------+
| id   | name | age  | sal  | bir        | sex   |
+------+------+------+------+------------+-------+
| 10   | lili |   20 | 1000 | 1988-01-02 | fmale |
| 13   | jack |   25 | 4000 | 1986-03-15 | male  |
+------+------+------+------+------------+-------+
2 rows in set (0.00 sec)
1.1.9 查询出名字叫lili与lucy这两名员工的名字、出生日期、年龄
mysql> select name,age,bir from ygb where name="lili" or name="lucy";
+------+------+------------+
| name | age  | bir        |
+------+------+------------+
| lili |   20 | 1988-01-02 |
| lucy |   20 | 1988-11-12 |
+------+------+------------+
2 rows in set (0.00 sec)
1.2.0 按多列排序 sal升序bir降序
mysql> select id,name,sal,bir from ygb order by sal ,bir desc;
+------+------+------+------------+
| id   | name | sal  | bir        |
+------+------+------+------------+
| 10   | lili | 1000 | 1988-01-02 |
| 11   | lucy | 2000 | 1988-11-12 |
| 12   | tom  | 3000 | 1986-09-02 |
| 13   | jack | 4000 | 1986-03-15 |
+------+------+------+------------+
4 rows in set (0.00 sec)
1.2.1 求年龄
mysql> select name,(to_days(now())-to_days(bir))/365 from ygb;
+------+-----------------------------------+
| name | (to_days(now())-to_days(bir))/365 |
+------+-----------------------------------+
| lili |                             20.55 |
| lucy |                             19.69 |
| tom  |                             21.89 |
| jack |                             22.36 |
+------+-----------------------------------+
4 rows in set (0.01 sec)
1.2.2 在上面例中（1.2.1）显示的结果第二列中名字太长不好记我们可以：
mysql> select name,(to_days(now())-to_days(bir))/365 as nl from ygb;
+------+-------+
| name | nl    |
+------+-------+
| lili | 20.55 |
| lucy | 19.69 |
| tom  | 21.89 |
| jack | 22.36 |
+------+-------+
4 rows in set (0.01 sec)
1.2.3 上例加上排序(注我们是按nl排序的不是age 我们要用as定义的那个)
mysql> select name,(to_days(now())-to_days(bir))/365 as nl from ygb order by nl;
+------+-------+
| name | nl    |
+------+-------+
| lucy | 19.69 |
| lili | 20.55 |
| tom  | 21.89 |
| jack | 22.36 |
+------+-------+
4 rows in set (0.00 sec)
1.2.4 查找三月份出生的员工(月份用mounth 年用year 天用 dayofmonth)
mysql> select name,bir from ygb where month(bir)=3;
+------+------------+
| name | bir        |
+------+------------+
| jack | 1986-03-15 |
+------+------------+
1 row in set (0.00 sec)
用英文找月份
mysql> select name,bir from ygb where monthname(bir)="March";
+------+------------+
| name | bir        |
+------+------------+
| jack | 1986-03-15 |
+------+------------+
1 row in set (0.00 sec)
1.2.5 当前月的下一个月的信息(如果是上个月就把1改为-1)
mysql> select *from ygb where month(bir)=month(date_add(now(),interval 1 month));
Empty set (0.00 sec) 因为我的这个表中没有8月份的我当前是月份它主要是针对12月份后没有13月
1.2.6  加1以得出当前月份的下一个月(在使用取模函数(MOD)后，如果它当前是12，则“绕回”月份到值0
注意，MONTH返回在1和12之间的一个数字，且MOD(something,12)返回在0和11之间的一个数字，因此必须在MOD()以后加1，否则我们将从11月( 11 )跳到1月(1)。
mysql> select * from ygb where month(bir)=mod(month(now()), 12) +1;
Empty set (0.00 sec)
1.2.7 匹配

mysql> select * from ygb where name like "l%";
+------+-------+------+------+------------+-------+
| id   | name  | age  | sal  | bir        | sex   |
+------+-------+------+------+------------+-------+
| 10   | lili  |   20 | 1000 | 1988-01-02 | fmale |
| 11   | lucy  |   20 | 2000 | 1988-11-12 | fmale |
| 18   | lilei |    0 | 2600 | 0000-00-00 | male  |
+------+-------+------+------+------------+-------+
3 rows in set (0.00 sec) 注:%在前面说明以谁为结尾的在前后面说明以谁为开头的在中间代表包含
1.2.8  用"_"来代表查找几个字符的名字打几个"_"代表几个
mysql> select * from ygb where name like "____";
+------+------+------+------+------------+-------+
| id   | name | age  | sal  | bir        | sex   |
+------+------+------+------+------------+-------+
| 10   | lili |   20 | 1000 | 1988-01-02 | fmale |
| 11   | lucy |   20 | 2000 | 1988-11-12 | fmale |
| 13   | jack |   25 | 4000 | 1986-03-15 | male  |
+------+------+------+------+------------+-------+
3 rows in set (0.00 sec)
1.2.9  查找以l开头的和不以l开头的

mysql> select * from ygb where name regexp "^l";
+------+-------+------+------+------------+-------+
| id   | name  | age  | sal  | bir        | sex   |
+------+-------+------+------+------------+-------+
| 10   | lili  |   20 | 1000 | 1988-01-02 | fmale |
| 11   | lucy  |   20 | 2000 | 1988-11-12 | fmale |
| 18   | lilei |    0 | 2600 | 0000-00-00 | male  |
+------+-------+------+------+------------+-------+
3 rows in set (0.01 sec)
mysql> select * from ygb where name not regexp "^l";
+------+------+------+------+------------+------+
| id   | name | age  | sal  | bir        | sex  |
+------+------+------+------+------------+------+
| 12   | tom  |   22 | 3000 | 1986-09-02 | male |
| 13   | jack |   25 | 4000 | 1986-03-15 | male |
+------+------+------+------+------------+------+
2 rows in set (0.00 sec)
1.3.0 查找名字中包含l,L 的
mysql> select * from ygb where name regexp "[l,L]";
+------+-------+------+------+------------+-------+
| id   | name  | age  | sal  | bir        | sex   |
+------+-------+------+------+------------+-------+
| 10   | lili  |   20 | 1000 | 1988-01-02 | fmale |
| 11   | lucy  |   20 | 2000 | 1988-11-12 | fmale |
| 18   | lilei |    0 | 2600 | 0000-00-00 | male  |
+------+-------+------+------+------------+-------+
3 rows in set (0.00 sec)

1.3.1  查找以i结尾的
mysql> select * from ygb where name regexp "i$";
+------+-------+------+------+------------+-------+
| id   | name  | age  | sal  | bir        | sex   |
+------+-------+------+------+------------+-------+
| 10   | lili  |   20 | 1000 | 1988-01-02 | fmale |
| 18   | lilei |    0 | 2600 | 0000-00-00 | male  |
+------+-------+------+------+------------+-------+
2 rows in set (0.00 sec)
1.3.2  找出正好包含五个字符的名字无论以什么开头或以什么结尾的

mysql> select *from ygb where name regexp "^.....$";
+------+-------+------+------+------------+------+
| id   | name  | age  | sal  | bir        | sex  |
+------+-------+------+------+------------+------+
| 18   | lilei |    0 | 2600 | 0000-00-00 | male |
+------+-------+------+------+------------+------+
1 row in set (0.01 sec)
方法二:
mysql> select *from ygb where name regexp "^.{5}$";
+------+-------+------+------+------------+------+
| id   | name  | age  | sal  | bir        | sex  |
+------+-------+------+------+------------+------+
| 18   | lilei |    0 | 2600 | 0000-00-00 | male |
+------+-------+------+------+------------+------+
1 row in set (0.00 sec)
1.3.3 查看表中男与女各多少个
mysql> select name,sex ,count(*) from ygb group by sex;
+------+-------+----------+
| name | sex   | count(*) |
+------+-------+----------+
| lili | fmale |        2 |
| tom  | male  |        3 |
+------+-------+----------+
2 rows in set (0.00 sec)
1.3.4 导入一个文件中的内容例如/下有个a.txt 其内容是 19 qq 20 25000 1998-12-12 male它们中间用table键隔开
mysql> use tom
Database changed
mysql> load data local infile "/a.txt" into table ygb;
Query OK, 1 row affected (0.00 sec)
Records: 1  Deleted: 0  Skipped: 0  Warnings: 2
mysql> select *from ygb;
+------+-------+------+-------+------------+-------+
| id   | name  | age  | sal   | bir        | sex   |
+------+-------+------+-------+------------+-------+
| 10   | lili  |   20 |  1000 | 1988-01-02 | fmale |
| 11   | lucy  |   20 |  2000 | 1988-11-12 | fmale |
| 12   | tom   |   22 |  3000 | 1986-09-02 | male  |
| 13   | jack  |   25 |  4000 | 1986-03-15 | male  |
| 18   | lilei |    0 |  2600 | 0000-00-00 | male  |
| 19   | qq    |   20 | 25000 | 1998-12-12 | male1 |
+------+-------+------+-------+------------+-------+
6 rows in set (0.00 sec)
1.3.5  例如我们有一个备份是数据库 tom 的在/a.sql
我们给它导入到另一个数据库test中
mysql> use test
Database changed
mysql> source /a.sql
Query OK, 0 rows affected (0.00 sec)
Query OK, 0 rows affected (0.00 sec)
Query OK, 0 rows affected (0.00 sec)
Query OK, 0 rows affected (0.00 sec)
Query OK, 0 rows affected (0.01 sec)
mysql> show tables;
+----------------+
| Tables_in_test |
+----------------+
| ll             |
| mm             |
| ygb            |
+----------------+,
3 rows in set (0.00 sec) 这样它中的表和tom中的一样而且如果在之前test中的表也不会被覆盖
1.3.6 复制表到新表

create table aaa select*from  ygb;
1.3.7 只复制表结构
create table bbb select*from  ygb where 1=2; 这里让where不成立即可也就是“=”号两边不一样就行
然后用describe bbb;来查看
1.3.8脚本
就是建一个脚本文件在里面写上建立表或库的语名我们举一个例子。

vi t.sql
create database rrr;
use rrr;
create table rrr
(id varchar(6)
,name varchar (10)
,age int
); 这里可加#!/bin/bash也可不加保存给执行权限。
然后在/usr/local/mysql/bin目录下执行mysql -uroot -p123456 < /t.sql
这样就在mysql中建立了一个新的数据库和表了。
1.3.9  is null 与is not null用法:

select * from 表名 where sal is null
select * from 表名 where sal is not null
这只是举一例子  sal 是字段名
1.4.0    把查询到的结果导出来（只能导到/usr/local/mysql/bin/目录下）
select *from 表名 into outfile "./a.txt"或写成
select *from 表名 into outfile "/usr/local/mysql/bin/a.txt"
1.5.0   insert ...... select用法就是将select查询到的结果加到insert表中是两个不同的表

insert into gcb(name,age) select name,age from yxb where name="ming" ;
前面字段与后面要对应也就是 name,age 如果一个字段也得用小括号括起来（gcb表名  yxb表名       name,age字段名）   这里还有个命令replace 和insert完全一样把insert替换成replace也可以
停止与mysql
mysql_dir/bin/mysqladmin -u root -p shutdown
查看字符编码:
SHOW VARIABLES LIKE 'character_set_%';
SHOW VARIABLES LIKE 'collation_%';

多个root用户：

mysql.user里有两条记录,如下

User: root
Host: localhost
Password: XXXXXXX

User:root
Host:127.0.0.1
Password:

结果：

> mysql -uroot -hlocalhost -p
> mysql -uroot -h127.0.0.1 -p
都可以登陆，但是即使host指明为127.0.0.1也需要输入第一条记录中的密码才能登陆。
即:
> mysql -uroot -h127.0.0.1 不能登录

原因：

因为mysql在验证用户时先对user表进行排序：
1. specified的host排在pattern的host前面。
2. 相同host的条目，specified的user排在anonymous的前面。
3. 其他按默认存储顺序。
排序结束后，从第一条开始匹配，如果匹配符合则忽略剩下所有。

Mysql中的索引：

一、创建索引

在执行CREATE TABLE语句时可以创建索引，也可以单独用CREATE INDEX或ALTER TABLE来为表增加索引。

1．ALTER TABLE

ALTER TABLE用来创建普通索引、UNIQUE索引或PRIMARY KEY索引。

ALTER TABLE table_name ADD INDEX index_name (column_list)

ALTER TABLE table_name ADD UNIQUE (column_list)

ALTER TABLE table_name ADD PRIMARY KEY (column_list)

其中table_name是要增加索引的表名，column_list指出对哪些列进行索引，多列时各列之间用逗号分隔。索引名index_name可选，缺省时，MySQL将根据第一个索引列赋一个名称。另外，ALTER TABLE允许在单个语句中更改多个表，因此可以在同时创建多个索引。

2．CREATE INDEX

CREATE INDEX可对表增加普通索引或UNIQUE索引。

CREATE INDEX index_name ON table_name (column_list)

CREATE UNIQUE INDEX index_name ON table_name (column_list)

table_name、index_name和column_list具有与ALTER TABLE语句中相同的含义，索引名不可选。另外，不能用CREATE INDEX语句创建PRIMARY KEY索引。

3．索引类型

在创建索引时，可以规定索引能否包含重复值。如果不包含，则索引应该创建为PRIMARY KEY或UNIQUE索引。对于单列惟一性索引，这保证单列不包含重复的值。对于多列惟一性索引，保证多个值的组合不重复。

PRIMARY KEY索引和UNIQUE索引非常类似。事实上，PRIMARY KEY索引仅是一个具有名称PRIMARY的UNIQUE索引。这表示一个表只能包含一个PRIMARY KEY，因为一个表中不可能具有两个同名的索引。

下面的SQL语句对students表在sid上添加PRIMARY KEY索引。

ALTER TABLE students ADD PRIMARY KEY (sid)

二、删除索引

可利用ALTER TABLE或DROP INDEX语句来删除索引。类似于CREATE INDEX语句，DROP INDEX可以在ALTER TABLE内部作为一条语句处理，语法如下。

DROP INDEX index_name ON talbe_name

ALTER TABLE table_name DROP INDEX index_name

ALTER TABLE table_name DROP PRIMARY KEY

其中，前两条语句是等价的，删除掉table_name中的索引index_name。

第3条语句只在删除PRIMARY KEY索引时使用，因为一个表只可能有一个PRIMARY KEY索引，因此不需要指定索引名。如果没有创建PRIMARY KEY索引，但表具有一个或多个UNIQUE索引，则MySQL将删除第一个UNIQUE索引。

如果从表中删除了某列，则索引会受到影响。对于多列组合的索引，如果删除其中的某列，则该列也会从索引中删除。如果删除组成索引的所有列，则整个索引将被删除。

Mysql中的grant命令详解

运行于 MySQL 5.0 及以上版本。

MySQL 赋予用户权限命令的简单格式可概括为：

grant 权限 on 数据库对象 to 用户

一、grant 普通数据用户，查询、插入、更新、删除数据库中所有表数据的权利。

grant select on testdb.* to common_user@'%'
grant insert on testdb.* to common_user@'%'
grant update on testdb.* to common_user@'%'
grant delete on testdb.* to common_user@'%'

或者，用一条 MySQL 命令来替代：

grant select, insert, update, delete on testdb.* to common_user@'%'

二、 grant 数据库开发人员，创建表、索引、视图、存储过程、函数。。。等权限。

grant 创建、修改、删除 MySQL 数据表结构权限。

grant create on testdb.* to developer@'192.168.0.%';
grant alter on testdb.* to developer@'192.168.0.%';
grant drop   on testdb.* to developer@'192.168.0.%';

grant 操作 MySQL 外键权限。

grant references on testdb.* to developer@'192.168.0.%';

grant 操作 MySQL 临时表权限。

grant create temporary tables on testdb.* to developer@'192.168.0.%';

grant 操作 MySQL 索引权限。

grant index on testdb.* to developer@'192.168.0.%';

grant 操作 MySQL 视图、查看视图源代码权限。

grant create view on testdb.* to developer@'192.168.0.%';
grant show   view on testdb.* to developer@'192.168.0.%';

grant 操作 MySQL 存储过程、函数权限。

grant create routine on testdb.* to developer@'192.168.0.%'; -- now, can show procedure status
grant alter routine on testdb.* to developer@'192.168.0.%'; -- now, you can drop a procedure
grant execute        on testdb.* to developer@'192.168.0.%';

三、grant 普通 DBA 管理某个 MySQL 数据库的权限。

grant all privileges on testdb to dba@'localhost'

其中，关键字 “privileges” 可以省略。
四、grant 高级 DBA 管理 MySQL 中所有数据库的权限。

grant all on *.* to dba@'localhost'

五、MySQL grant 权限，分别可以作用在多个层次上。

1. grant 作用在整个 MySQL 服务器上：

grant select on *.* to dba@localhost; -- dba 可以查询 MySQL 中所有数据库中的表。
grant all    on *.* to dba@localhost; -- dba 可以管理 MySQL 中的所有数据库

2. grant 作用在单个数据库上：

grant select on testdb.* to dba@localhost; -- dba 可以查询 testdb 中的表。

3. grant 作用在单个数据表上：

grant select, insert, update, delete on testdb.orders to dba@localhost;

4. grant 作用在表中的列上：

grant select(id, se, rank) on testdb.apache_log to dba@localhost;

5. grant 作用在存储过程、函数上：

grant execute on procedure testdb.pr_add to 'dba'@'localhost'
grant execute on function testdb.fn_add to 'dba'@'localhost'

六、查看 MySQL 用户权限

查看当前用户（自己）权限：

show grants;

查看其他 MySQL 用户权限：

show grants for dba@localhost;

七、撤销已经赋予给 MySQL 用户权限的权限。

revoke 跟 grant 的语法差不多，只需要把关键字 “to” 换成 “from” 即可：

grant all on *.* to   dba@localhost;
revoke all on *.* from dba@localhost;

八、MySQL grant、revoke 用户权限注意事项

1. grant, revoke 用户权限后，该用户只有重新连接 MySQL 数据库，权限才能生效。

2. 如果想让授权的用户，也可以将这些权限 grant 给其他用户，需要选项 “grant option“

grant select on testdb.* to dba@localhost ;

这个特性一般用不到。实际中，数据库权限最好由 DBA 来统一管理。

(1)mysql>GRANT ALL PRIVILEGES ON *.* TO root@localhost IDENTIFIED BY ’something’ ;

mysql>GRANT ALL PRIVILEGES ON *.* TO root@"%" IDENTIFIED BY ’something’ ;

第一句增加了一个root用户只能通过本地机(localhost)访问，密码“something”。

第二句则是使用通配符，授权root用户从所有其他主机发起的访问。

外键及其他

create table category(

category_id char(2) primary key,

category_name varchar(20))engine=innodb;

INSERT INTO st.category (category_id, category_name) VALUES ('01', 'java');

INSERT INTO st.category (category_id, category_name) VALUES ('02', 'linux');

CREATE TABLE question (questionid INT NOT NULL AUTO_INCREMENT, subject VARCHAR(300),

choice_a VARCHAR(100), choice_b VARCHAR(100), choice_c VARCHAR(100),

choice_d VARCHAR(100), answer VARCHAR(4), typeid INT, category_id CHAR(2),

PRIMARY KEY (questionid),

INDEX (category_id), FOREIGN KEY (category_id)

REFERENCES category(category_id) ON DELETE CASCADE)engine=innodb;

INSERT INTO st.question (subject, choice_a, choice_b, choice_c, choice_d, answer, typeid, category_id) VALUES ('ActionEvent类在( )包中', 'java.util', 'java.io ', 'java.awt', 'java.awt.event', 'd', NULL, '01');

INSERT INTO st.question (subject, choice_a, choice_b, choice_c, choice_d, answer, typeid, category_id) VALUES ('下述选项中不属于JDBC基本功能的是：', '与数据库建立连接', '提交SQL语句', '数据库维护管理', '处理查询结果', 'c', NULL, '01');

INSERT INTO st.question (subject, choice_a, choice_b, choice_c, choice_d, answer, typeid, category_id) VALUES ('mysql数据库的JDBC驱动程序类名及完整包路径为：', 'jdbc.driver.mysql.Driver', 'jdbc.com.driver.Driver', 'mysql.com.jdbc.Driver', 'com.mysql.jdbc.Driver', 'd', NULL, '01');

INSERT INTO st.question (subject, choice_a, choice_b, choice_c, choice_d, answer, typeid, category_id) VALUES ('执行完以下代码int[ ] x = new int[25]；后，以下哪项说明是正确的：', 'x[24]为0', 'x[24]未定义 ', 'x[25]为0 ', 'x[0]为空', 'a', NULL, '01');

INSERT INTO st.question (subject, choice_a, choice_b, choice_c, choice_d, answer, typeid, category_id) VALUES ('FileReader类在( )包中', 'java.util', 'java.io ', 'java.awt ', 'java.lang', 'b', NULL, '01');

INSERT INTO st.question (subject, choice_a, choice_b, choice_c, choice_d, answer, typeid, category_id) VALUES ('ArrayList类在( )包中', 'java.util', 'java.io ', 'java.awt ', 'java.lang', 'a', NULL, '01');

INSERT INTO st.question (subject, choice_a, choice_b, choice_c, choice_d, answer, typeid, category_id) VALUES ('( )命令可以从文本文件的每一行中截取指定内容的数据。', 'cp', 'dd', 'fmt', 'cut', 'd', NULL, '02');

INSERT INTO st.question (subject, choice_a, choice_b, choice_c, choice_d, answer, typeid, category_id) VALUES ('改变文件所有者的命令为', 'chmod', 'touch', 'chown', 'cat', 'c', NULL, '02');

INSERT INTO st.question (subject, choice_a, choice_b, choice_c, choice_d, answer, typeid, category_id) VALUES ('在unix下以小圆点开头的文件名是', '可执行文件', '子目录', '隐藏文件', '当前目录', 'c', NULL, '02');

INSERT INTO st.question (subject, choice_a, choice_b, choice_c, choice_d, answer, typeid, category_id) VALUES ('下面（）命令可以删除一个用户并同时删除用户的主目录。', 'rmuser -r', 'deluser -r', 'userdel -r', 'usermgr -r', 'c', NULL, '02');

create table answer

(

an_id int auto_increment,

answer varchar(255),

score int,

category_id char(2),

question_id int,

user_id int,

primary key(an_id))engine=innodb;

**************

create database books default character set gbk;

Use books;

Drop table category;

Drop table book;

create table category(

categoryId int primary key,

categoryname varchar(20))TYPE=InnoDB;

create table book(

id int not null auto_increment primary key,

categoryid int,

name varchar(20),

author varchar(20),

publisher varchar(20),

price float,

INDEX (categoryid), FOREIGN KEY (categoryid)

REFERENCES category(categoryid) ON DELETE CASCADE on update cascade

)TYPE=InnoDB;

INSERT INTO books.category VALUES (1,'计算机');

INSERT INTO books.category VALUES (2,'经管');

INSERT INTO books.category VALUES (3,'数学');

INSERT INTO books.book (categoryid, name, author, publisher, price) VALUES (1, 'Java编程思想', '侯捷', '机械', 99.0);

INSERT INTO books.book (categoryid, name, author, publisher, price) VALUES (1, 'Java Applet编程实例', '何梅', '清华大学出版社', 36.0);

INSERT INTO books.book (categoryid, name, author, publisher, price) VALUES (1, 'JSP基础教程', '耿祥义', '清华大学出版社', 22.0);

INSERT INTO books.book (categoryid, name, author, publisher, price) VALUES (1, 'JSP高级开发与应用', 'David', '科学出版社', 42.0);

INSERT INTO books.book (categoryid, name, author, publisher, price) VALUES (2, '货币金融学', '郑艳文', '中国人民大学出版社', 79.0);

INSERT INTO books.book (categoryid, name, author, publisher, price) VALUES (2, '金融学', '伊志宏', '中国人民大学出版社', 50.0);

INSERT INTO books.book (categoryid, name, author, publisher, price) VALUES (3, '组合数学', '冯舜玺', '机械工业出版社', 40.5);

INSERT INTO books.book (categoryid, name, author, publisher, price) VALUES (3, '高等数学（第五版）（上册）', '同济大学应用数学系', '高等教育出版社', 26.1);

第二种做法

create table category(

categoryId int primary key,

categoryname varchar(20))TYPE=InnoDB;

create table book(

id int not null auto_increment primary key,

categoryid int,

name varchar(20),

author varchar(20),

publisher varchar(20),

price float

)TYPE=InnoDB;

alter table book add index FK4B9075708EBC77F7 (categoryid), add constraint FK4B9075708EBC77F7 foreign key (categoryid) references category(categoryid) on delete cascade;

delete from category where categoryid=2;

Update category set categoryid=4 where categoryid=2

INSERT INTO `title` VALUES ( NULL , 0, 'title1', '' , 0, 0, '');
INSERT INTO `article` VALUES (last_insert_id(),'content1');

INSERT INTO `title` VALUES ( NULL , 0, 'title2', '' , 0, 0, '');
INSERT INTO `article` VALUES (last_insert_id(),'content2');

INSERT INTO `title` VALUES ( NULL , 0, 'title3', '' , 0, 0, '');
INSERT INTO `article` VALUES (last_insert_id(),'content3');

重新排列主键的值

alter table question drop questionid,add questioid int auto_increment

Primary key;

随机查询

select * from st.question where typeid="01" order by rand() limit 3

将查询结果插入到另外一个表中

insert into st.dust(no,name) (select typeid,category_id from st.question where typeid="01" order by rand() limit 3)

grant后的 with grant option:

WITH GRANT OPTION子句给予用户能力，可以在指定的权限层级，向其它用户给定其拥有的任何权限。您不能向其它用户授予您自己没有的权限；GRANT OPTION权限只允许您赋予您自己拥有的权限。

The MAX_QUERIES_PER_HOUR count, MAX_UPDATES_PER_HOUR count, and MAX_CONNECTIONS_PER_HOUR count options limit the number of queries, updates, and logins a user can perform during any given one-hour period. If count is 0 (the default), this means that there is no limitation for that user. MAX_QUERIES_PER_HOUR count, MAX_UPDATES_PER_HOUR count和MAX_CONNECTIONS_PER_HOUR count选项限制了在任何给定的一小时期间，用户可以执行的查询、更新和登录的数目。如果count是0（默认值），这意味着，对该用户没有限制。

MAX_USER_CONNECTIONS count选项限制了账户可以同时进行的连接的最大数目。如果count是0（默认值），则max_user_connections系统可以决定该账户同时连接的数目。

mysql> grant all on *.* to db8@localhost identified by '123' with MAX_QUERIES_PE

R_HOUR 0;

Query OK, 0 rows affected (0.03 sec)

其他操作

在Java中，获得ResultSet的总行数的方法有以下几种。

第一种：利用ResultSet的getRow方法来获得ResultSet的总行数

Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
ResultSet rset = stmt.executeQuery("select * from yourTableName");
rset.last();
int rowCount = rset.getRow(); //获得ResultSet的总行数

第二种：利用循环ResultSet的元素来获得ResultSet的总行数

ResultSet rset = stmt.executeQuery("select * from yourTableName");
int rowCount = 0;
while(rset.next()) {
rowCount++;
}

rowCount就是ResultSet的总行数。

第三种：利用sql语句中的count函数获得ResultSet的总行数

ResultSet rset = stmt.executeQuery("select count(*) totalCount from yourTableName");
int rowCount = 0;
if(rset.next()) {
rowCount=rset .getInt("totalCount ");
}

rowCount就是ResultSet的总行数。

以下是异常代码的举例

try {

   DBConnection db = new DBConnection();//DBConnection是自定义用于实现JDBC-ODBC数据库连接的类,类
                                       //中实现了返回Connection 和 Statement 的方法
   ResultSet rs1,rs2 ;
   Statement stmt = db.getStatement();
   rs1 = stmt.executeQuery("select * from table1;");

   while(rs1.next()){
       rs2 = stmt.executeQuery("select * from table2;");
       while(rs2.next()){
                        /* 一段代码 */
       }
    }
    rs2.close();
    rs1.close();
    stmt.close();
}catch (SQLException ex) { System.out.println(ex); }

代码运行后, 就会抛出 java.sql.SQLException: ResultSet is closed 的异常,这是因为程序在while与while的嵌套循环中,每循环到一次rs1的时候,就会循环到一次rs2,而rs1和rs2都是通过stmt生成的结果集,所以在生成rs2的时候,stmt就自动把rs1关掉了,再循环到rs1的时候,系统自然酒会抛出ResultSet is closed 的异常了,解决的方法就是创建两个Statement,rs1和rs2分别由不同的Statement生成,就不会抛出异常了修改如下

try {
  DBConnection db = new DBConnection();//DBConnection是自定义的用于实现JDBC-ODBC数据库连接的类,类
                                                  // 中实现了返回Connection 和 Statement 的方法
  ResultSet rs1,rs2;
  Statement stmt1,stmt2;
  Connection conn = db.getConnection();
  stmt1 = conn.createStatement();// 创建两个Statement实例
  stmt2 = conn.createStatement();

  rs1 = stmt1.executeQuery("select * from table1;");//rs1由stmt1生成结果
  while(rs1.next()){
      rs2 = stmt2.executeQuery("select * from table2;");//rs2由stmt2生成结果
      while(rs2.next()){
           /* 一段代码 */
      }
   }
   rs2.close();
   rs1.close();
   stmt1.close();
   stmt2.close();
}catch (SQLException ex) { System.out.println(ex); }

这样运行就不会抛出异常了

0 0

数据库操作

第11章 数据库操作（一）

第一节 MySQL 的基本操作

一、MySQL数据库简介

二、服务器的启动与停止

1、启动服务器

2、停止服务器

三、登录与退出

1、登录

2、退出

四、修改密码

1、修改root密码

通过grant命令修改

2、添加普通用户名

第二种方法：

取消权限：

删除用户：

删除一个用户：

五、MySQL的data文件夹

六、数据库操作

1、建立数据库

2、打开数据库

3、删除数据库

4、显示所有的数据库

七、名字的大小写敏感性

八、列类型

1、数字类型

2、日期类型

3、字符类型

CHAR [BINARY]

VARCHAR[BINARY]

text与Blob类型

九、注释句法

十、表操作

1、表的创建

AUTO_INCREMENT：仅用于整数列类型，使这一列上的数值自动增长。初始值可用AUTO_INCREMENT选项确明指定，缺省为1。AUTO_INCREMENT列还必须指定为UNIQUE索引或PRIMARY KEY，而且应该为NOT NULL。

还可用CREATE TABLE IF NOT EXISTS

插入数据

2、表结构的修改

3、INSERT命令

4、显示表的结构

5、显示数据库中的所有表

6、将表中记录清空

7、删除表文件

将一个表里的数据插入到另一个表里

十一、用户变量

十二、Latin1（iso-8859-1）编码

十三、字符集

十四、通过MY.INI中文问题

打开windows目录下MY.INI,将下面的默认字符改为GBK

十五、数据的导入与导出

十六、source命令

十七、找回管理员的密码

或mysqld --skip-grant-tables

十八、ql的 limit $offset,$pagesize

十九、模糊查询

修改表的常用操作

mysql :alter table命令：

第二节 其他常用操作

一、插入现在时间

二、将mysql表中的主键删除掉

三、zerofill

四、查看权限：

五、存储过程：（选学）

六、批量导入数据

七、导出数据

八、（选学）关于information_schema

查询五个最大表

九、 触发器（选学）

第二节 JDBC的概念及组成、操作步骤

一、JDBC的概念

二、JDBC的基本功能

三、JDBC的组成

四、导入java.sql包

五、登记驱动程序

1、连接Oracle

2、连接Mysql

3、连接 SQL Server数据库

4、连接DB2数据库

5、连接PostgreSQL数据库

第11章数据库操作（一）

4、显示表的结构　

6、将表中记录清空　

第二节其他常用操作

九、触发器（选学）

第四节数据库的基本操作