MySQL 是一个精巧的 SQL 数据库管理系统，虽然它不是开放源代码的产品，但在某些情况下你可以自由使用。由于它的强大功能、灵活性、丰富的应用编程接口（API）以及精巧的系统结构，受到了广大自由软件爱好者甚至是商业软件用户的青睐，特别是与 Apache 和 PHP 结合，为建立基于数据库的动态网站提供了强大动力。被 Linux 下 WEB 开发者称为 PHP 的黄金搭档。

数据库设计技巧(一)

在动态网站的设计中，数据库设计的重要性不言而喻。如果设计不当,查询起来就非常吃力，程序的性能也会受到影响。无
论你使用的是mySQL或者Oracle数据库，通过进行正规化的表格设计，可以令你的PHP代码更具可读性，更容易扩展，从而
也会提升应用的性能。

　　简单说来，正规化就是在表格设计时，消除冗余性和不协调的从属关系。在本文中，我将通过五个渐进的过程来告诉
你在设计中应该了解的正规化技巧。从而建立一个可行而且
效率高的数据库。本文也会详细分析一下可以利用的关系类型。

　　这里假定我们要建立一个用户信息的表格，其中要存储用户的名字、公司、公司地址和一些个人的收藏夹或url。在开
始时，你可能定义一个如下的表格结构：

　　零状态形式

　　users

　　name company company_address url1 url2

　　Joe ABC 1 Work Lane abc.com xyz.com

　　Jill XYZ 1 Job Street abc.com xyz.com

　　由于没有进行任何的正规化处理，我们将这种形式的表称为零状态形式的表。留意其中的url1和url2字段---如果我们
在应用中需要第三个url呢？这样你就要在表格中多加一列，很明显，这不是一个好办法。如果你要创建一个富有扩展性的
系统，你就要考虑使用第一个正规化的形式，并且应用到该表格中。

　　第一级正规化形式

　　1.消除每个表格中重复的组

　　2.为每套相关的数据建立一个独立的表格

　　3.使用一个主键来标识每套相关的数据

　　以上的表格明显违反了上面第一条的规定，那么第三条的主键又是什么意思呢？很简单，它只是在每个记录中加入一
个唯一的、自动增加的整型值。通过这个值，就可以将两个姓名一样的记录区分开来。通过应用第一级正规化形式，我们
得到了以下的表格：

　　users

　　userId name company company_address url

　　1 Joe ABC 1 Work Lane abc.com

　　1 Joe ABC 1 Work Lane xyz.com

　　2 Jill XYZ 1 Job Street abc.com

　　2 Jill XYZ 1 Job Street xyz.com

　　现在我们的表格可以说已经处在第一级正规化的形式了，它已经解决了url字段的限制问题，不过这样的处理后又带来
了一个新的问题。每次在user表中插入一条记录的时候，我们都必须重复所有的公司和用户数据。这样不仅令数据库比以
前大了，而且很容易出错。因此还要经过第二级正规化处理。

数据库设计技巧(二)

1.为应用在多条记录的字段建立独立的表格

2.通过一个foreign key来关联这些表格的值


　　我们将url的值放在一个独立的表格中，这样我们就可以在以后加入更多的数据，而无需担心产生重复的值。我们还通
过主键值来关联这些字段：

　　users

　　userId name company company_address

　　1 Joe ABC 1 Work Lane

　　2 Jill XYZ 1 Job Street

　　urls

　　urlId relUserId url

　　1 1 abc.com

　　2 1 xyz.com

　　3 2 abc.com

　　4 2 xyz.com

　　如上所示，我们创建了独立的表格，users表中的主键userid现在与url表中的foreign key relUserId关联。现在的情
况好象已经得到了明显的改善。不过，如果我们要为ABC公司加入一个员工记录呢？或者更多，200个？这样我们就必须重
复使用公司名和地址，这明显不够冗余。因此我们将应用第三级正规化方法：

　　第三级正规化形式

　　1.消除不依赖于该键的字段

　　公司名及地址与User Id都是没有关系的，因此它们应用拥有自己的公司Id：

　　users

　　userId name relCompId

　　1 Joe 1

　　2 Jill 2

　　companies

　　compId company company_address

　　1 ABC 1 Work Lane

　　2 XYZ 1 Job Street

　　urls

　　urlId relUserId url

　　1 1 abc.com

　　2 1 xyz.com

　　3 2 abc.com

　　4 2 xyz.com

　　这样我们就将companies表中的主键comId和users表中名字为relCompId的foreign key关联起来，就算为ABC公司加入
200个员工，在companies中也只有一条记录。我们的users和urls表可以不断地扩大，而无需担心插入不必要的数据。大部
分的开发者都认为经过三步的正规化就足够了，这个数据库的设计已经可以很方便地处理整个企业的负担，此看法在大多
数的情况下是正确的。

　　我们可以留意一下URL的字段--你注意到数据的冗余了吗？如果给用户用户输入这些url数据的HTML页面是一个文本
框，可任意输入的话，这并没有问题，两个用户输入同样收藏夹的概率较少，不过，如果是通过一个下拉式的菜单，只让
用户选择两个url输入，或者更多一点。这种情况下，我们的数据库还可以进行下一级别的优化--第四步，对于大多数的开
发者来说，这一步都是忽略的，因为它要依赖一个很特别的关系--一个多对多的关系，这在我们的应用中是还没有遇到过的.

数据库设计技巧(三)

在定义第四个正规化的形式前，我想首先提一下三种基本的数据关系：一对一，一对多和多对多。我们回头看一下经
过第一个正规化的users表。要是我们将url的字段放在一个独立的表中，每次在users表中插入一个记录，我们就会在urls
表中插入一行。我们将得到一个一对一的关系：用户表中的每一行，都将在urls表中找到相应的一行。对于我们的应用来
说，这既不实用也不标准。

　　然后看看第二个正规化的例子。对于每个用户记录，我们的表格允许有多个urls的记录与之关联。这是一个一对多的
关系，这是一个很常见的关系。

