创建通用的分组索引查询

        谷歌地图原理给人印象深刻，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;
    }