在实现缓存排序功能之前，必须先明白这一功能的合理性。不妨思考一下，既然可以在数据库中排序，为什么还要把排序功能放在缓存中实现呢？这里简单总结了两个原因：首先，排序会增加数据库的负载，难以支撑高并发的应用；其次，在缓存中排序不会遇到表锁定的问题。Redis恰好提供了排序功能，使我们可以方便地实现缓存排序。

        Redis中用于实现排序功能的是SORT命令。该命令提供了多种参数，可以对列表，集合和有序集合进行排序。SORT命令格式如下：

SORT key [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC | DESC] [ALPHA] [STORE destination]

SORT resultset.hash:123456 BY *->timestamp

        LIMIT参数用于限制排序以后返回元素的数量，功能类似于SQL中的limit。该参数接受另外两个参数，即offset和count，LIMIT offset count表示跳过前offset个元素，返回之后的连续count个元素。可见，LIMIT参数可以用于实现分页功能。

        GET参数用于返回指定的字段值。以集合resultset.hash:123456为例，使用BY参数对集合中的所有哈希键按照哈希结构中的timestamp字段排序后，SORT命令返回所有排序之后的哈希键。如果某个请求需要不是键而是某些字段值，这时就要使用GET参数，使SORT命令返回指定字段值。假设除timestamp字段以外，集合中每个哈希键对应的哈希结构中还有一个名为“id”的字段，通过以下命令可以使SORT返回按照timestamp排序以后的每个哈希键对应的哈希结构中的timestamp和id值：

[plain] view plaincopyprint?

1. SORT resultset.hash:123456 BY *->timestamp GET *->timestamp GET *->id  

SORT resultset.hash:123456 BY *->timestamp GET *->timestamp GET *->id

        ASC和DESC参数用于指定排序顺序（默认为ASC，即从低到高），ALPHA参数用于按照字典顺序排列非数字元素。

        STORE参数用于将SORT命令的返回值，即排序结果存入一个指定的列表。加上STORE参数后，SORT命令的返回值就变为排序结果的个数。

        下面的代码实现了按照哈希的某个字段对集合中的哈希键排序，并将结果存入列表的过程：

[cpp] view plaincopyprint?