　　对于多对多的关系来说，就有点复杂了。在我们的第三个正规化形式的例子中，我们的一个用户与很多的url有关，而
我们想将该结构变为允许多个用户与多个的urls有关，这样我们就可以得到一个多对多的结构。在讨论前，我们先看看表
格结构会有些什么变化

　　users

　　userId name relCompId

　　1 Joe 1

　　2 Jill 2

　　companies

　　compId company company_address

　　1 ABC 1 Work Lane

　　2 XYZ 1 Job Street

　　urls

　　urlId url

　　1 abc.com

　　2 xyz.com

　　url_relations

　　relationId relatedUrlId relatedUserId

　　1 1 1

　　2 1 2

　　3 2 1

　　4 2 2

　　为了进一步减低数据的冗余，我们运用第四级正规化形式。我们创建了一个颇奇怪的url_relations表，里面的字段均
为主键或者foreign key。通过这个表，我们就可以消除urls表中的重复项目。以下是第四个正规化形式的具体要求：

　　第四个正规化形式

　　1.在一个多对多的关系中，独立的实体不能存放在同一个表格中

　　由于它仅应用于多对多的关系，因此大多数的开发者可以忽略这条规定。不过在某些情况下，它是非常实用的，这个
例子就是这样，我们通过将相同的实体分离出来，并且将关系移到它们自己的表格中，从而改进了urls表格。

　　为了令你更容易明白，我们举个具体的例子，以下将用一个SQL语句选择出所有属于joe的urls：

　　SELECT name, url FROM users, urls, url_relationsswheresurl_relations.relatedUserId = 1 AND
users.userId = 1 AND urls.urlId = url_relations.relatedUrlId

　　如果我们想要遍历每个人的个人信息和url信息，我们可以这样做：

　　SELECT name, url FROM users, urls, url_relationsswheresusers.userId = url_relations.relatedUserId AND
urls.urlId = url_relations.relatedUrlId

　　第五级正规化形式

　　还有一级正规化的形式，它并不常见，有点深奥，并且在大部分的情况下都是不必要的。它的原则是：

　　1.原来的表格必须可以通过由它分离出去的表格重新构建

　　使用这个规定的好处是，你可以确保不会在分离的表格中引入多余的列，所有你创建的表格结构都与它们的实际需要
一样大。应用这条规定是一个好习惯，不过除非你要处理一个非常大型的数据，否则你将不需要用到它。

　　希望这篇文章对你有用，并且可以帮助你在所有的项目中应用这些正规化的规定。你可能想知道这些方法是从哪来
的，我可以告诉你，前面三个正规化的规定是1972年，Dr. E.F. Codd在他的论文“进一步正规化数据库的关系模型中”提
出的，其余的规定是经过后来的集合理论和关系数学家理论化的。评论：正所谓物级必反，将表格分得过细有时并不好，
因为这样需要将各表进行各种的关联，这会令查询时变得复杂，而且效率也可能降低，这些正规化的规定可以参考，在实
际应用时，要根据项目的大小，必要时可以进行一些测试，以设计出更合理的表格结构。

如何利用MySQL加密函数保护Web网站敏感数据

如果您正在运行使用MySQL的Web应用程序，那么它把密码或者其他敏感信息保存在应用程序里的机会就很大。保护这些数据免受黑客或者窥探者的获取是一个令人关注的重要问题，因为您既不能让未经授权的人员使用或者破坏应用程序，同时还要保证您的竞争优势。幸运的是，MySQL带有很多设计用来提供这种类型安全的加密函数。本文概述了其中的一些函数，并说明了如何使用它们，以及它们能够提供的不同级别的安全。

双向加密

就让我们从最简单的加密开始：双向加密。在这里，一段数据通过一个密钥被加密，只能够由知道这个密钥的人来解密。MySQL有两个函数来支持这种类型的加密，分别叫做ENCODE()和DECODE()。下面是一个简单的实例：

mysql> INSERT INTO users (username, password) VALUES ('joe', ENCODE('guessme', 'abracadabra'));
Query OK, 1 row affected (0.14 sec)

其中，Joe的密码是guessme，它通过密钥abracadabra被加密。要注意的是，加密完的结果是一个二进制字符串，如下所示：

mysql> SELECT * FROM users WHERE username='joe';
+----------+----------+
| username | password |
+----------+----------+
| joe      | ¡?i??!?  |
+----------+----------+
1 row in set (0.02 sec)

abracadabra这个密钥对于恢复到原始的字符串至关重要。这个密钥必须被传递给DECODE()函数，以获得原始的、未加密的密码。下面就是它的使用方法：

mysql> SELECT DECODE(password, 'abracadabra') FROM users WHERE username='joe';
+---------------------------------+
| DECODE(password, 'abracadabra') |
+---------------------------------+
| guessme                         |
+---------------------------------+
1 row in set (0.00 sec)

应该很容易就看到它在Web应用程序里是如何运行的——在验证用户登录的时候，DECODE()会用网站专用的密钥解开保存在数据库里的密码，并和用户输入的内容进行对比。假设您把PHP用作自己的脚本语言，那么可以像下面这样进行查询：

<?php
$query = "SELECT COUNT(*) FROM users WHERE username='$inputUser' AND DECODE(password, 'abracadabra') = '$inputPass'";?>

提示：虽然ENCODE()和DECODE()这两个函数能够满足大多数的要求，但是有的时候您希望使用强度更高的加密手段。在这种情况下，您可以使用AES_ENCRYPT()和AES_DECRYPT()函数，它们的工作方式是相同的，但是加密强度更高。



  

单向加密

单向加密与双向加密不同，一旦数据被加密就没有办法颠倒这一过程。因此密码的验证包括对用户输入内容的重新加密，并将它与保存的密文进行比对，看是否匹配。一种简单的单向加密方式是MD5校验码。MySQL的MD5()函数会为您的数据创建一个“指纹”并将它保存起来，供验证测试使用。下面就是如何使用它的一个简单例子：

mysql> INSERT INTO users (username, password) VALUES ('joe', MD5('guessme'));
Query OK, 1 row affected (0.00 sec)

mysql> SELECT * FROM users WHERE username='joe';
+----------+----------------------------------+
| username | password                         |
+----------+----------------------------------+
| joe      | 81a58e89df1f34c5487568e17327a219 |
+----------+----------------------------------+
1 row in set (0.02 sec)

