hbase 读写空间数据(四)-空间查询优化

已于 2022-03-13 13:47:25 修改
阅读量2.4k 收藏 1
点赞数
分类专栏： 数据库 java GIS开发 文章标签： hbase 数据库 database
于 2022-03-13 13:44:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chijingjing/article/details/123458171
版权
GIS开发 同时被 3 个专栏收录
66 篇文章 4 订阅
订阅专栏
数据库
23 篇文章 0 订阅
订阅专栏
java
12 篇文章 1 订阅
订阅专栏

上一篇空间查询不涉及到任何得效率优化, 本篇先做一个简单得效率优化,

仅仅针对点数据的(PS:  线面数据还没搞定), 具体原理如下:

1: hbase 得索引都在rowkey上, rowkey在hbase中是排序的, 查询如果指定Start rowkey 那么在大数据量情况下可以快速定位到数据在那些节点上, 这有点类似 跳表得多级索引, 例如  1-10亿个排序点值,  如果我指定从5亿位置开始那么将减少一半搜索区间.

2: 点数据目前实验代码采用geohash(网上虽然一艘一大堆, 但是这里要注意, 对于空间数据, 网上geohash的精度不够, 最多是12位, 这样精度在几十米, 显然无法适应GIS专业行业需求, 所以建议找一下精度更加高的Geohash编码实现), 如果给一个范围查找在这个范围内的点集合, 我们只需要找到这个范围对应的rowkey范围即可, 最后是直接遍历这个范围的rowkey还是, 直接设置startrowkey和endrowkey, 大数据我还没实验, 目前小数据都是可以, 区别不大. 找rowkey范围示意图如下:

图上是一个编码顺序图, 红框子是范围, 但是红框子计算出来的rowkey其实如果只取15和192将比红框子范围大的数据都会进去,   具体实施得时候要看数据情况,  是给一个startrowkey 和endrowkey, 还是给一堆呢?  反正我这里有不是在Geometry列簇中还有xmin,ymin,xmax,ymax 吗?  联合起来用一下不就可以了, 至于对于点直接取15,26,27,30,31 ....192这样全部取出来我觉得也是可以得,  只是我没测过, 因为我觉得慢.

下面放一下测试代码:

package hbasedatabase;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.Cell.Type;
import org.apache.hadoop.hbase.CellBuilder;
import org.apache.hadoop.hbase.CellBuilderFactory;
import org.apache.hadoop.hbase.CellBuilderType;
import org.apache.hadoop.hbase.CompareOperator;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor;
import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.client.TableDescriptor;
import org.apache.hadoop.hbase.client.TableDescriptorBuilder;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.apache.hadoop.hbase.util.Bytes;
import org.locationtech.jts.io.ParseException;
import org.locationtech.jts.io.WKBReader;
import org.locationtech.jts.io.WKTWriter;
import com.geostar.kernel.GsAny;
import com.geostar.kernel.GsBox;
import com.geostar.kernel.GsBox3D;
import com.geostar.kernel.GsConnectProperty;
import com.geostar.kernel.GsEnvelope;
import com.geostar.kernel.GsFeature;
import com.geostar.kernel.GsFeatureClass;
import com.geostar.kernel.GsFeatureCursor;
import com.geostar.kernel.GsField;
import com.geostar.kernel.GsFieldType;
import com.geostar.kernel.GsFieldVector;
import com.geostar.kernel.GsFields;
import com.geostar.kernel.GsGeoDatabase;
import com.geostar.kernel.GsGeohash;
import com.geostar.kernel.GsGeometry;
import com.geostar.kernel.GsGeometryBlob;
import com.geostar.kernel.GsGeometryFactory;
import com.geostar.kernel.GsSpatialQueryFilter;
import com.geostar.kernel.GsSqliteGeoDatabaseFactory;
import com.geostar.kernel.GsWKTOGCWriter;

public class featureRowkeySpatialQuery {

