TableStore工具类

1 编辑

• 1.1 构建主键

 /**
     * 构建主键
     * @param map 主键集合
     * @return 主键
     */
    public static PrimaryKey buildPrimaryKey(Map<String, Object> map) {
        //构造主键
        PrimaryKeyBuilder primaryKeyBuilder = PrimaryKeyBuilder.createPrimaryKeyBuilder();
        for (String key : map.keySet()) {
            if (map.get(key) instanceof Integer) {
                primaryKeyBuilder.addPrimaryKeyColumn(key, PrimaryKeyValue.fromLong(Integer.valueOf(map.get(key).toString())));
            }
            if (map.get(key) instanceof String) {
                primaryKeyBuilder.addPrimaryKeyColumn(key, PrimaryKeyValue.fromString((String) map.get(key)));
            }
        }
        return primaryKeyBuilder.build();
    }

• 1.2 更新一行多列

 /**
     * 更新多个列值
     *
     * @param tableName, mapkey, mapValues
     * @return void
     * @date 2019/4/23
     */
    public static void updateRow(SyncClient client, String tableName, Map<String, Object> mapKey, Map<String, Object> mapValues) {
        PrimaryKey primaryKey = buildPrimaryKey(mapKey);
        RowUpdateChange rowUpdateChange = new RowUpdateChange(tableName, primaryKey);
        //更新一些列
        for (String column : mapValues.keySet()) {
            if (mapValues.get(column) instanceof Integer) {
                rowUpdateChange.put(new Column(column, ColumnValue.fromLong(Integer.valueOf(mapValues.get(column).toString()))));
            }
            if (mapValues.get(column) instanceof String) {
                rowUpdateChange.put(new Column(column, ColumnValue.fromString(mapValues.get(column).toString())));
            }
        }
        client.updateRow(new UpdateRowRequest(rowUpdateChange));
    }

1.3 deleteTable:清空全表数据

public static void deleteTable() {
       SearchQuery searchQuery = new SearchQuery();
       searchQuery.setQuery(new MatchAllQuery());
       searchQuery.setGetTotalCount(true);
       SearchRequest searchRequest = new SearchRequest("表名", "索引名", searchQuery);
       SearchResponse resp = CLIENT.search(searchRequest);
       if (!resp.isAllSuccess()) {
           throw new RuntimeException("not all success");
       }
       List<Row> rows = resp.getRows();
       while (resp.getNextToken() != null) { //读到NextToken为null为止，即读出全部数据
           //把Token设置到下一次请求中
           searchRequest.getSearchQuery().setToken(resp.getNextToken());
           resp = CLIENT.search(searchRequest);
           if (!resp.isAllSuccess()) {
               throw new RuntimeException("not all success");
           }
           rows.addAll(resp.getRows());
           List<Row> rows1 = resp.getRows();
           List<Map<String, Object>> list = TableStoreHelper.rowsToMap(rows1);
           for (Map<String, Object> map : list) {
               PrimaryKeyBuilder primaryKeyBuilder = PrimaryKeyBuilder.createPrimaryKeyBuilder();
               primaryKeyBuilder.addPrimaryKeyColumn("主键字段名", PrimaryKeyValue.fromString((String) map.get("主键字段名")));
               PrimaryKey primaryKey = primaryKeyBuilder.build();
               RowDeleteChange rowDeleteChange = new RowDeleteChange("表名", primaryKey);
               CLIENT.deleteRow(new DeleteRowRequest(rowDeleteChange));
           }
           System.out.println("已删除" + list.size());
       }
       System.out.println("RowSize: " + rows.size());
       System.out.println("TotalCount: " + resp.getTotalCount());
   }

---

2 查询

• 2.1 TermQuery : 单条件精确查询

	/**
	  * 单条件精确查询
	  * 
	  * @param fieldName 字段名
	  * @param fieldValue 需要查询该字段的属性
	  * @return TermQuery
	*/
	public static TermQuery createTermQuery(String fieldName, Object fieldValue) {
       ColumnValue columnValue = null;
       TermQuery termQuery = new TermQuery();
       termQuery.setFieldName(fieldName);
       if (fieldValue instanceof Integer) {
           columnValue = ColumnValue.fromLong((int) fieldValue);
       } else if (fieldValue instanceof String) {
           columnValue = ColumnValue.fromString((String) fieldValue);
       } else if (fieldValue instanceof Double) {
           columnValue = ColumnValue.fromDouble((double) fieldValue);
       } else if (fieldValue instanceof Boolean) {
           columnValue = ColumnValue.fromBoolean((boolean) fieldValue);
       } else if (fieldValue instanceof Byte[]) {
           columnValue = ColumnValue.fromBinary((byte[]) fieldValue);
       }
       termQuery.setTerm(columnValue);
       return termQuery;
   }

---

