为快速高维OLAP实现壳片段shell-fragment的方法（具体实现）

最新推荐文章于 2022-09-13 22:02:19 发布

时间里的河

最新推荐文章于 2022-09-13 22:02:19 发布

阅读量567

点赞数

分类专栏： CS java

本文链接：https://blog.csdn.net/weixin_37726222/article/details/84947050

版权

java 同时被 2 个专栏收录

26 篇文章 0 订阅

订阅专栏

9 篇文章 0 订阅

订阅专栏

本文目录结构

数据存储
索引建立
- 原始索引
- 壳片段的完全数据立方体的倒排索引
在壳片段计算完成之后，处理点查询和子立方体查询。
- 对于点查询
- 对于子立方体查询
下面是一些技术细节（附代码）

数据存储

为方便程序的读取，同时节约内存开支，我把存储在csv文件中的数据读入数据库，在数据库中建立oriTable用来存放原始表格数据。

索引建立

原始索引

通过一遍扫描（按列扫描），为原始数据表中的部分字段（根据数据特点和具体的需要进行选取）建立索引。并且在相同数据库下为每一个字段建立一张表，用来存放该字段下全部数据的倒排索引表。

壳片段的完全数据立方体的倒排索引

对每一个片段（egA1,A2,A3），需要对它的每一个方体(eg A1,A2)的每一个单元(eg,1/0,0/0,1/1,1/0)计算倒排索引表，对每一个单元，记录它关联的TID列表。并存入数据库。

在壳片段计算完成之后，处理点查询和子立方体查询。

对于点查询

首先对查询语句进行处理，划分成壳片段的部分和单一维度的部分，对于“*”由于是不相关的，把它视为孤立的单一维度，并且不对它进行处理。

对于子立方体查询

把?询问的维度看作是单一维度，对于它的每一个值，分别与其他的各个例示的值组成一条点查询。如果有两个或者三个问号，则需要进行交叉。这个就把一个复杂问题分解成了许多个可以handle的小问题。
壳片段与完全立方体的区别

下面是一些技术细节（附代码）

1.我的项目目录结构：

简要介绍一下每一个类的功能。
其实我觉得我的命名很规范，算了，不介绍了。给你个眼神你自己体会。

DataToDB（将csv文件中的原始数据写到数据库中去）

表是我手动建立的，核心还是调用了DBU的插入函数。

package com.chang;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;

public class DataToDB {
	public static ArrayList<String> readCsv(String filepath) {
		File csv = new File(filepath); // CSV文件路径
		csv.setReadable(true);// 设置可读
		csv.setWritable(true);// 设置可写
		BufferedReader br = null;
		try {
			br = new BufferedReader(new FileReader(csv));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		String line = "";
		String everyLine = "";
		ArrayList<String> allString = new ArrayList<>();
		try {
			while ((line = br.readLine()) != null) // 读取到的内容给line变量
			{
				everyLine = line;
				allString.add(everyLine);
			}
			System.out.println("csv表格中所有行数：" + allString.size());
		} catch (IOException e) {
			e.printStackTrace();
		}
		return allString;
	}
	//前提是先在数据库中创建好了表。
	public static void main(String[] args) {
		System.out.println("hello");
		ArrayList<String> arrayList = new ArrayList<>();
		// .\代表当前路径
		arrayList = readCsv("./resourse\\employees.csv");
		//获取到列名数组。
		String col_names = arrayList.remove(0);
		String[] col_names_array = col_names.split(",");
		System.out.println(Arrays.toString(col_names_array));
		int i=0;
		for (String str : arrayList) {
			// System.out.println(str);
			i++;
			String[] values_array =str.split(",");
			System.out.println(Arrays.toString(values_array));
			DBUtil.insert("ori_table", col_names_array, values_array);
			System.out.println(i);
		}
	}
}

效果如下图：
数据库的原始数据表

DBUtil.java （数据库交互）

其中在创建表之前，加入了判断，如果已经存在同名的表，那么将同名的表删除掉。在select函数取数据的时候，怎么都取不出来，后来发现是因为数字作字段名，需要数字两边加上``。还有一个获取表的列名的函数，用的地方其实挺多，挺有用的。由于存放壳片段产生的索引的需要，我在DBUtil中加入了一个建表的函数，输入是表名和字段名的数组，输出当然是数据库里的一张表啦，不太好的是这个函数被我写死了,因为是用来存长长的索引串的，所以一律采用longtext存储。

package com.chang;

import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Arrays;
import java.util.Properties;

import com.mysql.cj.jdbc.PreparedStatement;
import com.mysql.cj.jdbc.result.ResultSetMetaData;

public class DBUtil {

