创建通用的分组索引查询

谷歌地图原理给人印象深刻，JadePool针对百万条、甚至千万条的大数据创建的分组索引查询，就是借鉴了这一做法。

谷歌地图原理是把巨大的全球地图分割成一张张100px*100px的小图，查找地图时，给用户加载了(N+2)*(N+2)张小图，每次在屏幕上只显示中间N*N张相连的小图，当鼠标拖动时，如向左侧拖动时，屏幕外最左侧一列图片被挤出队列，屏幕外右侧一列图片进入屏幕右侧，新的相邻的一列小图被预加载到右侧屏幕外，如此生生不息，给用户带来了平滑地浏览全球的感觉。

如果一个表，其中的记录只有几百条、几千条，我们没有必要去费什么心思；如果记录有上万条、甚至千万条，我们必须认真对待。对记录创建分组索引相当于把全球地图分割成一张张小图，在建立了分组索引后，可以按照指定位置准确查询某一组记录。

具体的做法是这样的：

首先，按照顺序或者倒序查询表的第一个主键，通过ResultSet结果，获取主键在查询结果中的位置信息，记录的位置是从1开始计算；

二是对主键索引的位置信息进行分组，默认的步长是1000，如果有1000万条记录将被划分成1万组，会生成1万个索引节点；

三是通过指定节点查询一组记录，默认情况下通常是1000条记录，不足1000条的则是余下的全部记录。

此外，JadePool根据分组索引的结果，实现了另外两个方法：

一是通过指定位置开始，查询一组指定长度的记录；

二是通过指定位置查询一条记录。

ProcessVO调用底层的核心方法private IndexNode[] _indexNodes(String tableName, boolean rebuildIndexNodes) throws SQLException创建表的分组索引，针对主键创建的分组索引信息保存在DbCenter有限多列模式的一个实例中。DbCenter的实例管理了一组Table对象。

在Table类中，有一个IndexNode[] indexNodes数组，它保存着每一个表的主键分组索引信息。使用默认步长1000，每增加1000条记录创建一个节点，最后一个节点保存最后一条记录信息，每个节点记录表的第一个主键值以及按该键顺序查询结果的行数。默认的步长可以通过ProcessVO的public void setIndexNodesStepLength(int indexStepLength)方法修改。

IndexNode类有两个属性，第一个主键值firstKeyValue和行数row。

private IndexNode[] _indexNodes(String tableName, boolean rebuildIndexNodes) throws SQLException源代码

/**
* 创建表的索引节点数组<br/>
* 使用默认步长1000，每增加1000条记录创建一个节点，最后一个节点保存最后一条记录信息，每个节点记录表的第一个主键值以及按该键顺序查询结果的行数<br/>
*
* @param tableName 表名
* @param rebuildIndexNodes 是否无条件重建
* @return 返回IndexNode数组
* @throws SQLException
*/
private IndexNode[] _indexNodes(String tableName, boolean rebuildIndexNodes) throws SQLException {
Table table = db.getTable(tableName);
String key = db.getFields(tableName)[0];
if (db.getKeys(tableName).length > 0) {
key = db.getKeys(tableName)[0];
}
int length = (int) this.queryCount(tableName);
int nodeNums = (int) Math.ceil((double) length / (double) indexStepLength);
IndexNode[] nodes = db.getTable(tableName).getIndexNodes();
if (nodes == null) {
nodes = new IndexNode[nodeNums];
} else if (nodes.length == 0) {
nodes = new IndexNode[nodeNums];
}
int countInNodes = 0;
if (nodes[nodes.length - 1] != null) {//======= ====
countInNodes = nodes[nodes.length - 1].getRow();//最后一个节点保存了记录总长度(总行数)信息
}
boolean b = false;
if (table.getIndexStepLength() != indexStepLength) {
b = true;
table.setIndexStepLength(indexStepLength);
} else if (rebuildIndexNodes) {
b = true;
} else if (countInNodes == 0) {//无条件重新建立索引
b = true;
} else if (length > countInNodes) {
b = true;
}
if (b) {
String querySql = "select " + key + " from " + tableName + " order by " + key;
stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);//创建不敏感的可滚动结果集
rs = stmt.executeQuery(querySql);
nodes = new IndexNode[nodeNums];

int row = indexStepLength;
for (int i = 0; i < nodes.length - 1; i++) {
rs.absolute(row);
nodes[i] = new IndexNode();
nodes[i].setFirstKeyValue(rs.getObject(key));
nodes[i].setRow(rs.getRow());//"第一个关键字段的值对应的行号"
row += indexStepLength;
}
rs.last();
nodes[nodes.length - 1] = new IndexNode();
nodes[nodes.length - 1].setFirstKeyValue(rs.getObject(key));
nodes[nodes.length - 1].setRow(rs.getRow());//"第一个关键字段的值对应的行号"
db.getTable(tableName).setIndexNodes(nodes);
}
rs.close();
stmt.close();
return nodes;
}