	private static final String TABLE_NAME = "RES1_4M_P";
	static GsFeatureClass pfcsClass = null;
	static GsGeohash ghGeohash = null;// new GsGeohash();
	static Configuration conf = null;
	static TableName tableName = null;
	static Table table = null;
	static Connection connection = null;
	static Admin admin = null;
	// 测试数据
	static String familygeos[] = { "GEOMETRY", "INFO" };
	static String family1[] = { "GEOMETRY", "XMIN", "YMIN", "XMAX", "YMAX" };
	static String family1FieldsType[] = { "eGeometryType", "eDoubleType", "eDoubleType", "eDoubleType", "eDoubleType" };
	static String family2[] = {};
	static GsFieldType family2FieldsType[] = {};
	static HashMap<String, HashMap<String, String>> map = new HashMap<String, HashMap<String, String>>();

	static HashMap<String, byte[]> valuesArrayList = new HashMap<String, byte[]>();

	static void InitConf() throws IOException, ParseException {
		System.loadLibrary("gsjavaport");
		com.geostar.kernel.GsKernel.Initialize();
		System.out.println("GsKernel loadlibrary succeed");
		Configuration cnf = new Configuration();

		cnf.set("hbase.zookeeper.quorum", "127.0.0.1:2181");
		cnf.set("hbase.zookeeper.property.clientPort", "2181");
		conf = HBaseConfiguration.create(cnf);
		connection = ConnectionFactory.createConnection(conf);
		admin = connection.getAdmin();
		tableName = TableName.valueOf(TABLE_NAME);
		table = connection.getTable(tableName);
		InitFeatureData();
	}

	static void InitFeatureData() throws ParseException {
		GsSqliteGeoDatabaseFactory factory = new GsSqliteGeoDatabaseFactory();
		GsConnectProperty connectProperty = new GsConnectProperty("D:\\source\\kernel\\testdata\\400sqlite");
		GsGeoDatabase pDatabase = factory.Open(connectProperty);
		pfcsClass = pDatabase.OpenFeatureClass(TABLE_NAME);
		ghGeohash = new GsGeohash();

		HashMap<String, String> family1t = new HashMap<String, String>();
		HashMap<String, String> family2t = new HashMap<String, String>();
		for (int i = 0; i < family1.length; i++) {
			family1t.put(family1[i], family1FieldsType[i]);
		}
		GsFields fdsFields = pfcsClass.Fields();
		GsFieldVector fdsFieldVector = fdsFields.getFields();
		for (int i = 0; i < fdsFieldVector.size(); i++) {
			GsField fdField = fdsFieldVector.get(i);
			String na = fdField.getName();
			if (na.equals("GEOMETRY"))
				continue;

			family2t.put(fdField.getName(), fdField.getType().toString());
		}

		map.put(familygeos[0], family1t);
		map.put(familygeos[1], family2t);

	}

	static void Exit() throws IOException {
//	  admin.disableTable(tableName);
//	  admin.close();
//	  table.close();
		connection.close();
	}


	
	public static void main(String... args) throws IOException, ParseException {
		InitConf();
		NewVersionTestCreateTable();
		Inserttest();

		long begintime1 = System.currentTimeMillis();
		SearchData(108, 20, 115, 26);
		System.out.println("SearchData(108,20,115,26); " + (System.currentTimeMillis() - begintime1) + " ms");

		begintime1 = System.currentTimeMillis();
		SearchData(108, 25, 115, 27);
		System.out.println(" SearchData(108,25,115,27); " + (System.currentTimeMillis() - begintime1) + " ms");
		Exit();
	}