	private static String dbDriver = "com.mysql.cj.jdbc.Driver";
	private static String dbUrl;
	private static String dbUser;
	private static String dbPass;

	public static boolean config(String mysqlURL, String mysqlUserName, String mysqlPassword) {
		try {
			Class.forName(dbDriver);
		} catch (ClassNotFoundException e) {
			System.err.println(e);
			return false;
		}

		dbUrl = mysqlURL;
		dbUser = mysqlUserName;
		dbPass = mysqlPassword;
		System.out.println("URL:" + dbUrl);
		System.out.println("UserName:" + dbUser);
		System.out.println("Password:" + dbPass);
		try {
			Connection conn = DriverManager.getConnection(dbUrl, dbUser, dbPass);
			conn.close();
		} catch (SQLException e) {
			System.err.println(e);
			dbUrl = null;
			dbPass = null;
			dbUser = null;
			return false;
		}
		return true;
	}

	public static Connection getConn() {
		try {
			Class.forName(dbDriver);
		} catch (ClassNotFoundException e) {
			System.err.println(e);
			return null;
		}
		Connection conn;
		if (dbUrl == null || dbUser == null || dbPass == null) {
			Properties prop = new Properties();
			try {
				prop.load(DBUtil.class.getResourceAsStream("/application.properties"));
			} catch (IOException e) {
				System.err.println(e);
				return null;
			}
			dbUrl = prop.getProperty("mysqlURL");
			dbUser = prop.getProperty("mysqlUserName");
			dbPass = prop.getProperty("mysqlPassword");
		}
		try {
			conn = DriverManager.getConnection(dbUrl, dbUser, dbPass);
		} catch (SQLException e) {
			System.err.println(e);
			return null;
		}
		return conn;
	}