public List indexByIndexNodes(String tableName, String[] fields, int position_of_indexNodes, boolean asc, boolean rebuildIndexNodes) throws SQLException源代码

/**
* 索引查询多条记录<br/> 根据已经建立的索引节点数组查询
* 返回的记录是当前节点的行数减前一节点的行数，即：默认的步长内的记录数，通常是1000。<br/>
* 默认步长可以调用pvo.setIndexNodesStepLength(indexStepLength)方法重新设置<br/>
* 可用于大数据分组分页查询
*
* @param tableName 表名
* @param fields 待查询的字段
* @param position_of_indexNodes
* 取第position_of_indexNodes位已建立的节点，取值[0,nodes.length - 1]
* @param asc 排列顺序，true顺序，false逆序
* @param rebuildIndexNodes 在查询前是否重新创建索引数组
* @return 返回List<Map>类型的结果
* @throws SQLException
*/
public List indexByIndexNodes(String tableName, String[] fields, int position_of_indexNodes, boolean asc, boolean rebuildIndexNodes) throws SQLException {
String key = db.getFields(tableName)[0];
if (db.getKeys(tableName).length > 0) {
key = db.getKeys(tableName)[0];
}
int step_old = db.getTable(tableName).getIndexStepLength();
if (this.indexStepLength != step_old) {
rebuildIndexNodes = true;
}//步长发生变化时，必须重建
IndexNode[] nodes = _indexNodes(tableName, rebuildIndexNodes);
List<Map> list = new ArrayList();
if (position_of_indexNodes < 0 || position_of_indexNodes >= (nodes.length - 1)) {
return list;//超出范围
}
Field f = db.getField(tableName, key);
String sort = "asc";
if (!asc) {
sort = "desc";
}
String sql = "select " + tool.arryToString(fields, ",") + " from  " + tableName + " where " + key + "<=" + nodes[position_of_indexNodes].getFirstKeyValue() + " order by " + key + " " + sort;
if (f.getTypeClassName().equals("java.lang.String")) {
sql = "select " + tool.arryToString(fields, ",") + " from  " + tableName + " where " + key + "<='" + nodes[position_of_indexNodes].getFirstKeyValue() + "' order by " + key + " " + sort;
}
if (position_of_indexNodes > 0 && position_of_indexNodes <= (nodes.length - 1)) {
sql = "select " + tool.arryToString(fields, ",") + " from  " + tableName + " where " + key + ">" + nodes[position_of_indexNodes - 1].getFirstKeyValue() + " and " + key + "<=" + nodes[position_of_indexNodes].getFirstKeyValue() + " order by " + key + " " + sort;
if (f.getTypeClassName().equals("java.lang.String")) {
sql = "select " + tool.arryToString(fields, ",") + " from  " + tableName + " where " + key + ">'" + nodes[position_of_indexNodes - 1].getFirstKeyValue() + "'and " + key + "<='" + nodes[position_of_indexNodes].getFirstKeyValue() + "' order by " + key + " " + sort;
}
}
db.getTable(tableName).setPosition_of_indexNodes(position_of_indexNodes);//保存本次查询的位置信息
list = this.query(sql);
return list;
}