1. // 该函数对集合中的所有HASH键进行排序，排序依据是HASH键所对应的HASH中的某个字段，  
2. // 排序结果被存入一个LIST结构，LIST键应当包含结果集标识符和排序字段标识符，  
3. // 形如“sorted:123456:1234”  
4. string SortHash(sql::Connection *mysql_connection,  
5.                 redisContext *redis_connection,   
6.                 const string &resultset_id,   
7.                 const string &sort_field,   
8.                 int offset, int count, int order, int ttl) {  
9.   // 只考虑存储HASH键的SET  
10.   string redis_row_set_key = "resultset.hash:" + resultset_id;  
11.   redisReply *reply;  
12.   // 检测SET是否存在  
13.   reply = static_cast<redisReply*>(redisCommand(redis_connection,   
14.                                                "EXISTS %s",  
15.                                                redis_row_set_key.c_str()));  
16.   if (reply->integer == 0) {  
17.     freeReplyObject(reply);  
18.     throw runtime_error("FAILURE - no resultsets");  
19.   } else {  
20.     freeReplyObject(reply);  
21.   }  
22.   string field_md5 = md5(sort_field);  // 利用MD5排除排序字段中空格造成的影响   
23.   // 将排序结果存入该LIST  
24.   string redis_sorted_list_key = "sorted:" + resultset_id + ":" + field_md5;  
25.   string by("*->" + sort_field);  //确定排序字段  
26.   string ord = (order == 1) ? "ASC" : "DESC";  //order==1时按照升序排列；否则为降序  
27.   stringstream ofsstream, cntstream;  
28.   ofsstream << offset;  
29.   cntstream << count;  
30.   // 执行排序命令，并把排序结果存入LIST  
31.   reply = static_cast<redisReply*>(redisCommand(  
32.                                       redis_connection,   
33.                                       "SORT %s BY %s LIMIT %s %s GET %s ALPHA STORE %s",  
34.                                       redis_row_set_key.c_str(),   
35.                                       by.c_str(),   
36.                                       ofsstream.str().c_str(),   
37.                                       cntstream.str().c_str(),   
38.                                       "#",   
39.                                       redis_sorted_list_key.c_str()));  
40.   freeReplyObject(reply);  
41.   stringstream ttlstream;  
42.   ttlstream << ttl;  
43.   // 设置LIST的过期时间  
44.   reply = static_cast<redisReply*>(redisCommand(redis_connection,   
45.                                                "EXPIRE %s %s",  
46.                                    redis_sorted_list_key.c_str(),   
47.                                                ttlstream.str().c_str()));  
48.   freeReplyObject(reply);  
49.   return redis_sorted_list_key;  // 返回LIST键，以便于其他函数获取该LIST中的内容  

// 该函数对集合中的所有HASH键进行排序，排序依据是HASH键所对应的HASH中的某个字段，
// 排序结果被存入一个LIST结构，LIST键应当包含结果集标识符和排序字段标识符，
// 形如“sorted:123456:1234”
string SortHash(sql::Connection *mysql_connection,
                redisContext *redis_connection, 
                const string &resultset_id, 
                const string &sort_field, 
                int offset, int count, int order, int ttl) {
  // 只考虑存储HASH键的SET
  string redis_row_set_key = "resultset.hash:" + resultset_id;
  redisReply *reply;
  // 检测SET是否存在
  reply = static_cast<redisReply*>(redisCommand(redis_connection, 
                                               "EXISTS %s",
                                               redis_row_set_key.c_str()));
  if (reply->integer == 0) {
    freeReplyObject(reply);
    throw runtime_error("FAILURE - no resultsets");
  } else {
    freeReplyObject(reply);
  }
  string field_md5 = md5(sort_field);  // 利用MD5排除排序字段中空格造成的影响 
  // 将排序结果存入该LIST
  string redis_sorted_list_key = "sorted:" + resultset_id + ":" + field_md5;
  string by("*->" + sort_field);  //确定排序字段
  string ord = (order == 1) ? "ASC" : "DESC";  //order==1时按照升序排列；否则为降序
  stringstream ofsstream, cntstream;
  ofsstream << offset;
  cntstream << count;
  // 执行排序命令，并把排序结果存入LIST
  reply = static_cast<redisReply*>(redisCommand(
                                      redis_connection, 
                                      "SORT %s BY %s LIMIT %s %s GET %s ALPHA STORE %s",
                                      redis_row_set_key.c_str(), 
                                      by.c_str(), 
                                      ofsstream.str().c_str(), 
                                      cntstream.str().c_str(), 
                                      "#", 
                                      redis_sorted_list_key.c_str()));
  freeReplyObject(reply);
  stringstream ttlstream;
  ttlstream << ttl;
  // 设置LIST的过期时间
  reply = static_cast<redisReply*>(redisCommand(redis_connection, 
                                               "EXPIRE %s %s",
                       redis_sorted_list_key.c_str(), 
                                               ttlstream.str().c_str()));
  freeReplyObject(reply);
  return redis_sorted_list_key;  // 返回LIST键，以便于其他函数获取该LIST中的内容

[cpp] view plaincopyprint?

1. // 该函数根据sql语句和排序参数，在Redis中查询相应的结果集并进行排序，最后返回  
2. // 排序之后的HASH键  
3. vector<string> GetSortedCache(sql::Connection *mysql_connection,  
4.                               redisContext *redis_connection,  
5.                               const string &sql, const string &sort_field,   
6.                               int offset, int count, int order, int ttl) {  
7.   vector<string> redis_row_key_vector;  
8.   redisReply *reply;  
9.   string resultset_id = md5(sql);  // 结果集标识符  
10.   string field_md5 = md5(sort_field);  // 排序字段标识符  
11.   // 尝试获取LIST中的所有HASH键  
12.   string redis_sorted_list_key = "sorted:" + resultset_id + ":" + field_md5;  
13.   // 尝试获取LIST中的所有HASH键  
14.   reply = static_cast<redisReply*>(redisCommand(redis_connection,   
15.                                                "LRANGE %s %s %s",  
16.                                                redis_sorted_list_key.c_str(),   
17.                                                "0",   
18.                                                "-1"));  
19.   if (reply->type == REDIS_REPLY_ARRAY) {  
20.     // 如果LIST不存在，调用Cache2Hash函数从Mysql中拉取数据到Redis，然后调用SortHash函数  
21.     // 对结果集进行排序并将排序后的HASH键存入LIST  
22.     if (reply->elements == 0) {   
23.       freeReplyObject(reply);  
24.       sql::Statement *stmt = mysql_connection->createStatement();  
25.       sql::ResultSet *resultset = stmt->executeQuery(sql);  
26.       Cache2Hash(mysql_connection, redis_connection, resultset,   
27.                  resultset_id, ttl);  
28.       redis_sorted_list_key = SortHash(mysql_connection, redis_connection,   
29.                                        resultset_id, sort_field, offset,   
30.                                        count, order, ttl);  
31.       // 再次尝试获取LIST中的所有HASH键  
32.       reply = static_cast<redisReply*>(redisCommand(  
33.                                           redis_connection,   
34.                                           "LRANGE %s %s %s",  
35.                                           redis_sorted_list_key.c_str(),   
36.                                           "0",   
37.                                           "-1"));  
38.       delete resultset;  
39.       delete stmt;  
40.     }  
41.     // 将LIST中的所有HASH键存入redis_row_key_vector中  
42.     string redis_row_key;  
43.     for (int i = 0; i < reply->elements; ++i) {  
44.       redis_row_key = reply->element[i]->str;  
45.       redis_row_key_vector.push_back(redis_row_key);  
46.     }  
47.     freeReplyObject(reply);  
48.   } else {  
49.     freeReplyObject(reply);  
50.     throw runtime_error("FAILURE - LRANGE error");  
51.   }  
52.   return redis_row_key_vector;  
53. }  

// 该函数根据sql语句和排序参数，在Redis中查询相应的结果集并进行排序，最后返回
// 排序之后的HASH键
vector<string> GetSortedCache(sql::Connection *mysql_connection,
                              redisContext *redis_connection,
                              const string &sql, const string &sort_field, 
                              int offset, int count, int order, int ttl) {
  vector<string> redis_row_key_vector;
  redisReply *reply;
  string resultset_id = md5(sql);  // 结果集标识符
  string field_md5 = md5(sort_field);  // 排序字段标识符
  // 尝试获取LIST中的所有HASH键
  string redis_sorted_list_key = "sorted:" + resultset_id + ":" + field_md5;
  // 尝试获取LIST中的所有HASH键
  reply = static_cast<redisReply*>(redisCommand(redis_connection, 
                                               "LRANGE %s %s %s",
                                               redis_sorted_list_key.c_str(), 
                                               "0", 
                                               "-1"));
  if (reply->type == REDIS_REPLY_ARRAY) {
    // 如果LIST不存在，调用Cache2Hash函数从Mysql中拉取数据到Redis，然后调用SortHash函数
    // 对结果集进行排序并将排序后的HASH键存入LIST
    if (reply->elements == 0) { 
      freeReplyObject(reply);
      sql::Statement *stmt = mysql_connection->createStatement();
      sql::ResultSet *resultset = stmt->executeQuery(sql);
      Cache2Hash(mysql_connection, redis_connection, resultset, 
                 resultset_id, ttl);
      redis_sorted_list_key = SortHash(mysql_connection, redis_connection, 
                                       resultset_id, sort_field, offset, 
                                       count, order, ttl);
      // 再次尝试获取LIST中的所有HASH键
      reply = static_cast<redisReply*>(redisCommand(
                                          redis_connection, 
                                          "LRANGE %s %s %s",
                                          redis_sorted_list_key.c_str(), 
                                          "0", 
                                          "-1"));
      delete resultset;
      delete stmt;
    }
    // 将LIST中的所有HASH键存入redis_row_key_vector中
    string redis_row_key;
    for (int i = 0; i < reply->elements; ++i) {
      redis_row_key = reply->element[i]->str;
      redis_row_key_vector.push_back(redis_row_key);
    }
    freeReplyObject(reply);
  } else {
    freeReplyObject(reply);
    throw runtime_error("FAILURE - LRANGE error");
  }
  return redis_row_key_vector;
}

        把Mysql结果集缓存到Redis的字符串或哈希结构中以后，我们面临一个新的问题，即如何为这些字符串或哈希命名，也就是如何确定它们的键。因为这些数据结构所对应的行都属于某个结果集，假如可以找到一种唯一标识结果集的方法，那么只需为这些数据结构分配一个唯一的序号，然后把结果集标识符与该序号结合起来，就能唯一标识一个数据结构了。于是，为字符串和哈希命名的问题就转化为确定结果集标识符的问题。

        经过调研，发现一种较为通用的确定结果集标识符的方法。正如我们所知道的，缓存在Redis中的结果集数据都是利用select等sql语句从Mysql中获取的。同样的查询语句会生成同样的结果集（这里暂时不讨论结果集中每条记录的顺序问题），这一性质刚好可以用来确定结果集的唯一标识符。当然，简单地把整个sql语句作为结果集标识符是不可取的，一个显而易见的理由是，未经处理的sql查询语句均包含若干空格，而Redis的键是不允许存在空格的。这时，我们需要一个可以把sql语句转换为唯一标识符的函数。通常，这一功能由散列函数完成，包括MD5，SHA系列等加密散列函数在内的很多算法均可达到这一目的。

        确定结果集标识符之后，从Redis读数据或向Redis写数据的思路就很清晰了。对于一个sql语句格式的数据请求，首先计算该语句的MD5并据此得到结果集标识符，然后利用该标识符在Redis中查找该结果集。注意，结果集中的每一行都有一个相应的键，这些键都存储在一个Redis集合结构中。这个集合恰好对应了所需的结果集，所以，该集合的键必须包含结果集标识符。如果Redis中不存在这样一个集合，说明要找的结果集不在Redis中，所以需要执行相应的sql语句，在Mysql中查询到相应的结果集，然后按照上面所说的办法把结果集中的每一行以字符串或哈希的形式存入Redis。在Redis中查找相应结果集的代码如下：

// 该函数根据sql语句在Redis中查询相应的结果集，并返回结果集中每一行所对应的数据结构的键
vector<string> GetCache(sql::Connection *mysql_connection,
                      redisContext *redis_connection,
                      const string &sql, int ttl, int type) {
  vector<string> redis_row_key_vector;
  string resultset_id = md5(sql);  // 计算sql语句的md5，这是唯一标识结果集的关键
  // type==1时，该函数将查询相应的STRING集合或将结果集写入若干STRING
  string cache_type = (type == 1) ? "string" : "hash";
  // 根据type信息和结果集标识符合成SET键
  string redis_row_set_key = "resultset." + cache_type + ":" + resultset_id;
  redisReply *reply;
  // 尝试从reply中获取SET中保存的所有键
  reply = static_cast<redisReply*>(redisCommand(redis_connection, 
                                               "SMEMBERS %s",
                                               redis_row_set_key.c_str()));
  if (reply->type == REDIS_REPLY_ARRAY) {
// 如果要找的SET不存在，说明Redis中没有相应的结果集，需要调用Cache2String或
// Cache2Hash函数把数据从Mysql拉取到Redis中
    if (reply->elements == 0) {
      freeReplyObject(reply);
      sql::Statement *stmt = mysql_connection->createStatement();
      sql::ResultSet *resultset = stmt->executeQuery(sql);
      if (type == 1) {
        redis_row_set_key = Cache2String(mysql_connection, redis_connection,
                                         resultset, resultset_id, ttl);
      } else {
        redis_row_set_key = Cache2Hash(mysql_connection, redis_connection, 
                                       resultset, resultset_id, ttl);
      }
  // 再次尝试从reply中获取SET中保存的所有键
      reply = static_cast<redisReply*>(redisCommand(redis_connection, 
                                                   "SMEMBERS %s",
                                                   redis_row_set_key.c_str()));
      delete resultset;
      delete stmt;
    }
// 把SET中的每个STRING或HASH键存入redis_row_key_vector中
    string redis_row_key;
    for (int i = 0; i < reply->elements; ++i) {
      redis_row_key = reply->element[i]->str;
      redis_row_key_vector.push_back(redis_row_key);
    }
    freeReplyObject(reply);
  } else {
    freeReplyObject(reply);
    throw runtime_error("FAILURE - SMEMBERS error");
  }
  return redis_row_key_vector;
}

        用Redis作Mysql数据库缓存，必须解决2个问题。首先，应该确定用何种数据结构存储来自Mysql的数据；在确定数据结构之后，还要考虑用什么标识作为该数据结构的键。

        直观上看，Mysql中的数据都是按表存储的；更微观地看，这些表都是按行存储的。每执行一次select查询，Mysql都会返回一个结果集，这个结果集由若干行组成。所以，一个自然而然的想法就是在Redis中找到一种对应于Mysql行的数据结构。Redis中提供了五种基本数据结构，即字符串（string）、列表（list）、哈希（hash）、集合（set）和有序集合（sorted set）。经过调研，发现适合存储行的数据结构有两种，即string和hash。

        要把Mysql的行数据存入string，首先需要对行数据进行格式化。事实上，结果集的每一行都可以看做若干由字段名和其对应值组成的键值对集合。这种键值对结构很容易让我们想起Json格式。因此，这里选用Json格式作为结果集每一行的格式化模板。根据这一想法，我们可以实现将结果集格式化为若干Json对象，并将Json对象转化为字符串存入Redis的代码：

[cpp] view plaincopyprint?

1. // 该函数把结果集中的每一行转换为一个Json格式的字符串并存入Redis的STRING结构中，  
2. // STRING键应该包含结果集标识符和STRING编号，形式如“cache.string:123456:1”  
3. string Cache2String(sql::Connection *mysql_connection,  
4.                     redisContext *redis_connection,  
5.                     sql::ResultSet *resultset,  
6.                     const string &resultset_id, int ttl) {  
7.   if (resultset->rowsCount() == 0) {  
8.     throw runtime_error("FAILURE - no rows");  
9.   }  
10.   // STRING键的前缀，包含了结果集的标识符  
11.   string prefix("cache.string:" + resultset_id + ":");  
12.   unsigned int num_row = 1;  // STRING编号，附加于STRING键的末尾，从1开始  
13.   sql::ResultSetMetaData *meta = resultset->getMetaData();  
14.   unsigned int num_col = meta->getColumnCount();  
15.   // 将结果集中所有行对应的所有STRING键存入该SET，SET键包含了结果集的标识符  
16.   string redis_row_set_key("resultset.string:" + resultset_id);  
17.   redisReply *reply;  
18.   string ttlstr;  
19.   stringstream ttlstream;  
20.   ttlstream << ttl;  
21.   ttlstr = ttlstream.str();  
22.   resultset->beforeFirst();  
23.   // 将结果集中的每一行转为Json格式的字符串，将这些Json字符串存入STRING，  
24.   // 每个STRING对应结果集中的一行  
25.   while (resultset->next()) {  
26.     string redis_row_key;  // STRING键名，由前缀和STRING编号组成  
27.     stringstream keystream;  
28.     keystream << prefix << num_row;  
29.     redis_row_key = keystream.str();  
30.     Json::Value row;  
31.     for (int i = 1; i <= num_col; ++i) {  
32.       string col_label = meta->getColumnLabel(i);  
33.       string col_value = resultset->getString(col_label);  
34.       row[col_label] = col_value;  
35.     }  
36.     Json::FastWriter writer;  
37.     string redis_row_value = writer.write(row);  
38.     // 将STRING键及Json格式的对应值对存入Redis  
39.     reply = static_cast<redisReply*>(redisCommand(redis_connection,   
40.                                                  "SET %s %s",  
41.                                                  redis_row_key.c_str(),   
42.                                                  redis_row_value.c_str()));  
43.     freeReplyObject(reply);  
44.     // 将STRING键加入SET中  
45.     reply = static_cast<redisReply*>(redisCommand(redis_connection,   
46.                                                  "SADD %s %s",  
47.                                                  redis_row_set_key.c_str(),   
48.                                                  redis_row_key.c_str()));  
49.     freeReplyObject(reply);  
50.     // 设置STRING的过期时间  
51.     reply = static_cast<redisReply*>(redisCommand(redis_connection,   
52.                                                  "EXPIRE %s %s",  
53.                                                  redis_row_key.c_str(),   
54.                                                  ttlstr.c_str()));  
55.     freeReplyObject(reply);  
56.     ++num_row;  
57.   }  
58.   // 设置SET的过期时间  
59.   reply = static_cast<redisReply*>(redisCommand(redis_connection,   
60.                                                "EXPIRE %s %s",  
61.                                                redis_row_set_key.c_str(),   
62.                                                ttlstr.c_str()));  
63.   freeReplyObject(reply);  
64.   return redis_row_set_key;  // 返回SET键，以便于其他函数获取该SET中的内容  
65. }  

// 该函数把结果集中的每一行转换为一个Json格式的字符串并存入Redis的STRING结构中，
// STRING键应该包含结果集标识符和STRING编号，形式如“cache.string:123456:1”
string Cache2String(sql::Connection *mysql_connection,
                    redisContext *redis_connection,
                    sql::ResultSet *resultset,
                    const string &resultset_id, int ttl) {
  if (resultset->rowsCount() == 0) {
    throw runtime_error("FAILURE - no rows");
  }
  // STRING键的前缀，包含了结果集的标识符
  string prefix("cache.string:" + resultset_id + ":");
  unsigned int num_row = 1;  // STRING编号，附加于STRING键的末尾，从1开始
  sql::ResultSetMetaData *meta = resultset->getMetaData();
  unsigned int num_col = meta->getColumnCount();
  // 将结果集中所有行对应的所有STRING键存入该SET，SET键包含了结果集的标识符
  string redis_row_set_key("resultset.string:" + resultset_id);
  redisReply *reply;
  string ttlstr;
  stringstream ttlstream;
  ttlstream << ttl;
  ttlstr = ttlstream.str();
  resultset->beforeFirst();
  // 将结果集中的每一行转为Json格式的字符串，将这些Json字符串存入STRING，
  // 每个STRING对应结果集中的一行
  while (resultset->next()) {
    string redis_row_key;  // STRING键名，由前缀和STRING编号组成
    stringstream keystream;
    keystream << prefix << num_row;
    redis_row_key = keystream.str();
    Json::Value row;
    for (int i = 1; i <= num_col; ++i) {
      string col_label = meta->getColumnLabel(i);
      string col_value = resultset->getString(col_label);
      row[col_label] = col_value;
    }
    Json::FastWriter writer;
    string redis_row_value = writer.write(row);
// 将STRING键及Json格式的对应值对存入Redis
    reply = static_cast<redisReply*>(redisCommand(redis_connection, 
                                                 "SET %s %s",
                                                 redis_row_key.c_str(), 
                                                 redis_row_value.c_str()));
    freeReplyObject(reply);
    // 将STRING键加入SET中
    reply = static_cast<redisReply*>(redisCommand(redis_connection, 
                                                 "SADD %s %s",
                                                 redis_row_set_key.c_str(), 
                                                 redis_row_key.c_str()));
    freeReplyObject(reply);
    // 设置STRING的过期时间
    reply = static_cast<redisReply*>(redisCommand(redis_connection, 
                                                 "EXPIRE %s %s",
                                                 redis_row_key.c_str(), 
                                                 ttlstr.c_str()));
    freeReplyObject(reply);
    ++num_row;
  }
  // 设置SET的过期时间
  reply = static_cast<redisReply*>(redisCommand(redis_connection, 
                                               "EXPIRE %s %s",
                                               redis_row_set_key.c_str(), 
                                               ttlstr.c_str()));
  freeReplyObject(reply);
  return redis_row_set_key;  // 返回SET键，以便于其他函数获取该SET中的内容
}

        要把Mysql的行数据存入hash，过程要比把数据存入string直观很多。这是由hash的结构性质决定的——hash本身就是一个键值对集合：一个“父键”下面包含了很多“子键”，每个“子键”都对应一个值。根据前面的分析可知，结果集中的每一行实际上也是键值对集合。用Redis键值对集合表示Mysql键值对集合应该再合适不过了：对于结果集中的某一行，字段对应于hash的“子键”，字段对应的值就是hash“子键”对应的值，即结果集的一行刚好对应一个hash。这一想法的实现代码如下：

[cpp] view plaincopyprint?

1. // 该函数把结果集中的每一行都存入一个HASH结构。HASH键应当包括结果集标识符和HASH编号，  
2. // 形如“cache.string:123456:1”  
3. string Cache2Hash(sql::Connection *mysql_connection,  
4.                   redisContext *redis_connection,  
5.                   sql::ResultSet *resultset,  
6.                   const string &resultset_id, int ttl) {  
7.   if (resultset->rowsCount() == 0) {  
8.     throw runtime_error("FAILURE - no rows");  
9.   }  
10.   // HASH键的前缀，包含了结果集的标识符  
11.   string prefix("cache.hash:" + resultset_id + ":");  
12.   unsigned int num_row = 1;  // HASH编号，附加于HASH键的末尾，从1开始  
13.   sql::ResultSetMetaData *meta = resultset->getMetaData();  
14.   unsigned int num_col = meta->getColumnCount();  
15.   // 将结果集中所有行对应的所有HASH键存入该SET，SET键包含了结果集的标识符  
16.   string redis_row_set_key("resultset.hash:" + resultset_id);  
17.   redisReply *reply;  
18.   string ttlstr;  
19.   stringstream ttlstream;  
20.   ttlstream << ttl;  
21.   ttlstr = ttlstream.str();  
22.   // 结果集中的每一行对应于一个HASH，将结果集的所有行都存入相应HASH中  
23.   resultset->beforeFirst();  
24.   while (resultset->next()) {  
25.     string redis_row_key;  // HASH键名，由前缀和HASH编号组成  
26.     stringstream keystream;  
27.     keystream << prefix << num_row;  
28.     redis_row_key = keystream.str();  
29.     for (int i = 1; i <= num_col; ++i) {  
30.       string col_label = meta->getColumnLabel(i);  
31.       string col_value = resultset->getString(col_label);  
32.       // 将结果集中一行的字段名和对应值存入HASH  
33.       reply = static_cast<redisReply*>(redisCommand(redis_connection,  
34.                                                    "HSET %s %s %s",  
35.                                                    redis_row_key.c_str(),   
36.                                                    col_label.c_str(),  
37.                                                    col_value.c_str()));  
38.       freeReplyObject(reply);  
39.     }  
40.     // 将HASH键加入SET中  
41.     reply = static_cast<redisReply*>(redisCommand(redis_connection,   
42.                                                  "SADD %s %s",  
43.                                                  redis_row_set_key.c_str(),   
44.                                                  redis_row_key.c_str()));   
45.     freeReplyObject(reply);  
46.     // 设置HASH的过期时间  
47.     reply = static_cast<redisReply*>(redisCommand(redis_connection,   
48.                                                  "EXPIRE %s %s",  
49.                                                  redis_row_key.c_str(),   
50.                                                  ttlstr.c_str()));  
51.     freeReplyObject(reply);  
52.     ++num_row;  
53.   }  
54.   // 设置SET的过期时间  
55.   reply = static_cast<redisReply*>(redisCommand(redis_connection,   
56.                                                "EXPIRE %s %s",  
57.                                                redis_row_set_key.c_str(),   
58.                                                ttlstr.c_str()));  
59.   freeReplyObject(reply);  
60.   return redis_row_set_key;  // 返回SET键，以便于其他函数获取该SET中的内容  
61. }  

// 该函数把结果集中的每一行都存入一个HASH结构。HASH键应当包括结果集标识符和HASH编号，
// 形如“cache.string:123456:1”
string Cache2Hash(sql::Connection *mysql_connection,
                  redisContext *redis_connection,
                  sql::ResultSet *resultset,
                  const string &resultset_id, int ttl) {
  if (resultset->rowsCount() == 0) {
    throw runtime_error("FAILURE - no rows");
  }
  // HASH键的前缀，包含了结果集的标识符
  string prefix("cache.hash:" + resultset_id + ":");
  unsigned int num_row = 1;  // HASH编号，附加于HASH键的末尾，从1开始
  sql::ResultSetMetaData *meta = resultset->getMetaData();
  unsigned int num_col = meta->getColumnCount();
  // 将结果集中所有行对应的所有HASH键存入该SET，SET键包含了结果集的标识符
  string redis_row_set_key("resultset.hash:" + resultset_id);
  redisReply *reply;
  string ttlstr;
  stringstream ttlstream;
  ttlstream << ttl;
  ttlstr = ttlstream.str();
  // 结果集中的每一行对应于一个HASH，将结果集的所有行都存入相应HASH中
  resultset->beforeFirst();
  while (resultset->next()) {
    string redis_row_key;  // HASH键名，由前缀和HASH编号组成
    stringstream keystream;
    keystream << prefix << num_row;
    redis_row_key = keystream.str();
    for (int i = 1; i <= num_col; ++i) {
      string col_label = meta->getColumnLabel(i);
      string col_value = resultset->getString(col_label);
  // 将结果集中一行的字段名和对应值存入HASH
      reply = static_cast<redisReply*>(redisCommand(redis_connection,
                                                   "HSET %s %s %s",
                                                   redis_row_key.c_str(), 
                                                   col_label.c_str(),
                                                   col_value.c_str()));
      freeReplyObject(reply);
    }
// 将HASH键加入SET中
    reply = static_cast<redisReply*>(redisCommand(redis_connection, 
                                                 "SADD %s %s",
                                                 redis_row_set_key.c_str(), 
                                                 redis_row_key.c_str())); 
    freeReplyObject(reply);
// 设置HASH的过期时间
    reply = static_cast<redisReply*>(redisCommand(redis_connection, 
                                                 "EXPIRE %s %s",
                                                 redis_row_key.c_str(), 
                                                 ttlstr.c_str()));
    freeReplyObject(reply);
    ++num_row;
  }
  // 设置SET的过期时间
  reply = static_cast<redisReply*>(redisCommand(redis_connection, 
                                               "EXPIRE %s %s",
                                               redis_row_set_key.c_str(), 
                                               ttlstr.c_str()));
  freeReplyObject(reply);
  return redis_row_set_key;  // 返回SET键，以便于其他函数获取该SET中的内容
}

        作为Redis提供的最简单的数据结构，字符串示意图及其常用命令如下图所示：

图1

        可见，Redis字符串类型实际上类似于C++中的map，一个键对应一个值。列表类型则是一种相对高级的数据结构，其示意图和常用命令如下图所示：

图2

        列表实际上由一个双向链表实现，所以在列表两端插入或删除数据效率极高，可以用于实现类似于微博、人人网上的“新鲜事”功能。 Redis提供的一个更有趣的结构称为哈希，其示意图和常用命令如下图所示：

图3

        一个哈希实际上是一组键值对的集合，哈希本身的键是“父键”，哈希中包含的若干字段是“子键”，每个“子键”都有相应的值。“子键”之间并没有一定的联系，但是它们共同组成了一个完整的哈希结构。我们可以把一个哈希看做关系数据库中的一行，哈希的每个子键对应行的一个字段。因此，当把关系数据库中的数据缓存至Redis时，使用哈希结构可能会带来方便。需要注意的是，哈希结构内部的子键之间是没有顺序关系的。Redis提供的另一个无顺序关系的结构是集合，其示意图和常用命令如下图所示：

图4

        集合中的数据满足唯一性和无序性。集合在Redis内部是用哈希表实现的，所以插入和删除操作的时间复杂度均为O(1)。Redis为集合提供了求交并差等运算命令，使用起来非常方便。与集合密切相关的另一个数据结构是有序集合，其示意图和常用命令如下图所示：

图5

        有序集合与集合的最大差异在于有序集合中的每个数据都有一个对应的分数，集合中的元素就是按照这些分数进行排序的。从结构功能和使用方法上来看，有序集合可能是Redis提供的5种数据结构中最高级的一种。

        Redis是一种内存数据库，这使其在数据存取效率方面表现突出。由于内存中的数据时刻面临丢失的危险，Redis提供了两种持久化机制，及时将内存中的数据写入硬盘。第一种机制为RDB，利用存储快照的方式把内存数据定期写入硬盘；第二种机制为AOF，利用写日志的方式，每执行一条更改Redis数据的命令，就在日志里附加上该命令并保存在硬盘上。Redis默认开启RDB模式，关闭AOF模式，这是因为AOF更加耗时。但是，如果对数据安全要求极高，无法承担任何数据丢失的后果，AOF模式就变成了持久化的首选。

        当然，即使Redis具备持久化机制，但是一旦本地硬盘损坏，数据丢失依然在所难免。所以，Redis又提供了复制功能，作用是将一个主数据库（master）的数据自动同步到多个从数据库（slave），从而尽可能防止数据丢失。Redis主从机制可以简单描述为：从数据库启动后，先向主数据库发送SYNC命令；主数据库接到SYNC命令后就开始保存快照，在此期间，所有发给主数据库的命令都被缓存起来；快照保存完成后，主数据库把快照和缓存的命令一起发给从数据库；从数据库保存主数据库发来的快照文件，并依次执行主数据库发来的缓存命令。在同步过程中，从数据库不会阻塞，它默认使用同步之前的数据继续响应客户端发来的命令。

        事务是Redis提供的特性之一。首先利用MULTI命令通知Redis，接下来的若干命令属于同一事务；然后输入若干命令，这些命令都被放入命令队列而不会被立即执行；最后，利用EXEC命令通知Redis，属于同一事务的所有命令均已输入完成，现在开始执行该事物。属于同一个事务的所有有效命令或者全部被执行，或者全部不执行，且在执行过程中不会插入其他命令。管道（pipeline）是Redis提供的另一个特性。该特性使Redis能够一次性接收多个命令，执行之后再一次性返回结果。这样能够减少客户端与Redis服务器的通信次数，从而降低往返时延。

        除事务和管道以外，Redis还提供了很多其他特性，如设置键的过期时间，利用BLPOP/BRPOP命令实现优先级队列，利用PUBLISH/SUBSCRIBE命令实现消息订阅和发布等，这里不再赘述。

        Redis由ANSI C写成，能够运行在包括Linux和OS X在内的大部分POSIX系统上，官方推荐的操作系统为Linux。Redis没有官方的Windows版本，但是微软移植并维护了一个能够运行在Windows上的Redis并放在github上（https://github.com/MSOpenTech/redis）。

        Redis的编程接口被称为客户端（clients），绝大部分主流编程语言都有官方推荐的客户端。下图中，具有Redis官方推荐客户端的语言标为绿色，没有官方推荐客户端的标为蓝色：

图6

        由于Redis没有官方推荐的C++客户端，因此可以使用C客户端予以代替。官方推荐的C客户端是hiredis，可以从github上找到（https://github.com/redis/hiredis）。

        作为一款功能强大，效率极高的NoSQL数据库，Redis已被包括新浪微博，知乎，Stackoverflow，暴雪和Flickr在内的多家公司成功用于实战。

注：图1-5均来自《Redis in Action》,Josiah L.Carlson, Manning Publications, 2013

参考文献：

1. 李子骅，Redis入门指南，人民邮电出版社，2013年5月第1版

2.Josiah L.Carlson, Redis in Action, Manning Publications, 2013

3. Redis官方网站http://www.redis.io

PLSQL变量有四种类型，分别是：

－ 标量类型（Scalar）

－ 复合类型（Composite）

－ 参照类型（Reference）

－ LOB类型（Large Object）

1、标量类型：
－ 只能存放单个数值的变量
－ 定义时，必须要指定标量的数据类型

1.1常用标量类型
（1）VARCHAR2(n)
定义可变长度的字符串
n指定字符串最大长度
n最大值是32767字节
使用时必须指定长度
当在PLSQL块钟使用该数据类型操纵VARCHAR2表列时，起数值长度不应超过4000字节

（2）CHAR(n)
定义固定长度字符串
n指定字符串的最大长度
n最大值是32767自己
使用时指定长度，若没指定，则使用默认值1
当在PLSQL块钟使用该数据类型操纵CHAR2表列时，起数值长度不应超过2000字节

（3）NUMBER(p，s)
定义固定长度的整数和浮点数
p表示精度，用于指定数字的总位数
s表示标度，用于指定小数点后的数字位数

（4）DATE
定义日期和数据数据

（5）BOOLEAN
定义布尔变量
值为：TRUE、FALSE、NULL
为PLSQL独有数据类型，表列不能采用该数据类型
NULL表示missing、inapplicable或者unknown

（6）LONG和LONG ROW
long：数据类型用于定义变长字符串，类似于VARCHAR2数据类型，但其字符串的最大长度为32760字节
long row：数据类型用于定义变长的二进制数据，其数据最大长度为32760字节

（7）BINARY_INTEGER
定义整数
数值范围-2147483647和2174483647之间

（8）BINARY_FLOAT和BINARY_DOUBLE
BINARY_FLOAT定义单精度浮点数（oracle 10g新增加）
BINARY_DOUBLE定义双精度浮点数（oracle 10g新增加）

（9）TIMESTAMP
定义时间和日期数据（oracle 9i新增加）
对其赋值方法与对date变量赋值方法完全相同
当显示TIMESTAMP变量数据时，不仅会显示日期，而且还会显示时间和上下午标记

1.2、定义标量类型
语法：
identifier [CONSTANT] datatype [NOT NULL] [ :=|DEFAULT expr]
identifier：指定变量或常量名称
CONSTANT：指定是常量
datatype：用于指定变量或常量的类型
NOT NULL：非空，有它是必须初始化
:= ：赋值符合
DEFAULT：默认值
expr：初始值

1.3、标量定义规则
每行声明一个变量
变量的赋值使用：identifier := value;
变量名称最多30个字符

1.4使用%TYPE属性
安装数据库列或其他变量来确定新变量的类型和长度（具有动态性和绑定性）
语法：identifier Table.column_name%TYPE;
或 identifier other_variable_name%TYPE;

2、复合变量指用于存放多个值的变量
当定义复合变量时，必须要使用PL/SQL的复合数据类型
PL/SQL的复合数据类型包括：
PL/SQL记录
PL/SQL表（索引表）
PL/SQL嵌套表
VARRAY
关于这些复合数据类型，由相关章节给出

3、参照变量指用于存放数值指针的变量
可以通过参照变量来共享相同对象，从而降低占用空间
两种参照变量：
游标变量（REF CURSOR）
对象类型变量（REF obj_type）
关于这些参照变量，由相关章节给出

4、LOB变量用于存储大批量数据的变量
分为两种：
内部LOB：包括CLOB、BLOB、NCLOB，它们的数据被存储在数据库中，并且支持事务操作
外部LOB：BFILE，该类型数据被存储在OS文件中，并且不支持事务操作

CLOB：存储大批量字符数据
NCLOB：存储大批量字符数据，unicode编码
BLOB：存储大批量二进制数据
BFILE：存储指向OS文件的指针

5、非PL/SQL变量5.1、替换变量（仅用于SQL *Plus或者用于原理和SQL *Plus相同的开发工具）：
临时存储值
利用它可以达到创建通用脚本的目的
利用它可以达到和用户交互，故在SQL *Plus中又称交互式命令
替换变量的格式式在变量名称前加一个&，以便在运行SQL命令时提示用户输入替换数据，然后按输入数据运行SQL命令
语法：
（1）& ：“&变量名”eg：&name;
生命周期：单次引用中，不需要声明，如果替换字符或日期类型，最好用单引号扩起
使用范围：where、order by、列表达式、表名、整个SELECT 语句中

（2）&& ：“&&变量名”eg：&&name;
生命周期：整个会话（session连接）,不需要声明

（3）define ：“define 变量名=变量值”eg：DEFINE a = clark;
生命周期：整个会话，预先声明，使用时用&引用声明的变量
define variable=用户创建的CHAR类型的值：define 变量名=值；
define column_name(变量名)：查看变量命令。
undefine 变量名：清除变量
define：查看在当前会话中所有的替换变量和它们的值

（4）accept

生命周期：整个会话
预先声明，可以客户化提示信息，使用时用&引用声明的变量。
定义：
accept 变量名name number/char/date prompt '提示信息内容'即：ACC[EPT] variable [NUM[BER] | CHAR | DATE] [FOR[MAT] format] [DEF[AULT] default] [PROMPT text | NOPR[OMPT]] [HIDE]
解释：
PROMPT命令：用于输出提示用户的信息，以便使用户了解脚本文件的功能和运行情况
PAUSE命令：用于暂停脚本文件的运行
HIDE选项：用于隐藏用户的输入，使别人不可见，安全
这条命令的意思是：当plsql程序段执行到变量name的时候，此时需要用户的交互才能继续执行下去，plsql程序段会显示“提示信息内容”让用户输入相关信息（如果指定hide选项，那么在接下去用户输入的东西将被用星号显示出来增加安全，有点像输入密码），用户输入的内容被接收到并且把它付给name，关于在“提示信息内容”下用户输入的内容的类型，plsql程序段开发人员来通过number/char/date指定，变量name得到正确的值以后，继续执行相关下面的程序！
例：accept a char prompt '请输入员工的雇佣时间(yyyy-mm-dd):' hide
例：accept a char prompt 'input a:' hide

替换变量非常的依赖SQL *Plus的环境，当环境变量verify被关闭的时候它就不可用，只有通过打开它才能使用：
set verify(环境变量) off;关闭调试命令（关掉替换过程）
set verify(环境变量) on;打开调试命令(可以看到替换过程)

5.2、SQL *PLUS环境变量（仅用于SQL *Plus或者用于原理和SQL *Plus相同的开发工具）：
ECHO 显示回显
HEADING {OFF/ON}是否显示列标题
ARRAYSIZE{20/n}每一次从查询得到的返回量的大小
FEEDBACK{OFF/ON}回馈，反馈信息
LONG{80/n}on/text} LONG类型
LINESIZE 行的宽度
SET LINESIZE n(最好是在200之内)
PAGESIZE ：设置页的大小。SET PAGESIZE N
wrap{off/on} 折行
SET 修改
SHOW 显示

SQL *PLUS中格式化显示的命令：
COLUMN[column option]可以设置字段或字段别名的格式
COLUMN last_name HEADING employee|name '|'代表换行
col 字段名 查看命令
CLE[AR]：清除列的格式
HEA[DING] TEXT：设置列标题
FOR[MAT] FORMAT：格式化显示列的值，对字符和数字有效，对日期无效，eg：column salary justify left format ＄999,999.00，其中justify left:左对齐；col manager_id format 999999999
限制字符串的长度有A+数字限制
限制数字的长度有9，有几为9就限制成几位。
NOPRINT/PRINT NOPRINT：把一个字段从输出上屏蔽掉（返回但不显示）。
col 字段名 noprint/print.
NULL如果有NULL值，显示什么。
col name null 'on employee'
TTITLE[text/off/on]设置报表的表头
BTITLE[text/off/on]设置报表的表尾
做报表的时候要先想好PAGESIZE的大小。
BREAK ON [REPORT_ELEMENT]
压制重复值的显示，只能跟一个字段名才有效，eg：
select department_id,last_name
from employees
where rownum<30
order by 1,2;
break on department_id

5.3、做PL/SQL脚本文件的过程：变量定义accept
环境变量设置SET
格式控制命令
SPOOL
使用变量的SQL
SPOOL OFF
清除格式控制
重置环境变量
释放变量

5.4、引用非PL/SQL变量当要在PL/SQL块中引用非PL/SQL变量时，也就是要引用PL/SQL块所在地的host变量（或称“环境变量”）时，必须要在非PL/SQL变量前加冒号（“：”），eg：”:name”,name为非PL/SQL变量。

一、深入浅出理解索引结构

　　实际上，您可以把索引理解为一种特殊的目录。微软的SQL SERVER提供了两种索引：聚集索引（clustered index，也称聚类索引、簇集索引）和非聚集索引（nonclustered index，也称非聚类索引、非簇集索引）。下面，我们举例来说明一下聚集索引和非聚集索引的区别：
　　其实，我们的汉语字典的正文本身就是一个聚集索引。比如，我们要查“安”字，就会很自然地翻开字典的前几页，因为“安”的拼音是“an”，而 按照拼音排序汉字的字典是以英文字母“a”开头并以“z”结尾的，那么“安”字就自然地排在字典的前部。如果您翻完了所有以“a”开头的部分仍然找不到这 个字，那么就说明您的字典中没有这个字；同样的，如果查“张”字，那您也会将您的字典翻到最后部分，因为“张”的拼音是“zhang”。也就是说，字典的 正文部分本身就是一个目录，您不需要再去查其他目录来找到您需要找的内容。我们把这种正文内容本身就是一种按照一定规则排列的目录称为“聚集索引”。
　　如果您认识某个字，您可以快速地从自动中查到这个字。但您也可能会遇到您不认识的字，不知道它的发音，这时候，您就不能按照刚才的方法找到您 要查的字，而需要去根据“偏旁部首”查到您要找的字，然后根据这个字后的页码直接翻到某页来找到您要找的字。但您结合“部首目录”和“检字表”而查到的字 的排序并不是真正的正文的排序方法，比如您查“张”字，我们可以看到在查部首之后的检字表中“张”的页码是672页，检字表中“张”的上面是“驰”字，但 页码却是63页，“张”的下面是“弩”字，页面是390页。很显然，这些字并不是真正的分别位于“张”字的上下方，现在您看到的连续的“驰、张、弩”三字 实际上就是他们在非聚集索引中的排序，是字典正文中的字在非聚集索引中的映射。我们可以通过这种方式来找到您所需要的字，但它需要两个过程，先找到目录中 的结果，然后再翻到您所需要的页码。我们把这种目录纯粹是目录，正文纯粹是正文的排序方式称为“非聚集索引”。
　　通过以上例子，我们可以理解到什么是“聚集索引”和“非聚集索引”。进一步引申一下，我们可以很容易的理解：每个表只能有一个聚集索引，因为目录只能按照一种方法进行排序。

二、何时使用聚集索引或非聚集索引

下面的表总结了何时使用聚集索引或非聚集索引（很重要）：

　　事实上，我们可以通过前面聚集索引和非聚集索引的定义的例子来理解上表。如：返回某范围内的数据一项。比如您的某个表有一个时间列，恰好您把聚 合索引建立在了该列，这时您查询2004年1月1日至2004年10月1日之间的全部数据时，这个速度就将是很快的，因为您的这本字典正文是按日期进行排 序的，聚类索引只需要找到要检索的所有数据中的开头和结尾数据即可；而不像非聚集索引，必须先查到目录中查到每一项数据对应的页码，然后再根据页码查到具 体内容。

三、结合实际，谈索引使用的误区

　　理论的目的是应用。虽然我们刚才列出了何时应使用聚集索引或非聚集索引，但在实践中以上规则却很容易被忽视或不能根据实际情况进行综合分析。下面我们将根据在实践中遇到的实际问题来谈一下索引使用的误区，以便于大家掌握索引建立的方法。

1、主键就是聚集索引
　　这种想法笔者认为是极端错误的，是对聚集索引的一种浪费。虽然SQL SERVER默认是在主键上建立聚集索引的。
　　通常，我们会在每个表中都建立一个ID列，以区分每条数据，并且这个ID列是自动增大的，步长一般为1。我们的这个办公自动化的实例中的列 Gid就是如此。此时，如果我们将这个列设为主键，SQL SERVER会将此列默认为聚集索引。这样做有好处，就是可以让您的数据在数据库中按照ID进行物理排序，但笔者认为这样做意义不大。
　　显而易见，聚集索引的优势是很明显的，而每个表中只能有一个聚集索引的规则，这使得聚集索引变得更加珍贵。
　　从我们前面谈到的聚集索引的定义我们可以看出，使用聚集索引的最大好处就是能够根据查询要求，迅速缩小查询范围，避免全表扫描。在实际应用 中，因为ID号是自动生成的，我们并不知道每条记录的ID号，所以我们很难在实践中用ID号来进行查询。这就使让ID号这个主键作为聚集索引成为一种资源 浪费。其次，让每个ID号都不同的字段作为聚集索引也不符合“大数目的不同值情况下不应建立聚合索引”规则；当然，这种情况只是针对用户经常修改记录内 容，特别是索引项的时候会负作用，但对于查询速度并没有影响。
　　在办公自动化系统中，无论是系统首页显示的需要用户签收的文件、会议还是用户进行文件查询等任何情况下进行数据查询都离不开字段的是“日期”还有用户本身的“用户名”。
　　通常，办公自动化的首页会显示每个用户尚未签收的文件或会议。虽然我们的where语句可以仅仅限制当前用户尚未签收的情况，但如果您的系统 已建立了很长时间，并且数据量很大，那么，每次每个用户打开首页的时候都进行一次全表扫描，这样做意义是不大的，绝大多数的用户1个月前的文件都已经浏览 过了，这样做只能徒增数据库的开销而已。事实上，我们完全可以让用户打开系统首页时，数据库仅仅查询这个用户近3个月来未阅览的文件，通过“日期”这个字 段来限制表扫描，提高查询速度。如果您的办公自动化系统已经建立的2年，那么您的首页显示速度理论上将是原来速度8倍，甚至更快。
　　在这里之所以提到“理论上”三字，是因为如果您的聚集索引还是盲目地建在ID这个主键上时，您的查询速度是没有这么高的，即使您在“日期”这 个字段上建立的索引（非聚合索引）。下面我们就来看一下在1000万条数据量的情况下各种查询的速度表现（3个月内的数据为25万条）：

（1）仅在主键上建立聚集索引，并且不划分时间段：

Select gid,fariqi,neibuyonghu,title from tgongwen

用时：128470毫秒（即：128秒）

（2）在主键上建立聚集索引，在fariq上建立非聚集索引：

select gid,fariqi,neibuyonghu,title from Tgongwen
where fariqi> dateadd(day,-90,getdate())

用时：53763毫秒（54秒）

（3）将聚合索引建立在日期列（fariqi）上：

select gid,fariqi,neibuyonghu,title from Tgongwen
where fariqi> dateadd(day,-90,getdate())

用时：2423毫秒（2秒）

　　虽然每条语句提取出来的都是25万条数据，各种情况的差异却是巨大的，特别是将聚集索引建立在日期列时的差异。事实上，如果您的数据库真的有 1000万容量的话，把主键建立在ID列上，就像以上的第1、2种情况，在网页上的表现就是超时，根本就无法显示。这也是我摒弃ID列作为聚集索引的一个 最重要的因素。得出以上速度的方法是：在各个select语句前加：

declare @d datetime
set @d=getdate()

并在select语句后加：

select [语句执行花费时间(毫秒)]=datediff(ms,@d,getdate())

2、只要建立索引就能显著提高查询速度
　　事实上，我们可以发现上面的例子中，第2、3条语句完全相同，且建立索引的字段也相同；不同的仅是前者在fariqi字段上建立的是非聚合索引，后者在此字段上建立的是聚合索引，但查询速度却有着天壤之别。所以，并非是在任何字段上简单地建立索引就能提高查询速度。
　　从建表的语句中，我们可以看到这个有着1000万数据的表中fariqi字段有5003个不同记录。在此字段上建立聚合索引是再合适不过了。 在现实中，我们每天都会发几个文件，这几个文件的发文日期就相同，这完全符合建立聚集索引要求的：“既不能绝大多数都相同，又不能只有极少数相同”的规 则。由此看来，我们建立“适当”的聚合索引对于我们提高查询速度是非常重要的。

3、把所有需要提高查询速度的字段都加进聚集索引，以提高查询速度
　　上面已经谈到：在进行数据查询时都离不开字段的是“日期”还有用户本身的“用户名”。既然这两个字段都是如此的重要，我们可以把他们合并起来，建立一个复合索引（compound index）。
　　很多人认为只要把任何字段加进聚集索引，就能提高查询速度，也有人感到迷惑：如果把复合的聚集索引字段分开查询，那么查询速度会减慢吗？带着 这个问题，我们来看一下以下的查询速度（结果集都是25万条数据）：（日期列fariqi首先排在复合聚集索引的起始列，用户名neibuyonghu排 在后列）：

（1）select gid,fariqi,neibuyonghu,title from Tgongwen where fariqi>''2004-5-5'' 

查询速度：2513毫秒

（2）select gid,fariqi,neibuyonghu,title from Tgongwen 
　　　　　　　　　　　　where fariqi>''2004-5-5'' and neibuyonghu=''办公室''

查询速度：2516毫秒

（3）select gid,fariqi,neibuyonghu,title from Tgongwen where neibuyonghu=''办公室''

查询速度：60280毫秒

　　从以上试验中，我们可以看到如果仅用聚集索引的起始列作为查询条件和同时用到复合聚集索引的全部列的查询速度是几乎一样的，甚至比用上全部的 复合索引列还要略快（在查询结果集数目一样的情况下）；而如果仅用复合聚集索引的非起始列作为查询条件的话，这个索引是不起任何作用的。当然，语句1、2 的查询速度一样是因为查询的条目数一样，如果复合索引的所有列都用上，而且查询结果少的话，这样就会形成“索引覆盖”，因而性能可以达到最优。同时，请记 住：无论您是否经常使用聚合索引的其他列，但其前导列一定要是使用最频繁的列。

四、其他书上没有的索引使用经验总结

1、用聚合索引比用不是聚合索引的主键速度快
　　下面是实例语句：（都是提取25万条数据）

select gid,fariqi,neibuyonghu,reader,title from Tgongwen where fariqi=''2004-9-16''

使用时间：3326毫秒

select gid,fariqi,neibuyonghu,reader,title from Tgongwen where gid<=250000

使用时间：4470毫秒

这里，用聚合索引比用不是聚合索引的主键速度快了近1/4。

2、用聚合索引比用一般的主键作order by时速度快，特别是在小数据量情况下

select gid,fariqi,neibuyonghu,reader,title from Tgongwen order by fariqi

用时：12936

select gid,fariqi,neibuyonghu,reader,title from Tgongwen order by gid

用时：18843

　　这里，用聚合索引比用一般的主键作order by时，速度快了3/10。事实上，如果数据量很小的话，用聚集索引作为排序列要比使用非聚集索引速度快得明显的多；而数据量如果很大的话，如10万以上，则二者的速度差别不明显。

3、使用聚合索引内的时间段，搜索时间会按数据占整个数据表的百分比成比例减少，而无论聚合索引使用了多少个：

select gid,fariqi,neibuyonghu,reader,title from Tgongwen where fariqi>''2004-1-1''

用时：6343毫秒（提取100万条）

select gid,fariqi,neibuyonghu,reader,title from Tgongwen where fariqi>''2004-6-6''

用时：3170毫秒（提取50万条）

select gid,fariqi,neibuyonghu,reader,title from Tgongwen where fariqi=''2004-9-16''

用时：3326毫秒（和上句的结果一模一样。如果采集的数量一样，那么用大于号和等于号是一样的）

select gid,fariqi,neibuyonghu,reader,title from Tgongwen 
　　　　　　　　　　　　where fariqi>''2004-1-1'' and fariqi<''2004-6-6''

用时：3280毫秒

4、日期列不会因为有分秒的输入而减慢查询速度
　　下面的例子中，共有100万条数据，2004年1月1日以后的数据有50万条，但只有两个不同的日期，日期精确到日；之前有数据50万条，有5000个不同的日期，日期精确到秒。

select gid,fariqi,neibuyonghu,reader,title from Tgongwen 
　　　　　　　　　　where fariqi>''2004-1-1'' order by fariqi

用时：6390毫秒

select gid,fariqi,neibuyonghu,reader,title from Tgongwen 
　　　　　　　　　　　　where fariqi<''2004-1-1'' order by fariqi

     为了方便我们创建两张最简易的表A、B，具体的表结构参看下面，来分析内连接与外连接的区别

                                  图1                                                                      图2

两个表要做连接，必须要有连接字段，而在表A和表B中连接字段是Aid和Bnamid,下图说明了连接之间关系图3

                                                                  图3

    （1) 内连接：利用内连接（等值）就可获取蓝色的公共部分C，即图3中的数据集C，结果集为如下：
 
       

                                                                   图4

   其实select * from A join B on A.Aid=B.Bnamid;等价于select * from A,B where A.Aid=B.Bnamid;
       注：非等值连接主要的话是针对一个范围来查询数据，自连接主要就是把1张表堪称两张表来用

                        
   (2)外连接：分为左外连接（left join）与右外连接（right join）
     
      左外连接即公共显示的蓝色部分C1+显示黄色的记录集A1，显示语句等价于select * from A,B where A.Aid=B.Bnamid（+）；       

                                                                    图  5