	public static void release(Connection conn, Statement st, ResultSet rs) {
		if (rs != null) {
			try {
				rs.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}

		}
		if (st != null) {
			try {
				st.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		if (conn != null) {
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}

	/*
	 * @param tableName,the target parameters,the parameter values
	 * 
	 * @return flag(true->success)
	 */
	public static boolean insert(String table, String[] params, String[] params_value) {
		boolean flag = true;
		Connection conn = null;
		PreparedStatement st = null;
		ResultSet rs = null;
		String sql = "insert into " + table + " (";
		for (int i = 0; i < params.length - 1; i++) {
			sql += "`" + params[i] + "`" + ",";
		}
		sql += "`" + params[params.length - 1] + "`" + ") values (";
		for (int j = 0; j < params_value.length - 1; j++) {
			sql += "'" + params_value[j] + "' ,";
		}
		sql += "'" + params_value[params_value.length - 1] + "');";
		try {
			conn = getConn();

			try {
				st = (PreparedStatement) conn.prepareStatement(sql);
			} catch (SQLException e) {
				flag = false;
				e.printStackTrace();
			}
			try {
				st.executeUpdate();
			} catch (SQLException e) {
				flag = false;
				e.printStackTrace();
			}
		} finally {
			release(conn, st, rs);
		}
		return flag;
	}

	/*
	 * select {params} from table
	 */
	public static String[][] select(String table, String[] params) {
		Connection conn = null;
		PreparedStatement st = null;
		ResultSet rs = null;
		String[][] result = null;
		String sql = "select ";
		for (int i = 0; i < params.length - 1; i++) {
			sql +="`"+ params[i] +"`"+ ",";
		}
		sql +="`"+ params[params.length - 1] + "`"+" from " + table;
		try {
			conn = getConn();
			try {
				st = (PreparedStatement) conn.prepareStatement(sql);
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				rs = st.executeQuery();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			java.sql.ResultSetMetaData mm = null;
			try {
				mm = rs.getMetaData();
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
			int columns = 0;
			try {
				columns = mm.getColumnCount();
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
			int rowCount = 0;
			try {
				rs.last();
				rowCount = rs.getRow();
			} catch (Exception e) {
				e.printStackTrace();
			}
			try {
				rs.beforeFirst();
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
			int k = 0;
			try {
				result = new String[rowCount][columns];
				while (rs.next()) {
					for (int i = 1; i <= columns; i++) {
						try {
							result[k][i - 1] = rs.getString(i);
						} catch (SQLException e) {
							e.printStackTrace();
						}
					}
					k++;
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			return result;

		} finally {
			release(conn, st, rs);
		}

	}

	/**
	 * 创建表
	 * 
	 * @param tabName
	 *            表名称
	 * @param tab_fields
	 *            表字段
	 */
	public static void createTableOri(String tabName, String[] tab_fields) {
		// 首先要获取连接，即连接到数据库
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			conn = getConn();
			String sql = "create table " + tabName + "(id int auto_increment primary key not null";
			if (tab_fields != null && tab_fields.length > 0) {
				sql += ",";
				int length = tab_fields.length;
				for (int i = 0; i < length; i++) {
					// 添加字段
					sql += tab_fields[i].trim() + " varchar(50)";
					// 防止最后一个,
					if (i < length - 1) {
						sql += ",";
					}
				}
			}
			// 拼凑完 建表语句 设置默认字符集
			sql += ")DEFAULT CHARSET=utf8;";
//			System.out.println("建表语句是：" + sql);
			ps = (PreparedStatement) conn.prepareStatement(sql);
			ps.executeUpdate(sql);
			ps.close();
			conn.close(); // 关闭数据库连接
		} catch (SQLException e) {
			System.out.println("建表失败" + e.getMessage());
		}
	}

	public static void createTable(String tabName, String[] tab_fields) {
		// 首先要获取连接，即连接到数据库
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			conn = getConn();
			String sql = "create table " + tabName + "(";
			if (tab_fields != null && tab_fields.length > 0) {
				int length = tab_fields.length;
				for (int i = 0; i < length; i++) {
					// 添加字段
					sql += "`" + tab_fields[i].trim() + "`" + " longtext";
					// 防止最后一个,
					if (i < length - 1) {
						sql += ",";
					}
				}
			}
			// 拼凑完 建表语句 设置默认字符集
			sql += ");";
//			System.out.println("建表语句是：" + sql);
			ps = (PreparedStatement) conn.prepareStatement(sql);
			ps.executeUpdate(sql);
			ps.close();
			conn.close(); // 关闭数据库连接
		} catch (SQLException e) {
			System.out.println("建表失败" + e.getMessage());
		}
	}

	public static void dropTable(String[] tabName) {
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			conn = getConn();
			// 下面开始拼凑sql语句。
			for (String aTabName : tabName) {
				String sql = "drop table if exists " + aTabName + ";";
//				System.out.println("删表语句是：" + sql);
				ps = (PreparedStatement) conn.prepareStatement(sql);
				ps.executeUpdate(sql);
			}

			ps.close();
			conn.close(); // 关闭数据库连接
		} catch (SQLException e) {
			System.out.println("删表失败" + e.getMessage());
		}
	}

	public static String[] GetColNames(String tbName) {
		Connection conn = null;
		PreparedStatement ps = null;
		String[]temp=null;
		try {
			conn = getConn();
			// 下面开始拼凑sql语句。
			String sql = "select*from " + tbName + ";";
			ps = (PreparedStatement) conn.prepareStatement(sql);
			ResultSet rs = ps.executeQuery(sql);
			ResultSetMetaData data = (ResultSetMetaData) rs.getMetaData();
			String[] colNames = new String[data.getColumnCount()];
			temp=colNames;
			for (int i = 0; i < data.getColumnCount(); i++) {
				// 获得指定列的列名
				colNames[i] = data.getColumnName(i + 1);
			}
			ps.close();
			conn.close(); // 关闭数据库连接
		} catch (SQLException e) {
			System.out.println("获取列名失败" + e.getMessage());
		}
		return temp;
	}

	public static void main(String[] args) throws ClassNotFoundException, SQLException {

		//
		// String table_name="ori_table";
		// String[]params= {"satisfaction_level","number_project","already_left"};
		// String[]params_value= {"5","5","2"};
		//
		// insert(table_name, params, params_value);
		// System.out.println("插入成功");
		
//		String tabName = "liu";
//		String[] tab_fields = { "name", "school" };
//		createTable(tabName, tab_fields);
//		String[] tabNames = { "liu" };
//		dropTable(tabNames);
//		
		String[]testcolNames=GetColNames("salary");
		System.out.println(Arrays.toString(testcolNames));
		
	}

}

GnerFrag（产生壳片段，并把索引写入数据库中）

可以说是本程序的核心代码了。其中crossGenrTable是对给定的字段数组交叉产生索引表的函数。
它可以接受三个参数，也可以接受两个参数。对于三个参数，，它可以递归的调用自己。不足，这个地方耦合度有点小高。

该程序可以反复运行。对于划分一个大小为3，一个为2维的两个壳片段，运行时间稳定在4秒。由此可见，壳片段的生成时间还是比较长的。

package com.chang;

import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class GenrFrag {

	public static String cal_array_and(String[][] firarray, String[][] secarray) {

		String fir_index_str = firarray[0][0];
		String sec_index_str = secarray[0][0];
		String[] fir_index_array = fir_index_str.split(",");
		String[] sec_index_array = sec_index_str.split(",");
//		System.out.println("检查数组1是否正常" + Arrays.toString(fir_index_array)+"length:"+fir_index_str.length());
//		System.out.println("检查数组2是否正常" + Arrays.toString(sec_index_array));

		// 问题在此处：
		HashSet<Integer> hashSet = new HashSet<>();
		HashSet<Integer> hashSet2 = new HashSet<>();
		String resultStr=null;
		if (fir_index_str.length() != 0) {
			for (String aNum : fir_index_array) {
				if ((aNum != null) && (aNum.trim() != "")) {
					hashSet.add(Integer.parseInt(aNum.trim()));
				}
			}

			for (String bNum : sec_index_array) {
				if (hashSet.contains(Integer.parseInt(bNum.trim()))) {
					hashSet2.add(Integer.parseInt(bNum.trim()));
				} else {
					continue;
				}
			}
			
			// 检查set是否正常
//			System.out.println("检查set");
//			for (Integer str : hashSet2) {
//				System.out.print(str);
//			}
//			System.out.println();
			// 下面为了把这个set转化为字符串。
			Integer[] array2 = hashSet2.toArray(new Integer[hashSet2.size()]);
			String valueStr = Arrays.toString(array2);
//			System.out.println("检查valueStr是否正常" + valueStr);
			String regEx = "[\\[\\]]";
			Pattern p = Pattern.compile(regEx);
			Matcher m = p.matcher(valueStr);
			resultStr = m.replaceAll("").trim();

		}else {
			resultStr="";
		}

	
		return resultStr;

	}

	@SuppressWarnings("null")
	public static String crossGenrTable(String[] colNames) {
		String new_table_name = "";
		if (colNames.length == 2) {
			String table_1 = colNames[0];
			String table_2 = colNames[1];
			// 需要一个获取表中列名数组的函数。
			String[] table_1_cols = DBUtil.GetColNames(table_1);
			String[] table_2_cols = DBUtil.GetColNames(table_2);
			// System.out.println(Arrays.toString(table_1_cols));
			// System.out.println(Arrays.toString(table_2_cols));

			// 下面生成新的表名：
			String newTableName = table_1 + "9" + table_2;

			// 下面生成新的列名数组：
			ArrayList<String> new_col_list = new ArrayList<>();
			for (String oneCol : table_1_cols) {
				for (String secCol : table_2_cols) {
					String temp_cross_col = oneCol + "9" + secCol;
					new_col_list.add(temp_cross_col);
				}
			}
			int size = new_col_list.size();
			String[] new_col_array = (String[]) new_col_list.toArray(new String[size]);
//			System.out.println(Arrays.toString(new_col_array));

			// 下面建立新的表：
			String[] newTableNames = { newTableName };
			DBUtil.dropTable(newTableNames);
			DBUtil.createTable(newTableName, new_col_array);

			// 下面需要往新的表中插入数据
			// 首先需要从旧表中，取出数据,需要进行交叉取出
			String[][] oneCol_data = null;
			String[][] secCol_data = null;
			HashMap<String, String> aHashMap = new HashMap<>();

//			System.out.println("此时的table1是" + table_1);
			for (String oneCol : table_1_cols) {
				for (String secCol : table_2_cols) {
					String temp_cross_col = oneCol + "9" + secCol;
					String[] oneCol_array = { oneCol };
					String[] secCol_array = { secCol };
					oneCol_data = DBUtil.select(table_1, oneCol_array);
					secCol_data = DBUtil.select(table_2, secCol_array);
					// 此处可以取到数据
//					System.out.println(Arrays.deepToString(oneCol_data));
					// 此处需要一个函数，输入两个二维的单列数组（第二维是0），输出一个valueStr，它作为交运算的结果存起来。
					// 是交计算的两个数组的运算结果。

					String resultStr = cal_array_and(oneCol_data, secCol_data);
					aHashMap.put(temp_cross_col, resultStr);
				}
			}

//			// 测试，遍历hashmap:
//			System.out.println("\n通过Map.keySet遍历key和value：");
//			for (String key : aHashMap.keySet()) {
//				System.out.println("Key: " + key + " Value: " + aHashMap.get(key));
//				System.out.println("长度是" + aHashMap.get(key).split(",").length);
//
//			}

			String[] params_value = new String[new_col_array.length];
			int i = 0;
			for (String key : new_col_array) {
				String value = aHashMap.get(key);
				params_value[i] = value;
				i++;
			}
			// 把上面得到的hashtable插入到新的表newTableName中。
			DBUtil.insert(newTableName, new_col_array, params_value);
			new_table_name = newTableName;
		} else if (colNames.length == 3) {
			String[][] son_cubes=get_son_cube(colNames);
			for(String[] each_son_cube:son_cubes) {
				crossGenrTable(each_son_cube);
			}
			
			String[] colNames_temp = new String[2];
			colNames_temp[0] = colNames[0];
			colNames_temp[1] = colNames[1];
			String newTabName = crossGenrTable(colNames_temp);
			colNames_temp[0] = newTabName;
			colNames_temp[1] = colNames[2];
			new_table_name = crossGenrTable(colNames_temp);
		}
		return new_table_name;
	}
	
	public static String[][] get_son_cube(String[]col_names){
		String[][]temp=new String[3][2];
		int k=0;
		for(int i=0;i<3;i++) {
	
				for(int j=i+1;j<3;j++) {
					temp[k][0]=col_names[i];
					temp[k][1]=col_names[j];
//					System.out.println("i $ j"+i+" "+j);
					k++;
				}
			
	
		}
//		System.out.println(Arrays.deepToString(temp));
		return temp;
	}

	public static void main(String[] args) throws FileNotFoundException {

		PrintStream ps = new PrintStream("./cout.txt");
		System.setOut(ps);// 把创建的打印输出流赋给系统。即系统下次向 ps输出
		// TODO Auto-generated method stub
		long startTime = System.currentTimeMillis();    //获取开始时间
		String[] colNames = { "dept", "salary", "number_project" };
		crossGenrTable(colNames);
		String[] colNames_1 = { "already_left", "promotion_last_5years" };
		crossGenrTable(colNames_1);
		
		
		long endTime = System.currentTimeMillis();
		
		System.out.println("程序运行时间是 "+(endTime-startTime)/1000+"(s)");
		
	}

}

IndexToDB.java 原始表的索引写入数据库

package com.chang;
import static java.lang.System.out; // 静态导入System类的 out 静态属性
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.chang.DBUtil;

public class IndexToDB {

	// 输入表名，列名
	// 返回该列的倒排索引表
	public static HashMap<String, ArrayList<Integer>> GetIndexTable(String tableName, String colName) {
		String[] params = { colName };
		String[][] result_set = DBUtil.select(tableName, params);
		// 每一个aStrings都是一个一维数组。
		HashMap<String, ArrayList<Integer>> cMap = new HashMap<>();
		int k = 1;
		for (String[] aStrings : result_set) {
			ArrayList<Integer> indexList = new ArrayList<>();
			if (!cMap.containsKey(aStrings[0])) {
				cMap.put(aStrings[0], indexList);
			} 
			cMap.get(aStrings[0]).add(k);
			
			k++;
		}
		return cMap;

	}

	// 输入表名，列名的字符串数组
	// 返回Hashmap的map，每一个元素key列名的标志，value是一个Integer List。
	public static HashMap<String, HashMap<String, ArrayList<Integer>>> GetAllIndex(String tableName, String[] params) {
		HashMap<String, HashMap<String, ArrayList<Integer>>> newHashmap = new HashMap<>();
		for (String param : params) {
			HashMap<String, ArrayList<Integer>> oneHashMap = GetIndexTable(tableName, param);
			newHashmap.put(param, oneHashMap);
		}
		return newHashmap;
	}

	public static String getMapStr(HashMap<String, ArrayList<Integer>> aHashMap) {
		// 测试用，打印hashmap
		String total_str = "";
		Iterator iter = aHashMap.entrySet().iterator();
		while (iter.hasNext()) {
			Map.Entry entry = (Map.Entry) iter.next();
			Object key = entry.getKey();
			ArrayList<Integer> value = (ArrayList<Integer>) entry.getValue();
			Object[] aObjects = { value };
			String valueStr = Arrays.deepToString(aObjects);
			String regEx = "[\\[\\]]";
			Pattern p = Pattern.compile(regEx);
			Matcher m = p.matcher(valueStr);
			valueStr = m.replaceAll("").trim();
			String temp = key + ":" + valueStr;
			total_str = total_str + temp + "\n";
		}
		return total_str;
	}
	
	public static String getIndexStr(ArrayList<Integer> params_value_list) {
		Object[]aObjects= {params_value_list};
		String valueStr = Arrays.deepToString(aObjects);
		String regEx = "[\\[\\]]";
		Pattern p = Pattern.compile(regEx);
		Matcher m = p.matcher(valueStr);
		valueStr = m.replaceAll("").trim();
		return valueStr;
	}

	public static void PrintHashMap(HashMap<String, HashMap<String, ArrayList<Integer>>> aHashMap) {
		System.out.println("\n通过Map.entrySet遍历key和value");
		for (Map.Entry<String, HashMap<String, ArrayList<Integer>>> entry : aHashMap.entrySet()) {
			System.out.println("Key: " + entry.getKey() + "\n" + " Value: " + getMapStr(entry.getValue()));
		}
	}
	

	public static void writeIndexToDB(HashMap<String, HashMap<String, ArrayList<Integer>>> aHashMap) {
		for (Map.Entry<String, HashMap<String, ArrayList<Integer>>> entry : aHashMap.entrySet()) {

			// 每一个entry都是一个表名啊（也就是原来的表中的一个列）。
			String akey = entry.getKey();
			Set<String> valueSet = entry.getValue().keySet();

			// 把set集合转化为数组。
			String[] setValues = valueSet.toArray(new String[valueSet.size()]);
			String[] tableNames= {akey};
			DBUtil.dropTable(tableNames);
			// 为每一个列创建表。其中akey是表名，setValues是列名数组。
			DBUtil.createTable(akey, setValues);

			// 接下来应该遍历hashmap,给每一个表的每一个列填充索引数组。
			
			String[]params_value=new String[valueSet.size()];
			int i=0;
			for (Map.Entry<String, ArrayList<Integer>> inner_entry : aHashMap.get(akey).entrySet()) {
				ArrayList<Integer> params_value_list = inner_entry.getValue();
				String one_param_value=getIndexStr(params_value_list);
				params_value[i]=one_param_value;
				i++;
			}
			System.out.println("当前的表名是"+akey);
			out.println("表参数是"+Arrays.toString(setValues));
			for(String each:params_value) {
				System.out.println(each);
			}
			
			DBUtil.insert(akey, setValues, params_value);
			// //test the valueSet
			// Iterator<String> aIterator = valueSet.iterator();
			// while (aIterator.hasNext()) {
			// String str = aIterator.next();
			// System.out.println(str);
			// }

		}
	}

	public static void main(String[] args) throws FileNotFoundException {

		PrintStream ps = new PrintStream("./cout.txt");
		System.setOut(ps);// 把创建的打印输出流赋给系统。即系统下次向 ps输出

		//ori_table中是原始的数据
		//指定要索引的列，然后在原始数据表相同的数据库里面放入所有索引表。
		String[] params = { "salary", "dept", "number_project", "time_spend_company", "work_accident", "already_left",
				"promotion_last_5years", "dept", "salary" };
		HashMap<String, HashMap<String, ArrayList<Integer>>> allMap = GetAllIndex("ori_table", params);
		// PrintHashMap(allMap);
		writeIndexToDB(allMap);
		
	}

}

Search.java 查询处理（点查询和子立方体查询）

在使用点查询时，※部分也可以进行例示
在使用子立方体查询时，？部分也可以进行※或者进行例示。

package com.chang;

import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Search {

	public static String tri_cube(String attr_Str) {
		String[] params = { attr_Str };
		String[][] result = null;
		result = DBUtil.select("dept9salary9number_project", params);
		return result[0][0];
	}

	public static String one_col(String attr_str, String tableName) {
		String[] params = { attr_str };
		String[][] result = null;
		result = DBUtil.select(tableName, params);
		return result[0][0];
	}

	public static String dou_cube(String attr_Str) {
		String[] params = { attr_Str };
		String[][] result = null;
		result = DBUtil.select("already_left9promotion_last_5years", params);
		return result[0][0];
	}

	public static String dot_search(String[] attrs) {
		String[] tri_temp = Arrays.copyOfRange(attrs, 0, 3);
		String[] dou_temp = Arrays.copyOfRange(attrs, 3, 5);
		String sixth_attr = attrs[5];
		String seventh_attr = attrs[6];
		String temp = tri_cube(combi_attrs(tri_temp));
		String temp1 = dou_cube(combi_attrs(dou_temp));

		String[][] firarray = { { temp } };
		String[][] secarray = { { temp1 } };
		String valueStr = GenrFrag.cal_array_and(firarray, secarray);
		
		if (sixth_attr!="*") {
			String temp2 = one_col(sixth_attr, "work_accident");
			String[][] firarray_1 = { { valueStr } };
			String[][] secarray_1 = { { temp2 } };
			valueStr = GenrFrag.cal_array_and(firarray_1, secarray_1);
		}
		if (seventh_attr!="*") {
			String temp3 = one_col(seventh_attr, "time_spend_company");
			String[][] firarray_2 = { { valueStr } };
			String[][] secarray_2 = { { temp3 } };
			valueStr = GenrFrag.cal_array_and(firarray_2, secarray_2);
		}
		return valueStr;
	}

	public static String combi_attrs(String[] attrs) {
		String regEx = "[\\[\\]]";
		Pattern p = Pattern.compile(regEx);
		Matcher m = p.matcher(Arrays.toString(attrs).replaceAll(", ", "9"));
		return m.replaceAll("").trim();
	}

	public static 	HashMap<String, String> cube_search(String[]attrs) {
		//目标：根据问号生成一组全部被例示的查询
		String[] col_names = 
			{"dept", "salary", "number_project", "already_left","prompotion_last_5years","work_accident","time_spned_company"};
		HashMap<String, String>aHashMap=new HashMap<>();
		if (attrs[5].equals("?")&&attrs[6].equals("?")) {
			String[]col_attrs_5=DBUtil.GetColNames("work_accident");
			String[]col_attrs_6=DBUtil.GetColNames("time_spend_company");
		
			for(String each_attr_5:col_attrs_5) {
				for(String each_attr_6:col_attrs_6) {
					attrs[5]=each_attr_5;
					attrs[6]=each_attr_6;
					String temp_res_str=dot_search(attrs);
					aHashMap.put("("+each_attr_5+","+each_attr_6+")",temp_res_str);
				}
			}
			
		}
		
		else if (attrs[5].equals("?")) {
			String[]col_attrs_5=DBUtil.GetColNames("work_accident");
			for(String each_attr_5:col_attrs_5) {
				attrs[5]=each_attr_5;
				String temp_res_str=dot_search(attrs);
				aHashMap.put("("+each_attr_5+")",temp_res_str);
			}
		}else if (attrs[6].equals("?")) {
			
			String[]col_attrs_6=DBUtil.GetColNames("time_spend_company");
			for(String each_attr_6:col_attrs_6) {
				attrs[6]=each_attr_6;
				String temp_res_str=dot_search(attrs);
				aHashMap.put("("+each_attr_6+")",temp_res_str);
			}
		}
		return aHashMap;
	}
	
	
	public static void main(String[] args) throws FileNotFoundException {
		PrintStream ps = new PrintStream("./cout.txt");
		System.setOut(ps);// 把创建的打印输出流赋给系统。即系统下次向 ps输出
//		String temp = tri_cube("accounting9medium92");
//		String temp1 = dou_cube("190");
//		String temp2 = one_col("0", "work_accident");
//		String[][] firarray = { { temp } };
//		String[][] secarray = { { temp2 } };
//		String valueStr = GenrFrag.cal_array_and(firarray, secarray);
//		System.out.println("The cal_result is \n" + valueStr);
//		String[][] firarray_1 = { { valueStr } };
//		String[][] secarray_1 = { { temp1 } };
//		valueStr = GenrFrag.cal_array_and(firarray_1, secarray_1);
//		System.out.println("The cal_result is \n" + valueStr);
		
		//各个索引字段的顺序。
		/*String[] col_names = 
		 * {"dept", "salary", "number_project", 
		 * 
		 * "already_left","prompotion_last_5years","work_accident","time_spned_company"};*/
		String[]attrs= {"sales","medium","2","1","0","*","*"};
		String result_str=dot_search(attrs);
		System.out.println("The result is as below \n" + result_str);
		System.out.println("The result length is as below \n"+result_str.split(",").length);
		
		String[]attrs_1= {"sales","medium","2","1","0","*","?"};
		HashMap<String, String>testMap=cube_search(attrs_1);
		Set<Entry<String, String>> ms =testMap.entrySet();
		for (Map.Entry entry : ms) {
			System.out.println(entry.getKey()+":  "+entry.getValue());
		}
	}

}

在这里插入图片描述

看，两个查询放在一起处理才用了653ms,也就是0.653s！太少了。
程序到此就介绍完毕了。
说点别的什么呢？感觉自己好像完成了多么了不起的事情似的，然而其实只是一个大作业而已。扭头干点别的吧。周末的两天就这样过去了，周一也这样过去了。然而，其实时间的利用很稀疏，如果全副身心在上面的话，也许一天就够了呢，也说不好。
总之，对于大项目，不要搁置，尽最大可能一鼓作气去完成，这是最简单快捷并且高效的办法。因为很多时候，中断导致你不得不重头看起，而大项目的完成需要连贯的思维。