分组索引查询范例：

/*
* 假设表tableName中含有100万条记录，按每组1000条记录分组，查找第99组记录[索引号98]
*/

Jade j = new Jade();
List<Map> v = j.indexByIndexNodes(tableName, new String[]{fieldName1, fieldName2, fieldName3}, 98, false降序, false不重新创建索引数组);
j.commit();

JadePool创建的分组索引不同于在数据库中创建的索引，按照我手头一部《SQL Server 2008实战》（人民邮电出版社）一书的说法，在数据库中创建索引可以有效地提高查询的效率，但是会带来一些副作用，它会扰动数据存储的物理结构，会影响插入、更新操作。JadePool针对主键创建的分组索引信息是保存在DbCenter有限多列模式的一个实例中，它不会扰动数据存储。用户可以使用分组索引信息实现精准的数据查询，从而提高了数据库的查询效率。JadePool这种做法至少在理论上是对的，在大数据查询上能否有效有待实践的检验。

另外两个方法

与indexByIndexNodes大致相同。

public List indexByRow(String tableName, String[] fields, int row_in_table, int length, boolean asc) throws SQLException 源代码

/**
* 索引查询多条记录
*
* @param tableName 表名
* @param fields 待查询的字段
* @param row_in_table 从该行开始，取值[1,记录总长度]，出界位置返回0长度List<Map>结果
* @param length 查询长度，row_in_table后记录数少于length，则返回其后的全部记录
* @param asc 排列顺序，true顺序，false逆序
* @return 返回List<Map>类型的结果
* @throws SQLException
*/
public List indexByRow(String tableName, String[] fields, int row_in_table, int length, boolean asc) throws SQLException {
String key = db.getFields(tableName)[0];
if (db.getKeys(tableName).length > 0) {
key = db.getKeys(tableName)[0];
}
List<Map> list = new ArrayList();
IndexNode[] nodes = _indexNodeTwo(tableName, row_in_table, length);
Field f = db.getField(tableName, key);
String sort = "asc";
if (!asc) {
sort = "desc";
}
String sql = "select " + tool.arryToString(fields, ",") + " from  " + tableName + " where " + key + ">=" + nodes[0].getFirstKeyValue() + " and  " + key + "<=" + nodes[1].getFirstKeyValue() + " order by " + key + " " + sort;
if (f.getTypeClassName().equals("java.lang.String")) {
sql = "select " + tool.arryToString(fields, ",") + " from  " + tableName + " where " + key + ">='" + nodes[0].getFirstKeyValue() + "' and  " + key + "<='" + nodes[1].getFirstKeyValue() + "' order by " + key + " " + sort;
}
list = this.query(sql);
return list;
}

public Map indexByRow(String tableName, String[] fields, int row_in_table) throws SQLException源代码

/**
* 索引查询一条记录
*
* @param tableName 表名
* @param fields 待查询的字段
* @param row_in_table 从该行开始，取值[1,记录总长度]，出界位置返回0长度List<Map>结果
* @return 返回List<Map>类型的结果
* @throws SQLException
*/
public Map indexByRow(String tableName, String[] fields, int row_in_table) throws SQLException {
String key = db.getFields(tableName)[0];
if (db.getKeys(tableName).length > 0) {
key = db.getKeys(tableName)[0];
}
IndexNode nodes = _indexNodeOne(tableName, row_in_table);
Field f = db.getField(tableName, key);
String sql = "select " + tool.arryToString(fields, ",") + " from  " + tableName + " where " + key + "=" + nodes.getFirstKeyValue();
if (f.getTypeClassName().equals("java.lang.String")) {
sql = "select " + tool.arryToString(fields, ",") + " from  " + tableName + " where " + key + " like '" + nodes.getFirstKeyValue() + "'";
}
Map m = this.queryOne(sql);
return m;
}