现在您可以测试用户输入的内容是否与已经保存的密码匹配，方法是取得用户输入密码的MD5校验码，并将它与已经保存的密码进行比对，就像下面这样：

mysql> SELECT COUNT(*) FROM users WHERE username='joe' AND password=MD5('guessme');
+----------+
| COUNT(*) |
+----------+
|        1 |
+----------+
1 row in set (0.00 sec)

或者，您考虑一下使用ENCRYPT()函数，它使用系统底层的crypt()系统调用来完成加密。这个函数有两个参数：一个是要被加密的字符串，另一个是双（或者多）字符的“salt”。它然后会用salt加密字符串；这个salt然后可以被用来再次加密用户输入的内容，并将它与先前加密的字符串进行比对。下面一个例子说明了如何使用它：

mysql> INSERT INTO users (username, password) VALUES ('joe', ENCRYPT('guessme', 'ab'));
Query OK, 1 row affected (0.00 sec)

mysql> SELECT * FROM users WHERE username='joe';
+----------+---------------+
| username | password      |
+----------+---------------+
| joe      | ab/G8gtZdMwak |
+----------+---------------+
1 row in set (0.00 sec)

结果是

mysql> SELECT COUNT(*) FROM users WHERE username='joe' AND password=ENCRYPT('guessme', 'ab');
+----------+
| COUNT(*) |
+----------+
|        1 |
+----------+
1 row in set (0.00 sec)

提示：ENCRYPT()只能用在*NIX系统上，因为它需要用到底层的crypt()库。

幸运的是，上面的例子说明了能够如何利用MySQL对您的数据进行单向和双向的加密，并告诉了您一些关于如何保护数据库和其他敏感数据库信息安全的理念。祝您编程愉快！

Linux网络备份MYSQL

一、本地备份
使用 mysqldump进行备份非常简单，如果要备份数据库“ phpbb_db_backup ”,使用命令：
#mysqldump –u -p phpbb_db_backup > /usr/backups/mysql/ phpbb_db_backup.2005.5.6
还可以使用gzip命令对备份文件进行压缩：
#mysqldump phpbb_db_backup | gzip > /usr/backups/mysql/ phpbb_db_backup.2005.5.6.gz
恢复数据使用命令：
#mysql –u -p phpbb_db_backup </usr/backups/mysql/phpbb_db_backup.2005－5－6
二、备份数据到DVD盘片
随着MYSQL数据量的增大，使用传统CD—R来备份硬盘并不现实，采用CD—RW分卷制作实在太麻烦、磁带机对于中小企业又过于昂贵。另外各个应用程序的复杂度日与剧增, 处理的数据量也都相当庞大,Linux用户常常遇到的问题就是:有什么办法可以经济快捷的对数据做备份与保存。随着DVD刻录机和盘片的价格迅速降低，使用DVD刻录机用来备份Linux操作系统非常明智的。
1、安装
下面以IDE接口的内置刻录设备为例，介绍在Linux环境中使用DVD刻录机。Linux 需要将IDE接口的刻录设备虚拟为SCSI设备才能进行DVD刻录。2.4以上内核Linux发行版本包含了已编译进内核的SCSI仿真，所以只要对启动文件作一些小改动；USB或1394(FireWire)接口的外置刻录机就简单多了。
把DVD刻录机设备接入计算机第二个IDE接口（dev/hdc），开启电源。假设系统用Grub启动，用文本编辑器打开/boot/grub/grub.conf，找到以“kernel”开头的一行，在这行内容的未尾加入“hdc=ide-scsi”，例如：“kernel /vmlinuz-2.4.20-8 ro root=LABEL=/ hdc=ide-scsi”。
2、安装刻录软件
DVD+RW-Tools ：一个包含有用于刻录DVD和映像的软件工具包，包括：Growisofs和dvd+rw-format。官方站点：http://fy.chalmers.se/~appro/linux/DVD+RW/ ，
CDRDAO：DAO即是Disk-At-Once(实时刻录)，是一种在烧录过程中没有音轨间的两秒缓冲的刻录方法。它可以对磁盘的布局和磁道进行完全的控制，这一功能在刻录多来源的盘片相当有帮助。
cdrtools：包含了一套用于CD、DVD刻录的工具。Growisofs在创建映像时会使用这个软件包中的mkisofs工具，并且用户可以使用readcd来从一个现有的DVD上创建ISO映像。此外，Cdrecord应用程序可被用于扫描连接系统上的CD／DVD刻录机，并且可以使用它来将ISO映像刻录到CD—R(W)光盘上。通常大多数Linux版本包括这个软件，也可以下载使用：http://freshmeat.net/redir/cdrec ... epage/cdrecord.html
dvdrecord：命令行下的DVD刻录软件。命令行下的DVD刻录可用于很多种情形，比如当我们通过远程访问主机时，机器上的图形界面无法启动时，或者机器由于某些原因无法启动GUI时。此外，在完成一些备份等自动重复的功能时，也需要使用命令行工具。
以上介绍了一下必须的软件和相关下载网址，安装过程比较简单，这里就不赘述了。
3、命令行下刻录
使用DVD+RW-Tools 进行刻录工作
growisofs是DVD+RW-Tools一个工具，Growlsofs访问其刻录设备使用的是一种不同的方式。它使用／dev下面的Unix路径来连接刻录机。不同的系统和发行版中用于刻录机的路径不尽相同，所以最好的方法是查看发行版中的帮助。在一些系统中，一个名为／dev／dvd的软链接会被设置成指向可用的DVD刻录机，在本文中，使用／dev／dvd来指定刻录机，如果系统中路径设置不同，那么请使用合适的路径将其取代。
（1）格式化可读写DVD光盘
可以使用DVD+RW-Tools工具包中提供的dvd十rw—format命令。它有两种格式化DVD光盘的方式：快速模式、完全模式。快速模式：
#dvd+rw-format -blank /dev/dvd
完全模式：
#dvd+rw-format -blank=full /dev/dvd
(2)将文件存储至DVD刻录盘：
DVD和普通的光盘一样，使用的也是ISO9660文件系统，以及同样的通用扩展(Joliet和RockRidge)。Growlsofs提供了一种简单的将文件或目录存储至DVD刻录盘的方法。先用调用mkisofs工具来创建一个映像，并且无需在将该映像存储至硬盘之前就刻录下来。其基本的命令格式如下：
#growisofs -dvd-compat -Z /dev/dvd -J -R /path/to/home/cao
此命令将/path/to/home/cao目录下的文件制作一个映像并且刻录到的DVD光盘。