	public static void NewVersionTestCreateTable() throws IOException {
		if (admin.tableExists(tableName)) {
			if (!admin.isTableDisabled(tableName))
				admin.disableTable(tableName);
			admin.deleteTable(tableName);
			System.out.println("Table is  exist. delete and  create it");
			// return;
		}
		// 创建表
		TableDescriptorBuilder tbuilder = TableDescriptorBuilder.newBuilder(tableName);
		ColumnFamilyDescriptor familygeo = ColumnFamilyDescriptorBuilder.newBuilder(familygeos[0].getBytes()).build();
		ColumnFamilyDescriptor familyinfo = ColumnFamilyDescriptorBuilder.newBuilder(familygeos[1].getBytes()).build();
		List<ColumnFamilyDescriptor> families = new ArrayList<>();
		families.add(familygeo);
		families.add(familyinfo);
		TableDescriptor tableDescriptor = TableDescriptorBuilder.newBuilder(tableName).setColumnFamilies(families)
				.build();
		admin.createTable(tableDescriptor);

	}

	public static void Inserttest() throws IOException {
		if (!admin.tableExists(tableName)) {
			System.out.println("Table does not exist.");
			System.exit(-1);
		}
		table = connection.getTable(tableName);
		CellBuilder cellbuilder = CellBuilderFactory.create(CellBuilderType.DEEP_COPY);

		GsSqliteGeoDatabaseFactory factory = new GsSqliteGeoDatabaseFactory();

		GsFeatureCursor pCursor = pfcsClass.Search();
		GsFeature pFeature = pCursor.Next();

		ArrayList<Put> arrayList = new ArrayList<Put>();

		int nCommiT = 0;
		int RegionServerCount = 9;
		GsFields fdsFields = pfcsClass.Fields();
		GsFieldVector fdsFieldVector = fdsFields.getFields();
		do {
			if (pFeature == null)
				break;

			// 这里是点只用编码一次
			int partl = (int) (pFeature.OID() % ((long) RegionServerCount));
			GsGeometry pGeometry = pFeature.Geometry();
			GsBox3D box3d = pGeometry.Envelope();
			String minString = ghGeohash.Forward(box3d.getXMin(), box3d.getYMin(), 18);
		
			byte[] rowkey = Bytes.toBytes(minString + pFeature.OID());
			Put put = new Put(rowkey);
			// 写几何
			int buffersize = (int) pGeometry.GeometryBlobPtr().BufferSize();

			byte[] bBlob = new byte[buffersize];
			pGeometry.GeometryBlobPtr().CopyToArray(bBlob, bBlob.length);
			for (int i = 0; i < family1.length; i++) {
				cellbuilder.setRow(rowkey);
				cellbuilder.setFamily(Bytes.toBytes("GEOMETRY"));
				if (0 == i) {
					cellbuilder.setQualifier(Bytes.toBytes(family1[i]));
					cellbuilder.setValue(bBlob);
				} else {
					cellbuilder.setQualifier(Bytes.toBytes(family1[i]));
					switch (i) {
					case 1:
						cellbuilder.setValue(Bytes.toBytes(box3d.getXMin()));
						break;
					case 2:
						cellbuilder.setValue(Bytes.toBytes(box3d.getYMin()));
						break;
					case 3:
						cellbuilder.setValue(Bytes.toBytes(box3d.getXMax()));
						break;
					case 4:
						cellbuilder.setValue(Bytes.toBytes(box3d.getYMax()));
						break;
					default:
						break;
					}
				}
				cellbuilder.setType(Type.Put);
				Cell cl = cellbuilder.build();
				put.add(cl);
			}

			// 写属性
			for (Map.Entry<String, HashMap<String, String>> kvEntry : map.entrySet()) {
				HashMap<String, String> vvkv = kvEntry.getValue();
				String keyString = kvEntry.getKey();
				if (keyString.equals("GEOMETRY"))
					continue;

				for (Map.Entry<String, String> kss : vvkv.entrySet()) {
					String colmunString = kss.getKey();

					int index = fdsFields.FindField(colmunString);
					GsFieldType type = fdsFieldVector.get(index).getType();
					cellbuilder.setRow(rowkey);
					cellbuilder.setFamily(Bytes.toBytes(keyString));
					cellbuilder.setQualifier(Bytes.toBytes(colmunString));
					cellbuilder.setType(Type.Put);

					switch (type) {
					case eErrorType:
						break;
					/// \brief BOOL类型
					case eBoolType:
						cellbuilder.setValue(Bytes.toBytes(pFeature.ValueInt(index)));
						break;
					/// \brief 32位的整型
					case eIntType:
					case eUIntType:
						cellbuilder.setValue(Bytes.toBytes(pFeature.ValueInt(index)));
						break;
					/// \brief 64位的整型
					case eInt64Type:
					case eUInt64Type:
						cellbuilder.setValue(Bytes.toBytes(pFeature.ValueInt64(index)));
						break;
					/// \brief 字符串类型
					case eStringType:
						cellbuilder.setValue(Bytes.toBytes(pFeature.ValueString(index)));
						break;
					/// \brief 二进制类型
					case eBlobType:
						GsAny anyblob = pFeature.ValueBlob(index);
						byte[] bBlob1 = new byte[anyblob.ValueSize()];
						anyblob.AsBlob(bBlob1);
						cellbuilder.setValue(bBlob1);
						break;
					/// \brief 浮点型
					case eFloatType:
						cellbuilder.setValue(Bytes.toBytes(pFeature.ValueFloat(index)));
						break;
					/// \brief 双精度浮点型
					case eDoubleType:
						cellbuilder.setValue(Bytes.toBytes(pFeature.ValueDouble(index)));
						break;
					/// \brief 几何类型
					case eGeometryType:
						break;
					/// \brief 日期类型
					case eDateType:
						cellbuilder.setValue(Bytes.toBytes(pFeature.ValueDateTime(index).getTime()));
						break;

					default:
						break;
					}

					Cell cl = cellbuilder.build();
					put.add(cl);
				}
			}
			arrayList.add(put);
			if (nCommiT > 1000) {
				// 插入数据
				table.put(arrayList);
				System.out.println("Insert nCommiT-" + nCommiT);
				nCommiT = 0;
				arrayList.clear();
			}
		} while (pCursor.Next(pFeature));

		// 插入数据
		table.put(arrayList);
		System.out.println("Insert end");
	}
	static FilterList IntersectFilter(double xmin, double ymin, double xmax, double ymax) {
		FilterList filters1 = new FilterList(FilterList.Operator.MUST_PASS_ALL);
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("XMIN"),
				CompareOperator.LESS, Bytes.toBytes(xmax)));
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("YMIN"),
				CompareOperator.LESS, Bytes.toBytes(ymax)));
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("XMAX"),
				CompareOperator.GREATER, Bytes.toBytes(xmin)));
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("YMAX"),
				CompareOperator.GREATER, Bytes.toBytes(ymin)));

		return filters1;
	}

	static FilterList WithInFilter(double xmin, double ymin, double xmax, double ymax) {
		FilterList filters1 = new FilterList(FilterList.Operator.MUST_PASS_ALL);
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("XMIN"),
				CompareOperator.LESS, Bytes.toBytes(xmin)));
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("YMIN"),
				CompareOperator.LESS, Bytes.toBytes(ymin)));
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("XMAX"),
				CompareOperator.GREATER, Bytes.toBytes(xmax)));
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("YMAX"),
				CompareOperator.GREATER, Bytes.toBytes(ymax)));
		return filters1;
	}

	static FilterList ContiansFilter(double xmin, double ymin, double xmax, double ymax) {
		FilterList filters1 = new FilterList(FilterList.Operator.MUST_PASS_ALL);
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("XMIN"),
				CompareOperator.GREATER, Bytes.toBytes(xmin)));
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("YMIN"),
				CompareOperator.GREATER, Bytes.toBytes(ymin)));
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("XMAX"),
				CompareOperator.LESS, Bytes.toBytes(xmax)));
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("YMAX"),
				CompareOperator.LESS, Bytes.toBytes(ymax)));
		return filters1;
	}


	static FilterList DisjoinFilter(double xmin, double ymin, double xmax, double ymax) {
		FilterList filters1 = new FilterList(FilterList.Operator.MUST_PASS_ONE);
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("XMIN"),
				CompareOperator.GREATER, Bytes.toBytes(xmax)));
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("YMIN"),
				CompareOperator.GREATER, Bytes.toBytes(ymax)));
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("XMAX"),
				CompareOperator.LESS, Bytes.toBytes(xmin)));
		filters1.addFilter(new SingleColumnValueFilter(Bytes.toBytes("GEOMETRY"), Bytes.toBytes("YMAX"),
				CompareOperator.LESS, Bytes.toBytes(ymin)));

		return filters1;
	}

	public static void SearchData(double xmin, double ymin, double xmax, double ymax)
			throws IOException, ParseException {
		if (!admin.tableExists(tableName)) {
			System.out.println("Table does not exist.");
			System.exit(-1);
		}
		table = connection.getTable(tableName);

		Scan scan1 = new Scan();
		String fString = ghGeohash.Forward(xmin, ymin, 18);
		byte[] start = Bytes.add(Bytes.toBytes(fString), Bytes.toBytes(Integer.MIN_VALUE));
		String feString = ghGeohash.Forward(xmax, ymax, 18);
		byte[] end = Bytes.add(Bytes.toBytes(feString), Bytes.toBytes(Integer.MAX_VALUE));
		scan1.withStartRow(start, true);
		scan1.withStopRow(end, true);
		scan1.setFilter(IntersectFilter(xmin, ymin, xmax, ymax));
		ResultScanner scanner1 = table.getScanner(scan1);

		// 打印行的值
		int ncount = 0;
		for (org.apache.hadoop.hbase.client.Result res : scanner1) {
			//这里不用服务端精确查询, 只用box查询返回结果后,通过本地过滤即可
			printrow(res, false);
			ncount++;
		}
		// 关闭释放资源
		scanner1.close();
		System.out.println("search end ,get" + ncount + " features");

		GsBox box = new GsBox(xmin, ymin, xmax, ymax);
		GsSpatialQueryFilter pFilter = new GsSpatialQueryFilter(new GsEnvelope(box));
		pFilter.FilterType("ANYINTERACT");
		long n = pfcsClass.FeatureCount(pFilter);
		System.out.println("GsKernel search end ,get" + n + " features");

	}

	static WKBReader wkbReader = new WKBReader();
	static WKTWriter wktWriter = new WKTWriter();
	static GsWKTOGCWriter gskwtWriter = null;

	static void printrow(org.apache.hadoop.hbase.client.Result rtResult, boolean print)
			throws ParseException, UnsupportedEncodingException {
		if (null == gskwtWriter) {
			gskwtWriter = new GsWKTOGCWriter();
		}
		// System.out.println(rtResult);
		// System.out.println(new String(rtResult.getRow()).toString());

		for (Map.Entry<String, HashMap<String, String>> kvEntry : map.entrySet()) {
			{
				HashMap<String, String> vvkv = kvEntry.getValue();
				String keyString = kvEntry.getKey();
				for (Map.Entry<String, String> kss : vvkv.entrySet()) {
					String typeString = kss.getValue();
					String colmunString = kss.getKey();
					Cell lengthCells = rtResult.getColumnLatestCell(Bytes.toBytes(keyString),
							Bytes.toBytes(colmunString));
					if (null == lengthCells)
						continue;
					switch (typeString) {
					case "eGeometryType":
						// byte[] vv = lengthCells.getValueArray();
						if (print) {
							int offset = lengthCells.getValueOffset();
							int len = lengthCells.getValueLength();
							byte[] vvv = Arrays.copyOfRange(lengthCells.getValueArray(), offset, len);
							GsGeometryBlob blob = new GsGeometryBlob();
							blob.Copy(vvv, len);

							GsGeometry pGeometry = GsGeometryFactory.CreateGeometryFromBlob(blob);
							gskwtWriter.Write(new GsEnvelope(pGeometry.Envelope()));
							String geometrystr = gskwtWriter.WKT();
							System.out.println(colmunString + "--" + geometrystr);
						}
						break;
					case "eDoubleType":
						byte[] v = lengthCells.getValueArray();
						if (print)
							System.out.println(colmunString + "--"
									+ String.format("%.8f", (Bytes.toDouble(v, lengthCells.getValueOffset()))));
						break;
					case "eInt64Type":
					case "eUInt64Type":
						byte[] v1 = lengthCells.getValueArray();
						if (print)
							System.out.println(colmunString + "--"
									+ (Bytes.toLong(v1, lengthCells.getValueOffset(), lengthCells.getValueLength())));
						break;
					case "eStringType":
						byte[] v11 = lengthCells.getValueArray();
						if (print)
							System.out.println(colmunString + "--" + new String(
									Bytes.toString(v11, lengthCells.getValueOffset(), lengthCells.getValueLength())));
						break;
					case "eIntType":
					case "eUIntType":
						byte[] v111 = lengthCells.getValueArray();
						if (print)
							System.out.println(colmunString + "--" + (Bytes.toInt(v111, lengthCells.getValueOffset())));
						break;
					case "eFloatType":
						byte[] v1111 = lengthCells.getValueArray();
						if (print)
							System.out.println(
									colmunString + "--" + (Bytes.toFloat(v1111, lengthCells.getValueOffset())));
						break;
					default:
						break;
					}
				}
			}
		}
	}
}