右外连接即公共显示的蓝色部分C1+显示绿色的B1，显示语句等价于select * from A,B where A.Aid(+)=B.Bnamid；

                                                                      图6

  表A和表B情况是相对的，以上实验都是A在左边的情况，其实A left join B与B right join A的情况的结果集是一样的。

一、 基础介绍

(a) SQL_TRACE说明

SQL_TRACE可以作为初始化参数在全局启用，也可以通过命令行方式在具体session启用。
1． 在全局启用
在参数文件(pfile/spfile)中指定:

sql_trace =true

在全局启用SQL_TRACE会导致所有进程的活动被跟踪，包括后台进程及所有用户进程，这通常会导致比较严重的性能问题，所以在生产环境中要谨慎使用，这个参数在10g之后是动态参数，可以随时调整，在某些诊断中非常有效。
提示: 通过在全局启用sql_trace，我们可以跟踪到所有后台进程的活动，很多在文档中的抽象说明，通过跟踪文件的实时变化，我们可以清晰的看到各个进程之间的紧密协调.

2． 在当前session级设置
大多数时候我们使用sql_trace跟踪当前进程.通过跟踪当前进程可以发现当前操作的后台数据库递归活动(这在研究数据库新特性时尤其有效)，
研究SQL执行，发现后台错误等.
在session级启用和停止sql_trace方式如下:

启用当前session的跟踪:
SQL> alter session set sql_trace=true;

Session altered.

此时的SQL操作将被跟踪:
SQL> select count(*) from dba_users;

  COUNT(*)
----------
        34
结束跟踪:
SQL> alter session set sql_trace=false;

Session altered.
       

3． 跟踪其他用户进程
在很多时候我们需要跟踪其他用户的进程，而不是当前用户，这可以通过Oracle提供的系统包DBMS_SYSTEM. SET_SQL_TRACE_IN_SESSION
来完成

SET_SQL_TRACE_IN_SESSION过程序要提供三个参数:

SQL> desc dbms_system
...
PROCEDURE SET_SQL_TRACE_IN_SESSION
 Argument Name                     Type                    In/Out Default?
 ------------------------------           -----------------------   ------ --------
 SID                               NUMBER                  IN
 SERIAL#                          NUMBER                  IN
 SQL_TRACE                        BOOLEAN                 IN
...

通过v$session我们可以获得sid、serial#等信息:

获得进程信息，选择需要跟踪的进程:

SQL> select sid,serial#,username from v$session
  2  where username is not null;

       SID    SERIAL#  USERNAME
---------- ---------- ------------------------------
         8       2041  SYS
         9        437  EYGLE

设置跟踪:
SQL> exec dbms_system.set_sql_trace_in_session(9,437,true)