二、网络备份
将MYSQL数据放在一台计算机上是不安全的，所以应当把数据备份到局域网中其他计算机中。假设Mysql服务器IP地址是：192.168.1.3。局域网使用Linux的远程计算机IP地址是192.168.1.17；局域网使用Windows的远程计算机IP地址是192.168.1.18。
1、通过NFS网络备份
类似于windows的网络共享，UNIX(Linux)系统也有自己的网络共享，那就是NFS(网络文件系统)，在linux客户端挂接(mount)NFS磁盘共享之前，必须先配置好NFS服务端。linux系统NFS服务端配置方法如下：
(1)修改 /etc/exports,增加共享目录
/export/home/sunky 192.168.1.17(rw)
/export/home/sunky1 *(rw)
/export/home/sunky2 linux-client(rw)
注：/export/home/目录下的sunky、sunky1、sunky2是准备共享的目录，10.140.133.23、*、linux-client是被允许挂接此共享linux客户机的IP地址或主机名。如果要使用主机名linux-client必须在服务端主机/etc/hosts文件里增加linux-client主机ip定义。格式如下：
192.168.1.17 linux-client
若修改/etc/export文件增加新的共享，应先停止NFS服务，再启动NFS服务方能使新增加的共享起作用。使用命令exportfs -rv也可以达到同样的效果。linux客户端挂接(mount)其他linux系统或UNIX系统的NFS共享。这里我们假设192.168.1.17是NFS服务端的主机IP地址，当然这里也可以使用主机名，但必须在本机/etc/hosts文件里增加服务端ip定义。/export/home/sunky为服务端共享的目录。如此就可以在linux客户端通过/mnt/nfs来访问其它linux系统或UNIX系统以NFS方式共享出来的文件了。
把MYSQL数据备份到使用Linux的远程计算机需要在两端都安装NFS协议（Network File System），远程NFS计算机安装NFS协议后还要修改配置文件：/etc/exports,加入一行：
/usr/backups/mysql/ 192.168.1.17 (rw, no_root_squash)
表示将/usr/backups/mysql/目录共享。这个目录具有远程root用户读写权限。保存NFS配置文件，然后使用命令：
#exportfs -a –r
然后重新启动NFS服务：
#service nfsd start
远程计算机设定后，在MYSQL服务器/mnt 目录下建立一个backup_share目录：
#mkdir /mnt/backup_share
将远程的Linux计算机的/usr/backups/mysql/目录挂载到MYSQL服务器的/mnt/backup_share目录下：
# mount -t nfs 192.168.1.17：/usr/backups/mysql /mnt/backup_share
将目录挂载进来后，只要进入/mnt/backup_share 目录，就等于到了IP地址：192.168.1.7那部NFS 计算机的/usr/backups/mysql 目录中。下面使用mysqldump把“phpbb_db_backup”备份到远程计算机：
# mysqldump phpbb_db_backup > /mnt/backup_share/ phpbb_db_backup.2005-5-6
2.通过Samba网络备份
Windows网络共享的核心是SMB/CIFS，在linux下要挂接(mount)windows的磁盘共享，就必须安装和使用samba软件包。现在流行的linux发行版绝大多数已经包含了samba软件包，如果安装linux系统时未安装samba请首先安装samba。当然也可以到www.samba.org网站下载samba软件包，现在最新的版本是3.0.10版。然后Windows计算机上建立一个目录（/arc）并且共享，赋予其读写权限。同样在MYSQL服务器/mnt 目录下建立一个backup_share1目录，然后进行挂载：
# mount -t smbfs -o username=cjh, password=XXXX //192.168.1.18/arc /mnt/backup_share
最后使用命令进行备份：
# mysqldump phpbb_db_backup > /mnt/backup_share/ phpbb_db_backup.2005-5-6

如何在linux下建立mysql镜像数据库

MySQL 版本：4.1

环境介绍：主库 192.168.0.205 从库 192.168.0.206

1、主库创建/etc/my.cnf，修改[mysqld]里边的键值增加

server-id=1

log-bin=binlog_name

2、主库增加用户，用于从库读取主库日志。

grant replication slave,reload,super on *.* to ’slave’@’192.168.0.206’ identified by ’123456’

3、从库连接主库进行测试。

/opt/mysql/bin/mysql -u slave -p -h 192.168.0.205

4、停从库，修改从库/etc/my.cnf，增加选项：


[mysqld] server-id=2 master-host=192.168.0.205 master-user=slave master-password=123456


5、启动从库，进行主从库数据同步

/opt/mysql/share/mysql/mysql start

/opt/mysql/bin/mysql -u root -p

mysql>load data from master;

说明：这一步也可以用数据库倒入或者直接目录考过来。

6、进行测试：

主库创建表，


mysql>create database sampdb; mysql>create table new (name char(20),phone char(20)); mysql>insert into new (’abc,’0532555555’);


打开从库，察看：


/opt/mysql/bin/mysql -u root -p mysql>show database; mysql sampdb test mysql>use sampdb; mysql>show tables; new


说明主从数据库创建成功。

7、主从数据库相关命令：

slave stop; slave start ; 开始停止从数据库。

show slave status\G; 显示从库正读取哪一个主数据库二进制日志

purge master logs to ’binlog.000004’; 此命令非常小心，删除主数据库没用的二进制日志文件。如果误删除，那么从库就没有办法自动更新了。

change master； 从服务器上修改参数使用。

几种显示数据的方法的比较