cejutue
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hbase数据读取优化_HBase读写性能优化
weixin_39968760的博客
12-19 295
一个系统上线之后，开发和调优将会一直伴随在系统的整个生命周期中，HBase也不例外。下面我们要学习如何进行HBase读写性能调优，以获取最大的读写效率。HBase写入优化客户端优化批量写采用批量写，可以减少客户端到RegionServer之间的RPC的次数，提高写入性能。批量写请求要么全部成功返回，要么抛出异常。HTable.put(List<Put>);异步批量提交如果业务可以接受异...
hbase-2.0.2-bin.tar
11-12
10. **Compaction**: HBase会定期进行Major Compaction，合并Region内的HFile，减少文件数量并清理过期数据，优化存储空间。 11. ** Coprocessors**: HBase引入Coprocessors机制，允许在RegionServer上执行自定义...
基于Hbase的大数据查询优化
07-04
Hbase有着先天的优势和先天的劣势,而劣势就是其较差的数据定位能力,也就是数据查询能力。因为面向列的特点,Hbase只能单单地以rowkey为主键作查询,而无法对表进行多维查询和join操作,并且查询通常都是全表扫描,耗费资源较大,查询效率较低。类比于传统型数据库里的一些查询方式,本文对Hbase的存储原理进行了研究,借助分布式计算框架Mapreduce在Hbase上构建了二级索引,就可以对表进行有针对性的定位和高效率的查找,同时也减轻zookeeper服务对资源调度的压力。
HBase查询优化
weixin_34185364的博客
08-05 678
1.概述 HBase是一个实时的非关系型数据库，用来存储海量数据。但是，在实际使用场景中，在使用HBase API查询HBase中的数据时，有时会发现数据查询会很慢。本篇博客将从客户端优化和服务端优化两个方面来介绍，如何提高查询HBase的效率。 2.内容 这里，我们先给大家介绍如何从客户端优化查询速度。 2.1 客户端优化 客户端查询HBase，均通过HBase API的来获取数据，如...
HBase查询优化——持续更新
weixin_34414650的博客
08-02 109
Scan:setBatch,setCaching,setCacheBlocks public void setBatch(int batch) public void setCaching(int caching) public void setCacheBlocks(boolean cacheBlocks) setBatch...
hbase 读写空间数据(三)-空间相交粗查
CJJ的专栏
03-11 1934
hbase 空间存储
sql优化查询
m0_64986686的博客
04-24 88
#创建索引 CREATE INDEX IX ProcessID ON T1(processid); #a语句不使用索引 SELECT * FROM T1 WHERE nextprocess = 1 AND processid IN (8,32,45); #b语句强制使用索引 SELECT * FROM T1 FROM INDEX(IX_ProcessID) WHERE nextprocess = 1 AND processid IN (8,32,45); CREATE TABLE IF NOT EXIST
hbase的hbase-1.2.0-cdh5.14.2.tar.gz资源包
07-14
HBase是大数据处理领域的重要工具，尤其适合实时查询和大规模数据存储。理解并掌握HBase的核心概念、安装配置、数据模型以及性能优化策略，对于开发和运维大数据系统至关重要。通过`hbase-1.2.0-cdh5.14.2.tar.gz`这...
hbase-2.2.3-bin.tar.gz
04-07
1. **Region Server优化**：HBase通过Region Server管理表的数据分区，2.2.3版本对Region Server进行了优化，提高了并发处理能力和数据读写的效率。 2. **Multi-Get与Scan优化**：此版本提升了多行获取（Multi-Get...
基于HBase的分布式空间数据库技术
11-07
基于HBase的分布式空间数据库技术，利用Hbase构建分布式空间数据库
hbase 读写空间数据(六)-总结
CJJ的专栏
03-15 2761
hbase空间存储查询总结
Hbase查询Scan优化和Row设计策略
尹忠政的博客
12-15 1072
Hbase查询Scan优化和Row设计策略Hbase查询Scan优化和Row设计策略前言分区号设计时间因素java查询代码总结 Hbase查询Scan优化和Row设计策略 好久没有分享工作和学习经验了，工作太忙，好多学习计划都落下了，后面得加油了，本次就分享下在项目中运用的Hbase查询和RowKey设计相关的东西。 前言 startKey和stopKey，scan中我建议必须要设置，限制扫描的...
使用java查询HBase的优化
nidayu的blog
03-27 2605
目前公司的HBase查询速度特别慢，但是从数据库查速度非常快，所以问题应该是出现在java代码的实现上 原来代码： public Map queryByRow(String tableName,String subRowkey){ HTableInterface table = hBasePool.hTablePool.getTable(tableName);
基于NoSQL数据库的空间数据存储（二）---HBase的构建
jamexfx的博客
11-17 613
一、问题描述海量空间数据存储要求服务器水平扩展性强，基于Hadoop的NoSQL数据库具有水平扩展性强的特点，其高效的并行存储机制也为空间检索提供快速响应的能力。二、方案选择由于将数据存入Hbase中需要考虑如何存储，空间数据处理的基本单位是二维或三维坐标，HBase只支持一维行键检索。行键的设置是HBase存储和处理空间数据首要解决的问题。不同于Hilbert、Geohash等降维方法，此次使用了
HBase 数据库数据索引与查询优化：提高查询效率和性能
最新发布
程序员光剑
12-26 1081
1.背景介绍 HBase是一个分布式、可扩展、高性能的列式存储系统，基于Google的Bigtable设计。它是Hadoop生态系统的一部分，可以与Hadoop Distributed File System (HDFS)和MapReduce等组件集成。HBase主要用于存储大规模的结构化数据，如日志、传感器数据等。 在大数据时代，数据量越来越大，查询性能越来越低。因此，优化查询性能成为了HB...
hbase 读写空间数据(五)-存储与空间查询瓦片数据
CJJ的专栏
03-14 2639
hbase 存空间数据 , 存储查询瓦片数据
基于HBase的面向空间应用数据对象存储高效检索方法
本文的研究成果对于改进空间数据存储系统具有重要的实践价值，有助于提升空间应用的数据处理能力，特别是在遥感、卫星通信和地理信息系统等领域，能有效提高数据处理的效率和准确性。此外，对于数据库设计者和空间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值