• 2.2 TermsQuery :多条件精确查询

	/**
	  * 多条件精确查询
	  * 
	  * @param fieldName 字段名
	  * @param filedValueList 需要查询该字段的多个属性
	  * @return TermsQuery
	*/
	public static TermsQuery createTermsQuery(String fieldName, List filedValueList) {
       List<ColumnValue> paramsList = new ArrayList<>();
       if (!filedValueList.isEmpty()) {
           for (Object object : filedValueList) {
               ColumnValue columnValue = null;
               if (object instanceof Integer) {
                   Integer integer = (Integer) object;
                   columnValue = ColumnValue.fromLong(integer);
               } else if (object instanceof String) {
                   String string = (String) object;
                   columnValue = ColumnValue.fromString(string);
               } else if (object instanceof Double) {
                   Double aDouble = (Double) object;
                   columnValue = ColumnValue.fromDouble(aDouble);
               }
               paramsList.add(columnValue);
           }
       }
       TermsQuery termsQuery = new TermsQuery();
       termsQuery.setFieldName(fieldName);
       termsQuery.setTerms(paramsList);
       return termsQuery;
   }

3 多元索引查询

---

• 3.1 SearchResponse : 执行搜索后的响应对象

 /**
     * 多条件分页排序查询
     *
     * @param client    客户端
     * @param tableName 表名
     * @param indexName 索引名称
     * @param listQuery 多个查询条件
     * @param limit  pageSize
     * @param offset pageStart
     * @param rankField 排序字段
     * @param rankType ASC|DESC
     *
     * @return 查询到的行数
     */
    public static SearchResponse boolQueryPage(SyncClient client, String tableName, String indexName, List<Query> listQuery,
                                               Integer limit, Integer offset, String rankField, String rankType) {
        BoolQuery boolQuery = new BoolQuery();
        boolQuery.setMustQueries(listQuery);
        //查询对象
        SearchQuery searchQuery = createPageSearchQuery(boolQuery, offset, limit, rankField, rankType);
        //查询请求
        SearchRequest searchRequest = new SearchRequest(tableName, indexName, searchQuery);
        //执行查询,返回所有列值
        SearchResponse resp = client.search(returnColumns(searchRequest));
        if (!resp.isAllSuccess()) {
            throw new RuntimeException("not all success");
        }
        return resp;
    }

    /**
     * 返回所有列值
     *
     * @param searchRequest SearchRequest
     *
     * @return SearchRequest
     */
    private static SearchRequest returnColumns(SearchRequest searchRequest) {
        SearchRequest.ColumnsToGet columnsToGet = new SearchRequest.ColumnsToGet();
        columnsToGet.setReturnAll(true);
        searchRequest.setColumnsToGet(columnsToGet);
        return searchRequest;
    }

---

• 3.2 SearchQuery : 创建SearchQuery 对象

/**
     * 创建查询对象
     *
     * @param query     多条件
     * @param limit     pageSize
     * @param offset    pageStart
     * @param rankField 排序字段
     * @param rankType  排序类型 ASC|DESC
     *
     * @return SearchQuery
     */
    public static SearchQuery createPageSearchQuery(Query query, Integer offset, Integer limit, String rankField, String rankType) {
        SearchQuery searchQuery = new SearchQuery();
        Sort sort;
        if ("ASC".equals(rankType)) {
            sort = rankSort(rankField, SortOrder.ASC);
        } else {
            sort = rankSort(rankField, SortOrder.DESC);
        }
        //排序
        searchQuery.setSort(sort);
        //查询
        searchQuery.setQuery(query);
        //分页
        if (limit != null && offset != null) {
            searchQuery.setLimit(limit);
            searchQuery.setOffset(offset);
        }
        //响应总条数
        searchQuery.setGetTotalCount(true);
        return searchQuery;
    }
    /**
     * 封装排序对象
     *
     * @param rankField 排序字段名
     * @param sortOrder 枚举类:正序|逆序
     *
     * @return Sort对象
     */
    private static Sort rankSort(String rankField, SortOrder sortOrder) {
        Sort.Sorter col = new FieldSort("默认排序字段", sortOrder);
        return new Sort(Arrays.asList(col));
    }

---

4 转化

• 4.1 Row–>Map : 一行转化为Map集合

/**
     * 将行转换成map集
     *
     * @param row 一行数据对象
     * @return 一行数据Map
     */
    public static Map<String, Object> rowToMap(Row row) {
        Assert.isTrue(row != null, "ROW CAN'T BE NULL");
        //获取主键
        PrimaryKey primaryKey = row.getPrimaryKey();
        //所有行
        Column[] columns = row.getColumns();
        //主键列
        PrimaryKeyColumn[] primaryKeyColumns = primaryKey.getPrimaryKeyColumns();
        Map<String, Object> map = new HashMap<>();
        for (PrimaryKeyColumn pri : primaryKeyColumns) {
            map.put(pri.getName(), pri.getValue().toString());
        }
        for (Column col : columns) {
            map.put(col.getName(), typeResolver(col.getValue()));
        }
        return map;
    }
    /**
     * 根据列数据类型进行解析
     * @param columnValue 列对象
     * @return 解析出的列值
     */
    public static Object typeResolver(ColumnValue columnValue) {
        String type = columnValue.getType().toString();
        String value = columnValue.toString();
        if (type.equals("INTEGER")) {
            return Integer.valueOf(value);
        }
        return value;
    }

• 4.2 Rows–>List< Map > : 多行转化为List集合

	 public static List<Map<String, Object>> rowsToList(List<Row> rows) {
        //  Assert.isTrue(rows != null && rows.size() > 0, "ROWS CAN'T BE NULL");
        List<Map<String, Object>> list = new ArrayList<>();
        for (Row row : rows) {
            list.add(rowToMap(row));
        }
        return list;
    }