用于显示数据库数据的时候，一般用循环体来做，常用的方法有while()和for()两种语句，下面就来讲一下他们在不同情况下各自的用法。
　　我们来分别介绍：
while()语句是可以显示全部数据，在不知道循环次数的情况下，尤其显得方便，而for()语句呢，可以输出显示从指定位置开始到指定位置结束的数据，在输出显示一定范围的数据时就用得上了。下面看一下编程实例：
　　我们先建一个数据库来备用：数据库名为：mydb 表名为：tbl。
用下面的语句：create table tal (idx int(3),url char (100),freetext char(100))
可以用phpmyadmin工具来向数库表中插入若干个数据。
编程开始：



$id=mysql_connect("localhost") or die("无法建立数据库链接");#链接数据库
$result=mysql_db_query("mydb","select * from tbl",$id);#查询结果并存入变量中
$rows=mysql_num_rows($result);#得出数据表中的总行数，也就是数据的总个数
echo"<table>";#准备以表格的形式输出
echo "</table>";#表格结束

在上面两句中插入输出语句，对应于不同的情况，输出语句分为几种情况：
若输出全部数据，先用for()来做

for($i=0;$i<$rows;$i++){
$total=mysql_fetch_array($result);
echo "<tr><td bgcolor=yellow><a href="http://$total[url]"target=_blank>$total[freetext]</a>$total[idx]</tr></td>";
}
用while()来做
while($total=mysql_fetch_array($result))
{ echo "<tr><td bgcolor=yellow><a href="http://$total[url]"target=_blank>$total[freetext]</a>$total[idx]</tr></td>";
}

当我们想要分页显示的时候，也就是不能一下子把所有的数据一次性的显示完，那么可以用for()来完成这个任务。
我们假设每输出10个数据，用$page来表示当前的页数$pagesize=10来表示第页的数据数量.语句如下所示：