PL/SQL procedure successfully completed.

....
可以等候片刻，跟踪session执行任务,捕获sql操作...
....

停止跟踪:
SQL> exec dbms_system.set_sql_trace_in_session(9,437,false)

PL/SQL procedure successfully completed.
  

(b) 10046事件说明
10046事件是Oracle提供的内部事件，是对SQL_TRACE的增强.
10046事件可以设置以下四个级别:
1 - 启用标准的SQL_TRACE功能,等价于sql_trace
4 - Level 1 加上绑定值(bind values)
8 - Level 1 + 等待事件跟踪
12 - Level 1 + Level 4 + Level 8
类似sql_trace，10046事件可以在全局设置，也可以在session级设置。
1． 在全局设置
在参数文件中增加:

event="10046 trace name context forever,level 12"

此设置对所有用户的所有进程生效、包括后台进程.

2． 对当前session设置
通过alter session的方式修改，需要alter session的系统权限:

SQL> alter session set events '10046 trace name context forever';

Session altered.

SQL> alter session set events '10046 trace name context forever, level 8';

Session altered.

SQL> alter session set events '10046 trace name context off';

Session altered.

      

3． 对其他用户session设置
通过DBMS_SYSTEM.SET_EV系统包来实现:

SQL> desc dbms_system
...
PROCEDURE SET_EV
 Argument Name                  Type                    In/Out Default?
 ------------------------------ ----------------------- ------ --------
 SI                             BINARY_INTEGER          IN
 SE                             BINARY_INTEGER          IN
 EV                             BINARY_INTEGER          IN
 LE                             BINARY_INTEGER          IN
 NM                             VARCHAR2                IN

...

其中的参数SI、SE来自v$session视图:
查询获得需要跟踪的session信息:
SQL> select sid,serial#,username from v$session where username is not null;

SID SERIAL# USERNAME
---------- ---------- ------------------------------
8 2041 SYS
9 437 EYGLE

执行跟踪:
SQL> exec dbms_system.set_ev(9,437,10046,8,'eygle');

PL/SQL procedure successfully completed.

结束跟踪:
SQL> exec dbms_system.set_ev(9,437,10046,0,'eygle');

PL/SQL procedure successfully completed.

(c) 获取跟踪文件
以上生成的跟踪文件位于user_dump_dest目录中，位置及文件名可以通过以下SQL查询获得:

SQL> select

  2    d.value||'/'||lower(rtrim(i.instance, chr(0)))||'_ora_'||p.spid||'.trc' trace_file_name
  3  from
  4    ( select p.spid
  5      from sys.v$mystat m,sys.v$session s,sys.v$process p
  6      where m.statistic# = 1 and s.sid = m.sid and p.addr = s.paddr) p,
  7    ( select t.instance from sys.v$thread  t,sys.v$parameter  v
  8      where v.name = 'thread' and (v.value = 0 or t.thread# = to_number(v.value))) i,
  9    ( select value from sys.v$parameter where name = 'user_dump_dest') d
 10  / 

TRACE_FILE_NAME
--------------------------------------------------------------------------------
/opt/oracle/admin/hsjf/udump/hsjf_ora_1026.trc 

(d) 读取当前session设置的参数
当我们通过alter session的方式设置了sql_trace,这个设置是不能通过show parameter的方式得到的,我们需要通过dbms_system.read_ev来获取：

SQL> set feedback off

SQL> set serveroutput on 

SQL> declare
2 event_level number;
3 begin
4 for event_number in 10000..10999 loop
5 sys.dbms_system.read_ev(event_number, event_level);
6 if (event_level > 0) then
7 sys.dbms_output.put_line(
8 'Event ' ||
9 to_char(event_number) ||
10 ' is set at level ' ||
11 to_char(event_level)
12 );
13 end if;
14 end loop;
15 end;
16 /
Event 10046 is set at level 1

1. 查看表空间
   select * from dba_tablespaces;
2. 创建表空间
   简单创建： create tablespace userdb datafile 'd:\datafile.dbf' size 200M;
   复杂创建：create tablespace userdb datafile 'd:\datafile.dbf' size 200M autoextend on next 20M maxsize unlimited
   extent management local
   segment space management auto;
   大文件表空间：create bigfile tablespace userdb datafile 'd:\datafile.dbf' size 200M autoextend on next 20M maxsize unlimited;
3. 删除表空间
   删除表空间：drop tablespace userdb including contents ;
   同时删除文件：drop tablespace userdb including contents and datafiles;
4. 扩展表空间
   修改文件大小：alter database datafile 'd:\fatafile.dbf' resize 300M;
   添加数据文件：alter dataspace userdb add datafile 'd:\datafile2.dbf' size ...;
   将表空间的数据文件设成自动扩展：alter database datafile 'd:\datafile2.dbf' autoextend on next 5M maxsize unlimited;
5. 表空间重命名
   alter tablespace userdb rename to userdb2;
6. 使表空间只读
   alter tablespace userdb read only;
7. 使表空间离线/在线
   alter tablespace userdb online/offline;

正在检查网络配置需求...
　　检查完成。此次检查的总体结果为: 未执行 <<<<
　　建议案: orcle支持在具有 DHCP 分配的 IP 地址的系统上进行安装。但在安装之前,
　　必须将 Microsoft LoopBack Adapter 配置为系统的主网络适配器。
　　有关在配置有 DHCP 的系统上安装软件的详细信息, 请参阅 Installation Guide。
　　=======================================================================

　　解决办法：
　　控制面板->添加硬件->是，我也经连接了此硬件->添加新硬件设备->安装我手动列表选择硬件(高级)->网络适配器->厂商：Microsoft 网卡：Microsoft Loopback Adapter 然后就行了。

操作之后你会发现你的网上邻居里面又两个网络连接。选择新建立的那个网络连接
　　随便为它配个IP地址就行了。

SQL> CREATE CONTROLFILE REUSE DATABASE "ORCL" RESETLOGS 
  2      MAXLOGFILES 16
  3      MAXLOGMEMBERS 3
  4      MAXDATAFILES 100
  5      MAXINSTANCES 8
  6      MAXLOGHISTORY 292
  7  LOGFILE
  8    GROUP 1 '/u01/oracle/oradata/orcl/redo01.log'  SIZE 50M,
  9    GROUP 2 '/u01/oracle/oradata/orcl/redo02.log'  SIZE 50M,
 10    GROUP 3 '/u01/oracle/oradata/orcl/redo03.log'  SIZE 50M
 11  -- STANDBY LOGFILE
 12  DATAFILE
 13    '/u01/oracle/oradata/orcl/system01.dbf',
 14    '/u01/oracle/oradata/orcl/undotbs01.dbf',
 15    '/u01/oracle/oradata/orcl/sysaux01.dbf',
 16    '/u01/oracle/oradata/orcl/users01.dbf',
 17  CHARACTER SET ZHS16GBK
 18  ;
CREATE CONTROLFILE REUSE DATABASE "ORCL" RESETLOGS
*
ERROR at line 1:
ORA-01503: CREATE CONTROLFILE failed
ORA-01163: SIZE clause indicates 12800 (blocks), but should match header 25600
ORA-01110: data file 4: '/u01/oracle/oradata/orcl/users01.dbf'

查了下官方文档

ORA-01163: SIZE clause indicates string (blocks), but should match header string
Cause: The size specified in bytes in the SIZE clause of the CREATE CONTROLFILE statement does not equate to the number of blocks recorded in the header.
Action: Specify the correct filename and size ( in bytes ).

问题原因

在user01.dbf后多了一个逗号 去掉逗号之后一切正常。

完成后删除E:\oracle10g\product\10.2.0\oradata\wst10g\UNDOTBS01.DBF，然后进行出下操作：

-- 创建一个新的小空间的UNDO TABLESPACE
Create UNDO TABLESPACE UNDOTBS1 DATAFILE 'E:\oracle10g\product\10.2.0\oradata\wst10g\UNDOTBS01.DBF' SIZE 100M REUSE AUTOEXTEND ON;
-- 设置新的表空间为系统UNDO_TABLESPACE
Alter SYSTEM SET UNDO_TABLESPACE=UNDOTBS1;
-- Drop 旧的表空间
Drop TABLESPACE UNDOTBS2 INCLUDING CONTENTS;
--查看所有表空间的情况
Select * FROM DBA_TABLESPACES;

完成后删除E:\oracle10g\product\10.2.0\oradata\wst10g\UNDOTBS02.DBF。

如果临时表空间很大处理的方法类似。

限制
Alter DATABASE DATAFILE 'E:\oracle10g\product\10.2.0\oradata\wst10g\UNDOTBS01.DBF' AUTOEXTEND ON MAXSIZE 300M;

本文转自 ☆★ 黑白前线 ★☆ - www.hackline.net 转载请注明出处，侵权必究！
原文链接：http://www.hackline.net/a/Special/wlgf/jbst/2010/0113/2524.html

环境 
windows2000＋sp4，oracle9.201 
oracle软件以oracle帐户安装 

一、sysdba的权限 
sysdba（sysoper和normal）是登录数据库的身份，与角色（dba、resource）、对象权限及系统权限有所区别，登录身份表明了可对数据库的整体进行哪些操作，sysdba有些类似unix下的root帐户。 
sysdba的权限或可对数据库进行的操作： 
startup,shutdown 
alter database open|mount 
alter database backup controlfile 
alter tablespace begin/end backup 
recover database 
alter database archivelog,restricted session 
create database 
recover database until 

二、os认证和口令文件认证 

1、os认证和口令文件认证其实质是对oracle数据库采取何种管理方式，是本地管理还是通过一台管理服务器统一管理。 
本地管理采用的就是os认证方式，统一管理采用的就是口令文件认证方式 
2、两种认证的实现 
oracle数据库通过sqlnet.ora文件中的参数SQLNET.AUTHENTICATION_SERVICES，PFILE（或SPFILE）文件中的参数REMOTE_LOGIN_PASSWORDFILE和口令文件PWDsid.ora三者协同作用实现身份认证。 
 
SQLNET.AUTHENTICATION_SERVICES＝(NTS)|(NONE) 
SQLNET.AUTHENTICATION_SERVICES＝(NTS): 操作系统认证方式，不使用口令文件 
SQLNET.AUTHENTICATION_SERVICES＝(NONE)：口令文件认证方式 
 
REMOTE_LOGIN_PASSWORDFILE=(NONE)|(EXCLUSIVE)|(SHARED) 
REMOTE_LOGIN_PASSWORDFILE=(NONE)：不使用口令文件，操作系统认证 
REMOTE_LOGIN_PASSWORDFILE=(EXCLUSIVE)：口令文件认证方式，但只有一个数据库实例可以使用此文件， 
系统允许将SYSOPER／SYSDBA授予除INTERNAL／SYS以外的其他用户，且以具有这类身份的其他用户登录是有效的 
REMOTE_LOGIN_PASSWORDFILE=(SHARED)：口令文件认证方式，可有多个数据库实例使用此文件，但是此设置下 
只有INTERNAL／SYS帐号能被识别，即使文件中存有其他用户的信息，也不允许他们以SYSOPER／SYSDBA登录 
 
1）SQLNET.AUTHENTICATION_SERVICES＝(NTS)同时REMOTE_LOGIN_PASSWORDFILE=(NONE)，此时为操作系统认证方式。 
当以oracle_dba组下的用户登录进入本地windows2000后进行下边的操作： 
sqlplus /nolog 
sql>conn /as sysdba 
或 
sqlplus /nolog 
sql>conn 任意用户名/密码 as sysdba 
均可以sysdba身份登录成功，进行数据库方面的操作 
当以远程进行登录时，执行 
sqlplus /nolog 
sql>conn /as sysdba 
或 
sqlplus /nolog 
sql>conn sys/密码 as sysdba 
均显示 
“ERROR： 
ORA-01031： insufficient privileges 
” 
也就是不允许以sysdba身份远程登录系统，这也是os认证之所以也称为本地认证方式的原因 
 
2）SQLNET.AUTHENTICATION_SERVICES＝(NONE)同时REMOTE_LOGIN_PASSWORDFILE=(EXCLUSIVE)或(SHARED)，配合口令文件 
PWDsid.ora，此时为口令文件认证方式 
当在本地以oracle_dba组下的用户登录进入windows2000后进行下边的操作： 
sqlplus /nolog 
sql>conn /as sysdba 
显示 
“ERROR： 
ORA-01031： insufficient privileges 
” 
实质上是要求提供拥有sysdba身份的用户名和密码 
在本地或远程进行下边的操作 
sqlplus "sys/密码@服务名 as sysdba" 
可进入系统 
也就是说口令文件认证方式允许用户从本地或远程以sysdba身份登录，但必须提供口令字 
 
3）SQLNET.AUTHENTICATION_SERVICES＝(NTS)同时REMOTE_LOGIN_PASSWORDFILE=(EXCLUSIVE)或(SHARED)，配合口令文件PWDsid.ora，此时操作系统认证和口令文件认证同时起作用 
当在本地以oracle_dba组下的用户登录进入windows2000后进行下边的操作： 
sqlplus /nolog 
sql>conn /as sysdba 
可进入系统 
当在远程执行 
sqlplus "sys/密码@服务名 as sysdba" 
同样可正常登录到数据库系统上 
上边的参数配置容易令人迷惑、混淆，造成假象。我推测网上有些朋友所以对身份认证产生费解可能就是因为这么 
配置参数的！ 

三、其他
 
从前边的讨论可以知道，我们能够对sys以外的用户赋予sysdba身份，具体方法就是 
SQLNET.AUTHENTICATION_SERVICES＝(NONE) 
REMOTE_LOGIN_PASSWORDFILE=(EXCLUSIVE) 
口令文件PWDsid.ora 
SQL>grant sysdba to 用户名 
这样，其他具有sysdba身份的用户就加入到PWDsid.ora中，并可以被PWDsid.ora识别，我们可以用这个被赋予sysdba身份的用户登录并进行类似sys用户下所能执行的操作。

补充：2008-12-31

首先将oracle改为口令认证模式；

sqlnet.ora路径C:\oracle\ora92\network\admin

SQL> conn sys/allview@allview as sysdba;
已连接。
SQL> alter user sys identified by sys;

用户已更改。

//首先确认新口令为sys  更改sys口令后可能需要重启服务

D:\Documents and Settings\LMing>sqlplus /nolog

SQL*Plus: Release 9.2.0.1.0 - Production on 星期三 12月 31 10:58:39 2008

Copyright (c) 1982, 2002, Oracle Corporation.  All rights reserved.

SQL> conn sys/sys@allview as sysdba;
已连接。
SQL> exit

//验证效果通过

D:\Documents and Settings\LMing>move C:\oracle\ora92\database\PWDAllView.ora C:\
oracle\ora92\database\PWDAV.ora

D:\Documents and Settings\LMing>sqlplus /nolog

SQL*Plus: Release 9.2.0.1.0 - Production on 星期三 12月 31 11:05:00 2008

Copyright (c) 1982, 2002, Oracle Corporation.  All rights reserved.

SQL> conn sys/sys@allview as sysdba;
ERROR:
ORA-01031: insufficient privileges

//由于口令文件被修改而无法登陆
SQL> exit

D:\Documents and Settings\LMing>orapwd file=C:\oracle\ora92\database\PWDAllView.
ora password=allview entries=4;

D:\Documents and Settings\LMing>sqlplus /nolog

SQL*Plus: Release 9.2.0.1.0 - Production on 星期三 12月 31 11:07:14 2008

Copyright (c) 1982, 2002, Oracle Corporation.  All rights reserved.

SQL> conn sys/allview@allview as sysdba;
ERROR:
ORA-01031: insufficient privileges

//重新创建密码文件后需要重启服务后生效
SQL> shutdown immediate;
ORA-01012: not logged on
SQL> exit

D:\Documents and Settings\LMing>sqlplus /nolog

SQL*Plus: Release 9.2.0.1.0 - Production on 星期三 12月 31 11:08:27 2008

Copyright (c) 1982, 2002, Oracle Corporation.  All rights reserved.

SQL> conn sys/allview@allview as sysdba;
已连接。

//测试成功

Error 1067: The process terminated unexpectedly.

---------------------------
OK  
---------------------------

解决方法：
进入注册表
HKEY_LOCAL_MACHINE  -> SYSTEM->CurrentControlSet->Services->
oracleOraDb10g_home1TNSListener -> ImagePath : C:\oracle\product\10.1.0\db_1\BIN\tnslsnr.exe
发现监听服务的地址还是指向10.1.0的
1.把ImagePath路径改成10.2.0
ImagePath : C:\oracle\product\10.2.0\db_1\BIN\tnslsnr.exe
2.重新启动OracleOraDb10g_home1TNSListener服务，成功。

01033, 00000, "ORACLE initialization or shutdown in progress"
// *Cause: An attempt was made to log on while Oracle is being started up
//         or shutdown.
// *Action: Wait a few minutes. Then retry the operation.

所以在http://www.sou3w.com/database16/database254111.htm就有网友建议重启,效果如何.我不知道,有兴趣可以自己去试.下面是我的解决的步骤.其实主要参考自下面的文章.

http://www.helpdiy.com/bbs/redirect.php?tid=208&goto=lastpost&fpage=1&sid=t2VqoX当然我的电脑没有断电,起因是我在做表空间练习的时候删除了我所创建的数据文件,

以sys登录为sysdba
sqlplus /NOLOG
SQL>connect sys/用户口令as sysdba
SQL>shutdown normal
SQL>startup mount
SQL>alter database open
SQL>shutdown normal
SQL>startup

结果出现
SQL> alter database open
  2  ;
alter database open
*
第 1 行出现错误:
ORA-01157: 无法标识/锁定数据文件 5 - 请参阅 DBWR 跟踪文件
ORA-01110: 数据文件 5: 'F:\ORACLE\TEST01.DBF'

由此可得出是我刚才的数据文件删除操作引起的,怎么办呢?

下面是我的命令行的贴图,希望不是太乱.

ORA-01157: 无法标识/锁定数据文件 5 - 请参阅 DBWR 跟踪文件
ORA-01110: 数据文件 5: 'F:\ORACLE\TEST01.DBF'

SQL> alter database create datafile 5;

数据库已更改。

SQL> conn scott/tiger
ERROR:
ORA-01033: ORACLE initialization or shutdown in progress

警告: 您不再连接到 ORACLE。
SQL> alter database datafile 5 offline drop;
SP2-0640: 未连接
SQL> conn sys/oracle
ERROR:
ORA-01033: ORACLE initialization or shutdown in progress

SQL> conn sys/oracle as sysdba;
已连接。
SQL> alter database datafile 5 offline drop;

数据库已更改。

SQL> conn scott/tiger
ERROR:
ORA-01033: ORACLE initialization or shutdown in progres

怎么还回出现相同的错误呢?重复上面的步骤,你会发现

ORA-01157: 无法标识/锁定数据文件 6- 请参阅 DBWR 跟踪文件
ORA-01110: 数据文件 6: 'F:\ORACLE\TEST01.DBF'

和上面出现同一个错误,不过,看清楚哦,,      是数据文件6   而不是数据文件5,

那么的话,继续吧SQL> alter database create datafile  6;

知道你重复上面的步骤,发现能用scott登陆为止,其实你删除了几个数据文件，你就要重复删除几次.

呵呵,抓紧时间,马上复习.希望考个好成绩!

第一种情况：

目标数据库中存在与导出用户的缺省表空间同名的表空间，此时，一定要将导入用户的 unlimited tablespace 权限 revoke 掉，否则，数据将全部被导入到那个同名的表空间中，而不是导入用户的缺省表空间中。

1、 从源数据库中导出数据

(1) 授予导出用户DBA权限

SQL> connect system@njgajhpt

Connected to Oracle9i Enterprise Edition Release 9.2.0.4.0

Connected as system

SQL> grant dba to sh;

Grant succeeded

SH的缺省表空间是EXAMPLE

SQL> select username,default_tablespace from dba_users

2 where username = 'SH';

USERNAME DEFAULT_TABLESPACE

------------------------------ ------------------------------

SH EXAMPLE

(2)、导出数据

C:Documents and Settingscuiqing>exp sh/sh@njgajhpt file='d:tempsh.dmp' tables=customers direct=y

Export: Release 9.2.0.1.0 - Production on 星期四 11月 16 16:36:31 2006

即将导出指定的表通过直接路径 ...

. . 正在导出表 CUSTOMERS 50000 行被导出

在没有警告的情况下成功终止导出。

2、 导入目标数据库

(1) 创建表空间

SQL> create tablespace ts_qcui

2 datafile 'D:ORACLEORADATAJWPTZJKts_qcui.ora'

3 size 20M autoextend on next 8M maxsize 1024M;

Tablespace created

(2) 创建用户

SQL> create user qcui identified by qcui

2 default tablespace ts_qcui;

User created

SQL> grant connect,resource to qcui;

Grant succeeded

(3) 导入数据

C:Documents and Settingscuiqing>imp qcui/qcui@jwptzjk fromuser=sh touser=qcui file='d:tempsh.dmp' constraints=n

Import: Release 9.2.0.1.0 - Production on 星期四 11月 16 16:43:00 2006

经由直接路径导出由EXPORT:V09.02.00创建的导出文件

IMP-00013: 只有 DBA 才能导入由其它 DBA 导出的文件

IMP-00000: 未成功终止导入

(4) 授予导入用户DBA权限

SQL> grant dba to qcui;

Grant succeeded

(5) 授权后重新导入

C:Documents and Settingscuiqing>imp qcui/qcui@jwptzjk fromuser=sh touser=qcui file='d:tempsh.dmp' constraints=n

经由直接路径导出由EXPORT:V09.02.00创建的导出文件

警告: 此对象由 SH 导出, 而不是当前用户

. . 正在导入表 "CUSTOMERS" 50000行被导入

成功终止导入，但出现警告。

(6) 检查数据存放的表空间。数据没有按预期存放在QCUI的缺省表空间TS_QCUI中

SQL> select table_name,tablespace_name from dba_tables

2 where owner = 'QCUI';

TABLE_NAME TABLESPACE_NAME

------------------------------ ------------------------------

CUSTOMERS EXAMPLE

(7) 回收QCUI的unlimited tablespace权限

SQL> revoke unlimited tablespace from qcui;

Revoke succeeded

SQL> alter user qcui quota unlimited on ts_qcui;

User altered

(8) 回收权限后重新导入

SQL> drop table qcui.customers;

Table dropped

C:Documents and Settingscuiqing>imp qcui/qcui@jwptzjk fromuser=sh touser=qcui file='d:tempsh.dmp' constraints=n

经由直接路径导出由EXPORT:V09.02.00创建的导出文件

警告: 此对象由 SH 导出, 而不是当前用户

. . 正在导入表 "CUSTOMERS" 50000行被导入

成功终止导入，但出现警告。

(9) 检查数据存放的表空间。数据存放在QCUI的缺省表空间TS_QCUI中

SQL> select table_name,tablespace_name from dba_tables

2 where owner = 'QCUI';

TABLE_NAME TABLESPACE_NAME

------------------------------ ------------------------------

CUSTOMERS TS_QCUI

关于IMP由拥有DBA权限的用户EXP数据时，数据存放表空间的几种情况(IMP-00013) -2

第二种情况：

目标数据库中没有与导出用户的缺省表空间同名的表空间，这种情况下，并不需要将导入用户的 unlimited tablespace 权限 revoke 掉。

1、从源数据库中导出数据

（1）创建表空间

SQL> create tablespace ts_candy

2 datafile 'D:ORACLEORADATANJGAJHPTts_candy.ora'

3 size 20M autoextend on next 8M maxsize 1024M;

Tablespace created

(2) 创建用户，缺省表空间是 ts_candy

SQL> create user candy identified by candy

2 default tablespace ts_candy;

User created

SQL> grant dba to candy;

Grant succeeded

(3) 创建表

SQL> connect candy/candy@njgajhpt

SQL> create table candy_tables

2 as

3 select * from all_tables;

Table created

(4) 导出数据

C:Documents and Settingscuiqing>exp candy/candy@njgajhpt file='d:tempcandy.dmp' direct=y

即将导出指定的表通过直接路径 ...

. . 正在导出表 CANDY_TABLES 991 行被导出

在没有警告的情况下成功终止导出。

2、 导入目标数据库

（1） 目标数据库中没有与 ts_candy同名的表空间

SQL> select tablespace_name from dba_tablespaces

2 where tablespace_name = 'TS_CANDY';

TABLESPACE_NAME

------------------------------

（2） 导入数据（导入用户qcui 已授予DBA权限，并且具有 unlimited tablespace权限）

SQL> select grantee,privilege from dba_sys_privs

2 where grantee = 'QCUI';

GRANTEE PRIVILEGE

------------------------------ ----------------------------------------

QCUI UNLIMITED TABLESPACE

C:Documents and Settingscuiqing>imp qcui/qcui@jwptzjk fromuser=candy touser=qcui file='d:tempcandy.dmp' constraints=n

经由直接路径导出由EXPORT:V09.02.00创建的导出文件

警告: 此对象由 CANDY 导出, 而不是当前用户

已经完成ZHS16GBK字符集和AL16UTF16 NCHAR 字符集中的导入

. . 正在导入表 "CANDY_TABLES" 919行被导入

成功终止导入，但出现警告。

(3) 检查数据存放的表空间。数据存放在QCUI的缺省表空间TS_QCUI中

SQL> select table_name,tablespace_name from dba_tables

2 where owner = 'QCUI';

TABLE_NAME TABLESPACE_NAME

------------------------------ ------------------------------

CUSTOMERS TS_QCUI

CANDY_TABLES TS_QCUI

小结：当拿到由拥有DBA权限的用户导出的数据时，最好问清楚其缺省表空间，如果目标数据库中存在与导出数据库同名的表空间时，这种情况需要特别注意。

我们往往在一看到“IMP-00013: 只有 DBA 才能导入由其它 DBA 导出的文件” 这个错误信息后，就立刻给导入用户授予DBA权限，但却忽略了DBA的角色是拥有对数据库中所有表空间unlimit的权限，造成花费很长时间import结束后，却发现没有导入到预期的表空间中。

简而言之，如果有同名表空间存在的话，必须将导入用户的 unlimited tablespace的权限 revoke 掉，否则数据将被直接存放到了那个同名表空间中，而不是导入用户缺省的表空间中；如果没有同名表空间，则无需进行 revoke，oracle 会自动将数据存放在导入用户的缺省表空间中。

最后一个需要注意的问题就是DBA授权问题，个人建议，一个数据库中除了system和sys用户以外，最好严格控制DBA权限的授予，尤其是不要随便赋予应用系统schema的owner以这个权限。目前国内的软件开发以及项目管理的能力还很薄弱，绝大多数项目中，不会设立专门的数据库管理角色，又为了图方便，往往赋予应用系统schema的owner以DBA权限，这样一来，在一个几十人或者上百人的团队中，其中任何一个开发人员或是运维人员一个随意的对DB的操作，对DB而言也许将会是灾难性的。因此，当导入数据后，应及时revoke掉 DBA 权限。

 导出文件: EXPDAT.DMP > D:/a.dmp

(2)U(用户), 或 (3)T(表): (2)U > 3

导出表数据 (yes/no): yes > yes

压缩区 (yes/no): yes >

已导出 ZHS16GBK 字符集和 AL16UTF16 NCHAR 字符集

即将导出指定的表通过常规路径...
要导出的表 (T) 或分区 (T: P): (按 RETURN 退出) > pfdept

. . 正在导出表                          PFDEPT导出了          83 行
要导出的表 (T) 或分区 (T: P): (按 RETURN 退出) >return
导出成功终止, 但出现警告。

3. 导出工具exp非交互式命令行方式的例子
$exp oa1/123@oracle file=D:/all.dmp grants=y

说明:把oa1用户的所有表导出到文件D:/all.dmp

$exp oa1/123@oracle tables=(pfdept,pfuser) file=D:/all.dmp  grants=y

说明:把oa1用户里两个表emp,dept导出到文件D:/all.dmp

$exp oa1/123@oracle tables=pfdept query=\"where predeptid=0745\" file=D:/all.dmp

说明:在exp里面加上导出pfdept 的查询条件predeptid=0745

$exp parfile=username.par file=/directory1/username_1.dmp,/directory1/username_2.dmp filesize=2000M log=/directory2/username_exp.log

参数文件username.par内容
userid=username/userpassword
buffer=8192000
compress=n
grants=y

说明:username.par为导出工具exp用的参数文件,里面具体参数可以根据需要去修改

     filesize指定生成的二进制备份文件的最大字节数
二.导入工具 imp

1. 它是操作系统下一个可执行的文件 存放目录/ORACLE_HOME/bin

imp导入工具将EXP形成的二进制系统文件导入到数据库中.

   它有三种模式：
       a.  用户模式： 导出用户所有对象以及对象中的数据；
       b.  表模式： 导出用户所有表或者指定的表；
       c.  整个数据库： 导出数据库中所有对象。
      
   只有拥有IMP_FULL_DATABASE和DBA权限的用户才能做整个数据库导入
  
   imp步骤：
   (1) create table  (2) insert data  (3) create index (4) create triggers,constraints

2.导入工具imp交互式命令行方式的例子
$ imp
Import: Release 10.1.0.2.0 - Production on 星期一 9月 3 08:21:32 2007
Copyright (c) 1982, 2004, Oracle.  All rights reserved.
用户名:  system
口令:****
连接到: Oracle Database 10g Enterprise Edition Release 10.1.0.2.0 - Production
With the Partitioning, OLAP and Data Mining options
导入文件: expdat.dmp> D:/all.dmp
输入插入缓冲区大小（最小为 8192 ) 30720>
经由常规路径导出由EXPORT:V08.01.06创建的文件
警告: 此对象由 TEST 导出, 而不是当前用户
已经完成ZHS16GBK字符集和ZHS16GBK NCHAR 字符集中的导入
只列出导入文件的内容(yes/no)：no>
由于对象已存在, 忽略创建错误(yes/no)：no> yes
导入权限(yes/no)：yes>
导入表数据(yes/no)：yes>
导入整个导出文件(yes/no)：no> yes
. 正在将TEST的对象导入到 SCOTT
. . 正在导入表                       "CMAMENU"       4336行被导入
成功终止导入，但出现警告。
3.导入工具imp非交互式命令行方式的例子

$ imp system/oracle fromuser=oa1 tables=(pfdept)
$ imp system/oracle fromuser=oa1 tables=(pfdept,pfuser)
$ imp system/oracle fromuser=oa1 touser=system
$ imp oa1/123 file = all.dmp full=y
$ imp oa1/123 file = all.dmp show=n buffer=2048000 ignore=n commit=y grants=y full=y log=D:/.log
$ imp oa1/123 parfile=params.dat
params.dat 内容
file=dba.dmp show=n ignore=n grants=y fromuser=oa1 tables=(pfdept,pfuser)

4.导入工具imp可能出现的问题

(1) 数据库对象已经存在
一般情况, 导入数据前应该彻底删除目标数据下的表, 序列, 函数/过程,触发器等; 
数据库对象已经存在, 按缺省的imp参数, 则会导入失败
如果用了参数ignore=y, 会把exp文件内的数据内容导入
如果表有唯一关键字的约束条件, 不合条件将不被导入
如果表没有唯一关键字的约束条件, 将引起记录重复

(2) 数据库对象有主外键约束
      不符合主外键约束时, 数据会导入失败
      解决办法: 先导入主表, 再导入依存表
disable目标导入对象的主外键约束, 导入数据后, 再enable它们
(3)  权限不够
如果要把A用户的数据导入B用户下, A用户需要有imp_full_database权限

(4)  导入大表( 大于80M ) 时, 存储分配失败
      默认的EXP时, compress = Y, 也就是把所有的数据压缩在一个数据块上.
      导入时, 如果不存在连续一个大数据块, 则会导入失败.
      导出80M以上的大表时, 记得compress= N, 则不会引起这种错误.

(5) imp和exp使用的字符集不同
      如果字符集不同, 导入会失败, 可以改变unix环境变量或者NT注册表里NLS_LANG相关信息.
      导入完成后再改回来.

(6) imp和exp版本不能往上兼容
imp可以成功导入低版本exp生成的文件, 不能导入高版本exp生成的文件
根据情况我们可以用

SQLplus rfiduser/jky_rfid_123 as sysdba
一:
create directory rfidnew as 'd:\rfidnew';
二:
grant read,wrITe on directory rfidnew to rfiduser;
三
impdp rfiduser/jky_rfid_123 directory=rfidnew dumpfile=myusertab1.dmp logfile=myusertab1.log tables=cc_info1,cc_info2,cc_car,cc_caifen,cc_recinfo,cc_accountinfo,cc_recinfo1,cc_user,road_info,managedep_info,ownerdep_info,tollstation_info,markstation_info,pikerate,vehicleregister,accountfreeze,accountthaw,tagreplace,ownerchange,vehiclelogout,vehiclecorrect,devicevindicate,devicelog,devicecontrol,enterrecord,markrecord,exitrecord,trafficrecord,pikerecord,pikesplitrecord,invoiceprintrecord,blacklist,userinfo,temprec_info,milesplit_info,costsplIT_info,InvalidTagRecord,BankAccount,deductRecord,tempmarkrec_info,synchronousrecord,delayexportrecord,feerate,accountrecharge,personuser,alarmlog,handiwork,systemlog,carchargeback,carbackout,transactionfaile,monthbalance

回答： 参考
http://www.cnblogs.com/KissKnife/archive/2007/09/17/896459.HTML

IMP数据到指定的表空间

一直以来，我都认为只要指定用户的默认表空间，向该用户导入数据时，会自动进入到默认表空间。后来发现从System导出的dmp文件在导入时，即使指定新用户的默认表空间，还是要往System表空间中导数据。

上网搜了一下，还是有解决方法的，常见的方法如下：

SQL> create user myhuang identified by myhuang default tablespace myhuang;

SQL> grant resource,connect to myhuang;

SQL> grant dba to myhuang;//赋DBA权限

SQL> revoke unlimITed tablespace from myhuang;//撤销此权限

SQL> alter user myhuang quota 0 on system;//将用户在System表空间的配额置为0

SQL> alter user myhuang quota unlimITed on myhuang;//设置在用户在myhuang表空间配额不受限。

经过上述设置后，就可以用imp导入数据，数据将会进入指定的myhuang表空间：

C:\Documents and Settings\myhuang>imp system/123456@vdb fromuser=lnxh tous

er=myhuang file=G:\myhuang\lnxh.dmp ignore=y grants=n

欢迎转载，但请保留出处，本文章转自[华软网] 原文链接：http://www.huarw.com/db/Oracle/200901/1655142.html

 2 将数据库中system用户与sys用户的表导出
   exp system/manager@TEST file=d:\daochu.dmp owner=(system,sys)

 3 将数据库中的表inner_notify、notify_staff_relat导出
    exp aichannel/aichannel@TESTDB2 file= d:\data\newsmgnt.dmp tables=(inner_notify,notify_staff_relat)

 4 将数据库中的表table1中的字段filed1以"00"打头的数据导出
   exp system/manager@TEST file=d:\daochu.dmp tables=(table1) query=\" where filed1 like '00%'\"
 
  上面是常用的导出，对于压缩，既用winzip把dmp文件可以很好的压缩。
  也可以在上面命令后面 加上 compress=y 来实现。
数据的导入
 1 将D:\daochu.dmp 中的数据导入 TEST数据库中。
   imp system/manager@TEST  file=d:\daochu.dmp
   imp aichannel/aichannel@HUST full=y  file=file= d:\data\newsmgnt.dmp ignore=y
   上面可能有点问题，因为有的表已经存在，然后它就报错，对该表就不进行导入。
   在后面加上 ignore=y 就可以了。

 2 将d:\daochu.dmp中的表table1 导入
 imp system/manager@TEST  file=d:\daochu.dmp  tables=(table1)
 
 基本上上面的导入导出够用了。不少情况要先是将表彻底删除，然后导入。
 
注意：
 操作者要有足够的权限，权限不够它会提示。
 数据库时可以连上的。可以用tnsping TEST 来获得数据库TEST能否连上。

附录一：
 给用户增加导入数据权限的操作
 第一,启动sql*puls
 第二，以system/manager登陆
 第三，create user 用户名 IDENTIFIED BY 密码 （如果已经创建过用户，这步可以省略）
 第四，GRANT CREATE USER,DROP USER,ALTER USER ,CREATE ANY VIEW ,
   DROP ANY VIEW,EXP_FULL_DATABASE,IMP_FULL_DATABASE,
      DBA,CONNECT,RESOURCE,CREATE SESSION  TO 用户名字
 第五, 运行-cmd-进入dmp文件所在的目录,
      imp userid=system/manager full=y file=*.dmp
      或者 imp userid=system/manager full=y file=filename.dmp

 执行示例:
 F:\Work\Oracle_Data\backup>imp userid=test/test full=y file=inner_notify.dmp

屏幕显示
Import: Release 8.1.7.0.0 - Production on 星期四 2月 16 16:50:05 2006
(c) Copyright 2000 Oracle Corporation.  All rights reserved.

连接到: Oracle8i Enterprise Edition Release 8.1.7.0.0 - Production
With the Partitioning option
JServer Release 8.1.7.0.0 - Production

经由常规路径导出由EXPORT:V08.01.07创建的文件
已经完成ZHS16GBK字符集和ZHS16GBK NCHAR 字符集中的导入
导出服务器使用UTF8 NCHAR 字符集 (可能的ncharset转换)
. 正在将AICHANNEL的对象导入到 AICHANNEL
. . 正在导入表                  "INNER_NOTIFY"          4行被导入
准备启用约束条件...
成功终止导入，但出现警告。

附录二：
 Oracle 不允许直接改变表的拥有者, 利用Export/Import可以达到这一目的.
  先建立import9.par,
  然后，使用时命令如下：imp parfile=/filepath/import9.par
  例 import9.par 内容如下：
        FROMUSER=TGPMS       
        TOUSER=TGPMS2     （注：把表的拥有者由FROMUSER改为TOUSER，FROMUSER和TOUSER的用户可以不同）          
        ROWS=Y
        INDEXES=Y
        GRANTS=Y
        CONSTRAINTS=Y
        BUFFER=409600
        file==/backup/ctgpc_20030623.dmp
        log==/backup/import_20030623.log

本文来自: 脚本之家(www.jb51.net) 详细出处参考：http://www.jb51.net/article/18251.htm

数据库连接池概述：

数据库连接的建立及关闭对系统而言是耗费系统资源的操作，在多层结构的应用环境中，这种耗费资源的动作对系统的性能影响尤为明显。在传统的数据库连接方式 （指通过DriverManager）中，一个数据库连接对象均对应一个物理数据库连接，每次操作都打开一个物理连接，使用完都关闭连接，这样造成系统的 性能低下。
数据库连接池的解决方案是在应用程序启动时建立足够的数据库连接，并讲这些连接组成一个连接池(简单说：在一个“池”里放了好多半成品的数据库联接对象)，由应用程序动态地对池中的连接进行申请、使用和释放。对于 多于连接池中连接数的并发请求，应该在请求队列中排队等待。并且应用程序可以根据池中连接的使用率，动态增加或减少池中的连接数。
连接池技术尽可能多地重用了消耗内存地资源，大大节省了内存，提高了服务器地服务效率，能够支持更多的客户服务。通过使用连接池，将大大提高程序运行效率，同时，我们可以通过其自身的管理机制来监视数据库连接的数量、使用情况等。

数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而再不是重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。
数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。数据库连接池的最小连接数和最大连接数的设置要考虑到下列几个因素：

1) 最小连接数是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费；

2) 最大连接数是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求将被加入到等待队列中，这会影响之后的数据库操作。

3) 如果最小连接数与最大连接数相差太大，那么最先的连接请求将会获利，之后超过最小连接数量的连接请求等价于建立一个新的数据库连接。不过，这些大于最小连接数的数据库连接在使用完不会马上被释放，它将被放到连接池中等待重复使用或是空闲超时后被释放。