YDB基本使用详解（转）
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了YDB基本使用详解（转）相关的知识，希望对你有一定的参考价值。
第七章YDB基本使用详解
一、如何与YDB对接（交互）
目前延云YDB提供如下几种方式
l命令行的方式
lWeb http接口的方式
lJDBC接口的方式
通过Java编程接入
通过可视化SQL分析统计接入
通过报表分析工具接入
二、命令行接入
进入ya100的安装目录的bin目录
1.直接执行 ./conn.sh 即可。
2.通过./sql.sh -f xxx.sql 直接执行文件中的SQL
三、WEB接入
WEB接口主要是为了给那些不支持HDBC访问的程序提供接口支持，如PHP。
1.图形SQL 提交地址
http://xxx.xx.xx.xx:1210/sparkview
2.Json接口
http://xxx.xx.xx.xx:1210/sparksql?sql=?
SQL参数可以GET方式提交，也可以POST方式提交
四、JDBC接口
1.JDBC接入方式连接字符串
Connection conn = DriverManager.getConnection("jdbc:hive2://ydbmaster:10009/default", "hdfs", "");
l10009表示JDBC的端口号，配置的值在ya100_evn.sh里面可以找到
lhdfs表示连接时所使用的Hadoop账号，大家也要跟配置文件中一致，以免其他未知账号产生垃圾文件没有及时的清理掉，以及造成Hadoop权限问题。
这个账号的配置目前存在两个位置，请大家配置一致，使用同一个账号。
2.JAVA编程接口
Class.forName("org.apache.Hive.jdbc.HiveDriver");
Connection conn = DriverManager.getConnection("jdbc:hive2://ydbmaster:10009/default", "hdfs", "");
Statement smst = conn.createStatement();
ResultSet rs = smst.executeQuery("/*ydb.pushdown(‘->‘)*/ select * from ydb_example_shu where ydbpartion = ‘3000w‘ limit 10 /*(‘<-‘)pushdown.ydb*/");
ResultSetMetaData m = rs.getMetaData();
int columns = m.getColumnCount();
for (int i = 1; i <= columns; i++) {
System.out.print(m.getColumnName(i));
System.out.print("\t\t");
}
while (rs.next()) {
for (int i = 1; i <= columns; i++) {
System.out.print(rs.getString(i));
System.out.print("\t\t");
}
System.out.println();
}
rs.close();
conn.close();
依赖的JDBC客户端jar包可以从这个地址获取，本质上就是HIVE的thrift接口，依赖的jar包也是Hive的jar包
http://url.cn/42R4CG8
3.通过可视化SQL分析统计接入
SQL分析工具有很多，只要支持HIVE接口即可，免费的有Squirrel、收费的有DbVisualizer等
4.通过报表分析工具接入
通过可视化报表分析工具，可以极大的提高程序开发的效率，只要是支持HIVE接口的可视化报表工具，都可以与YDB集成，下面以帆软报表为例。
五、YDB分区
1.关于分区的说明
随着时间的日积月累，单个索引会越来越大，从而导致系统瓶颈。YDB不会将全部的数据都完整的创建在一个索引中，YDB会对数据进行分区，分区的方式由用户来定义，可以按照日期分区，也可以按照某些固定的HASH方式来分区。
一条数据的分区，在导入的时候直接指定，具体请参考后面的数据导入用法。
如果按照日期进行分区，每天就会生成一个分区，如需查询哪天的数据，就去对应的分区中检索，其他的分区则闲置。
YDB 的SQL需要通过ydbpartion来指定分区; SQL查询必须要设置分区，而且要写在SQL的最外层。
如果没有指定ydbpartion分区的查询，ydb表默认会去查询 " ydb_default_partion" 这个分区，也就是说，如果我们真的不想进行数据分区，不想在sql上添加ydbpartion的条件来指定分区，那么请将数据都导入到 " ydb_default_partion"这个分区里面。
设置分区例子如下：
ydbpartion =‘20140928‘
ydbpartion in (‘20140928‘,‘20140927‘)
目前不支持大于等于，小于等于的范围指定分区，仅支持等于与in的方式。
2.关于分区的数量与粒度，控制多少比较好？
l如果我们的数据可以按照时间进行切分，是不是切分的越细越好？
很遗憾，YDB并不适合特别多的分区，分区越多代表索引文件越多
1)YDB中打开一个索引是有很大的开销的，打开一个索引加载的列的信息、索引的BlockTree的相关主干节点等，需要消耗较多的内存，而且要持久化到内存里去维护这个索引的状态。这就是为什么大家会发现，对于一个表第一次查询会比较慢，但是我们进行一次count以后，在进行别的查询就会快很多。
2)YDB在一个进程里能够打开的索引数量是有限的，如果超过了打开的索引文件数量，那么就要关闭一些索引，以保证内存不会OOM。
3)小文件太多，对HDFS的NameNode的压力较大。
l那么分区粒度控制在多少为好？
基本原则就是在避免索引频繁的打开与关闭的情况下，索引粒度越小越好。
1)如果我们的数量不是很大，一年加在一起还不到10亿，那么我就建议采用按年分区。
2)如果我们的数据处于中等，每月的数据增量为1亿左右，那么我们建议按照季度分区。
3)如果我们的数据每天写入量特别大，如果按照月份分区，单个索引太大会造成写入瓶颈，那么我们建议按照天进行分区。
很多时候我们还可以根据不同的查询方式，采用两种粒度的分区
1)最近一两天的数据经常被查询，我们最近3天的数据按照天进行分区
2)但是偶尔也会发生查询整年的数据，如果采用按天分区的话，一次打开的索引太多，那么我们可以再加一个按照季度的分区。
3)按天的数据分区只保存最近7天的数据，超过7天的数据会通过insert的方式归档按照季度的分区里。
六、YDB的数据类型
1.基本类型
基本类型的存储方式均为 按列存储
|
YDB类型 |
只索引 |
只存储 |
Hive类型 |
解释 |
|
string |
synn |
--- |
string |
字符串类型，该类型不分词，通常用来存储比较短的字符串，如类目 |
|
tint |
tiynn |
--- |
int |
整形32位-适合大范围的range过滤查询 |
|
tlong |
tlynn |
--- |
bigint |
整形64位-适合大范围的range过滤查询 |
|
tdouble |
tdynn |
--- |
double |
Double类型-适合大范围的range过滤查询 |
|
tfloat |
tfynn |
--- |
float |
Float类型-适合大范围的range过滤查询 |
|
int |
iynn |
--- |
int |
整形32位，占用存储空间少，但是范围查找性能低 |
|
long |
lynn |
--- |
bigint |
整形64位，占用存储空间少，但是范围查找性能低 |
|
double |
dynn |
--- |
double |
Double类型，占用存储空间少，但是范围查找性能低 |
|
float |
fynn |
--- |
float |
Float类型，占用存储空间少，但是范围查找性能低 |
|
geopoint |
--- |
--- |
bigint |
用于地理位置搜索-使用方法详见《26.地理位置感知搜索.txt》 |
2.分词类型
分词( Word Segmentation) 指的是将一个词字序列切分成一个一个单独的词。分词就是将连续的词序列按照一定的规范重新组合成词序列的过程.
分词类型，均为按行存储，在YDB中可以进行模糊检索，但是不能在SQL里面进行group by（YSQL函数以外是可以的）。
|
YDB类型 |
只索引 |
只存储 |
Hive类型 |
解释 |
|
simpletext |
simpletextyn |
simpletextny |
string |
ydb内置的普通文本分词 采用1~3元分词 |
|
haoma |
haomayn |
haomany |
string |
ydb内置的适合号码类型的分词，采用3~5元分词实现，分词粒度为char |
|
chepai |
chepaiyn |
chepainy |
string |
ydb内置的适合号码类型的分词，采用2~5元分词实现，分词粒度为char |
|
text |
tyn |
tny |
string |
为lucene默认的standard分词，在（处理手机号，邮箱，IP地址，网址等中英文与字典组合的数据上 不准确，请慎用） |
|
cjkyy |
cjkyn |
cjkny |
string |
为lucene默认的cjk分词即二元分词 （处理手机号，邮箱，IP地址，网址等中英文与字典组合的数据上 不准确，请慎用） |
以下类型除了分词外，还保存了分词后的词的顺序 ，可以进行顺序匹配
|
YDB类型 |
只索引 |
只存储 |
Hive类型 |
解释 |
|
charlike |
--- |
--- |
string |
按照字符char 1~5元分词 (效果较好，term区分了词元，适合车牌，手机号类型的较短文本) |
|
wordlike |
--- |
--- |
string |
按字与词 1~3元分词 (效果较好，term区分了词元，适合文本类型) |
|
pchepai |
--- |
--- |
string |
按照字符char 2~5元分词 |
|
phaoma |
--- |
--- |
string |
按照字符char 3~5元分词 |
|
psimpletext |
--- |
--- |
string |
按字与词 1~3元分词 |
|
pyy |
pyn |
pny |
string |
lucene的cjk分词，中文采用二元分词，英文与数字采用 单字分词 |
3.多值列类型
有些时候，我们想在一个列里面存储多个值的时候，就可以考虑使用多值列了
比如说，可以将一个人 的多个标签值 存储在一个记录里面，一个人的每天的行为数据 放在一个记录里面。
一定要注意，
1.字符串类型的多值列，返回的值的无序，并且是排重的，故这块有额外注意。
2.数值型的则是有序的（与导入的顺序一致），并且是没有排重的。
3.传递的数值是按照空格拆分的，如 11 22 33 44
4.如果传递的是空值，会当做null处理
多值列所有数据类型均为按列存储
|
YDB类型 |
Hive类型 |
解释 |
|
mt_syn |
string |
string类型的多值列 |
|
mt_tlyn |
string |
tlong类型的多值列 |
|
mt_lyn |
string |
long类型的多值列 |
|
mt_tdyn |
string |
tdouble类型的多值列 |
|
mt_dyn |
string |
double类型的多值列 |
|
mt_iyn |
string |
int类型的多值列 |
|
mt_tiyn |
string |
tint类型的多值列 |
|
mt_fyn |
string |
float类型的多值列 |
|
mt_tfyn |
string |
tfolat类型的多值列 |
七、创建YDB表
/*ydb.pushdown(‘->‘)*/
create table ydb_example_shu(
phonenum long,
usernick string,
ydb_sex string,
ydb_province string,
ydb_grade string,
ydb_age string,
ydb_blood string,
ydb_zhiye string,
ydb_earn string,
ydb_prefer string,
ydb_consume string,
ydb_day string,
amtdouble tdouble,
amtlong int,
content textcjk
)
/*(‘<-‘)pushdown.ydb*/
八、将HIVE表中的数据导入到YDB中
通过ydbpartion表向YDB中导入数据,下面示例中的ydb_example_shu为YDB表的表名，3000w为YDB表的分区名。
1.直接追加数据
insert into table ydbpartion
select ‘ydb_example_shu‘, ‘3000w‘, ‘‘,
YROW(
‘phonenum‘,phonenum,
‘usernick‘,usernick,
‘ydb_sex‘,ydb_sex,
‘ydb_province‘,ydb_province,
‘ydb_grade‘,ydb_grade,
‘ydb_age‘,ydb_age,
‘ydb_blood‘,ydb_blood,
‘ydb_zhiye‘,ydb_zhiye,
‘ydb_earn‘,ydb_earn,
‘ydb_prefer‘,ydb_prefer,
‘ydb_consume‘,ydb_consume,
‘ydb_day‘,ydb_day,
‘amtdouble‘,amtdouble,
‘amtlong‘,amtlong,
‘content‘,content
)
from ydb_import_txt;
2.覆盖数据
insert overwrite table ydbpartion
select ‘ydb_example_shu‘, ‘3000w‘, ‘‘,
YROW(
‘phonenum‘,phonenum,
‘usernick‘,usernick,
‘ydb_sex‘,ydb_sex,
‘ydb_province‘,ydb_province,
‘ydb_grade‘,ydb_grade,
‘ydb_age‘,ydb_age,
‘ydb_blood‘,ydb_blood,
‘ydb_zhiye‘,ydb_zhiye,
‘ydb_earn‘,ydb_earn,
‘ydb_prefer‘,ydb_prefer,
‘ydb_consume‘,ydb_consume,
‘ydb_day‘,ydb_day,
‘amtdouble‘,amtdouble,
‘amtlong‘,amtlong,
‘content‘,content
)
from ydb_import_txt;
3.在追加数据前，先执行按条件删除
insert into table ydbpartion
select ‘ydb_example_shu‘, ‘3000w‘, ‘ydb_sex=‘男‘ and ydb_blood=‘A‘‘,
YROW(
‘phonenum‘,phonenum,
‘usernick‘,usernick,
‘ydb_sex‘,ydb_sex,
‘ydb_province‘,ydb_province,
‘ydb_grade‘,ydb_grade,
‘ydb_age‘,ydb_age,
‘ydb_blood‘,ydb_blood,
‘ydb_zhiye‘,ydb_zhiye,
‘ydb_earn‘,ydb_earn,
‘ydb_prefer‘,ydb_prefer,
‘ydb_consume‘,ydb_consume,
‘ydb_day‘,ydb_day,
‘amtdouble‘,amtdouble,
‘amtlong‘,amtlong,
‘content‘,content
)
from ydb_import_txt;
4.HIVE表数据导入优化-控制并发数
#######为什么要控制并发数############
1)启动时候的Map数量不容易控制，如果启动的map数量很多，而Spark又没有容量调度器，会占满所有的资源，影响查询。
2)所以很多时候我们的业务期望，在进行数据导入的时候，不要启动太多的Map数量，而是希望留出一部分资源，能让给查询，于是控制Map数量就显得特别重要了。
3)我们导入数据，倾向于数据能更均衡一些，这样查询的时候，不会因为数据倾斜而影响性能。
4)针对大量小文件，Spark并没有像Hive那样使用了combine inputformat ，合并map查询，这样会导致启动的map数量很多，我们希望依然采用Hive那种能够将一些小的Map进行合并。
YDB提供了combine的方法，用来解决上述问题
类名为cn.NET.ycloud.ydb.handle.YdbCombineInputFormat (旧版名字为：cn.Net.ycloud.ydb.handle.Ya100FixNumCombineTextInputFormat)
1)####文本形式的示例####
drop table ydb_import_txt;
CREATE external table ydb_import_txt(
phonenum string, usernick string, ydb_sex string, ydb_province string, ydb_grade string, ydb_age string, ydb_blood string, ydb_zhiye string, ydb_earn string, ydb_prefer string, ydb_consume string, ydb_day string, amtdouble double,amtlong bigint,content string,multyvalue string
)
row format delimited fields terminated by ‘,‘
stored as
INPUTFORMAT ‘cn.net.ycloud.ydb.handle.YdbCombineInputFormat‘
OUTPUTFORMAT ‘org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat‘
location ‘/data/example/ydb‘
TBLPROPERTIES (
‘ydb.combine.input.format.raw.format‘=‘org.apache.hadoop.mapred.TextInputFormat‘
);
select count(*) from ydb_import_txt limit 10;
insert overwrite table ydbpartion
select ‘ydb_example_shu‘, ‘txt‘, ‘‘,
YROW(
‘phonenum‘,phonenum,
‘usernick‘,usernick,
‘ydb_sex‘,ydb_sex,
‘ydb_province‘,ydb_province,
‘ydb_grade‘,ydb_grade,
‘ydb_age‘,ydb_age,
‘ydb_blood‘,ydb_blood,
‘ydb_zhiye‘,ydb_zhiye,
‘ydb_earn‘,ydb_earn,
‘ydb_prefer‘,ydb_prefer,
‘ydb_consume‘,ydb_consume,
‘ydb_day‘,ydb_day,
‘amtdouble‘,amtdouble,
‘amtlong‘,amtlong,
‘content‘,content
)
from ydb_import_txt;
/*ydb.pushdown(‘->‘)*/
select count(*) from ydb_example_shu where ydbpartion = ‘txt‘
/*(‘<-‘)pushdown.ydb*/
;
2)####RCFILE格式示例####
drop table ydb_import_rcfile;
CREATE external table ydb_import_rcfile(
phonenum string, usernick string, ydb_sex string, ydb_province string, ydb_grade string, ydb_age string, ydb_blood string, ydb_zhiye string, ydb_earn string, ydb_prefer string, ydb_consume string, ydb_day string, amtdouble double,amtlong bigint,content string
)
ROW FORMAT SERDE ‘org.apache.hadoop.hive.serde2.columnar.LazyBinaryColumnarSerDe‘
STORED AS
INPUTFORMAT ‘cn.net.ycloud.ydb.handle.YdbCombineInputFormat‘
OUTPUTFORMAT ‘org.apache.hadoop.hive.ql.io.RCFileOutputFormat‘
TBLPROPERTIES (
‘ydb.combine.input.format.raw.format‘=‘org.apache.hadoop.hive.ql.io.RCFileInputFormat‘
);
insert overwrite table ydb_import_rcfile select * from ydb_import_txt;
select count(*) from ydb_import_rcfile limit 10;
insert overwrite table ydbpartion
select ‘ydb_example_shu‘, ‘rcfile‘, ‘‘,
YROW(
‘phonenum‘,phonenum,
‘usernick‘,usernick,
‘ydb_sex‘,ydb_sex,
‘ydb_province‘,ydb_province,
‘ydb_grade‘,ydb_grade,
‘ydb_age‘,ydb_age,
‘ydb_blood‘,ydb_blood,
‘ydb_zhiye‘,ydb_zhiye,
‘ydb_earn‘,ydb_earn,
‘ydb_prefer‘,ydb_prefer,
‘ydb_consume‘,ydb_consume,
‘ydb_day‘,ydb_day,
‘amtdouble‘,amtdouble,
‘amtlong‘,amtlong,
‘content‘,content
)
from ydb_import_rcfile;
/*ydb.pushdown(‘->‘)*/
select count(*) from ydb_example_shu where ydbpartion = ‘rcfile‘
/*(‘<-‘)pushdown.ydb*/
;
3)####SEQUENCEFILE格式示例####
drop table ydb_import_sequencefile;
CREATE external table ydb_import_sequencefile(
phonenum string, usernick string, ydb_sex string, ydb_province string, ydb_grade string, ydb_age string, ydb_blood string, ydb_zhiye string, ydb_earn string, ydb_prefer string, ydb_consume string, ydb_day string, amtdouble double,amtlong bigint,content string
)
ROW FORMAT SERDE ‘org.apache.hadoop.hive.serde2.columnar.LazyBinaryColumnarSerDe‘
STORED AS
INPUTFORMAT ‘cn.net.ycloud.ydb.handle.YdbCombineInputFormat‘
OUTPUTFORMAT ‘org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat‘
TBLPROPERTIES (
‘ydb.combine.input.format.raw.format‘=‘org.apache.hadoop.mapred.SequenceFileInputFormat‘
);
SET hive.exec.compress.output=true;
SET mapred.output.compression.codec=org.apache.hadoop.io.compress.DefaultCodec;
SET mapred.output.compression.type=BLOCK;
insert overwrite table ydb_import_sequencefile select * from ydb_import_txt;
select count(*) from ydb_import_sequencefile limit 10;
insert overwrite table ydbpartion
select ‘ydb_example_shu‘, ‘sequencefile‘, ‘‘,
YROW(
‘phonenum‘,phonenum,
‘usernick‘,usernick,
‘ydb_sex‘,ydb_sex,
‘ydb_province‘,ydb_province,
‘ydb_grade‘,ydb_grade,
‘ydb_age‘,ydb_age,
‘ydb_blood‘,ydb_blood,
‘ydb_zhiye‘,ydb_zhiye,
‘ydb_earn‘,ydb_earn,
‘ydb_prefer‘,ydb_prefer,
‘ydb_consume‘,ydb_consume,
‘ydb_day‘,ydb_day,
‘amtdouble‘,amtdouble,
‘amtlong‘,amtlong,
‘content‘,content
)
from ydb_import_sequencefile;
/*ydb.pushdown(‘->‘)*/
select count(*) from ydb_example_shu where ydbpartion = ‘sequencefile‘
/*(‘<-‘)pushdown.ydb*/
4)####PARQUET格式示例####
###Spark内部对SERDE含有Parquet格式的类名进行了特殊处理，会导致设置的inputformat不生效，所以YDB也特殊处理下，就换成不含有Parquet的名字
drop table ydb_import_parquet;
CREATE external table ydb_import_parquet(
phonenum string, usernick string, ydb_sex string, ydb_province string, ydb_grade string, ydb_age string, ydb_blood string, ydb_zhiye string, ydb_earn string, ydb_prefer string, ydb_consume string, ydb_day string, amtdouble double,amtlong bigint,content string
)
ROW FORMAT SERDE ‘cn.net.ycloud.ydb.handle.combine.YdbParHiveSerDe‘
STORED AS
INPUTFORMAT ‘cn.net.ycloud.ydb.handle.YdbCombineInputFormat‘
OUTPUTFORMAT ‘cn.net.ycloud.ydb.handle.combine.YdbParMapredParquetOutputFormat‘
TBLPROPERTIES (
‘ydb.combine.input.format.raw.format‘=‘org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat‘
);
set parquet.block.size=16777216;
insert overwrite table ydb_import_parquet select * from ydb_import_txt;
select count(*) from ydb_import_parquet limit 10;
insert overwrite table ydbpartion
select ‘ydb_example_shu‘, ‘parquet‘, ‘‘,
YROW(
‘phonenum‘,phonenum,
‘usernick‘,usernick,
‘ydb_sex‘,ydb_sex,
‘ydb_province‘,ydb_province,
‘ydb_grade‘,ydb_grade,
‘ydb_age‘,ydb_age,
‘ydb_blood‘,ydb_blood,
‘ydb_zhiye‘,ydb_zhiye,
‘ydb_earn‘,ydb_earn,
‘ydb_prefer‘,ydb_prefer,
‘ydb_consume‘,ydb_consume,
‘ydb_day‘,ydb_day,
‘amtdouble‘,amtdouble,
‘amtlong‘,amtlong,
‘content‘,content
)
from ydb_import_parquet;
/*ydb.pushdown(‘->‘)*/
select count(*) from ydb_example_shu where ydbpartion = ‘parquet‘
/*(‘<-‘)pushdown.ydb*/
九、YDB 查询SQL 写法
注意YDB的表强制必须指定分区
为了区分YDB表与Hive表,YDB语句需要使用
/*ydb.pushdown(‘->‘)*/ 与 /*(‘<-‘)pushdown.ydb*/ 前后包含起来，以方便解析
1.基本示例
----count(*)计数
/*ydb.pushdown(‘->‘)*/
select count(*) from ydb_example_shu where ydbpartion = ‘2015‘
/*(‘<-‘)pushdown.ydb*/ ;
----数据预览
/*ydb.pushdown(‘->‘)*/
select * from ydb_example_shu where ydbpartion = ‘3000w‘ limit 10
/*(‘<-‘)pushdown.ydb*/;
----全文检索
/*ydb.pushdown(‘->‘)*/
select content,usernick from ydb_example_shu where ydbpartion = ‘3000w‘ and content=‘王老吉‘ limit 10
/*(‘<-‘)pushdown.ydb*/;
----多个条件组合过滤
/*ydb.pushdown(‘->‘)*/
select ydb_sex,ydb_grade,ydb_age,ydb_blood,amtlong from ydb_example_shu where ydbpartion = ‘3000w‘ and ydb_sex=‘女‘ and ydb_grade=‘本科‘ and (ydb_age=‘20到30岁‘ or ydb_blood=‘O‘) and (amtlong like ‘([3000 TO 4000] )‘) limit 10
/*(‘<-‘)pushdown.ydb*/;
----sum求和
/*ydb.pushdown(‘->‘)*/
select sum(amtdouble) from ydb_example_shu where ydbpartion = ‘3000w‘
/*(‘<-‘)pushdown.ydb*/;
----avg求平均数
/*ydb.pushdown(‘->‘)*/
select avg(amtdouble) as avgamt from ydb_example_shu where ydbpartion = ‘3000w‘
/*(‘<-‘)pushdown.ydb*/;
----更复杂点的统计
/*ydb.pushdown(‘->‘)*/
select count(*),count(amtdouble),avg(amtdouble),sum(amtdouble),min(amtdouble),max(amtdouble)
,min(ydb_province),max(ydb_province) from ydb_example_shu where ydbpartion = ‘3000w‘
/*(‘<-’)pushdown.ydb*/;
----单列group by
/*ydb.pushdown(‘->‘)*/
select ydb_sex,count(*),count(amtdouble),sum(amtdouble) from ydb_example_shu where ydbpartion = ‘3000w‘ group by ydb_sex limit 10
/*(‘<-‘)pushdown.ydb*/;
----多列group by
/*ydb.pushdown(‘->‘)*/
select ydb_sex,ydb_province,count(*) as cnt,count(amtdouble),sum(amtdouble) from ydb_example_shu where ydbpartion = ‘3000w‘ group by ydb_sex,ydb_province order by cnt desc limit 10
/*(‘<-‘)pushdown.ydb*/;
----top N 排序
/*ydb.pushdown(‘->‘)*/
select ydb_sex, phonenum,amtlong,amtdouble
from ydb_example_shu where ydbpartion=‘3000w‘ order by amtdouble desc ,amtlong limit 10
/*(‘<-‘)pushdown.ydb*/;
2.YDB特有的BlockSort排序(排序大跃进)
按照时间逆序排序可以说是很多日志系统的硬指标。在延云YDB系统中，我们改变了传统的暴力排序方式，通过索引技术，可以超快对数据进行单列排序，不需要全表暴力扫描，这个技术我们称之为BlockSort，目前支持tlong、tdouble、tint、tfloat四种数据类型。
由于BlockSort是借助搜索的索引来实现的，所以采用blockSort的排序，不需要暴力扫描，性能有大幅度的提升。
BlockSort的排序，并非是预计算的方式，可以全表进行排序，也可以基于任意的过滤筛选条件进行过滤排序。
|
|
正常写法 |
blockSort写法 |
|
单列升序 |
/*ydb.pushdown(‘->‘)*/ select tradetime, nickname from blocksort_ydb order by tradetime limit 10 /*(‘<-‘)pushdown.ydb*/;
|
/*ydb.pushdown(‘->‘)*/ select tradetime, nickname from blocksort_ydb where ydbkv=‘blocksort.field:tradetime‘ and ydbkv=‘blocksort.limit:10‘ order by tradetime limit 10 /*(‘<-‘)pushdown.ydb*/; |
|
单列降序 |
/*ydb.pushdown(‘->‘)*/ select tradetime, nickname from blocksort_ydb order by tradetime desc limit 10 /*(‘<-‘)pushdown.ydb*/; |
/*ydb.pushdown(‘->‘)*/ select tradetime, nickname from blocksort_ydb where ydbkv=‘blocksort.field:tradetime‘ and ydbkv=‘blocksort.limit:10‘ and ydbkv=‘blocksort.desc:true‘ order by tradetime desc limit 10 /*(‘<-‘)pushdown.ydb*/; |
3.数据导出
----导出数据到hive表
insert overwrite table ydb_import_importtest
/*ydb.pushdown(‘->‘)*/
select phonenum,usernick,ydb_sex,ydb_province,
ydb_grade,ydb_age,ydb_blood,ydb_zhiye,ydb_earn,
ydb_prefer,ydb_consume,ydb_day,amtdouble,amtlong,content
from ydb_example_shu where ydbpartion = ‘3000w‘
/*(‘<-‘)pushdown.ydb*/;
#有limit的导出示例 （在Spark的当前版本有BUG，需要采用如下变通方法解决）
insert overwrite table ydb_import_importtest
select * from (
/*ydb.pushdown(‘->‘)*/
select
phonenum,usernick,ydb_sex,ydb_province,ydb_grade,ydb_age,ydb_blood,ydb_zhiye,ydb_earn,ydb_prefer,ydb_consume,ydb_day,amtdouble,amtlong,content
from ydb_example_shu where ydbpartion = ‘3000w‘ and ydbkv=‘export.max.return.docset.size:1000‘
/*(‘<-‘)pushdown.ydb*/
) tmp order by rand() limit 1000;
----数据导出到YDB的其他分区里示例
insert overwrite table ydbpartion
select ‘ydb_example_shu‘, ‘test3‘, ‘‘,
YROW(
‘phonenum‘,tmp.phonenum,
‘usernick‘,tmp.usernick,
‘ydb_sex‘,tmp.ydb_sex,
‘ydb_province‘,tmp.ydb_province,
‘ydb_grade‘,tmp.ydb_grade,
‘ydb_age‘,tmp.ydb_age,
‘ydb_blood‘,tmp.ydb_blood,
‘ydb_zhiye‘,tmp.ydb_zhiye,
‘ydb_earn‘,tmp.ydb_earn,
‘ydb_prefer‘,tmp.ydb_prefer,
‘ydb_consume‘,tmp.ydb_consume,
‘ydb_day‘,tmp.ydb_day,
‘amtdouble‘,tmp.amtdouble,
‘amtlong‘,tmp.amtlong,
‘content‘,tmp.content
)
from (
/*ydb.pushdown(‘->‘)*/
select
phonenum,usernick,ydb_sex,ydb_province,ydb_grade,ydb_age,ydb_blood,ydb_zhiye,ydb_earn,ydb_prefer,ydb_consume,ydb_day,amtdouble,amtlong,content
from ydb_example_shu where ydbpartion = ‘3000w‘
/*(‘<-‘)pushdown.ydb*/
) tmp
;
----导出数据到HDFS
由于Spark当前版本无法通过insert Directory的方式直接导出数据到HDFS，但是可以将数据导出到Hive表，故数据导出到HDFS可以通过导出到Hive表变通的方式来解决
可以通过创建一个导出表来解决
CREATE external table ydb_import_importtest(
phonenum bigint, usernick string, ydb_sex string, ydb_province string, ydb_grade string, ydb_age string, ydb_blood string, ydb_zhiye string, ydb_earn string, ydb_prefer string, ydb_consume string, ydb_day string, amtdouble double,amtlong int,content string
)location ‘/data/example/ydb_import_importtest‘;
如果我们创建表的时候，没有加location，我们可以通过show create table xxx表名 可以看到location的位置
4.多表关联示例
1)---两个卡口left semi join
select k1.vehiclePlate as vehiclePlate from (
/*ydb.pushdown(‘->‘)*/
select vehiclePlate,tollCode from vehiclepass where ydbpartion = ‘3000w‘ and tollCode=‘1‘
/*(‘<-‘)pushdown.ydb*/
) k1
LEFT SEMI JOIN
(
/*ydb.pushdown(‘->‘)*/
select vehiclePlate,tollCode from vehiclepass where ydbpartion = ‘3000w‘ and tollCode=‘2‘
/*(‘<-‘)pushdown.ydb*/
) k2
on (k1.vehiclePlate=k2.vehiclePlate);
+---------------+--+
| vehiclePlate |
+---------------+--+
| c22 |
| c23 |
| c33 |
| c34 |
+---------------+--+
2)---两个卡口left join
select k1.vehiclePlate as vehiclePlate,k2.vehiclePlate from (
/*ydb.pushdown(‘->‘)*/
select vehiclePlate,tollCode from vehiclepass where ydbpartion = ‘3000w‘ and tollCode=‘1‘
/*(‘<-‘)pushdown.ydb*/
) k1
LEFT JOIN
(
/*ydb.pushdown(‘->‘)*/
select vehiclePlate,tollCode from vehiclepass where ydbpartion = ‘3000w‘ and tollCode=‘1‘
/*(‘<-‘)pushdown.ydb*/
) k2
on (k1.vehiclePlate=k2.vehiclePlate);
+---------------+---------------+--+
| vehiclePlate | vehiclePlate |
+---------------+---------------+--+
| c11 | NULL |
| c22 | c22 |
| c23 | c23 |
| c33 | c33 |
| c34 | c34 |
+---------------+---------------+--+
3)---三个卡口left semi join
select k21.vehiclePlate from(
select k1.vehiclePlate as vehiclePlate from (
/*ydb.pushdown(‘->‘)*/
select vehiclePlate,tollCode from vehiclepass where ydbpartion = ‘3000w‘ and tollCode=‘1‘
/*(‘<-‘)pushdown.ydb*/
) k1
LEFT SEMI JOIN
(
/*ydb.pushdown(‘->‘)*/
select vehiclePlate,tollCode from vehiclepass where ydbpartion = ‘3000w‘ and tollCode=‘2‘
/*(‘<-‘)pushdown.ydb*/
) k2
on (k1.vehiclePlate=k2.vehiclePlate)
) k21
LEFT SEMI JOIN
(
/*ydb.pushdown(‘->‘)*/
select vehiclePlate,tollCode from vehiclepass where ydbpartion = ‘3000w‘ and tollCode=‘3‘
/*(‘<-‘)pushdown.ydb*/
) k22 on k21.vehiclePlate=k22.vehiclePlate order by k21.vehiclePlate;
+---------------+--+
| vehiclePlate |
+---------------+--+
| c33 |
| c34 |
+---------------+--+
4)---三个卡口left join
select k21.vehiclePlate,k22.vehiclePlate from(
select k1.vehiclePlate as vehiclePlate from (
/*ydb.pushdown(‘->‘)*/
select vehiclePlate,tollCode from vehiclepass where ydbpartion = ‘3000w‘ and tollCode=‘1‘
/*(‘<-‘)pushdown.ydb*/
) k1
LEFT JOIN
(
/*ydb.pushdown(‘->‘)*/
select vehiclePlate,tollCode from vehiclepass where ydbpartion = ‘3000w‘ and tollCode=‘2‘
/*(‘<-‘)pushdown.ydb*/
) k2
on (k1.vehiclePlate=k2.vehiclePlate)
) k21
LEFT JOIN
(
/*ydb.pushdown(‘->‘)*/
select vehiclePlate,tollCode from vehiclepass where ydbpartion = ‘3000w‘ and tollCode=‘3‘
/*(‘<-‘)pushdown.ydb*/
) k22 on k21.vehiclePlate=k22.vehiclePlate ;
+---------------+---------------+--+
| vehiclePlate | vehiclePlate |
+---------------+---------------+--+
| c11 | NULL |
| c22 | NULL |
| c23 | NULL |
| c33 | c33 |
| c34 | c34 |
+---------------+---------------+--+
5)----三个卡口 先left SEMI join 之后再 left join
select k21.vehiclePlate,k22.vehiclePlate from(
select k1.vehiclePlate as vehiclePlate from (
/*ydb.pushdown(‘->‘)*/
select vehiclePlate,tollCode from vehiclepass where ydbpartion = ‘3000w‘ and tollCode=‘1‘
/*(‘<-‘)pushdown.ydb*/
) k1
LEFT SEMI JOIN
(
/*ydb.pushdown(‘->‘)*/
select vehiclePlate,tollCode from vehiclepass where ydbpartion = ‘3000w‘ and tollCode=‘2‘
/*(‘<-‘)pushdown.ydb*/
) k2
on (k1.vehiclePlate=k2.vehiclePlate)
) k21
LEFT JOIN
(
/*ydb.pushdown(‘->‘)*/
select vehiclePlate,tollCode from vehiclepass where ydbpartion = ‘3000w‘ and tollCode=‘3‘
/*(‘<-‘)pushdown.ydb*/
) k22 on k21.vehiclePlate=k22.vehiclePlate ;
+---------------+---------------+--+
| vehiclePlate | vehiclePlate |
+---------------+---------------+--+
| c22 | NULL |
| c23 | NULL |
| c33 | c33 |
| c34 | c34 |
+---------------+---------------+--+
5.UNION示例
1)--union--统计的结果
select sum(cnt) as cnt from
(
/*ydb.pushdown(‘->‘)*/
select count(*) as cnt from ydb_example_shu where ydbpartion = ‘3000w‘
/*(‘<-‘)pushdown.ydb*/
union all
/*ydb.pushdown(‘->‘)*/
select count(*) as cnt from ydb_example_shu where ydbpartion = ‘300winsert‘
/*(‘<-‘)pushdown.ydb*/
union all
/*ydb.pushdown(‘->‘)*/
select count(*) as cnt from ydb_example_shu where ydbpartion = ‘300winsert2‘
/*(‘<-‘)pushdown.ydb*/
union all
/*ydb.pushdown(‘->‘)*/
select count(*) as cnt from ydb_example_shu where ydbpartion = ‘3000w‘ and content=‘王老吉‘
/*(‘<-‘)pushdown.ydb*/
union all
/*ydb.pushdown(‘->‘)*/
select count(*) as cnt from ydb_example_shu where ydbpartion = ‘20151011‘ and content=‘工商银行‘
/*(‘<-‘)pushdown.ydb*/
union all
/*ydb.pushdown(‘->‘)*/
select count(*) as cnt from ydb_example_shu where ydbpartion = ‘20151011‘
/*(‘<-‘)pushdown.ydb*/
) tmp limit 10;
2)--union order by的结果，注意，这里有个子查询SQL
select * from
(
/*ydb.pushdown(‘->‘)*/ s
elect amtlong,content from ydb_example_shu where ydbpartion = ‘3000w‘ and content=‘旺旺‘ order by amtlong desc limit 1
/*(‘<-‘)pushdown.ydb*/
union all
/*ydb.pushdown(‘->‘)*/
select amtlong,content from ydb_example_shu where ydbpartion = ‘3000w‘ and content=‘王老吉‘ order by amtlong desc limit 1
/*(‘<-‘)pushdown.ydb*/
union all
/*ydb.pushdown(‘->‘)*/
select amtlong,content from ydb_example_shu where ydbpartion = ‘3000w‘ and content=‘汇源‘ order by amtlong desc limit 1
/*(‘<-‘)pushdown.ydb*/
union all
/*ydb.pushdown(‘->‘)*/
select amtlong,content from ydb_example_shu where ydbpartion = ‘3000w‘ and content=‘哇哈哈‘ order by amtlong desc limit 1
/*(‘<-‘)pushdown.ydb*/
) tmp limit 1000;
3)YDB表的多个分区一起查询，通过IN来实现
/*ydb.pushdown(‘->‘)*/
select count(*),count(amtdouble),sum(amtdouble),avg(amtdouble),min(amtdouble),max(amtdouble),min(ydb_province),max(ydb_province) from ydb_example_shu where ydbpartion in ( ‘3000w0‘,‘3000w1‘ ,‘3000w2‘,‘3000w3‘,‘3000w4‘,‘3000w5‘,‘3000w6‘,‘3000w7‘,‘3000w8‘,‘3000w9‘,‘3000w10‘ ,‘3000w11‘,‘3000w12‘,‘3000w13‘,‘3000w14‘,‘3000w15‘ ,‘3000w16‘ ,‘3000w17‘,‘3000w18‘,‘3000w19‘
,‘3000a0‘,‘3000a1‘ ,‘3000a2‘,‘3000a3‘,‘3000a4‘,‘3000a5‘,‘3000a6‘,‘3000a7‘,‘3000a8‘,‘3000a9‘,‘3000a10‘ ,‘3000a11‘,‘3000a12‘,‘3000a13‘,‘3000a14‘,‘3000a15‘ ,‘3000a16‘ ,‘3000a17‘,‘3000a18‘,‘3000a19‘
,‘3000b0‘,‘3000b1‘ ,‘3000b2‘,‘3000b3‘,‘3000b4‘,‘3000b5‘,‘3000b6‘,‘3000b7‘,‘3000b8‘,‘3000b9‘,‘3000b10‘ ,‘3000b11‘,‘3000b12‘,‘3000b13‘,‘3000b14‘,‘3000b15‘ ,‘3000b16‘ ,‘3000b17‘,‘3000b18‘,‘3000b19‘
)
/*(‘<-‘)pushdown.ydb*/
;
6.DISTINCT示例
-----#####如果distinct的数据并不多，可以考虑采用collect_set 性能较好#######
1)----####直接count distinct##########
select
size(collect_set(tmp.ydb_sex)) as dist_sex,
size(collect_set(tmp.ydb_province)) as dist_province,
count(*) as cnt,
count(tmp.amtlong) as cnt_long,
count(distinct tmp.amtlong) as dist_long
from (
/*ydb.pushdown(‘->‘)*/
select ydb_sex,ydb_province,amtlong from ydb_example_shu where ydbpartion = ‘3000w‘ and content=‘王老吉‘
/*(‘<-‘)pushdown.ydb*/
) tmp limit 10;
2)----group by 加 count distinct####
select
tmp.ydb_sex as ydb_sex,
size(collect_set(tmp.ydb_province)) as dist_province,
count(*) as cnt,
count(tmp.amtlong) as cnt_long,
count(distinct tmp.amtlong) as dist_long
from
(
/*ydb.pushdown(‘->‘)*/
select ydb_sex,ydb_province,amtlong from ydb_example_shu where ydbpartion = ‘3000w‘ and content=‘王老吉‘
/*(‘<-‘)pushdown.ydb*/
) tmp
group by tmp.ydb_sex limit 10;
7.行转列示例
select ydb_sex,concat_ws(‘#‘, sort_array(collect_set(concat_ws(‘,‘,ydb_province,cnt,cntamt,sumamt)))) from (
/*ydb.pushdown(‘->‘)*/
select ydb_sex,ydb_province,count(*) as cnt,count(amtdouble) as cntamt,sum(amtdouble) as sumamt from ydb_example_shu where ydbpartion = ‘3000w‘ group by ydb_sex,ydb_province
/*(‘<-‘)pushdown.ydb*/
)tmp group by ydb_sex limit 10;
select ydb_province,sum(cnt) as scnt,concat_ws(‘#‘, sort_array(collect_set(concat_ws(‘,‘,ydb_sex,cnt,cntamt,sumamt)))) from (
/*ydb.pushdown(‘->‘)*/
select ydb_sex,ydb_province,count(*) as cnt,count(amtdouble) as cntamt,sum(amtdouble) as sumamt from ydb_example_shu where ydbpartion = ‘3000w‘ group by ydb_sex,ydb_province
/*(‘<-‘)pushdown.ydb*/
)tmp group by ydb_province order by scnt desc limit 10;
select ydb_province,sum(cnt) as scnt,concat_ws(‘#‘, sort_array(collect_set(concat_ws(‘,‘,ydb_blood,ydb_sex,cnt,cntamt)))) from (
/*ydb.pushdown(‘->‘)*/
select ydb_blood,ydb_sex,ydb_province,count(*) as cnt,count(amtdouble) as cntamt from ydb_example_shu where ydbpartion = ‘3000w‘ group by ydb_blood,ydb_sex,ydb_province
/*(‘<-‘)pushdown.ydb*/
)tmp group by ydb_province order by scnt desc limit 10;
select ydb_day,sum(cnt) as scnt,concat_ws(‘#‘, sort_array(collect_set(concat_ws(‘,‘,ydb_blood,ydb_sex,cnt,cntamt)))) from (
/*ydb.pushdown(‘->‘)*/
select ydb_day,ydb_sex,ydb_blood,count(*) as cnt,count(amtdouble) as cntamt from ydb_example_shu where ydbpartion = ‘3000w‘ group by ydb_day,ydb_sex,ydb_blood
/*(‘<-‘)pushdown.ydb*/
)tmp group by ydb_day order by scnt desc limit 10;
8.对于时间的高效处理
我数据里面时间格式是yyyy-MM-dd hh:mm:ss
1)ydb没有时间类型，应该怎么处理？
可以用tlong类型代替时间类型
存储的值 转换成 yyyyMMddhhmmss ，这样是定长的，而且可读性好（比unix时间磋可读性好）
如果时间精度是 秒 ，毫秒，纳秒的 话 一定要使用 tlong （范围查找比long快很多)，如果是天，小时的话，可以使用long 节省存储空间
2)这些用于时间操作的转换函数我们一定会用到
cast (from_unixtime(unix_timestamp(substring(recevicetime,0,18),‘dd-MMM-yy HH.mm.ss‘),‘yyyyMMddHHmmss‘) as bigint),
cast (from_unixtime(unix_timestamp(substring(recevicetime,0,18),‘dd-MMM-yy HH.mm.ss‘),‘yyyyMMddHHmm‘)as bigint),
cast (from_unixtime(unix_timestamp(substring(recevicetime,0,18),‘dd-MMM-yy HH.mm.ss‘),‘yyyyMMddHH‘)as bigint) ,
select (2017-cast(substring(‘201831198307123487‘,7,4) as bigint) ) from spark_txt limit 10;
9.null值与空值的匹配
1)----匹配空串
/*ydb.pushdown(‘->‘)*/
select phonenum,usernick,ydb_sex,ydb_province from ydb_example_shu where ydbpartion = ‘nullcheck‘ and ydb_sex=‘empty‘
/*(‘<-‘)pushdown.ydb*/
;
2)--匹配非空值
/*ydb.pushdown(‘->‘)*/
select phonenum,usernick,ydb_sex,ydb_province from ydb_example_shu where ydbpartion = ‘nullcheck‘ and ydb_sex<>‘empty‘
/*(‘<-‘)pushdown.ydb*/
;
3)--匹配null值
##############null值的匹配非常消耗性能,采用暴力扫描倒排表的方式实现，如果该列的值排重后的值特别多，如sessionId，身份证号码，手机号等，请慎用########
####如果是检索明细数据，建议在hive层进行过滤####
####TODO 未来可以通过标签里面的live bits改进null值匹配的性能####
/*ydb.pushdown(‘->‘)*/
select phonenum,usernick,ydb_sex,ydb_province from ydb_example_shu where ydbpartion = ‘nullcheck‘ and ydb_sex=‘null‘
/*(‘<-‘)pushdown.ydb*/
;
4)--匹配非null值
/*ydb.pushdown(‘->‘)*/
select phonenum,usernick,ydb_sex,ydb_province from ydb_example_shu where ydbpartion = ‘nullcheck‘ and ydb_sex<>‘null‘
/*(‘<-‘)pushdown.ydb*/
;
10.近似文本匹配
1)近似文本匹配
有些时候，我们只想找到一篇跟当前指定文章类似的文章。可能中间相差几个字不一样无所谓，或者局部的字顺序前后颠倒也无所谓。
需要注意
a)单词会进行排重。
b)并不考虑单词顺序（虽然伪造的数据是有顺序的，但是匹配是不考虑顺序的）。
c)30表示排重后，至少有30%的单词会匹配上才算匹配
d)匹配是按照分词的结果后进行匹配的，并不是按照空格进行拆分的，具体如何检验分词，
1：近似文本匹配示例
/*ydb.pushdown(‘->‘)*/
select content from ydb_example_shu where ydbpartion = ‘3000w‘ and content=‘[email protected]@100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 ‘ limit 10
/*(‘<-‘)pushdown.ydb*/;
2)近似特征匹配
有一种搜索是这样的搜索，我指定一系列的特征，如 高矮、胖瘦、年龄段、性别、时间等一系列目击者看到的嫌疑人特征，但是有可能有些目击者描述的不准确，所以不能进行精确匹配，如果能与大部分的匹配条件都相似，一两个条件没匹配上，但已经足以相似了，那么也要返回匹配结果。
--五个特征中必须匹配4个特征
/*ydb.pushdown(‘->‘)*/
select ydb_sex,ydb_province,ydb_blood,amtdouble,content from ydb_example_shu where ydbpartion = ‘3000w‘ and ydb_raw_query_s like ‘[email protected]=4&fq=ydb_sex:女&fq=ydb_province:辽宁&fq=amtdouble:[14 TO 200]&fq=ydb_blood:O&fq=content:王老吉‘
limit 10
/*(‘<-‘)pushdown.ydb*/;
==通过wt与score参数将content模糊匹配的权重增大
/*ydb.pushdown(‘->‘)*/
select ydb_sex,ydb_province,ydb_blood,amtdouble,content from ydb_example_shu where ydbpartion = ‘3000w‘ and ydb_raw_query_s like ‘[email protected]=4&score=8&fq=ydb_sex:女&wt=1&fq=ydb_province:辽宁&wt=1&fq=amtdouble:[14 TO 200]&wt=1&fq=ydb_blood:O&wt=1&fq=content:王老吉&wt=9‘
limit 10
/*(‘<-‘)pushdown.ydb*/;
11.多值列示例
有些时候，我们想在一个列里面存储多个值的时候，就可以考虑使用多值列了
比如说，可以将一个人 的多个标签值 存储在一个记录里面，一个人的每天的行为数据 放在一个记录里面。
一定要注意，
1.字符串类型的多值列，返回的值的无序，并且是排重的，故这块有额外注意。
2.数值型的则是有序的（与导入的顺序一致），并且是没有排重的。
3.传递的数值是按照空格 拆分的 ，如 11 22 33 44
4.如果传递的是空值，会当做null处理
5.只要数据类型定义为多之列，程序目前会按照空格识别来将传入的数据拆分成多个值分别存储
1)--检索--
/*ydb.pushdown(‘->‘)*/
select multyvalue_string,multyvalue_tlong,multyvalue_long,multyvalue_tdouble,multyvalue_double from ydb_example_shu_multyvalue where ydbpartion=‘3000w‘
limit 10
/*(‘<-‘)pushdown.ydb*/;
2)--多值列group by
/*ydb.pushdown(‘->‘)*/
select multyvalue_long,count(*) as cnt from ydb_example_shu_multyvalue where ydbpartion = ‘3000w‘ group by multyvalue_long order by cnt
limit 10
/*(‘<-‘)pushdown.ydb*/;
3)普通列与多值列group by
/*ydb.pushdown(‘->‘)*/
select multyvalue_long,ydb_sex,count(*) as cnt from ydb_example_shu_multyvalue where ydbpartion = ‘3000w‘ group by multyvalue_long,ydb_sex order by cnt
limit 10
/*(‘<-‘)pushdown.ydb*/;
4)--两个多值列group by ，（笛卡尔集，要注意内存，以及性能，要慎重）
/*ydb.pushdown(‘->‘)*/
select multyvalue_long,multyvalue_string,count(*) from ydb_example_shu_multyvalue where ydbpartion = ‘3000w‘ group by multyvalue_long,multyvalue_string order by multyvalue_long,multyvalue_string
limit 10
/*(‘<-‘)pushdown.ydb*/;
12.地理位置感知搜索
现在手机APP满天飞，我想大家都用过这个功能：【搜索我附近的饭店或宾馆】之类的功能，类似这样的地理位置搜索功能非常适用，因为它需要利用到用户当前的地理位置数据，是以用户角度出发，找到符合用户自身需求的信息，应用返回的信息对于用户来说满意度会比较高。可见，地理位置空间搜索在提高用户体验方面有至关重要的作用。在Lucene中，地理位置空间搜索是借助Spatial模块来实现的。
要实现地理位置空间搜索，我们首先需要对地理位置数据创建索引，比较容易想到的就是把经度和纬度存入索引，可是这样做，有个弊端，因为地理位置数据(经纬度)是非常精细的，一般两个地点相差就0.0几，这样我们需要构建的索引体积会很大，这会显著减慢你的搜索速度。在精确度上采取折衷的方法通常是将纬度和经度封装到层中。您可以将每个层看作是地图的特定部分的缩放级别，比如位于美国中央上方的第 2 层几乎包含了整个北美，而第 19 层可能只是某户人家的后院。尤其是，每个层都将地图分成 2层的箱子或网格。然后给每个箱子分配一个号码并添加到文档索引中。如果希望使用一个字段，那么可以使用 Geohash编码方式将纬度/经度编码到一个 String 中。Geohash 的好处是能够通过切去散列码末尾的字符来实现任意的精度。在许多情况下，相邻的位置通常有相同的前缀。
1)测试表的创建，注意使用mortonhash的列的类型是geopoint
create table lonlattable_test(
lon tdouble,
lat tdouble,
mortonhash geopoint
)
2)导入数据-注意YMortonHash函数是用于生成Morton数的，将来在索引中用于匹配
insert overwrite table ydbpartion
select ‘lonlattable_test‘, ‘3000w‘, ‘‘,
YROW(
‘lon‘,r[0],
‘lat‘,r[1],
‘mortonhash‘,YMortonHash(r[0],r[1])
)
from ydb where YSQL(‘from‘,‘select LAT,LON from ydb_oribit where ydbpartion=‘20160619‘ ‘,‘segment‘) ;
3)#数据预览,注意YMortonUnHash用于将数据在还原为经纬度，YMortonHashDistance则用来计算距离，单位是m
select tmp.lon,tmp.lat,tmp.mortonhash,YMortonUnHash(tmp.mortonhash),YMortonHashDistance(tmp.mortonhash,8.1,9.2) as distance from
(
/*ydb.pushdown(‘->‘)*/
select lon,lat,mortonhash from lonlattable_test where ydbpartion=‘3000w‘
/*(‘<-‘)pushdown.ydb*/
)tmp order by distance limit 10 ;
4)地理位置检索，给一个坐标，搜寻最近多少米远的所有记录，注意[email protected]的使用
select tmp.lon,tmp.lat,tmp.mortonhash,YMortonUnHash(tmp.mortonhash),YMortonHashDistance(tmp.mortonhash,8.1,9.2) as distance from
(
/*ydb.pushdown(‘->‘)*/
select lon,lat,mortonhash from lonlattable_test where ydbpartion=‘3000w‘ and ydb_raw_query_s like ‘[email protected]=mortonhash&lon=8.1&lat=9.2&radius=10000‘
/*(‘<-‘)pushdown.ydb*/
)tmp order by distance limit 10 ;
5)####################按照矩形区域搜索isbox=true
select tmp.lon,tmp.lat,tmp.mortonhash,YMortonUnHash(tmp.mortonhash),YMortonHashDistance(tmp.mortonhash,8.1,9.2) as distance from
(
/*ydb.pushdown(‘->‘)*/
select lon,lat,mortonhash from lonlattable_test where ydbpartion=‘3000w‘ and ydb_raw_query_s like ‘[email protected]=mortonhash&isbox=true&lon=8.1&lat=9.2&radius=10000‘
/*(‘<-‘)pushdown.ydb*/
)tmp order by distance limit 10 ;
13.考虑单词顺序的模糊匹配
默认YDB提供了simpletex,haoma等类型进行模糊匹配。
他们本质上是通过分词进行匹配，并不考虑匹配的词的顺序，如果要进行模糊匹配并且又要保证匹配的先后顺序，那么就需要在进行中文分词的时候保存词的位置。
如果保存了顺序，我们可以通过[email protected]方法 按照单词顺序进行匹配查询
如：
phonenum=‘[email protected]‘
phonenum=‘[email protected]*63*72*76‘
phonenum=‘[email protected]*2*6*3*6*88‘
content=‘[email protected]可口*可乐*磊‘
content=‘[email protected] 15 * 24 28 * 37 41 ‘
目前保存词的位置的数据类型有如下几种:
charlike: 按照字符char 1~5元分词 (效果较好，term区分了词元，适合车牌，手机号类型的较短文本)
wordlike: 按字与词 1~3元分词 (效果较好，term区分了词元，适合文本类型)
pchepai：按照字符char 2~5元分词
phaoma ：按照字符char 3~5元分词
psimpletext： 按字与词 1~3元分词
pyy ：lucene的cjk分词，中文采用二元分词，英文与数字采用 单字分词
注意：目前的这种Ylike还实现不了前缀与后缀匹配，如果要进行前缀与后缀匹配，建议在导入数据前，加入前缀与后缀的特殊符号
比如说如果ip地址是192.168.3.40，那么我们可以使用charlike类型的字段，并且导入的时候 加上 start192.168.3.40end ，这样前后分别由start与end里两个特殊的字符串
这样进行前缀匹配的时候，可以通过phonenum=‘[email protected]‘ 来匹配，后缀匹配可以通过 phonenum=‘[email protected]‘ 来进行匹配
1.##############号码与车牌类型的示例
/*ydb.pushdown(‘->‘)*/
select phonenum from ydb_example_shu_positon where ydbpartion = ‘3000w‘ and phonenum=‘[email protected]‘
limit 10
/*(‘<-‘)pushdown.ydb*/
;
+------------------+--+
| phonenum |
+------------------+--+
| 18882496377 |
| 18824963110 |
| 18824963481 |
| 17082496383 |
| 13824963971 |
| 15928249639 |
| 18824963904 |
| 13238249639 |
+------------------+--+
8 rows selected (0.272 seconds)
2.#######使用*通配符###
/*ydb.pushdown(‘->‘)*/
select phonenum from ydb_example_shu_positon where ydbpartion = ‘3000w‘ and phonenum=‘[email protected]*963‘
limit 100
/*(‘<-‘)pushdown.ydb*/
;
+------------------+--+
| phonenum |
+------------------+--+
| 13824096330 |
| 13824229634 |
| 18824963481 |
| 18824096302 |
| 17082496383 |
| 18824296372 |
| 18824963110 |
| 18824196307 |
| 13238249639 |
| 13824769963 |
| 18824649639 |
| 18882496377 |
| 13482479635 |
| 13824799638 |
| 13824963971 |
| 18824396346 |
| 15928249639 |
| 18824963904 |
| 18898248963 |
+------------------+--+
19 rows selected (0.26 seconds)
/*ydb.pushdown(‘->‘)*/
select phonenum from ydb_example_shu_positon where ydbpartion = ‘3000w‘ and phonenum=‘[email protected]*63*72*76‘
limit 100
/*(‘<-‘)pushdown.ydb*/
;
+------------------+--+
| phonenum |
+------------------+--+
| 18863872476 |
| 18863767276 |
| 18836372076 |
| 18863726576 |
+------------------+--+
4 rows selected (0.241 seconds)
3.文本类型顺序匹配检索示例
/*ydb.pushdown(‘->‘)*/
select content from ydb_example_shu_positon where ydbpartion = ‘3000w‘ and content=‘[email protected] 5 14 15 24 28 37 41 49‘
limit 100
/*(‘<-‘)pushdown.ydb*/
;
4.通过* 允许中间某些词 不连续，但依然保证顺序######
/*ydb.pushdown(‘->‘)*/
select content from ydb_example_shu_positon where ydbpartion = ‘3000w‘ and content=‘[email protected] 5 14 * 24 28 37‘
limit 100
/*(‘<-‘)pushdown.ydb*/
;
14.管理员命令
--查看YDB表
/*ydb.pushdown(‘->‘)*/
show tables
/*(‘<-‘)pushdown.ydb*/
;
--查看表的分区
/*ydb.pushdown(‘->‘)*/
show partions ydb_example_shu
/*(‘<-‘)pushdown.ydb*/
;
--按条件删除
/*ydb.pushdown(‘->‘)*/
select count(*) from ydb_example_shu where ydbpartion=‘3000w‘ and ydb_sex=‘男‘ and ydb_blood=‘A‘ and ydbkv=‘ydb.delete.query:true‘
/*(‘<-‘)pushdown.ydb*/
;
--整个分区清理，数据清空，但是分区还在
/*ydb.pushdown(‘->‘)*/
select count(*) from ydb_example_shu where ydbpartion=‘3000w‘ and ydbkv=‘ydb.truncate:true‘
/*(‘<-‘)pushdown.ydb*/
;
--物理清理掉整个分区的数据(清理后分区也跟着删掉)
/*ydb.pushdown(‘->‘)*/
drop table ydb_example_shu partions 3000a4
/*(‘<-‘)pushdown.ydb*/
;
/*ydb.pushdown(‘->‘)*/
drop table ydb_example_shu partions 3000a4,3000a5,3000a6
/*(‘<-‘)pushdown.ydb*/
;
--删除一个表的所有分区-保留表结构
/*ydb.pushdown(‘->‘)*/
truncate table ydb_example_shu
/*(‘<-‘)pushdown.ydb*/
;
--删除一个表，表结构也删除掉
/*ydb.pushdown(‘->‘)*/
drop table ydb_example_shu
/*(‘<-‘)pushdown.ydb*/
;
--暂停kafka的消费3600秒
/*ydb.pushdown(‘->‘)*/
select count(*) from y_system_log where ydbkv=‘ydb.reader.pause:true‘ and ydbkv=‘ydb.reader.pause.secs:3600‘
/*(‘<-‘)pushdown.ydb*/
;
--恢复 暂停的kafka的消费,让kafka继续消费数据
/*ydb.pushdown(‘->‘)*/
‘select count(*) from y_system_log where ydbkv=‘ydb.reader.pause:true‘ and ydbkv=‘ydb.reader.pause.secs:0‘
/*(‘<-‘)pushdown.ydb*/
;
--将binlog立即刷到磁盘上
/*ydb.pushdown(‘->‘)*/
select count(*) from ydb_example_trade where ydbpartion=‘k25_005_0‘ and ydbkv=‘ydb.force.sync.binlog:true‘
/*(‘<-‘)pushdown.ydb*/
;
--刷新缓冲区的数据，让其能被搜索到，（binlog会持久化但数据并不会立即持久化到hdfs）
/*ydb.pushdown(‘->‘)*/
select count(*) from ydb_example_trade where ydbpartion=‘k25_005_0‘ and ydbkv=‘ydb.force.sync.ram:true‘
/*(‘<-‘)pushdown.ydb*/
;
--主动触发，将内存中的数据刷盘操作,(数据会被搜索到，并且持久化到磁盘)
/*ydb.pushdown(‘->‘)*/
select count(*) from ydb_example_trade where ydbpartion=‘k25_005_0‘ and ydbkv=‘ydb.force.sync:true‘
/*(‘<-‘)pushdown.ydb*/
;
15.变通方式的分页方案
默认Spark SQL无法进行分页，YDB由于使用了Spark也存在这个问题，故我们采取了变通方式来实现分页。
以每页pagesize大小为10为例
######1024条记录以内####
第一页 直接limit 10，并且将每一行的数据，都按pagekey取个crc32的值 存储在lru的hashmap中
第二页 直接limit 20，并且根据第一页的crc32与当前的20条记录进行移除，有可能剩余12条或更多，但至少剩余10条，然后取出10条返回，并且将crc32缓存在LRU的hashmap中
第三页 直接limit 30,同第二页一样，移除掉与crc32匹配的记录，返回10条并且添加第三页的crc32
这样一直处理到1024条记录 ，如果同时能处理1024个session，我们认为内存是能够放1024*1024个crc32的long类型
######超过1024条记录######
我们采用导出成文件的方式，即insert overwrite table的方式，但是考虑到insert 的方式响应可能会很慢，故我们改写了outputformat，也就是后面大家看到的YdbMoreTextOutputFormat
通过YdbMoreTextOutputFormat我们不需要等待这个insert overwrite执行完毕后才返回，而是在YdbMoreTextOutputFormat中将少量数据发送到缓冲区供立即返回，而大量数据写入到磁盘。
在这种方式下，由于需要与先前生成的crc32值进行排重，目前的实现没有精确控制返回的数据条数，而是返回介于pagesize到pagesize*2的记录数，
----这个分页的使用限制大家注意--
1.不能跳页，只能一页一页的向下翻。
2.只能向后翻页，不能向前翻页。
3.每页返回的行数是一个近似值，介于pagesize到pagesize*2的记录数。
4.SQL本身就不在需要写limit了
4.sql中的 as pagekey与pagevalue 不能省略，本质是KV返回
如果数据表的规模很大，建议配置如下参数控制每个segments导出的记录条数，以免占用太多的HDFS空间
and ydbkv="export.max.return.docset.size:1000" and ydbkv="max.return.docset.size:1000"
###使用方法##
---先创建如下的表
drop table ydb_page_session;
CREATE external table ydb_page_session(
pagekey string,
pagevalue string
)
partitioned by (ydbsession string)
stored as INPUTFORMAT ‘cn.net.ycloud.ydb.handle.Ya100FixNumCombineTextInputFormat‘ OUTPUTFORMAT ‘cn.net.ycloud.ydb.handle.more.YdbMoreTextOutputFormat‘
location ‘/data/ycloud/ydb/rawdata/ydb_page_session‘;
drop table ydb_more_session;
CREATE external table ydb_more_session(
line string
)
partitioned by (ydbsession string)
stored as INPUTFORMAT ‘cn.net.ycloud.ydb.handle.Ya100FixNumCombineTextInputFormat‘ OUTPUTFORMAT ‘cn.net.ycloud.ydb.handle.more.YdbMoreTextOutputFormat‘
location ‘/data/ycloud/ydb/rawdata/ydb_more_session‘;
---通过如下接口查询数据----
注意生成的pagekey不能省略，用于排重，如果是查询明细可以用y_uuid_s的内置列填充。
http://ydbmaster:1210/ydbpage?reqid=002_page&pagesize=100&sql=select r[0] as pagekey,concat_ws(‘,‘,r) as pagevalue from ydb where YSQL(‘from‘,‘select y_uuid_s,phonenum,usernick,content from ydb_example_shu where ydbpartion="3000w" and content="王老吉" and ydbkv="export.max.return.docset.size:1000" and ydbkv="max.return.docset.size:1000" ‘,‘segment‘)
http://ydbmaster:1210/ydbpage?reqid=00d3_page&pagesize=100&sql=select r[0] as pagekey,concat_ws(‘,‘,r) as pagevalue from ydb where YSQL(‘from‘,‘select y_uuid_s,phonenum,usernick from ydb_example_shu where ydbpartion="3000w" and ydbkv="export.max.return.docset.size:1000" and ydbkv="max.return.docset.size:1000" ‘,‘segment‘)
http://ydbmaster:1210/ydbpage?reqid=0234_page&pagesize=100&sql=select concat_ws(‘,‘,r[0],r[1],r[2]) as pagekey,concat_ws(‘,‘,r) as pagevalue from ydb where YSQL(‘from‘,‘select amtdouble,amtlong,y_uuid_s,content,usernick,ydb_sex from ydb_example_shu where ydbpartion="3000w" and ydbkv="export.max.return.docset.size:1000" and ydbkv="max.return.docset.size:1000" ‘,‘segment‘)
16.分词
分词( Word Segmentation) 指的是将一个词字序列切分成一个一个单独的词。分词就是将连续的词序列按照一定的规范重新组合成词序列的过程。我们知道，在英文的行文中，单词之间是以空格作为自然分界符的，而中文只是字、句和段能通过明显的分界符来简单划界，唯独词没有一个形式上的分界符，虽然英文也同样存在短语的划分问题，不过在词这一层上，中文比之英文要复杂的多、困难的多。
默认YDB提供了如下几种分词
simpletext ydb内置的普通文本分词 采用1~3元分词
haoma ydb内置的适合号码类型的分词，采用3~5元分词实现，分词粒度为char
chepai ydb内置的适合号码类型的分词，采用2~5元分词实现，分词粒度为char
text 为lucene默认的standard分词，在（处理手机号，邮箱，IP地址，网址等中英文与字典组合的数据上 不准确，请慎用）
cjkyy 为lucene默认的cjk分词即二元分词 （处理手机号，邮箱，IP地址，网址等中英文与字典组合的数据上 不准确，请慎用）
ikyy与textik 为开源的ik分词的实现，采用词库分词，词库我们可以再lib下找到
以下类型除了分词外，还保存了分词后的词的顺序，可以进行顺序匹配 更多请参考《27.考虑单词顺序的模糊匹配》
charlike: 按照字符char 1~5元分词 (效果较好，term区分了词元，适合车牌，手机号类型的较短文本)
wordlike: 按字与词 1~3元分词 (效果较好，term区分了词元，适合文本类型)
pchepai：按照字符char 2~5元分词
phaoma ：按照字符char 3~5元分词
psimpletext： 按字与词 1~3元分词
pyy ：lucene的cjk分词，中文采用二元分词，英文与数字采用 单字分词
--我们可以通过如下SQL 了解不同分词的差异
select
YAnalyzer(‘charlike‘,‘query‘,‘中华人民123456‘) as charlikequery,
YAnalyzer(‘charlike‘,‘index‘,‘中华人民123456‘) as charlikeindex
from (
/*ydb.pushdown(‘->‘)*/
select content from ydb_example_shu_multyvalue where ydbpartion=‘3000w‘
/*(‘<-‘)pushdown.ydb*/
) tmp
limit 1;
select
YAnalyzer(‘wordlike‘,‘query‘,‘中华人民123456‘) as wordlikequery,
YAnalyzer(‘wordlike‘,‘index‘,‘中华人民123456‘) as wordlikeindex
from
(
/*ydb.pushdown(‘->‘)*/
select content from ydb_example_shu_multyvalue where ydbpartion=‘3000w‘
/*(‘<-‘)pushdown.ydb*/
) tmp
limit 1;
+-------------------------+---------------------------------------------------------------------------+--+
| wordlikequery | wordlikeindex |
+-------------------------+---------------------------------------------------------------------------+--+
| [email protected]中华人 [email protected]华人民 [email protected]人民123456 | [email protected]中 [email protected]华 [email protected]人 [email protected]民 [email protected] [email protected]中华 [email protected]华人 [email protected]人民 [email protected]民123456 [email protected]中华人 [email protected]华人民 [email protected]人民123456 |
+-------------------------+---------------------------------------------------------------------------+--+
1 row selected (0.889 seconds)
select
YAnalyzer(‘phaoma‘,‘query‘,‘中华人民123456‘) as phaomaquery,
YAnalyzer(‘phaoma‘,‘index‘,‘中华人民123456‘) as phaomaindex
from
(
/*ydb.pushdown(‘->‘)*/
select content from ydb_example_shu_multyvalue where ydbpartion=‘3000w‘
/*(‘<-‘)pushdown.ydb*/
) tmp
limit 1;
+--------------------------------------+---------------------------------------------------------------------------------------------------------+--+
| phaomaquery | phaomaindex |
+--------------------------------------+---------------------------------------------------------------------------------------------------------+--+
| 中华人民1 华人民12 人民123 民1234 12345 23456 | 中华人 华人民 人民1 民12 123 234 345 456 中华人民 华人民1 人民12 民123 1234 2345 3456 中华人民1 华人民12 人民123 民1234 12345 23456 |
+--------------------------------------+---------------------------------------------------------------------------------------------------------+--+
select
YAnalyzer(‘psimpletext‘,‘query‘,‘中华人民123456‘) as psimpletextquery,
YAnalyzer(‘psimpletext‘,‘index‘,‘中华人民123456‘) as psimpletextindex
from
(
/*ydb.pushdown(‘->‘)*/
select content from ydb_example_shu_multyvalue where ydbpartion=‘3000w‘
/*(‘<-‘)pushdown.ydb*/
) tmp
limit 1;
+-------------------+---------------------------------------------------+--+
| psimpletextquery | psimpletextindex |
+-------------------+---------------------------------------------------+--+
| 中华人 华人民 人民123456 | 中 华 人 民 123456 中华 华人 人民 民123456 中华人 华人民 人民123456 |
+-------------------+---------------------------------------------------+--+
ik词库分词
词库文件位于 ya100/lib/IK_ext.dic
17.with as 写法简化SQL
如果我们的SQL，嵌套层级太深，可以考虑通过with as 方法，将子SQL抽取出来，让整体的SQL看起来逻辑更清晰，大家阅读SQL的时候也便于理解。
with as 遵循HIVE语法，下面为写法示例
Hive 可以用with as将某个查询命名为一个临时的表名，其他语句可以随时使用该临时表名进行查询。
with q1 as (select * from src where key= ‘5’),
q2 as (select * from src s2 where key = ‘4’)
select * from q1 union all select * from q2;
一个简单的例子
with
y_customer as (
/*ydb.pushdown(‘->‘)*/
select c_custkey from customer_ydb where c_mktsegment = ‘BUILDING‘
/*(‘<-‘)pushdown.ydb*/
),
y_lineitem as (
/*ydb.pushdown(‘->‘)*/
select l_orderkey,l_extendedprice,l_discount from lineitem_ydb where l_shipdate > ‘1995-03-15‘
/*(‘<-‘)pushdown.ydb*/
)
,
y_orders as (
/*ydb.pushdown(‘->‘)*/
select o_orderdate, o_shippriority,o_orderkey,o_custkey from orders_ydb where o_orderdate < ‘1995-03-15‘
/*(‘<-‘)pushdown.ydb*/
)
select
l_orderkey, sum(l_extendedprice*(1-l_discount)) as revenue, o_orderdate, o_shippriority
from
y_customer c join y_orders o
on c.c_custkey = o.o_custkey
join y_lineitem l
on l.l_orderkey = o.o_orderkey
where
o_orderdate < ‘1995-03-15‘
group by l_orderkey, o_orderdate, o_shippriority
order by revenue desc, o_orderdate ,l_orderkey, o_shippriority
limit 10;
一个稍微复杂点的例子
with
y_nation as (
/*ydb.pushdown(‘->‘)*/
select n_name,n_regionkey,n_nationkey from nation_ydb
/*(‘<-‘)pushdown.ydb*/
),
y_region as (
/*ydb.pushdown(‘->‘)*/
select r_regionkey,r_name from region_ydb where r_name = ‘EUROPE‘
/*(‘<-‘)pushdown.ydb*/
),
y_supplier as (
/*ydb.pushdown(‘->‘)*/
select s_acctbal, s_name,s_address,s_phone, s_comment ,s_nationkey,s_suppkey
from supplier_ydb
/*(‘<-‘)pushdown.ydb*/
),
y_partsupp as (
/*ydb.pushdown(‘->‘)*/
select ps_supplycost,ps_suppkey,ps_partkey
from partsupp_ydb
/*(‘<-‘)pushdown.ydb*/
),
y_part as (
/*ydb.pushdown(‘->‘)*/
select p_partkey,p_mfgr,p_size,p_type
from part_ydb where p_size = 15 and p_type like ‘%BRASS‘
/*(‘<-‘)pushdown.ydb*/
),
q2_minimum_cost_supplier_tmp1 as (select
s.s_acctbal, s.s_name, n.n_name, p.p_partkey, ps.ps_supplycost, p.p_mfgr, s.s_address, s.s_phone, s.s_comment
from
y_nation n join y_region r
on
n.n_regionkey = r.r_regionkey
join y_supplier s
on
s.s_nationkey = n.n_nationkey
join y_partsupp ps
on
s.s_suppkey = ps.ps_suppkey
join y_part p
on
p.p_partkey = ps.ps_partkey ),
q2_minimum_cost_supplier_tmp2 as (
select
p_partkey, min(ps_supplycost) as ps_min_supplycost
from
q2_minimum_cost_supplier_tmp1
group by p_partkey
)
select
t1.s_acctbal, t1.s_name, t1.n_name, t1.p_partkey, t1.p_mfgr, t1.s_address, t1.s_phone, t1.s_comment
from
q2_minimum_cost_supplier_tmp1 t1 join q2_minimum_cost_supplier_tmp2 t2
on
t1.p_partkey = t2.p_partkey and t1.ps_supplycost=t2.ps_min_supplycost
order by s_acctbal desc, n_name, s_name, p_partkey,p_mfgr,s_address,s_phone,s_comment
limit 100;
十、通过Kafka实时导入数据
默认的Kafka导入数据只支持Json格式，如果需要支持其他格式，需要自己通过Java写Parser.。
1.Kafka配置的注意点
第一：注意Kafka server 的num.partitions一定要大于YDB启动的进程*线程数量，否则有的进程消费不到数据
如果发现之前配置错了，要清空下ZK相关路径（现在好像有API接口了），否则修改完了也不生效
Kafka的启动很简单 ./kafka-server-start.sh ../config/server.properties
第二：请参考第四章的Kafka配置注意事项，这里不再重复介绍
2.YDB中配置Kafka的消费
在ydb_site.yaml中添加如下的配置，并更改相关连接参数
ydb.reader.list: "default,filesplit,kafka_json"
#如果您要使用其他的消息中间件，可以自定义Reader，默认为Kafka的实现
ydb.reader.read.class.kafka_json: "cn.net.ycloud.ydb.server.reader.kafka.KafkaDataReader"
#如果您的数据格式是非标准的JSON格式，可以自定义Parser，默认为按照Json方式解析
ydb.reader.parser.class.kafka_json: "cn.net.ycloud.ydb.server.reader.JsonParser"
kafka.topic.kafka_json: "kafkaydb"
kafka.group.kafka_json: "kafkaydb_group"
bootstrap.servers.kafka_json: "192.168.3.2:6667"
3.重启YDB后,10分钟后会开始导入数据
4.Kafka导入的数据格式如下
1）一次只导入一条
{"tablename":"ydbexample","ydbpartion":"20151005","data":{"indexnum":4,"label":"l_4","userage":14,"clickcount":4,"paymoney":4.132,"price":4.12,"content":"4 4 4 延云 ydb 延云 测试 中文分词 中华人民共和国 沈阳延云云计算技术有限公司","contentcjk":"4 4 4 延云 ydb 延云 测试 中文分词 中华人民共和国 沈阳延云云计算技术有限公司"}}
2）一次导入多条（通过减少数据条数，提升Kafka性能）
{"tablename":"ydb_example_trade","ydbpartion":"20151018","list":[{"tradeid":"2016030811044018","nickname":"凌浦泽","province":"澳门特别行政区","tradetype"
...... ",\"amt\":8321,\"bank\":\"交通银行\"}"}]}
5.Kafka模式实时导入数据，为什么会有重复数据
YDB能确保从Kafka消费到的数据0丢失，但是由于Kafka的实现机制，以下情况会导致出现重复数据
具体原理可以参考这篇文章
http://www.iteblog.com/pdf/1716
进程异常退出（主动kill或者进程BUG等原因导致）
Kafka采用commitoffset的方式提交数据，由于此时会存在数据已经消费，但是Kafka的offset没有来得及提交，这样会导致数据重复。
Kafka的Rebalancing
由于进程退出，或者首次启动时，会产生一个新的consumer加入一个consumer group时，会有一个rebalance的操作，导致每一个consumer和partition的关系重新分配。也就会发生了rebalancing 。
如果一个消息已经被消费了，但是还没有提交offset，就开始了Rebalancing，这个时候会造成数据的重复。这个在Kafka里已经积累了一部分数据后的首次启动时最为明显。
如果仅仅发生了一个进程异常退出，但是没有导致Rebalancing，那么最多重复的数据条数就是这个进程还没有来得及提交的部分。
如果发生了Rebalancing（进程异常退出也会导致Rebalancing）,那么则要按全部没有来得及提交的线程数来计算。
6.Kafka模式对数据可靠性的几种配置
ydb.realtime.kafka.commit.intervel用来控制Kafka的offset commit频率，每次commit也会导致binglog(wal)同步，所以该值一般要小于等于ydb.realtime.binlog.sync.intervel的频率
尽量减少进程重启 导致的数据重复的配置（每个线程32条重复数据）
ydb.realtime.kafka.commit.intervel: 32
ydb.realtime.binlog.sync.intervel: 1024
尽量增加吞吐量的配置, 可能有重复（每个线程1024条重复数据）
ydb.realtime.kafka.commit.intervel: 1024
ydb.realtime.binlog.sync.intervel: 2048
7.多个Kafka Topic一起消费
ydb.reader.list: "default,filesplit,kafka_json,kafka_json2,kafka_json3"
##kafka_json##
ydb.reader.read.class.kafka_json: "cn.net.ycloud.ydb.server.reader.kafka.KafkaDataReader"
ydb.reader.parser.class.kafka_json: "cn.net.ycloud.ydb.server.reader.JsonParser"
kafka.topic.kafka_json: "a961"
kafka.group.kafka_json: "bn961n_groupv1_kafka_json"
bootstrap.servers.kafka_json: "192.168.3.2:6667"
##kafka_json2##
ydb.reader.read.class.kafka_json2: "cn.net.ycloud.ydb.server.reader.kafka.KafkaDataReader"
ydb.reader.parser.class.kafka_json2: "cn.net.ycloud.ydb.server.reader.JsonParser"
kafka.topic.kafka_json2: "b961"
kafka.group.kafka_json2: "bn961n_groupv1_kafka_json2"
bootstrap.servers.kafka_json2: "192.168.3.2:6667"
##kafka_json3##
ydb.reader.read.class.kafka_json3: "cn.net.ycloud.ydb.server.reader.kafka.KafkaDataReader"
ydb.reader.parser.class.kafka_json3: "cn.net.ycloud.ydb.server.reader.JsonParser"
kafka.topic.kafka_json3: "c961"
kafka.group.kafka_json3: "bn961n_groupv1_kafka_json3"
bootstrap.servers.kafka_json3: "192.168.3.2:6667"
十一、通过mdrill提升简单查询的查询速度
默认配置所有的SQL查询均是通过spark SQL进行相应，但是由于SPARK本身的框架很重，每次任务调度都会有200~300毫秒的调度时间，对于简单查询来说，我们可以将简单查询的SQL通过轻量级的mdrill接口进行访问，而不通过SPARK SQL进行调度，从而在调度上节省时间。
默认简单SQL通过mdrill来执行这个功能是关闭的，大家可以通过下述方式，将一个简单SQL转换为mdrill查询。
1.通过统一配置
可以在ydb_site.yaml里配置 ydb.sql.ismdrill.first的值为true，让ydb系统自动选择是使用mdrill来进行查询还是使用spark调度来执行SQL。
通过该配置，数据明细查询、排序，以及不含有group by的统计会通过mdrill查询。
group by由于mdrill的一万个group 的限制，该方式不会启用。
2.通过ydb_force_to_mdrill_mark让SQL以mdrill的方式显示执行
如果ydb.sql.ismdrill.first为false，不会使用mdrill的调度，但如果我们在SQL加上该标记，就会强制该SQL采用mdrill的调度，而不是采用spark的调度。
示例如下：
/*ydb.pushdown(‘->‘)*/
select ydb_sex, count(*) as cbt from ydb_example_shu where ydbpartion=‘20150811‘ and ydbkv=‘mdrill.force:ydb_force_to_mdrill_mark‘ group by ydb_sex limit 10
/*(‘<-‘)pushdown.ydb*/
3.通过ydb_force_to_spark_mark让SQL以spark的方式执行
/*ydb.pushdown(‘->‘)*/
select ydb_sex, count(*) as cbt from ydb_example_shu where ydbpartion=‘20150811‘ and ydbkv=‘mdrill.force:ydb_force_to_spark_mark‘ group by ydb_sex limit 10
/*(‘<-‘)pushdown.ydb*/
以上是关于YDB基本使用详解（转）的主要内容，如果未能解决你的问题，请参考以下文章