for ($i=0;$i<$pagesize;$i++)
{
$start=($page-1)*$pagesize+$i;#计数起始的数据行数
if ($start<$rows)
$idx=mysql_result($result,$start,"idx");
$url=mysql_result($result,$start,"url");
$freetext=mysql_result($result,$start,"freetext");
echo "<tr><td bgcolor=yellow><a href="http://$url"target=_blank>$freetext</a>$idx</tr></td>";

上述语句用for()分别得出数据表中的各字段的值存入变量中，用echo语句显示出来。

以上程序在apache+mysql+php4中运行通过

使用数据库保存session的方法

使用数据库保存session的方法
php的session默认是以文件方式保存在服务器端，并且在客户端使用cookie保存变量，这就会出现一个问题，当一个用户由于某种安全原因关闭了浏览器的cookie，程序中的session相关操作将无法执行。因此，如果能以数据库保存session数据，将不受客户端设置的限制，并且在性能和扩展性等方面有一个飞跃。程序中使用关键函数是session_set_save_handler，同时要将php.ini里的session.save_handler = files 改为 user。这里我们讨论的环境是linux(freesd)+apache+mysql+php。

数据表结构：[sessions]
CREATE TABLE sessions (  
sesskey char(32) not null,  
expiry int(11) unsigned not null,  
value text not null,  
PRIMARY KEY (sesskey)  
);

程序代码：[session_inc.php]

复制内容到剪贴板

代码:

<?php
$SESS_DBHOST = "yourhost";
/**
* database server hostname
*/
$SESS_DBNAME = "yourdb";
/**
* database name
*/
$SESS_DBUSER = "youruser";
/**
* database user
*/
$SESS_DBPASS = "yourpassword";
/**
* database password
*/

$SESS_DBH = "";
$SESS_LIFE = get_cfg_var("session.gc_maxlifetime");

function sess_open($save_path, $session_name) {
        global $SESS_DBHOST, $SESS_DBNAME, $SESS_DBUSER, $SESS_DBPASS, $SESS_DBH;

        if (! $SESS_DBH = mysql_pconnect($SESS_DBHOST, $SESS_DBUSER, $SESS_DBPASS)) {
                echo "<li>Can't connect to $SESS_DBHOST as $SESS_DBUSER";
                echo "<li>MySQL Error: " . mysql_error();
                die;
        }

        if (! mysql_select_db($SESS_DBNAME, $SESS_DBH)) {
                echo "<li>Unable to select database $SESS_DBNAME";
                die;
        }

        return true;
}

function sess_close() {
        return true;
}

function sess_read($key) {
        global $SESS_DBH, $SESS_LIFE;

        $qry = "SELECT value FROM session_tbl WHERE sesskey = '$key' AND expiry > " . time();
        $qid = mysql_query($qry, $SESS_DBH);

        if (list($value) = mysql_fetch_row($qid)) {
                return $value;
        }

        return false;
}

function sess_write($key, $val) {
        global $SESS_DBH, $SESS_LIFE;

        $expiry = time() + $SESS_LIFE; //过期时间  
        $value = addslashes($val);

        $qry = "INSERT INTO session_tbl VALUES ('$key', $expiry, '$value')";
        $qid = mysql_query($qry, $SESS_DBH);

        if (! $qid) {
                $qry = "UPDATE session_tbl SET expiry = $expiry, value = '$value' WHERE sesskey = '$key' AND expiry > " . time();
                $qid = mysql_query($qry, $SESS_DBH);
        }

        return $qid;
}

function sess_destroy($key) {
        global $SESS_DBH;

        $qry = "DELETE FROM session_tbl WHERE sesskey = '$key'";
        $qid = mysql_query($qry, $SESS_DBH);

        return $qid;
}

function sess_gc($maxlifetime) {
        global $SESS_DBH;

        $qry = "DELETE FROM session_tbl WHERE expiry < " . time();
        $qid = mysql_query($qry, $SESS_DBH);

        return mysql_affected_rows($SESS_DBH);
}

session_set_save_handler(
        "sess_open",
        "sess_close",
        "sess_read",
        "sess_write",
        "sess_destroy",
        "sess_gc");

session_start();

?>

完成以上步骤后，在程序中使用require("session_inc.php")来代替session_start()即可，其他的session函数还是象以前一样的方法调用

MySQL 查询中的分页思路的优化

似乎讨论分页的人很少，难道大家都沉迷于limit m,n?
在有索引的情况下，limit m,n速度足够，可是在复杂条件搜索时，
where somthing order by somefield somefield
mysql会搜遍数据库，找出“所有”符合条件的记录，然后取出m,n条记录。
如果你的数据量有几十万条，用户又搜索一些很通俗的词，
然后要依次读最后几页重温旧梦。。。mysql该很悲壮的不停操作硬盘。

所以，可以试着让mysql也存储分页，当然要程序配合。
（这里只是提出一个设想，欢迎大家一起讨论）

ASP的分页：在ASP系统中有Recordset对象来实现分页，但是大量数据放在内存中，而且不知道什么时候才失效(请ASP高手
指点).
SQL数据库分页：用存储过程 游标方式分页，具体实现原理不是很清楚，设想如果用一次查询就得到需要的结果，或者是
id集，需要后续页时只要按照结果中的IDs读出相关记录。这样只要很小的空间保留本次查询的所有IDs. (SQL中的查询结
果不知道怎样清楚过期垃圾?)

这样，可以让mysql模拟存储分页机制：
1. select id from $table where $condition order by $field limit $max_pages*$count;
查询符合条件的IDs.
限定最大符合条件的记录数量，也可以不加。
2. 因为php在执行结束后所有变量都要lost，所以可以考虑:
方案a. 在mysql建立临时表，查询结果用一个时间或随机数作为唯一标志插入。
其中建立page1~pagen个字段，每个字段保存该页中需要的ids, 这样一个id对一条记录.
方案b. 如果打开session,也可以放在session中保存，实际上是放在文件中保存。
建立一个$IDs数组，$IDs[1]~$IDs[$max_pages]. 考虑到有时候用户会开几个
窗口同时查询，要为$ids做一个唯一标志，避免查询结果相互覆盖。二维数组
和$$var都是好办法。
3. 在每页页的请求中，直接找到对应的IDs，中间以","间隔：
select * from $table where id in ($ids); 速度绝对快
4. 收尾要考虑查询结果的自动清除，可以设置定时或者按比例随机清楚。如果用mysql临时表要加上一个时间标志字段，
session中要加入$IDs["time"]=time(); 在一定时间以后不操作视为过期数据。

5. 如果要优化，可以考虑用把1和2.a中的语句合并成select ...... into ....

Note:
1.以上只是针对mysql的修补方案，希望mysql哪天能把这些功能加进去
2.其它数据库也可以套用。
3.如果其它数据库还有更先进的分页方式，请告诉我或mailto: steeven@kali.com.cn
4.如果真的有很多数据要查询，还是和mysql再见吧，sql,oracle都提供了更先进的关键词索引查询。

精益求精，以上只是抛砖引玉，欢迎共同探讨分页问题。（也可关于其它数据库）
希望有一天能把各种分页方式整理出来供新手参考。

提高MySQL查询效率的三个技巧

　MySQL由于它本身的小巧和操作的高效, 在数据库应用中越来越多的被采用.我在开发一个P2P应用的时候曾经使用MySQL来保存P2P节点,由于P2P的应用中,结点数动辄上万个,而且节点变化频繁,因此一定要保持查询和插入的高效.以下是我在使用过程中做的提高效率的三个有效的尝试.

　　使用statement进行绑定查询

　　使用statement可以提前构建查询语法树,在查询时不再需要构建语法树就直接查询.因此可以很好的提高查询的效率. 这个方法适合于查询条件固定但查询非常频繁的场合.

　　使用方法是:

　　绑定, 创建一个MYSQL_STMT变量,与对应的查询字符串绑定,字符串中的问号代表要传入的变量,每个问号都必须指定一个变量.
　　查询, 输入每个指定的变量, 传入MYSQL_STMT变量用可用的连接句柄执行.
　　代码如下:

复制内容到剪贴板

代码:

//1.绑定
bool CDBManager::BindInsertStmt(MYSQL * connecthandle)
{
       //作插入操作的绑定
       MYSQL_BIND insertbind[FEILD_NUM];
       if(m_stInsertParam == NULL)
              m_stInsertParam = new CHostCacheTable;
       m_stInsertStmt = mysql_stmt_init(connecthandle);
       //构建绑定字符串
       char insertSQL[SQL_LENGTH];
       strcpy(insertSQL, "insert into HostCache(SessionID, ChannelID, ISPType, "
              "ExternalIP, ExternalPort, InternalIP, InternalPort) "
              "values(?, ?, ?, ?, ?, ?, ?)");
       mysql_stmt_prepare(m_stInsertStmt, insertSQL, strlen(insertSQL));
       int param_count= mysql_stmt_param_count(m_stInsertStmt);
       if(param_count != FEILD_NUM)
              return false;
       //填充bind结构数组, m_sInsertParam是这个statement关联的结构变量
       memset(insertbind, 0, sizeof(insertbind));
       insertbind[0].buffer_type = MYSQL_TYPE_STRING;
       insertbind[0].buffer_length = ID_LENGTH /* -1 */;
       insertbind[0].buffer = (char *)m_stInsertParam->sessionid;
       insertbind[0].is_null = 0;
       insertbind[0].length = 0;

       insertbind[1].buffer_type = MYSQL_TYPE_STRING;
       insertbind[1].buffer_length = ID_LENGTH /* -1 */;
       insertbind[1].buffer = (char *)m_stInsertParam->channelid;
       insertbind[1].is_null = 0;
       insertbind[1].length = 0;

       insertbind[2].buffer_type = MYSQL_TYPE_TINY;
       insertbind[2].buffer = (char *)&m_stInsertParam->ISPtype;
       insertbind[2].is_null = 0;
       insertbind[2].length = 0;

       insertbind[3].buffer_type = MYSQL_TYPE_LONG;
       insertbind[3].buffer = (char *)&m_stInsertParam->externalIP;
       insertbind[3].is_null = 0;
       insertbind[3].length = 0;
      
       insertbind[4].buffer_type = MYSQL_TYPE_SHORT;
       insertbind[4].buffer = (char *)&m_stInsertParam->externalPort;
       insertbind[4].is_null = 0;
       insertbind[4].length = 0;

       insertbind[5].buffer_type = MYSQL_TYPE_LONG;
       insertbind[5].buffer = (char *)&m_stInsertParam->internalIP;
       insertbind[5].is_null = 0;
       insertbind[5].length = 0;

       insertbind[6].buffer_type = MYSQL_TYPE_SHORT;
       insertbind[6].buffer = (char *)&m_stInsertParam->internalPort;
       insertbind[6].is_null = 0;
       insertbind[6].is_null = 0;
       //绑定
       if (mysql_stmt_bind_param(m_stInsertStmt, insertbind))
              return false;
       return true;
}

随机的获取记录

　　在某些数据库的应用中, 我们并不是要获取所有的满足条件的记录,而只是要随机挑选出满足条件的记录. 这种情况常见于数据业务的统计分析,从大容量数据库中获取小量的数据的场合.

　　有两种方法可以做到

　　1. 常规方法,首先查询出所有满足条件的记录,然后随机的挑选出部分记录.这种方法在满足条件的记录数很多时效果不理想.

　　2. 使用limit语法,先获取满足条件的记录条数, 然后在sql查询语句中加入limit来限制只查询满足要求的一段记录. 这种方法虽然要查询两次,但是在数据量大时反而比较高效.

　　示例代码如下:

复制内容到剪贴板

代码:

//1.常规的方法
//性能瓶颈,10万条记录时,执行查询140ms, 获取结果集500ms,其余可忽略
int CDBManager::QueryHostCache(MYSQL* connecthandle, char * channelid, int ISPtype, CDBManager::CHostCacheTable * &hostcache)
{     
       char selectSQL[SQL_LENGTH];
       memset(selectSQL, 0, sizeof(selectSQL));
       sprintf(selectSQL,"select * from HostCache where ChannelID = '%s' and ISPtype = %d", channelid, ISPtype);
       if(mysql_real_query(connecthandle, selectSQL, strlen(selectSQL)) != 0)   //检索
              return 0;
       //获取结果集
       m_pResultSet = mysql_store_result(connecthandle);
       if(!m_pResultSet)   //获取结果集出错
              return 0;
       int iAllNumRows = (int)(mysql_num_rows(m_pResultSet));      ///<所有的搜索结果数
       //计算待返回的结果数
       int iReturnNumRows = (iAllNumRows <= RETURN_QUERY_HOST_NUM)? iAllNumRows:RETURN_QUERY_HOST_NUM;
       if(iReturnNumRows <= RETURN_QUERY_HOST_NUM)
       {
              //获取逐条记录
              for(int i = 0; i<iReturnNumRows; i++)
              {
                     //获取逐个字段
                     m_Row = mysql_fetch_row(m_pResultSet);
                     if(m_Row[0] != NULL)
                            strcpy(hostcache[i].sessionid, m_Row[0]);
                     if(m_Row[1] != NULL)
                            strcpy(hostcache[i].channelid, m_Row[1]);
                     if(m_Row[2] != NULL)
                            hostcache[i].ISPtype      = atoi(m_Row[2]);
                     if(m_Row[3] != NULL)
                            hostcache[i].externalIP   = atoi(m_Row[3]);
                     if(m_Row[4] != NULL)
                            hostcache[i].externalPort = atoi(m_Row[4]);
                     if(m_Row[5] != NULL)
                            hostcache[i].internalIP   = atoi(m_Row[5]);
                     if(m_Row[6] != NULL)
                            hostcache[i].internalPort = atoi(m_Row[6]);              
              }
       }
       else
       {
              //随机的挑选指定条记录返回
              int iRemainder = iAllNumRows%iReturnNumRows;    ///<余数
              int iQuotient = iAllNumRows/iReturnNumRows;      ///<商
              int iStartIndex = rand()%(iRemainder + 1);         ///<开始下标  
              //获取逐条记录
        for(int iSelectedIndex = 0; iSelectedIndex < iReturnNumRows; iSelectedIndex++)
        {
                            mysql_data_seek(m_pResultSet, iStartIndex + iQuotient * iSelectedIndex);
                            m_Row = mysql_fetch_row(m_pResultSet);
                  if(m_Row[0] != NULL)
                       strcpy(hostcache[iSelectedIndex].sessionid, m_Row[0]);
                   if(m_Row[1] != NULL)
                                   strcpy(hostcache[iSelectedIndex].channelid, m_Row[1]);
                   if(m_Row[2] != NULL)
                       hostcache[iSelectedIndex].ISPtype      = atoi(m_Row[2]);
                   if(m_Row[3] != NULL)
                       hostcache[iSelectedIndex].externalIP   = atoi(m_Row[3]);
                    if(m_Row[4] != NULL)
                       hostcache[iSelectedIndex].externalPort = atoi(m_Row[4]);
                   if(m_Row[5] != NULL)
                       hostcache[iSelectedIndex].internalIP   = atoi(m_Row[5]);
                   if(m_Row[6] != NULL)
                       hostcache[iSelectedIndex].internalPort = atoi(m_Row[6]);
        }
      }
       //释放结果集内容
       mysql_free_result(m_pResultSet);
       return iReturnNumRows;
}

//2.使用limit版
int CDBManager::QueryHostCache(MYSQL * connecthandle, char * channelid, unsigned int myexternalip, int ISPtype, CHostCacheTable * hostcache)
{
       //首先获取满足结果的记录条数,再使用limit随机选择指定条记录返回
       MYSQL_ROW row;
       MYSQL_RES * pResultSet;
       char selectSQL[SQL_LENGTH];
       memset(selectSQL, 0, sizeof(selectSQL));

       sprintf(selectSQL,"select count(*) from HostCache where ChannelID = '%s' and ISPtype = %d", channelid, ISPtype);
       if(mysql_real_query(connecthandle, selectSQL, strlen(selectSQL)) != 0)   //检索
              return 0;
       pResultSet = mysql_store_result(connecthandle);
       if(!pResultSet)      
              return 0;
       row = mysql_fetch_row(pResultSet);
       int iAllNumRows = atoi(row[0]);
       mysql_free_result(pResultSet);
       //计算待取记录的上下范围
       int iLimitLower = (iAllNumRows <= RETURN_QUERY_HOST_NUM)?
              0:(rand()%(iAllNumRows - RETURN_QUERY_HOST_NUM));
       int iLimitUpper = (iAllNumRows <= RETURN_QUERY_HOST_NUM)?
              iAllNumRows:(iLimitLower + RETURN_QUERY_HOST_NUM);
       //计算待返回的结果数
       int iReturnNumRows = (iAllNumRows <= RETURN_QUERY_HOST_NUM)?
               iAllNumRows:RETURN_QUERY_HOST_NUM;
      
       //使用limit作查询
       sprintf(selectSQL,"select SessionID, ExternalIP, ExternalPort, InternalIP, InternalPort "
              "from HostCache where ChannelID = '%s' and ISPtype = %d limit %d, %d"
              , channelid, ISPtype, iLimitLower, iLimitUpper);
       if(mysql_real_query(connecthandle, selectSQL, strlen(selectSQL)) != 0)   //检索
              return 0;
       pResultSet = mysql_store_result(connecthandle);
       if(!pResultSet)
              return 0;
       //获取逐条记录
       for(int i = 0; i<iReturnNumRows; i++)
       {
              //获取逐个字段
              row = mysql_fetch_row(pResultSet);
              if(row[0] != NULL)
                     strcpy(hostcache[i].sessionid, row[0]);
              if(row[1] != NULL)
                     hostcache[i].externalIP   = atoi(row[1]);
              if(row[2] != NULL)
                     hostcache[i].externalPort = atoi(row[2]);
              if(row[3] != NULL)
                     hostcache[i].internalIP   = atoi(row[3]);
              if(row[4] != NULL)
                     hostcache[i].internalPort = atoi(row[4]);            
       }
       //释放结果集内容
       mysql_free_result(pResultSet);
       return iReturnNumRows;
}

使用连接池管理连接.

　　在有大量节点访问的数据库设计中,经常要使用到连接池来管理所有的连接.

　　一般方法是:建立两个连接句柄队列,空闲的等待使用的队列和正在使用的队列.

　　当要查询时先从空闲队列中获取一个句柄,插入到正在使用的队列,再用这个句柄做数据库操作,完毕后一定要从使用队列中删除,再插入到空闲队列.

　　设计代码如下:

复制内容到剪贴板

代码:

//定义句柄队列
typedef std::list<MYSQL *> CONNECTION_HANDLE_LIST;
typedef std::list<MYSQL *>::iterator CONNECTION_HANDLE_LIST_IT;

//连接数据库的参数结构
class CDBParameter            
{
public:
       char *host;                                 ///<主机名
       char *user;                                 ///<用户名
       char *password;                         ///<密码
       char *database;                           ///<数据库名
       unsigned int port;                 ///<端口，一般为0
       const char *unix_socket;      ///<套接字，一般为NULL
       unsigned int client_flag; ///<一般为0
};

//创建两个队列
CONNECTION_HANDLE_LIST m_lsBusyList;                ///<正在使用的连接句柄
CONNECTION_HANDLE_LIST m_lsIdleList;                  ///<未使用的连接句柄

//所有的连接句柄先连上数据库,加入到空闲队列中,等待使用.
bool CDBManager::Connect(char * host /* = "localhost" */, char * user /* = "chenmin" */, \
                                           char * password /* = "chenmin" */, char * database /* = "HostCache" */)
{
       CDBParameter * lpDBParam = new CDBParameter();
       lpDBParam->host = host;
       lpDBParam->user = user;
       lpDBParam->password = password;
       lpDBParam->database = database;
       lpDBParam->port = 0;
       lpDBParam->unix_socket = NULL;
       lpDBParam->client_flag = 0;
       try
       {
              //连接
              for(int index = 0; index < CONNECTION_NUM; index++)
              {
                     MYSQL * pConnectHandle = mysql_init((MYSQL*) 0);     //初始化连接句柄
                     if(!mysql_real_connect(pConnectHandle, lpDBParam->host, lpDBParam->user, lpDBParam->password,\
       lpDBParam->database,lpDBParam->port,lpDBParam->unix_socket,lpDBParam->client_fla))
                            return false;
//加入到空闲队列中
                     m_lsIdleList.push_back(pConnectHandle);
              }
       }
       catch(...)
       {
              return false;
       }
       return true;
}

//提取一个空闲句柄供使用
MYSQL * CDBManager::GetIdleConnectHandle()
{
       MYSQL * pConnectHandle = NULL;
       m_ListMutex.acquire();
       if(m_lsIdleList.size())
       {
              pConnectHandle = m_lsIdleList.front();      
              m_lsIdleList.pop_front();
              m_lsBusyList.push_back(pConnectHandle);
       }
       else //特殊情况,闲队列中为空,返回为空
       {
              pConnectHandle = 0;
       }
       m_ListMutex.release();

       return pConnectHandle;
}

//从使用队列中释放一个使用完毕的句柄,插入到空闲队列
void CDBManager::SetIdleConnectHandle(MYSQL * connecthandle)
{
       m_ListMutex.acquire();
       m_lsBusyList.remove(connecthandle);
       m_lsIdleList.push_back(connecthandle);
       m_ListMutex.release();
}
//使用示例,首先获取空闲句柄,利用这个句柄做真正的操作,然后再插回到空闲队列
bool CDBManager::DeleteHostCacheBySessionID(char * sessionid)
{
       MYSQL * pConnectHandle = GetIdleConnectHandle();
       if(!pConnectHandle)
              return 0;
       bool bRet = DeleteHostCacheBySessionID(pConnectHandle, sessionid);
       SetIdleConnectHandle(pConnectHandle);
       return bRet;
}
//传入空闲的句柄,做真正的删除操作
bool CDBManager::DeleteHostCacheBySessionID(MYSQL * connecthandle, char * sessionid)
{
       char deleteSQL[SQL_LENGTH];
       memset(deleteSQL, 0, sizeof(deleteSQL));
       sprintf(deleteSQL,"delete from HostCache where SessionID = '%s'", sessionid);
       if(mysql_query(connecthandle,deleteSQL) != 0) //删除
              return false;
       return true;
}